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
@@ -13,36 +13,34 @@ namespace Sass {
13
13
  class Context;
14
14
  class Node;
15
15
 
16
- typedef Subset_Map<std::string, std::pair<Sequence_Selector*, SimpleSequence_Selector*> > ExtensionSubsetMap;
17
-
18
16
  class Extend : public Operation_CRTP<void, Extend> {
19
17
 
20
18
  Context& ctx;
21
- ExtensionSubsetMap& subset_map;
19
+ Subset_Map& subset_map;
22
20
 
23
- void fallback_impl(AST_Node* n) { }
21
+ void fallback_impl(AST_Node_Ptr n) { }
24
22
 
25
23
  public:
26
24
  static Node subweave(Node& one, Node& two, Context& ctx);
27
- static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething, std::set<SimpleSequence_Selector>& seen);
28
- static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething);
29
- static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace = false) {
25
+ static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, bool isReplace, bool& extendedSomething, std::set<Compound_Selector>& seen);
26
+ static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, bool isReplace, bool& extendedSomething);
27
+ static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, bool isReplace = false) {
30
28
  bool extendedSomething = false;
31
29
  return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething);
32
30
  }
33
- static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, std::set<SimpleSequence_Selector>& seen) {
31
+ static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, std::set<Compound_Selector>& seen) {
34
32
  bool isReplace = false;
35
33
  bool extendedSomething = false;
36
34
  return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething, seen);
37
35
  }
38
- Extend(Context&, ExtensionSubsetMap&);
36
+ Extend(Context&, Subset_Map&);
39
37
  ~Extend() { }
40
38
 
41
- void operator()(Block*);
42
- void operator()(Ruleset*);
43
- void operator()(Supports_Block*);
44
- void operator()(Media_Block*);
45
- void operator()(Directive*);
39
+ void operator()(Block_Ptr);
40
+ void operator()(Ruleset_Ptr);
41
+ void operator()(Supports_Block_Ptr);
42
+ void operator()(Media_Block_Ptr);
43
+ void operator()(Directive_Ptr);
46
44
 
47
45
  template <typename U>
48
46
  void fallback(U x) { return fallback_impl(x); }
@@ -4,10 +4,9 @@
4
4
  #include <string>
5
5
  #include <vector>
6
6
 
7
- namespace Sass {
7
+ #include "ast_fwd_decl.hpp"
8
8
 
9
- class Block;
10
- class Context;
9
+ namespace Sass {
11
10
 
12
11
  namespace File {
13
12
 
@@ -105,9 +104,9 @@ namespace Sass {
105
104
  class StyleSheet : public Resource {
106
105
  public:
107
106
  // parsed root block
108
- Block* root;
107
+ Block_Obj root;
109
108
  public:
110
- StyleSheet(const Resource& res, Block* root)
109
+ StyleSheet(const Resource& res, Block_Obj root)
111
110
  : Resource(res), root(root)
112
111
  { }
113
112
  };
@@ -38,13 +38,13 @@ namespace Sass {
38
38
  using std::stringstream;
39
39
  using std::endl;
40
40
 
41
- Definition* make_native_function(Signature sig, Native_Function func, Context& ctx)
41
+ Definition_Ptr make_native_function(Signature sig, Native_Function func, Context& ctx)
42
42
  {
43
43
  Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[built-in function]"));
44
44
  sig_parser.lex<Prelexer::identifier>();
45
45
  std::string name(Util::normalize_underscores(sig_parser.lexed));
46
- Parameters* params = sig_parser.parse_parameters();
47
- return SASS_MEMORY_NEW(ctx.mem, Definition,
46
+ Parameters_Obj params = sig_parser.parse_parameters();
47
+ return SASS_MEMORY_NEW(Definition,
48
48
  ParserState("[built-in function]"),
49
49
  sig,
50
50
  name,
@@ -53,7 +53,7 @@ namespace Sass {
53
53
  false);
54
54
  }
55
55
 
56
- Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx)
56
+ Definition_Ptr make_c_function(Sass_Function_Entry c_func, Context& ctx)
57
57
  {
58
58
  using namespace Prelexer;
59
59
 
@@ -66,8 +66,8 @@ namespace Sass {
66
66
  exactly < Constants::debug_kwd >
67
67
  > >();
68
68
  std::string name(Util::normalize_underscores(sig_parser.lexed));
69
- Parameters* params = sig_parser.parse_parameters();
70
- return SASS_MEMORY_NEW(ctx.mem, Definition,
69
+ Parameters_Obj params = sig_parser.parse_parameters();
70
+ return SASS_MEMORY_NEW(Definition,
71
71
  ParserState("[c function]"),
72
72
  sig,
73
73
  name,
@@ -108,7 +108,7 @@ namespace Sass {
108
108
  T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace)
109
109
  {
110
110
  // Minimal error handling -- the expectation is that built-ins will be written correctly!
111
- T* val = dynamic_cast<T*>(env[argname]);
111
+ T* val = dynamic_cast<T*>(&env[argname]);
112
112
  if (!val) {
113
113
  std::string msg("argument `");
114
114
  msg += argname;
@@ -121,24 +121,24 @@ namespace Sass {
121
121
  return val;
122
122
  }
123
123
 
124
- Map* get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
124
+ Map_Ptr get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
125
125
  {
126
126
  // Minimal error handling -- the expectation is that built-ins will be written correctly!
127
- Map* val = dynamic_cast<Map*>(env[argname]);
127
+ Map_Ptr val = SASS_MEMORY_CAST(Map, env[argname]);
128
128
  if (val) return val;
129
129
 
130
- List* lval = dynamic_cast<List*>(env[argname]);
131
- if (lval && lval->length() == 0) return SASS_MEMORY_NEW(ctx.mem, Map, pstate, 0);
130
+ List_Ptr lval = SASS_MEMORY_CAST(List, env[argname]);
131
+ if (lval && lval->length() == 0) return SASS_MEMORY_NEW(Map, pstate, 0);
132
132
 
133
133
  // fallback on get_arg for error handling
134
134
  val = get_arg<Map>(argname, env, sig, pstate, backtrace);
135
135
  return val;
136
136
  }
137
137
 
138
- Number* get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
138
+ Number_Ptr get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
139
139
  {
140
140
  // Minimal error handling -- the expectation is that built-ins will be written correctly!
141
- Number* val = get_arg<Number>(argname, env, sig, pstate, backtrace);
141
+ Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, backtrace);
142
142
  double v = val->value();
143
143
  if (!(lo <= v && v <= hi)) {
144
144
  std::stringstream msg;
@@ -152,18 +152,18 @@ namespace Sass {
152
152
  #define ARGSEL(argname, seltype, contextualize) get_arg_sel<seltype>(argname, env, sig, pstate, backtrace, ctx)
153
153
 
154
154
  template <typename T>
155
- T* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx);
155
+ T get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx);
156
156
 
157
157
  template <>
158
- CommaSequence_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
159
- Expression* exp = ARG(argname, Expression);
158
+ Selector_List_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
159
+ Expression_Obj exp = ARG(argname, Expression);
160
160
  if (exp->concrete_type() == Expression::NULL_VAL) {
161
161
  std::stringstream msg;
162
162
  msg << argname << ": null is not a valid selector: it must be a string,\n";
163
163
  msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
164
164
  error(msg.str(), pstate);
165
165
  }
166
- if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
166
+ if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, exp)) {
167
167
  str->quote_mark(0);
168
168
  }
169
169
  std::string exp_src = exp->to_string(ctx.c_options) + "{";
@@ -171,36 +171,19 @@ namespace Sass {
171
171
  }
172
172
 
173
173
  template <>
174
- Sequence_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
175
- Expression* exp = ARG(argname, Expression);
176
- if (exp->concrete_type() == Expression::NULL_VAL) {
177
- std::stringstream msg;
178
- msg << argname << ": null is not a valid selector: it must be a string,\n";
179
- msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
180
- error(msg.str(), pstate);
181
- }
182
- if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
183
- str->quote_mark(0);
184
- }
185
- std::string exp_src = exp->to_string(ctx.c_options) + "{";
186
- CommaSequence_Selector* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
187
- return (sel_list->length() > 0) ? sel_list->first() : 0;
188
- }
189
-
190
- template <>
191
- SimpleSequence_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
192
- Expression* exp = ARG(argname, Expression);
174
+ Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
175
+ Expression_Obj exp = ARG(argname, Expression);
193
176
  if (exp->concrete_type() == Expression::NULL_VAL) {
194
177
  std::stringstream msg;
195
178
  msg << argname << ": null is not a string for `" << function_name(sig) << "'";
196
179
  error(msg.str(), pstate);
197
180
  }
198
- if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
181
+ if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, exp)) {
199
182
  str->quote_mark(0);
200
183
  }
201
184
  std::string exp_src = exp->to_string(ctx.c_options) + "{";
202
- CommaSequence_Selector* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
203
- return (sel_list->length() > 0) ? sel_list->first()->tail()->head() : 0;
185
+ Selector_List_Obj sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
186
+ return (sel_list->length() > 0) ? &sel_list->first()->tail()->head() : 0;
204
187
  }
205
188
 
206
189
  #ifdef __MINGW32__
@@ -243,7 +226,7 @@ namespace Sass {
243
226
  // RGB FUNCTIONS
244
227
  ////////////////
245
228
 
246
- inline double color_num(Number* n) {
229
+ inline double color_num(Number_Ptr n) {
247
230
  if (n->unit() == "%") {
248
231
  return std::min(std::max(n->value() * 255 / 100.0, 0.0), 255.0);
249
232
  } else {
@@ -251,7 +234,7 @@ namespace Sass {
251
234
  }
252
235
  }
253
236
 
254
- inline double alpha_num(Number* n) {
237
+ inline double alpha_num(Number_Ptr n) {
255
238
  if (n->unit() == "%") {
256
239
  return std::min(std::max(n->value(), 0.0), 100.0);
257
240
  } else {
@@ -262,7 +245,7 @@ namespace Sass {
262
245
  Signature rgb_sig = "rgb($red, $green, $blue)";
263
246
  BUILT_IN(rgb)
264
247
  {
265
- return SASS_MEMORY_NEW(ctx.mem, Color,
248
+ return SASS_MEMORY_NEW(Color,
266
249
  pstate,
267
250
  color_num(ARG("$red", Number)),
268
251
  color_num(ARG("$green", Number)),
@@ -272,7 +255,7 @@ namespace Sass {
272
255
  Signature rgba_4_sig = "rgba($red, $green, $blue, $alpha)";
273
256
  BUILT_IN(rgba_4)
274
257
  {
275
- return SASS_MEMORY_NEW(ctx.mem, Color,
258
+ return SASS_MEMORY_NEW(Color,
276
259
  pstate,
277
260
  color_num(ARG("$red", Number)),
278
261
  color_num(ARG("$green", Number)),
@@ -283,8 +266,8 @@ namespace Sass {
283
266
  Signature rgba_2_sig = "rgba($color, $alpha)";
284
267
  BUILT_IN(rgba_2)
285
268
  {
286
- Color* c_arg = ARG("$color", Color);
287
- Color* new_c = SASS_MEMORY_NEW(ctx.mem, Color, *c_arg);
269
+ Color_Ptr c_arg = ARG("$color", Color);
270
+ Color_Ptr new_c = SASS_MEMORY_COPY(c_arg);
288
271
  new_c->a(alpha_num(ARG("$alpha", Number)));
289
272
  new_c->disp("");
290
273
  return new_c;
@@ -292,22 +275,22 @@ namespace Sass {
292
275
 
293
276
  Signature red_sig = "red($color)";
294
277
  BUILT_IN(red)
295
- { return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->r()); }
278
+ { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->r()); }
296
279
 
297
280
  Signature green_sig = "green($color)";
298
281
  BUILT_IN(green)
299
- { return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->g()); }
282
+ { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->g()); }
300
283
 
301
284
  Signature blue_sig = "blue($color)";
302
285
  BUILT_IN(blue)
303
- { return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->b()); }
286
+ { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->b()); }
304
287
 
305
288
  Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
306
289
  BUILT_IN(mix)
307
290
  {
308
- Color* color1 = ARG("$color-1", Color);
309
- Color* color2 = ARG("$color-2", Color);
310
- Number* weight = ARGR("$weight", Number, 0, 100);
291
+ Color_Ptr color1 = ARG("$color-1", Color);
292
+ Color_Ptr color2 = ARG("$color-2", Color);
293
+ Number_Ptr weight = ARGR("$weight", Number, 0, 100);
311
294
 
312
295
  double p = weight->value()/100;
313
296
  double w = 2*p - 1;
@@ -316,7 +299,7 @@ namespace Sass {
316
299
  double w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0;
317
300
  double w2 = 1 - w1;
318
301
 
319
- return SASS_MEMORY_NEW(ctx.mem, Color,
302
+ return SASS_MEMORY_NEW(Color,
320
303
  pstate,
321
304
  Sass::round(w1*color1->r() + w2*color2->r(), ctx.c_options.precision),
322
305
  Sass::round(w1*color1->g() + w2*color2->g(), ctx.c_options.precision),
@@ -372,7 +355,7 @@ namespace Sass {
372
355
  return m1;
373
356
  }
374
357
 
375
- Color* hsla_impl(double h, double s, double l, double a, Context& ctx, ParserState pstate)
358
+ Color_Ptr hsla_impl(double h, double s, double l, double a, Context& ctx, ParserState pstate)
376
359
  {
377
360
  h /= 360.0;
378
361
  s /= 100.0;
@@ -401,7 +384,7 @@ namespace Sass {
401
384
  double g = (h_to_rgb(m1, m2, h) * 255.0);
402
385
  double b = (h_to_rgb(m1, m2, h - 1.0/3.0) * 255.0);
403
386
 
404
- return SASS_MEMORY_NEW(ctx.mem, Color, pstate, r, g, b, a);
387
+ return SASS_MEMORY_NEW(Color, pstate, r, g, b, a);
405
388
  }
406
389
 
407
390
  Signature hsl_sig = "hsl($hue, $saturation, $lightness)";
@@ -429,38 +412,38 @@ namespace Sass {
429
412
  Signature hue_sig = "hue($color)";
430
413
  BUILT_IN(hue)
431
414
  {
432
- Color* rgb_color = ARG("$color", Color);
415
+ Color_Ptr rgb_color = ARG("$color", Color);
433
416
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
434
417
  rgb_color->g(),
435
418
  rgb_color->b());
436
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, hsl_color.h, "deg");
419
+ return SASS_MEMORY_NEW(Number, pstate, hsl_color.h, "deg");
437
420
  }
438
421
 
439
422
  Signature saturation_sig = "saturation($color)";
440
423
  BUILT_IN(saturation)
441
424
  {
442
- Color* rgb_color = ARG("$color", Color);
425
+ Color_Ptr rgb_color = ARG("$color", Color);
443
426
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
444
427
  rgb_color->g(),
445
428
  rgb_color->b());
446
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, hsl_color.s, "%");
429
+ return SASS_MEMORY_NEW(Number, pstate, hsl_color.s, "%");
447
430
  }
448
431
 
449
432
  Signature lightness_sig = "lightness($color)";
450
433
  BUILT_IN(lightness)
451
434
  {
452
- Color* rgb_color = ARG("$color", Color);
435
+ Color_Ptr rgb_color = ARG("$color", Color);
453
436
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
454
437
  rgb_color->g(),
455
438
  rgb_color->b());
456
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, hsl_color.l, "%");
439
+ return SASS_MEMORY_NEW(Number, pstate, hsl_color.l, "%");
457
440
  }
458
441
 
459
442
  Signature adjust_hue_sig = "adjust-hue($color, $degrees)";
460
443
  BUILT_IN(adjust_hue)
461
444
  {
462
- Color* rgb_color = ARG("$color", Color);
463
- Number* degrees = ARG("$degrees", Number);
445
+ Color_Ptr rgb_color = ARG("$color", Color);
446
+ Number_Ptr degrees = ARG("$degrees", Number);
464
447
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
465
448
  rgb_color->g(),
466
449
  rgb_color->b());
@@ -475,8 +458,8 @@ namespace Sass {
475
458
  Signature lighten_sig = "lighten($color, $amount)";
476
459
  BUILT_IN(lighten)
477
460
  {
478
- Color* rgb_color = ARG("$color", Color);
479
- Number* amount = ARGR("$amount", Number, 0, 100);
461
+ Color_Ptr rgb_color = ARG("$color", Color);
462
+ Number_Ptr amount = ARGR("$amount", Number, 0, 100);
480
463
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
481
464
  rgb_color->g(),
482
465
  rgb_color->b());
@@ -497,8 +480,8 @@ namespace Sass {
497
480
  Signature darken_sig = "darken($color, $amount)";
498
481
  BUILT_IN(darken)
499
482
  {
500
- Color* rgb_color = ARG("$color", Color);
501
- Number* amount = ARGR("$amount", Number, 0, 100);
483
+ Color_Ptr rgb_color = ARG("$color", Color);
484
+ Number_Ptr amount = ARGR("$amount", Number, 0, 100);
502
485
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
503
486
  rgb_color->g(),
504
487
  rgb_color->b());
@@ -521,13 +504,13 @@ namespace Sass {
521
504
  BUILT_IN(saturate)
522
505
  {
523
506
  // CSS3 filter function overload: pass literal through directly
524
- Number* amount = dynamic_cast<Number*>(env["$amount"]);
507
+ Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$amount"]);
525
508
  if (!amount) {
526
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "saturate(" + env["$color"]->to_string(ctx.c_options) + ")");
509
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "saturate(" + env["$color"]->to_string(ctx.c_options) + ")");
527
510
  }
528
511
 
529
512
  ARGR("$amount", Number, 0, 100);
530
- Color* rgb_color = ARG("$color", Color);
513
+ Color_Ptr rgb_color = ARG("$color", Color);
531
514
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
532
515
  rgb_color->g(),
533
516
  rgb_color->b());
@@ -553,8 +536,8 @@ namespace Sass {
553
536
  Signature desaturate_sig = "desaturate($color, $amount)";
554
537
  BUILT_IN(desaturate)
555
538
  {
556
- Color* rgb_color = ARG("$color", Color);
557
- Number* amount = ARGR("$amount", Number, 0, 100);
539
+ Color_Ptr rgb_color = ARG("$color", Color);
540
+ Number_Ptr amount = ARGR("$amount", Number, 0, 100);
558
541
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
559
542
  rgb_color->g(),
560
543
  rgb_color->b());
@@ -581,12 +564,12 @@ namespace Sass {
581
564
  BUILT_IN(grayscale)
582
565
  {
583
566
  // CSS3 filter function overload: pass literal through directly
584
- Number* amount = dynamic_cast<Number*>(env["$color"]);
567
+ Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$color"]);
585
568
  if (amount) {
586
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "grayscale(" + amount->to_string(ctx.c_options) + ")");
569
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "grayscale(" + amount->to_string(ctx.c_options) + ")");
587
570
  }
588
571
 
589
- Color* rgb_color = ARG("$color", Color);
572
+ Color_Ptr rgb_color = ARG("$color", Color);
590
573
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
591
574
  rgb_color->g(),
592
575
  rgb_color->b());
@@ -601,7 +584,7 @@ namespace Sass {
601
584
  Signature complement_sig = "complement($color)";
602
585
  BUILT_IN(complement)
603
586
  {
604
- Color* rgb_color = ARG("$color", Color);
587
+ Color_Ptr rgb_color = ARG("$color", Color);
605
588
  HSL hsl_color = rgb_to_hsl(rgb_color->r(),
606
589
  rgb_color->g(),
607
590
  rgb_color->b());
@@ -617,13 +600,13 @@ namespace Sass {
617
600
  BUILT_IN(invert)
618
601
  {
619
602
  // CSS3 filter function overload: pass literal through directly
620
- Number* amount = dynamic_cast<Number*>(env["$color"]);
603
+ Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$color"]);
621
604
  if (amount) {
622
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
605
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
623
606
  }
624
607
 
625
- Color* rgb_color = ARG("$color", Color);
626
- return SASS_MEMORY_NEW(ctx.mem, Color,
608
+ Color_Ptr rgb_color = ARG("$color", Color);
609
+ return SASS_MEMORY_NEW(Color,
627
610
  pstate,
628
611
  255 - rgb_color->r(),
629
612
  255 - rgb_color->g(),
@@ -638,28 +621,28 @@ namespace Sass {
638
621
  Signature opacity_sig = "opacity($color)";
639
622
  BUILT_IN(alpha)
640
623
  {
641
- String_Constant* ie_kwd = dynamic_cast<String_Constant*>(env["$color"]);
624
+ String_Constant_Ptr ie_kwd = SASS_MEMORY_CAST(String_Constant, env["$color"]);
642
625
  if (ie_kwd) {
643
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "alpha(" + ie_kwd->value() + ")");
626
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "alpha(" + ie_kwd->value() + ")");
644
627
  }
645
628
 
646
629
  // CSS3 filter function overload: pass literal through directly
647
- Number* amount = dynamic_cast<Number*>(env["$color"]);
630
+ Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$color"]);
648
631
  if (amount) {
649
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "opacity(" + amount->to_string(ctx.c_options) + ")");
632
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "opacity(" + amount->to_string(ctx.c_options) + ")");
650
633
  }
651
634
 
652
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->a());
635
+ return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->a());
653
636
  }
654
637
 
655
638
  Signature opacify_sig = "opacify($color, $amount)";
656
639
  Signature fade_in_sig = "fade-in($color, $amount)";
657
640
  BUILT_IN(opacify)
658
641
  {
659
- Color* color = ARG("$color", Color);
642
+ Color_Ptr color = ARG("$color", Color);
660
643
  double amount = ARGR("$amount", Number, 0, 1)->value();
661
644
  double alpha = std::min(color->a() + amount, 1.0);
662
- return SASS_MEMORY_NEW(ctx.mem, Color,
645
+ return SASS_MEMORY_NEW(Color,
663
646
  pstate,
664
647
  color->r(),
665
648
  color->g(),
@@ -671,10 +654,10 @@ namespace Sass {
671
654
  Signature fade_out_sig = "fade-out($color, $amount)";
672
655
  BUILT_IN(transparentize)
673
656
  {
674
- Color* color = ARG("$color", Color);
657
+ Color_Ptr color = ARG("$color", Color);
675
658
  double amount = ARGR("$amount", Number, 0, 1)->value();
676
659
  double alpha = std::max(color->a() - amount, 0.0);
677
- return SASS_MEMORY_NEW(ctx.mem, Color,
660
+ return SASS_MEMORY_NEW(Color,
678
661
  pstate,
679
662
  color->r(),
680
663
  color->g(),
@@ -689,27 +672,27 @@ namespace Sass {
689
672
  Signature adjust_color_sig = "adjust-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)";
690
673
  BUILT_IN(adjust_color)
691
674
  {
692
- Color* color = ARG("$color", Color);
693
- Number* r = dynamic_cast<Number*>(env["$red"]);
694
- Number* g = dynamic_cast<Number*>(env["$green"]);
695
- Number* b = dynamic_cast<Number*>(env["$blue"]);
696
- Number* h = dynamic_cast<Number*>(env["$hue"]);
697
- Number* s = dynamic_cast<Number*>(env["$saturation"]);
698
- Number* l = dynamic_cast<Number*>(env["$lightness"]);
699
- Number* a = dynamic_cast<Number*>(env["$alpha"]);
675
+ Color_Ptr color = ARG("$color", Color);
676
+ Number_Ptr r = SASS_MEMORY_CAST(Number, env["$red"]);
677
+ Number_Ptr g = SASS_MEMORY_CAST(Number, env["$green"]);
678
+ Number_Ptr b = SASS_MEMORY_CAST(Number, env["$blue"]);
679
+ Number_Ptr h = SASS_MEMORY_CAST(Number, env["$hue"]);
680
+ Number_Ptr s = SASS_MEMORY_CAST(Number, env["$saturation"]);
681
+ Number_Ptr l = SASS_MEMORY_CAST(Number, env["$lightness"]);
682
+ Number_Ptr a = SASS_MEMORY_CAST(Number, env["$alpha"]);
700
683
 
701
684
  bool rgb = r || g || b;
702
685
  bool hsl = h || s || l;
703
686
 
704
687
  if (rgb && hsl) {
705
- error("cannot specify both RGB and HSL values for `adjust-color`", pstate);
688
+ error("Cannot specify HSL and RGB values for a color at the same time for `adjust-color'", pstate);
706
689
  }
707
690
  if (rgb) {
708
691
  double rr = r ? ARGR("$red", Number, -255, 255)->value() : 0;
709
692
  double gg = g ? ARGR("$green", Number, -255, 255)->value() : 0;
710
693
  double bb = b ? ARGR("$blue", Number, -255, 255)->value() : 0;
711
694
  double aa = a ? ARGR("$alpha", Number, -1, 1)->value() : 0;
712
- return SASS_MEMORY_NEW(ctx.mem, Color,
695
+ return SASS_MEMORY_NEW(Color,
713
696
  pstate,
714
697
  color->r() + rr,
715
698
  color->g() + gg,
@@ -729,14 +712,14 @@ namespace Sass {
729
712
  pstate);
730
713
  }
731
714
  if (a) {
732
- return SASS_MEMORY_NEW(ctx.mem, Color,
715
+ return SASS_MEMORY_NEW(Color,
733
716
  pstate,
734
717
  color->r(),
735
718
  color->g(),
736
719
  color->b(),
737
720
  color->a() + (a ? a->value() : 0));
738
721
  }
739
- error("not enough arguments for `adjust-color`", pstate);
722
+ error("not enough arguments for `adjust-color'", pstate);
740
723
  // unreachable
741
724
  return color;
742
725
  }
@@ -744,27 +727,27 @@ namespace Sass {
744
727
  Signature scale_color_sig = "scale-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)";
745
728
  BUILT_IN(scale_color)
746
729
  {
747
- Color* color = ARG("$color", Color);
748
- Number* r = dynamic_cast<Number*>(env["$red"]);
749
- Number* g = dynamic_cast<Number*>(env["$green"]);
750
- Number* b = dynamic_cast<Number*>(env["$blue"]);
751
- Number* h = dynamic_cast<Number*>(env["$hue"]);
752
- Number* s = dynamic_cast<Number*>(env["$saturation"]);
753
- Number* l = dynamic_cast<Number*>(env["$lightness"]);
754
- Number* a = dynamic_cast<Number*>(env["$alpha"]);
730
+ Color_Ptr color = ARG("$color", Color);
731
+ Number_Ptr r = SASS_MEMORY_CAST(Number, env["$red"]);
732
+ Number_Ptr g = SASS_MEMORY_CAST(Number, env["$green"]);
733
+ Number_Ptr b = SASS_MEMORY_CAST(Number, env["$blue"]);
734
+ Number_Ptr h = SASS_MEMORY_CAST(Number, env["$hue"]);
735
+ Number_Ptr s = SASS_MEMORY_CAST(Number, env["$saturation"]);
736
+ Number_Ptr l = SASS_MEMORY_CAST(Number, env["$lightness"]);
737
+ Number_Ptr a = SASS_MEMORY_CAST(Number, env["$alpha"]);
755
738
 
756
739
  bool rgb = r || g || b;
757
740
  bool hsl = h || s || l;
758
741
 
759
742
  if (rgb && hsl) {
760
- error("cannot specify both RGB and HSL values for `scale-color`", pstate);
743
+ error("Cannot specify HSL and RGB values for a color at the same time for `scale-color'", pstate);
761
744
  }
762
745
  if (rgb) {
763
746
  double rscale = (r ? ARGR("$red", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
764
747
  double gscale = (g ? ARGR("$green", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
765
748
  double bscale = (b ? ARGR("$blue", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
766
749
  double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
767
- return SASS_MEMORY_NEW(ctx.mem, Color,
750
+ return SASS_MEMORY_NEW(Color,
768
751
  pstate,
769
752
  color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),
770
753
  color->g() + gscale * (gscale > 0.0 ? 255 - color->g() : color->g()),
@@ -785,14 +768,14 @@ namespace Sass {
785
768
  }
786
769
  if (a) {
787
770
  double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
788
- return SASS_MEMORY_NEW(ctx.mem, Color,
771
+ return SASS_MEMORY_NEW(Color,
789
772
  pstate,
790
773
  color->r(),
791
774
  color->g(),
792
775
  color->b(),
793
776
  color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
794
777
  }
795
- error("not enough arguments for `scale-color`", pstate);
778
+ error("not enough arguments for `scale-color'", pstate);
796
779
  // unreachable
797
780
  return color;
798
781
  }
@@ -800,23 +783,23 @@ namespace Sass {
800
783
  Signature change_color_sig = "change-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)";
801
784
  BUILT_IN(change_color)
802
785
  {
803
- Color* color = ARG("$color", Color);
804
- Number* r = dynamic_cast<Number*>(env["$red"]);
805
- Number* g = dynamic_cast<Number*>(env["$green"]);
806
- Number* b = dynamic_cast<Number*>(env["$blue"]);
807
- Number* h = dynamic_cast<Number*>(env["$hue"]);
808
- Number* s = dynamic_cast<Number*>(env["$saturation"]);
809
- Number* l = dynamic_cast<Number*>(env["$lightness"]);
810
- Number* a = dynamic_cast<Number*>(env["$alpha"]);
786
+ Color_Ptr color = ARG("$color", Color);
787
+ Number_Ptr r = SASS_MEMORY_CAST(Number, env["$red"]);
788
+ Number_Ptr g = SASS_MEMORY_CAST(Number, env["$green"]);
789
+ Number_Ptr b = SASS_MEMORY_CAST(Number, env["$blue"]);
790
+ Number_Ptr h = SASS_MEMORY_CAST(Number, env["$hue"]);
791
+ Number_Ptr s = SASS_MEMORY_CAST(Number, env["$saturation"]);
792
+ Number_Ptr l = SASS_MEMORY_CAST(Number, env["$lightness"]);
793
+ Number_Ptr a = SASS_MEMORY_CAST(Number, env["$alpha"]);
811
794
 
812
795
  bool rgb = r || g || b;
813
796
  bool hsl = h || s || l;
814
797
 
815
798
  if (rgb && hsl) {
816
- error("cannot specify both RGB and HSL values for `change-color`", pstate);
799
+ error("Cannot specify HSL and RGB values for a color at the same time for `change-color'", pstate);
817
800
  }
818
801
  if (rgb) {
819
- return SASS_MEMORY_NEW(ctx.mem, Color,
802
+ return SASS_MEMORY_NEW(Color,
820
803
  pstate,
821
804
  r ? ARGR("$red", Number, 0, 255)->value() : color->r(),
822
805
  g ? ARGR("$green", Number, 0, 255)->value() : color->g(),
@@ -833,14 +816,14 @@ namespace Sass {
833
816
  }
834
817
  if (a) {
835
818
  double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
836
- return SASS_MEMORY_NEW(ctx.mem, Color,
819
+ return SASS_MEMORY_NEW(Color,
837
820
  pstate,
838
821
  color->r(),
839
822
  color->g(),
840
823
  color->b(),
841
824
  alpha);
842
825
  }
843
- error("not enough arguments for `change-color`", pstate);
826
+ error("not enough arguments for `change-color'", pstate);
844
827
  // unreachable
845
828
  return color;
846
829
  }
@@ -855,7 +838,7 @@ namespace Sass {
855
838
  Signature ie_hex_str_sig = "ie-hex-str($color)";
856
839
  BUILT_IN(ie_hex_str)
857
840
  {
858
- Color* c = ARG("$color", Color);
841
+ Color_Ptr c = ARG("$color", Color);
859
842
  double r = cap_channel<0xff>(c->r());
860
843
  double g = cap_channel<0xff>(c->g());
861
844
  double b = cap_channel<0xff>(c->b());
@@ -872,7 +855,7 @@ namespace Sass {
872
855
  for (size_t i = 0, L = result.length(); i < L; ++i) {
873
856
  result[i] = std::toupper(result[i]);
874
857
  }
875
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, result);
858
+ return SASS_MEMORY_NEW(String_Quoted, pstate, result);
876
859
  }
877
860
 
878
861
  ///////////////////
@@ -882,40 +865,40 @@ namespace Sass {
882
865
  Signature unquote_sig = "unquote($string)";
883
866
  BUILT_IN(sass_unquote)
884
867
  {
885
- AST_Node* arg = env["$string"];
886
- if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
887
- String_Constant* result = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, string_quoted->value());
868
+ AST_Node_Obj arg = env["$string"];
869
+ if (String_Quoted_Ptr string_quoted = SASS_MEMORY_CAST(String_Quoted, arg)) {
870
+ String_Constant_Ptr result = SASS_MEMORY_NEW(String_Constant, pstate, string_quoted->value());
888
871
  // remember if the string was quoted (color tokens)
889
872
  result->is_delayed(true); // delay colors
890
873
  return result;
891
874
  }
892
- else if (dynamic_cast<String_Constant*>(arg)) {
893
- return (Expression*) arg;
875
+ else if (SASS_MEMORY_CAST(String_Constant, arg)) {
876
+ return (Expression_Ptr) &arg;
894
877
  }
895
878
  else {
896
879
  Sass_Output_Style oldstyle = ctx.c_options.output_style;
897
880
  ctx.c_options.output_style = SASS_STYLE_NESTED;
898
881
  std::string val(arg->to_string(ctx.c_options));
899
- val = dynamic_cast<Null*>(arg) ? "null" : val;
882
+ val = SASS_MEMORY_CAST(Null, arg) ? "null" : val;
900
883
  ctx.c_options.output_style = oldstyle;
901
884
 
902
885
  deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
903
- return (Expression*) arg;
886
+ return (Expression_Ptr) &arg;
904
887
  }
905
888
  }
906
889
 
907
890
  Signature quote_sig = "quote($string)";
908
891
  BUILT_IN(sass_quote)
909
892
  {
910
- AST_Node* arg = env["$string"];
893
+ AST_Node_Obj arg = env["$string"];
911
894
  // only set quote mark to true if already a string
912
- if (String_Quoted* qstr = dynamic_cast<String_Quoted*>(arg)) {
895
+ if (String_Quoted_Ptr qstr = SASS_MEMORY_CAST(String_Quoted, arg)) {
913
896
  qstr->quote_mark('*');
914
897
  return qstr;
915
898
  }
916
899
  // all other nodes must be converted to a string node
917
900
  std::string str(quote(arg->to_string(ctx.c_options), String_Constant::double_quote()));
918
- String_Quoted* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
901
+ String_Quoted_Ptr result = SASS_MEMORY_NEW(String_Quoted, pstate, str);
919
902
  result->quote_mark('*');
920
903
  return result;
921
904
  }
@@ -926,7 +909,7 @@ namespace Sass {
926
909
  {
927
910
  size_t len = std::string::npos;
928
911
  try {
929
- String_Constant* s = ARG("$string", String_Constant);
912
+ String_Constant_Ptr s = ARG("$string", String_Constant);
930
913
  len = UTF_8::code_point_count(s->value(), 0, s->value().size());
931
914
 
932
915
  }
@@ -934,7 +917,7 @@ namespace Sass {
934
917
  // other errors will be re-thrown
935
918
  catch (...) { handle_utf8_error(pstate, backtrace); }
936
919
  // return something even if we had an error (-1)
937
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)len);
920
+ return SASS_MEMORY_NEW(Number, pstate, (double)len);
938
921
  }
939
922
 
940
923
  Signature str_insert_sig = "str-insert($string, $insert, $index)";
@@ -942,13 +925,13 @@ namespace Sass {
942
925
  {
943
926
  std::string str;
944
927
  try {
945
- String_Constant* s = ARG("$string", String_Constant);
928
+ String_Constant_Ptr s = ARG("$string", String_Constant);
946
929
  str = s->value();
947
930
  str = unquote(str);
948
- String_Constant* i = ARG("$insert", String_Constant);
931
+ String_Constant_Ptr i = ARG("$insert", String_Constant);
949
932
  std::string ins = i->value();
950
933
  ins = unquote(ins);
951
- Number* ind = ARG("$index", Number);
934
+ Number_Ptr ind = ARG("$index", Number);
952
935
  double index = ind->value();
953
936
  size_t len = UTF_8::code_point_count(str, 0, str.size());
954
937
 
@@ -973,14 +956,14 @@ namespace Sass {
973
956
  str = ins + str;
974
957
  }
975
958
 
976
- if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
959
+ if (String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s)) {
977
960
  if (ss->quote_mark()) str = quote(str);
978
961
  }
979
962
  }
980
963
  // handle any invalid utf8 errors
981
964
  // other errors will be re-thrown
982
965
  catch (...) { handle_utf8_error(pstate, backtrace); }
983
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
966
+ return SASS_MEMORY_NEW(String_Quoted, pstate, str);
984
967
  }
985
968
 
986
969
  Signature str_index_sig = "str-index($string, $substring)";
@@ -988,8 +971,8 @@ namespace Sass {
988
971
  {
989
972
  size_t index = std::string::npos;
990
973
  try {
991
- String_Constant* s = ARG("$string", String_Constant);
992
- String_Constant* t = ARG("$substring", String_Constant);
974
+ String_Constant_Ptr s = ARG("$string", String_Constant);
975
+ String_Constant_Ptr t = ARG("$substring", String_Constant);
993
976
  std::string str = s->value();
994
977
  str = unquote(str);
995
978
  std::string substr = t->value();
@@ -997,7 +980,7 @@ namespace Sass {
997
980
 
998
981
  size_t c_index = str.find(substr);
999
982
  if(c_index == std::string::npos) {
1000
- return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
983
+ return SASS_MEMORY_NEW(Null, pstate);
1001
984
  }
1002
985
  index = UTF_8::code_point_count(str, 0, c_index) + 1;
1003
986
  }
@@ -1005,7 +988,7 @@ namespace Sass {
1005
988
  // other errors will be re-thrown
1006
989
  catch (...) { handle_utf8_error(pstate, backtrace); }
1007
990
  // return something even if we had an error (-1)
1008
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)index);
991
+ return SASS_MEMORY_NEW(Number, pstate, (double)index);
1009
992
  }
1010
993
 
1011
994
  Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
@@ -1013,22 +996,22 @@ namespace Sass {
1013
996
  {
1014
997
  std::string newstr;
1015
998
  try {
1016
- String_Constant* s = ARG("$string", String_Constant);
999
+ String_Constant_Ptr s = ARG("$string", String_Constant);
1017
1000
  double start_at = ARG("$start-at", Number)->value();
1018
1001
  double end_at = ARG("$end-at", Number)->value();
1019
- String_Quoted* ss = dynamic_cast<String_Quoted*>(s);
1002
+ String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s);
1020
1003
 
1021
1004
  std::string str = unquote(s->value());
1022
1005
 
1023
1006
  size_t size = utf8::distance(str.begin(), str.end());
1024
1007
 
1025
- if (!dynamic_cast<Number*>(env["$end-at"])) {
1008
+ if (!SASS_MEMORY_CAST(Number, env["$end-at"])) {
1026
1009
  end_at = -1;
1027
1010
  }
1028
1011
 
1029
1012
  if (end_at == 0 || (end_at + size) < 0) {
1030
1013
  if (ss && ss->quote_mark()) newstr = quote("");
1031
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, newstr);
1014
+ return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
1032
1015
  }
1033
1016
 
1034
1017
  if (end_at < 0) {
@@ -1050,20 +1033,20 @@ namespace Sass {
1050
1033
  utf8::advance(end, end_at - start_at + 1, str.end());
1051
1034
  newstr = std::string(start, end);
1052
1035
  }
1053
- if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
1036
+ if (ss) {
1054
1037
  if(ss->quote_mark()) newstr = quote(newstr);
1055
1038
  }
1056
1039
  }
1057
1040
  // handle any invalid utf8 errors
1058
1041
  // other errors will be re-thrown
1059
1042
  catch (...) { handle_utf8_error(pstate, backtrace); }
1060
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, newstr);
1043
+ return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
1061
1044
  }
1062
1045
 
1063
1046
  Signature to_upper_case_sig = "to-upper-case($string)";
1064
1047
  BUILT_IN(to_upper_case)
1065
1048
  {
1066
- String_Constant* s = ARG("$string", String_Constant);
1049
+ String_Constant_Ptr s = ARG("$string", String_Constant);
1067
1050
  std::string str = s->value();
1068
1051
 
1069
1052
  for (size_t i = 0, L = str.length(); i < L; ++i) {
@@ -1072,19 +1055,19 @@ namespace Sass {
1072
1055
  }
1073
1056
  }
1074
1057
 
1075
- if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
1076
- String_Quoted* cpy = SASS_MEMORY_NEW(ctx.mem, String_Quoted, *ss);
1058
+ if (String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s)) {
1059
+ String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);
1077
1060
  cpy->value(str);
1078
1061
  return cpy;
1079
1062
  } else {
1080
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
1063
+ return SASS_MEMORY_NEW(String_Quoted, pstate, str);
1081
1064
  }
1082
1065
  }
1083
1066
 
1084
1067
  Signature to_lower_case_sig = "to-lower-case($string)";
1085
1068
  BUILT_IN(to_lower_case)
1086
1069
  {
1087
- String_Constant* s = ARG("$string", String_Constant);
1070
+ String_Constant_Ptr s = ARG("$string", String_Constant);
1088
1071
  std::string str = s->value();
1089
1072
 
1090
1073
  for (size_t i = 0, L = str.length(); i < L; ++i) {
@@ -1093,12 +1076,12 @@ namespace Sass {
1093
1076
  }
1094
1077
  }
1095
1078
 
1096
- if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
1097
- String_Quoted* cpy = SASS_MEMORY_NEW(ctx.mem, String_Quoted, *ss);
1079
+ if (String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s)) {
1080
+ String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);
1098
1081
  cpy->value(str);
1099
1082
  return cpy;
1100
1083
  } else {
1101
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
1084
+ return SASS_MEMORY_NEW(String_Quoted, pstate, str);
1102
1085
  }
1103
1086
  }
1104
1087
 
@@ -1109,16 +1092,16 @@ namespace Sass {
1109
1092
  Signature percentage_sig = "percentage($number)";
1110
1093
  BUILT_IN(percentage)
1111
1094
  {
1112
- Number* n = ARG("$number", Number);
1095
+ Number_Ptr n = ARG("$number", Number);
1113
1096
  if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate);
1114
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, n->value() * 100, "%");
1097
+ return SASS_MEMORY_NEW(Number, pstate, n->value() * 100, "%");
1115
1098
  }
1116
1099
 
1117
1100
  Signature round_sig = "round($number)";
1118
1101
  BUILT_IN(round)
1119
1102
  {
1120
- Number* n = ARG("$number", Number);
1121
- Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
1103
+ Number_Ptr n = ARG("$number", Number);
1104
+ Number_Ptr r = SASS_MEMORY_COPY(n);
1122
1105
  r->pstate(pstate);
1123
1106
  r->value(Sass::round(r->value(), ctx.c_options.precision));
1124
1107
  return r;
@@ -1127,8 +1110,8 @@ namespace Sass {
1127
1110
  Signature ceil_sig = "ceil($number)";
1128
1111
  BUILT_IN(ceil)
1129
1112
  {
1130
- Number* n = ARG("$number", Number);
1131
- Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
1113
+ Number_Ptr n = ARG("$number", Number);
1114
+ Number_Ptr r = SASS_MEMORY_COPY(n);
1132
1115
  r->pstate(pstate);
1133
1116
  r->value(std::ceil(r->value()));
1134
1117
  return r;
@@ -1137,8 +1120,8 @@ namespace Sass {
1137
1120
  Signature floor_sig = "floor($number)";
1138
1121
  BUILT_IN(floor)
1139
1122
  {
1140
- Number* n = ARG("$number", Number);
1141
- Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
1123
+ Number_Ptr n = ARG("$number", Number);
1124
+ Number_Ptr r = SASS_MEMORY_COPY(n);
1142
1125
  r->pstate(pstate);
1143
1126
  r->value(std::floor(r->value()));
1144
1127
  return r;
@@ -1147,8 +1130,8 @@ namespace Sass {
1147
1130
  Signature abs_sig = "abs($number)";
1148
1131
  BUILT_IN(abs)
1149
1132
  {
1150
- Number* n = ARG("$number", Number);
1151
- Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
1133
+ Number_Ptr n = ARG("$number", Number);
1134
+ Number_Ptr r = SASS_MEMORY_COPY(n);
1152
1135
  r->pstate(pstate);
1153
1136
  r->value(std::abs(r->value()));
1154
1137
  return r;
@@ -1157,11 +1140,11 @@ namespace Sass {
1157
1140
  Signature min_sig = "min($numbers...)";
1158
1141
  BUILT_IN(min)
1159
1142
  {
1160
- List* arglist = ARG("$numbers", List);
1161
- Number* least = 0;
1143
+ List_Ptr arglist = ARG("$numbers", List);
1144
+ Number_Obj least = NULL;
1162
1145
  for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1163
- Expression* val = arglist->value_at_index(i);
1164
- Number* xi = dynamic_cast<Number*>(val);
1146
+ Expression_Obj val = arglist->value_at_index(i);
1147
+ Number_Obj xi = SASS_MEMORY_CAST(Number, val);
1165
1148
  if (!xi) {
1166
1149
  error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate);
1167
1150
  }
@@ -1169,17 +1152,17 @@ namespace Sass {
1169
1152
  if (*xi < *least) least = xi;
1170
1153
  } else least = xi;
1171
1154
  }
1172
- return least;
1155
+ return least.detach();
1173
1156
  }
1174
1157
 
1175
1158
  Signature max_sig = "max($numbers...)";
1176
1159
  BUILT_IN(max)
1177
1160
  {
1178
- List* arglist = ARG("$numbers", List);
1179
- Number* greatest = 0;
1161
+ List_Ptr arglist = ARG("$numbers", List);
1162
+ Number_Obj greatest = NULL;
1180
1163
  for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1181
- Expression* val = arglist->value_at_index(i);
1182
- Number* xi = dynamic_cast<Number*>(val);
1164
+ Expression_Obj val = arglist->value_at_index(i);
1165
+ Number_Obj xi = SASS_MEMORY_CAST(Number, val);
1183
1166
  if (!xi) {
1184
1167
  error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate);
1185
1168
  }
@@ -1187,37 +1170,37 @@ namespace Sass {
1187
1170
  if (*greatest < *xi) greatest = xi;
1188
1171
  } else greatest = xi;
1189
1172
  }
1190
- return greatest;
1173
+ return greatest.detach();
1191
1174
  }
1192
1175
 
1193
1176
  Signature random_sig = "random($limit:false)";
1194
1177
  BUILT_IN(random)
1195
1178
  {
1196
- AST_Node* arg = env["$limit"];
1197
- Value* v = dynamic_cast<Value*>(arg);
1198
- Number* l = dynamic_cast<Number*>(arg);
1199
- Boolean* b = dynamic_cast<Boolean*>(arg);
1179
+ AST_Node_Obj arg = env["$limit"];
1180
+ Value_Ptr v = SASS_MEMORY_CAST(Value, arg);
1181
+ Number_Ptr l = SASS_MEMORY_CAST(Number, arg);
1182
+ Boolean_Ptr b = SASS_MEMORY_CAST(Boolean, arg);
1200
1183
  if (l) {
1201
1184
  double v = l->value();
1202
1185
  if (v < 1) {
1203
1186
  stringstream err;
1204
- err << "$limit " << v << " must be greater than or equal to 1 for `random`";
1187
+ err << "$limit " << v << " must be greater than or equal to 1 for `random'";
1205
1188
  error(err.str(), pstate);
1206
1189
  }
1207
1190
  bool eq_int = std::fabs(trunc(v) - v) < NUMBER_EPSILON;
1208
1191
  if (!eq_int) {
1209
1192
  stringstream err;
1210
- err << "Expected $limit to be an integer but got `" << v << "` for `random`";
1193
+ err << "Expected $limit to be an integer but got " << v << " for `random'";
1211
1194
  error(err.str(), pstate);
1212
1195
  }
1213
1196
  std::uniform_real_distribution<> distributor(1, v + 1);
1214
1197
  uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
1215
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)distributed);
1198
+ return SASS_MEMORY_NEW(Number, pstate, (double)distributed);
1216
1199
  }
1217
1200
  else if (b) {
1218
1201
  std::uniform_real_distribution<> distributor(0, 1);
1219
1202
  double distributed = static_cast<double>(distributor(rand));
1220
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, distributed);
1203
+ return SASS_MEMORY_NEW(Number, pstate, distributed);
1221
1204
  } else if (v) {
1222
1205
  throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number", v);
1223
1206
  } else {
@@ -1233,26 +1216,26 @@ namespace Sass {
1233
1216
  Signature length_sig = "length($list)";
1234
1217
  BUILT_IN(length)
1235
1218
  {
1236
- if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(env["$list"])) {
1237
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)sl->length());
1219
+ if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, env["$list"])) {
1220
+ return SASS_MEMORY_NEW(Number, pstate, (double)sl->length());
1238
1221
  }
1239
- Expression* v = ARG("$list", Expression);
1222
+ Expression_Ptr v = ARG("$list", Expression);
1240
1223
  if (v->concrete_type() == Expression::MAP) {
1241
- Map* map = dynamic_cast<Map*>(env["$list"]);
1242
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)(map ? map->length() : 1));
1224
+ Map_Ptr map = SASS_MEMORY_CAST(Map, env["$list"]);
1225
+ return SASS_MEMORY_NEW(Number, pstate, (double)(map ? map->length() : 1));
1243
1226
  }
1244
1227
  if (v->concrete_type() == Expression::SELECTOR) {
1245
- if (SimpleSequence_Selector* h = dynamic_cast<SimpleSequence_Selector*>(v)) {
1246
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)h->length());
1247
- } else if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(v)) {
1248
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)ls->length());
1228
+ if (Compound_Selector_Ptr h = dynamic_cast<Compound_Selector_Ptr>(v)) {
1229
+ return SASS_MEMORY_NEW(Number, pstate, (double)h->length());
1230
+ } else if (Selector_List_Ptr ls = SASS_MEMORY_CAST_PTR(Selector_List, v)) {
1231
+ return SASS_MEMORY_NEW(Number, pstate, (double)ls->length());
1249
1232
  } else {
1250
- return SASS_MEMORY_NEW(ctx.mem, Number, pstate, 1);
1233
+ return SASS_MEMORY_NEW(Number, pstate, 1);
1251
1234
  }
1252
1235
  }
1253
1236
 
1254
- List* list = dynamic_cast<List*>(env["$list"]);
1255
- return SASS_MEMORY_NEW(ctx.mem, Number,
1237
+ List_Ptr list = SASS_MEMORY_CAST(List, env["$list"]);
1238
+ return SASS_MEMORY_NEW(Number,
1256
1239
  pstate,
1257
1240
  (double)(list ? list->size() : 1));
1258
1241
  }
@@ -1260,24 +1243,24 @@ namespace Sass {
1260
1243
  Signature nth_sig = "nth($list, $n)";
1261
1244
  BUILT_IN(nth)
1262
1245
  {
1263
- Number* n = ARG("$n", Number);
1264
- Map* m = dynamic_cast<Map*>(env["$list"]);
1265
- if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(env["$list"])) {
1246
+ Number_Ptr n = ARG("$n", Number);
1247
+ Map_Ptr m = SASS_MEMORY_CAST(Map, env["$list"]);
1248
+ if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, env["$list"])) {
1266
1249
  size_t len = m ? m->length() : sl->length();
1267
1250
  bool empty = m ? m->empty() : sl->empty();
1268
1251
  if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
1269
1252
  double index = std::floor(n->value() < 0 ? len + n->value() : n->value() - 1);
1270
1253
  if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
1271
1254
  // return (*sl)[static_cast<int>(index)];
1272
- Listize listize(ctx.mem);
1255
+ Listize listize;
1273
1256
  return (*sl)[static_cast<int>(index)]->perform(&listize);
1274
1257
  }
1275
- List* l = dynamic_cast<List*>(env["$list"]);
1258
+ List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
1276
1259
  if (n->value() == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate);
1277
1260
  // if the argument isn't a list, then wrap it in a singleton list
1278
1261
  if (!m && !l) {
1279
- l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1280
- *l << ARG("$list", Expression);
1262
+ l = SASS_MEMORY_NEW(List, pstate, 1);
1263
+ l->append(ARG("$list", Expression));
1281
1264
  }
1282
1265
  size_t len = m ? m->length() : l->length();
1283
1266
  bool empty = m ? m->empty() : l->empty();
@@ -1286,28 +1269,28 @@ namespace Sass {
1286
1269
  if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
1287
1270
 
1288
1271
  if (m) {
1289
- l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1290
- *l << m->keys()[static_cast<unsigned int>(index)];
1291
- *l << m->at(m->keys()[static_cast<unsigned int>(index)]);
1292
- return l;
1272
+ l = SASS_MEMORY_NEW(List, pstate, 1);
1273
+ l->append(m->keys()[static_cast<unsigned int>(index)]);
1274
+ l->append(m->at(m->keys()[static_cast<unsigned int>(index)]));
1275
+ return l.detach();
1293
1276
  }
1294
1277
  else {
1295
- Expression* rv = l->value_at_index(static_cast<int>(index));
1278
+ Expression_Obj rv = l->value_at_index(static_cast<int>(index));
1296
1279
  rv->set_delayed(false);
1297
- return rv;
1280
+ return rv.detach();
1298
1281
  }
1299
1282
  }
1300
1283
 
1301
1284
  Signature set_nth_sig = "set-nth($list, $n, $value)";
1302
1285
  BUILT_IN(set_nth)
1303
1286
  {
1304
- Map* m = dynamic_cast<Map*>(env["$list"]);
1305
- List* l = dynamic_cast<List*>(env["$list"]);
1306
- Number* n = ARG("$n", Number);
1307
- Expression* v = ARG("$value", Expression);
1287
+ Map_Obj m = SASS_MEMORY_CAST(Map, env["$list"]);
1288
+ List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
1289
+ Number_Obj n = ARG("$n", Number);
1290
+ Expression_Obj v = ARG("$value", Expression);
1308
1291
  if (!l) {
1309
- l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1310
- *l << ARG("$list", Expression);
1292
+ l = SASS_MEMORY_NEW(List, pstate, 1);
1293
+ l->append(ARG("$list", Expression));
1311
1294
  }
1312
1295
  if (m) {
1313
1296
  l = m->to_list(ctx, pstate);
@@ -1315,9 +1298,9 @@ namespace Sass {
1315
1298
  if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
1316
1299
  double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
1317
1300
  if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
1318
- List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, l->length(), l->separator());
1301
+ List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator());
1319
1302
  for (size_t i = 0, L = l->length(); i < L; ++i) {
1320
- *result << ((i == index) ? v : (*l)[i]);
1303
+ result->append(((i == index) ? v : (*l)[i]));
1321
1304
  }
1322
1305
  return result;
1323
1306
  }
@@ -1325,39 +1308,39 @@ namespace Sass {
1325
1308
  Signature index_sig = "index($list, $value)";
1326
1309
  BUILT_IN(index)
1327
1310
  {
1328
- Map* m = dynamic_cast<Map*>(env["$list"]);
1329
- List* l = dynamic_cast<List*>(env["$list"]);
1330
- Expression* v = ARG("$value", Expression);
1311
+ Map_Obj m = SASS_MEMORY_CAST(Map, env["$list"]);
1312
+ List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
1313
+ Expression_Obj v = ARG("$value", Expression);
1331
1314
  if (!l) {
1332
- l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1333
- *l << ARG("$list", Expression);
1315
+ l = SASS_MEMORY_NEW(List, pstate, 1);
1316
+ l->append(ARG("$list", Expression));
1334
1317
  }
1335
1318
  if (m) {
1336
1319
  l = m->to_list(ctx, pstate);
1337
1320
  }
1338
1321
  for (size_t i = 0, L = l->length(); i < L; ++i) {
1339
- if (Eval::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)(i+1));
1322
+ if (Eval::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(Number, pstate, (double)(i+1));
1340
1323
  }
1341
- return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
1324
+ return SASS_MEMORY_NEW(Null, pstate);
1342
1325
  }
1343
1326
 
1344
1327
  Signature join_sig = "join($list1, $list2, $separator: auto)";
1345
1328
  BUILT_IN(join)
1346
1329
  {
1347
- Map* m1 = dynamic_cast<Map*>(env["$list1"]);
1348
- Map* m2 = dynamic_cast<Map*>(env["$list2"]);
1349
- List* l1 = dynamic_cast<List*>(env["$list1"]);
1350
- List* l2 = dynamic_cast<List*>(env["$list2"]);
1351
- String_Constant* sep = ARG("$separator", String_Constant);
1330
+ Map_Obj m1 = SASS_MEMORY_CAST(Map, env["$list1"]);
1331
+ Map_Obj m2 = SASS_MEMORY_CAST(Map, env["$list2"]);
1332
+ List_Obj l1 = SASS_MEMORY_CAST(List, env["$list1"]);
1333
+ List_Obj l2 = SASS_MEMORY_CAST(List, env["$list2"]);
1334
+ String_Constant_Obj sep = ARG("$separator", String_Constant);
1352
1335
  enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);
1353
1336
  if (!l1) {
1354
- l1 = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1355
- *l1 << ARG("$list1", Expression);
1337
+ l1 = SASS_MEMORY_NEW(List, pstate, 1);
1338
+ l1->append(ARG("$list1", Expression));
1356
1339
  sep_val = (l2 ? l2->separator() : SASS_SPACE);
1357
1340
  }
1358
1341
  if (!l2) {
1359
- l2 = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1360
- *l2 << ARG("$list2", Expression);
1342
+ l2 = SASS_MEMORY_NEW(List, pstate, 1);
1343
+ l2->append(ARG("$list2", Expression));
1361
1344
  }
1362
1345
  if (m1) {
1363
1346
  l1 = m1->to_list(ctx, pstate);
@@ -1371,48 +1354,47 @@ namespace Sass {
1371
1354
  if (sep_str == "space") sep_val = SASS_SPACE;
1372
1355
  else if (sep_str == "comma") sep_val = SASS_COMMA;
1373
1356
  else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
1374
- List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, len, sep_val);
1375
- *result += l1;
1376
- *result += l2;
1377
- return result;
1357
+ List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val);
1358
+ result->concat(&l1);
1359
+ result->concat(&l2);
1360
+ return result.detach();
1378
1361
  }
1379
1362
 
1380
1363
  Signature append_sig = "append($list, $val, $separator: auto)";
1381
1364
  BUILT_IN(append)
1382
1365
  {
1383
- Map* m = dynamic_cast<Map*>(env["$list"]);
1384
- List* l = dynamic_cast<List*>(env["$list"]);
1385
- Expression* v = ARG("$val", Expression);
1386
- if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(env["$list"])) {
1387
- Listize listize(ctx.mem);
1388
- l = dynamic_cast<List*>(sl->perform(&listize));
1366
+ Map_Obj m = SASS_MEMORY_CAST(Map, env["$list"]);
1367
+ List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
1368
+ Expression_Obj v = ARG("$val", Expression);
1369
+ if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, env["$list"])) {
1370
+ Listize listize;
1371
+ l = SASS_MEMORY_CAST_PTR(List, sl->perform(&listize));
1389
1372
  }
1390
- String_Constant* sep = ARG("$separator", String_Constant);
1373
+ String_Constant_Obj sep = ARG("$separator", String_Constant);
1391
1374
  if (!l) {
1392
- l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1393
- *l << ARG("$list", Expression);
1375
+ l = SASS_MEMORY_NEW(List, pstate, 1);
1376
+ l->append(ARG("$list", Expression));
1394
1377
  }
1395
1378
  if (m) {
1396
1379
  l = m->to_list(ctx, pstate);
1397
1380
  }
1398
- List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, l->length() + 1, l->separator());
1381
+ List_Ptr result = SASS_MEMORY_COPY(l);
1399
1382
  std::string sep_str(unquote(sep->value()));
1400
- if (sep_str == "space") result->separator(SASS_SPACE);
1401
- else if (sep_str == "comma") result->separator(SASS_COMMA);
1402
- else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
1403
- *result += l;
1404
- bool is_arglist = l->is_arglist();
1405
- result->is_arglist(is_arglist);
1406
- if (is_arglist) {
1407
- *result << SASS_MEMORY_NEW(ctx.mem, Argument,
1408
- v->pstate(),
1409
- v,
1410
- "",
1411
- false,
1412
- false);
1383
+ if (sep_str != "auto") { // check default first
1384
+ if (sep_str == "space") result->separator(SASS_SPACE);
1385
+ else if (sep_str == "comma") result->separator(SASS_COMMA);
1386
+ else error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
1387
+ }
1388
+ if (l->is_arglist()) {
1389
+ result->append(SASS_MEMORY_NEW(Argument,
1390
+ v->pstate(),
1391
+ v,
1392
+ "",
1393
+ false,
1394
+ false));
1413
1395
 
1414
1396
  } else {
1415
- *result << v;
1397
+ result->append(v);
1416
1398
  }
1417
1399
  return result;
1418
1400
  }
@@ -1420,34 +1402,35 @@ namespace Sass {
1420
1402
  Signature zip_sig = "zip($lists...)";
1421
1403
  BUILT_IN(zip)
1422
1404
  {
1423
- List* arglist = SASS_MEMORY_NEW(ctx.mem, List, *ARG("$lists", List));
1405
+ List_Obj arglist = SASS_MEMORY_COPY(ARG("$lists", List));
1424
1406
  size_t shortest = 0;
1425
1407
  for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1426
- List* ith = dynamic_cast<List*>(arglist->value_at_index(i));
1427
- Map* mith = dynamic_cast<Map*>(arglist->value_at_index(i));
1408
+ List_Obj ith = SASS_MEMORY_CAST(List, arglist->value_at_index(i));
1409
+ Map_Obj mith = SASS_MEMORY_CAST(Map, arglist->value_at_index(i));
1428
1410
  if (!ith) {
1429
1411
  if (mith) {
1430
1412
  ith = mith->to_list(ctx, pstate);
1431
1413
  } else {
1432
- ith = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1433
- *ith << arglist->value_at_index(i);
1414
+ ith = SASS_MEMORY_NEW(List, pstate, 1);
1415
+ ith->append(arglist->value_at_index(i));
1434
1416
  }
1435
1417
  if (arglist->is_arglist()) {
1436
- ((Argument*)(*arglist)[i])->value(ith);
1418
+ Argument_Obj arg = (Argument_Ptr)(&arglist->at(i));
1419
+ arg->value(&ith);
1437
1420
  } else {
1438
- (*arglist)[i] = ith;
1421
+ (*arglist)[i] = &ith;
1439
1422
  }
1440
1423
  }
1441
1424
  shortest = (i ? std::min(shortest, ith->length()) : ith->length());
1442
1425
  }
1443
- List* zippers = SASS_MEMORY_NEW(ctx.mem, List, pstate, shortest, SASS_COMMA);
1426
+ List_Ptr zippers = SASS_MEMORY_NEW(List, pstate, shortest, SASS_COMMA);
1444
1427
  size_t L = arglist->length();
1445
1428
  for (size_t i = 0; i < shortest; ++i) {
1446
- List* zipper = SASS_MEMORY_NEW(ctx.mem, List, pstate, L);
1429
+ List_Ptr zipper = SASS_MEMORY_NEW(List, pstate, L);
1447
1430
  for (size_t j = 0; j < L; ++j) {
1448
- *zipper << (*static_cast<List*>(arglist->value_at_index(j)))[i];
1431
+ zipper->append(SASS_MEMORY_CAST(List, arglist->value_at_index(j))->at(i));
1449
1432
  }
1450
- *zippers << zipper;
1433
+ zippers->append(zipper);
1451
1434
  }
1452
1435
  return zippers;
1453
1436
  }
@@ -1455,12 +1438,12 @@ namespace Sass {
1455
1438
  Signature list_separator_sig = "list_separator($list)";
1456
1439
  BUILT_IN(list_separator)
1457
1440
  {
1458
- List* l = dynamic_cast<List*>(env["$list"]);
1441
+ List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
1459
1442
  if (!l) {
1460
- l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
1461
- *l << ARG("$list", Expression);
1443
+ l = SASS_MEMORY_NEW(List, pstate, 1);
1444
+ l->append(ARG("$list", Expression));
1462
1445
  }
1463
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted,
1446
+ return SASS_MEMORY_NEW(String_Quoted,
1464
1447
  pstate,
1465
1448
  l->separator() == SASS_COMMA ? "comma" : "space");
1466
1449
  }
@@ -1472,12 +1455,15 @@ namespace Sass {
1472
1455
  Signature map_get_sig = "map-get($map, $key)";
1473
1456
  BUILT_IN(map_get)
1474
1457
  {
1475
- Map* m = ARGM("$map", Map, ctx);
1476
- Expression* v = ARG("$key", Expression);
1458
+ // leaks for "map-get((), foo)" if not Obj
1459
+ // investigate why this is (unexpected)
1460
+ Map_Obj m = ARGM("$map", Map, ctx);
1461
+ Expression_Obj v = ARG("$key", Expression);
1477
1462
  try {
1478
- return m->at(v);
1463
+ Expression_Obj val = m->at(v); // XXX
1464
+ return val ? val.detach() : SASS_MEMORY_NEW(Null, pstate);
1479
1465
  } catch (const std::out_of_range&) {
1480
- return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
1466
+ return SASS_MEMORY_NEW(Null, pstate);
1481
1467
  }
1482
1468
  catch (...) { throw; }
1483
1469
  }
@@ -1485,18 +1471,18 @@ namespace Sass {
1485
1471
  Signature map_has_key_sig = "map-has-key($map, $key)";
1486
1472
  BUILT_IN(map_has_key)
1487
1473
  {
1488
- Map* m = ARGM("$map", Map, ctx);
1489
- Expression* v = ARG("$key", Expression);
1490
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, m->has(v));
1474
+ Map_Obj m = ARGM("$map", Map, ctx);
1475
+ Expression_Obj v = ARG("$key", Expression);
1476
+ return SASS_MEMORY_NEW(Boolean, pstate, m->has(v));
1491
1477
  }
1492
1478
 
1493
1479
  Signature map_keys_sig = "map-keys($map)";
1494
1480
  BUILT_IN(map_keys)
1495
1481
  {
1496
- Map* m = ARGM("$map", Map, ctx);
1497
- List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, m->length(), SASS_COMMA);
1482
+ Map_Obj m = ARGM("$map", Map, ctx);
1483
+ List_Ptr result = SASS_MEMORY_NEW(List, pstate, m->length(), SASS_COMMA);
1498
1484
  for ( auto key : m->keys()) {
1499
- *result << key;
1485
+ result->append(key);
1500
1486
  }
1501
1487
  return result;
1502
1488
  }
@@ -1504,10 +1490,10 @@ namespace Sass {
1504
1490
  Signature map_values_sig = "map-values($map)";
1505
1491
  BUILT_IN(map_values)
1506
1492
  {
1507
- Map* m = ARGM("$map", Map, ctx);
1508
- List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, m->length(), SASS_COMMA);
1493
+ Map_Obj m = ARGM("$map", Map, ctx);
1494
+ List_Ptr result = SASS_MEMORY_NEW(List, pstate, m->length(), SASS_COMMA);
1509
1495
  for ( auto key : m->keys()) {
1510
- *result << m->at(key);
1496
+ result->append(m->at(key));
1511
1497
  }
1512
1498
  return result;
1513
1499
  }
@@ -1515,13 +1501,14 @@ namespace Sass {
1515
1501
  Signature map_merge_sig = "map-merge($map1, $map2)";
1516
1502
  BUILT_IN(map_merge)
1517
1503
  {
1518
- Map* m1 = ARGM("$map1", Map, ctx);
1519
- Map* m2 = ARGM("$map2", Map, ctx);
1504
+ Map_Obj m1 = ARGM("$map1", Map, ctx);
1505
+ Map_Obj m2 = ARGM("$map2", Map, ctx);
1520
1506
 
1521
1507
  size_t len = m1->length() + m2->length();
1522
- Map* result = SASS_MEMORY_NEW(ctx.mem, Map, pstate, len);
1523
- *result += m1;
1524
- *result += m2;
1508
+ Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, len);
1509
+ // concat not implemented for maps
1510
+ *result += &m1;
1511
+ *result += &m2;
1525
1512
  return result;
1526
1513
  }
1527
1514
 
@@ -1529,9 +1516,9 @@ namespace Sass {
1529
1516
  BUILT_IN(map_remove)
1530
1517
  {
1531
1518
  bool remove;
1532
- Map* m = ARGM("$map", Map, ctx);
1533
- List* arglist = ARG("$keys", List);
1534
- Map* result = SASS_MEMORY_NEW(ctx.mem, Map, pstate, 1);
1519
+ Map_Obj m = ARGM("$map", Map, ctx);
1520
+ List_Obj arglist = ARG("$keys", List);
1521
+ Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, 1);
1535
1522
  for (auto key : m->keys()) {
1536
1523
  remove = false;
1537
1524
  for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {
@@ -1545,16 +1532,18 @@ namespace Sass {
1545
1532
  Signature keywords_sig = "keywords($args)";
1546
1533
  BUILT_IN(keywords)
1547
1534
  {
1548
- List* arglist = SASS_MEMORY_NEW(ctx.mem, List, *ARG("$args", List));
1549
- Map* result = SASS_MEMORY_NEW(ctx.mem, Map, pstate, 1);
1535
+ List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List)); // copy
1536
+ Map_Obj result = SASS_MEMORY_NEW(Map, pstate, 1);
1550
1537
  for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {
1551
- std::string name = std::string(((Argument*)(*arglist)[i])->name());
1538
+ Expression_Obj obj = arglist->at(i);
1539
+ Argument_Obj arg = (Argument_Ptr)&obj;
1540
+ std::string name = std::string(arg->name());
1552
1541
  name = name.erase(0, 1); // sanitize name (remove dollar sign)
1553
- *result << std::make_pair(SASS_MEMORY_NEW(ctx.mem, String_Quoted,
1542
+ *result << std::make_pair(SASS_MEMORY_NEW(String_Quoted,
1554
1543
  pstate, name),
1555
- ((Argument*)(*arglist)[i])->value());
1544
+ arg->value());
1556
1545
  }
1557
- return result;
1546
+ return result.detach();
1558
1547
  }
1559
1548
 
1560
1549
  //////////////////////////
@@ -1564,29 +1553,29 @@ namespace Sass {
1564
1553
  Signature type_of_sig = "type-of($value)";
1565
1554
  BUILT_IN(type_of)
1566
1555
  {
1567
- Expression* v = ARG("$value", Expression);
1568
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, v->type());
1556
+ Expression_Ptr v = ARG("$value", Expression);
1557
+ return SASS_MEMORY_NEW(String_Quoted, pstate, v->type());
1569
1558
  }
1570
1559
 
1571
1560
  Signature unit_sig = "unit($number)";
1572
1561
  BUILT_IN(unit)
1573
- { return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, quote(ARG("$number", Number)->unit(), '"')); }
1562
+ { return SASS_MEMORY_NEW(String_Quoted, pstate, quote(ARG("$number", Number)->unit(), '"')); }
1574
1563
 
1575
1564
  Signature unitless_sig = "unitless($number)";
1576
1565
  BUILT_IN(unitless)
1577
- { return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, ARG("$number", Number)->is_unitless()); }
1566
+ { return SASS_MEMORY_NEW(Boolean, pstate, ARG("$number", Number)->is_unitless()); }
1578
1567
 
1579
1568
  Signature comparable_sig = "comparable($number-1, $number-2)";
1580
1569
  BUILT_IN(comparable)
1581
1570
  {
1582
- Number* n1 = ARG("$number-1", Number);
1583
- Number* n2 = ARG("$number-2", Number);
1571
+ Number_Ptr n1 = ARG("$number-1", Number);
1572
+ Number_Ptr n2 = ARG("$number-2", Number);
1584
1573
  if (n1->is_unitless() || n2->is_unitless()) {
1585
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
1574
+ return SASS_MEMORY_NEW(Boolean, pstate, true);
1586
1575
  }
1587
- Number tmp_n2(*n2);
1576
+ Number tmp_n2(n2); // copy
1588
1577
  tmp_n2.normalize(n1->find_convertible_unit());
1589
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, n1->unit() == tmp_n2.unit());
1578
+ return SASS_MEMORY_NEW(Boolean, pstate, n1->unit() == tmp_n2.unit());
1590
1579
  }
1591
1580
 
1592
1581
  Signature variable_exists_sig = "variable-exists($name)";
@@ -1595,10 +1584,10 @@ namespace Sass {
1595
1584
  std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1596
1585
 
1597
1586
  if(d_env.has("$"+s)) {
1598
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
1587
+ return SASS_MEMORY_NEW(Boolean, pstate, true);
1599
1588
  }
1600
1589
  else {
1601
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
1590
+ return SASS_MEMORY_NEW(Boolean, pstate, false);
1602
1591
  }
1603
1592
  }
1604
1593
 
@@ -1608,10 +1597,10 @@ namespace Sass {
1608
1597
  std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1609
1598
 
1610
1599
  if(d_env.has_global("$"+s)) {
1611
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
1600
+ return SASS_MEMORY_NEW(Boolean, pstate, true);
1612
1601
  }
1613
1602
  else {
1614
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
1603
+ return SASS_MEMORY_NEW(Boolean, pstate, false);
1615
1604
  }
1616
1605
  }
1617
1606
 
@@ -1621,10 +1610,10 @@ namespace Sass {
1621
1610
  std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1622
1611
 
1623
1612
  if(d_env.has_global(s+"[f]")) {
1624
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
1613
+ return SASS_MEMORY_NEW(Boolean, pstate, true);
1625
1614
  }
1626
1615
  else {
1627
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
1616
+ return SASS_MEMORY_NEW(Boolean, pstate, false);
1628
1617
  }
1629
1618
  }
1630
1619
 
@@ -1634,10 +1623,10 @@ namespace Sass {
1634
1623
  std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1635
1624
 
1636
1625
  if(d_env.has_global(s+"[m]")) {
1637
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
1626
+ return SASS_MEMORY_NEW(Boolean, pstate, true);
1638
1627
  }
1639
1628
  else {
1640
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
1629
+ return SASS_MEMORY_NEW(Boolean, pstate, false);
1641
1630
  }
1642
1631
  }
1643
1632
 
@@ -1647,10 +1636,10 @@ namespace Sass {
1647
1636
  std::string s = unquote(ARG("$name", String_Constant)->value());
1648
1637
 
1649
1638
  if(features.find(s) == features.end()) {
1650
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
1639
+ return SASS_MEMORY_NEW(Boolean, pstate, false);
1651
1640
  }
1652
1641
  else {
1653
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
1642
+ return SASS_MEMORY_NEW(Boolean, pstate, true);
1654
1643
  }
1655
1644
  }
1656
1645
 
@@ -1658,34 +1647,36 @@ namespace Sass {
1658
1647
  BUILT_IN(call)
1659
1648
  {
1660
1649
  std::string name = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1661
- List* arglist = SASS_MEMORY_NEW(ctx.mem, List, *ARG("$args", List));
1650
+ List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
1662
1651
 
1663
- Arguments* args = SASS_MEMORY_NEW(ctx.mem, Arguments, pstate);
1652
+ Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
1664
1653
  // std::string full_name(name + "[f]");
1665
- // Definition* def = d_env.has(full_name) ? static_cast<Definition*>((d_env)[full_name]) : 0;
1666
- // Parameters* params = def ? def->parameters() : 0;
1654
+ // Definition_Ptr def = d_env.has(full_name) ? static_cast<Definition_Ptr>((d_env)[full_name]) : 0;
1655
+ // Parameters_Ptr params = def ? def->parameters() : 0;
1667
1656
  // size_t param_size = params ? params->length() : 0;
1668
1657
  for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1669
- Expression* expr = arglist->value_at_index(i);
1658
+ Expression_Obj expr = arglist->value_at_index(i);
1670
1659
  // if (params && params->has_rest_parameter()) {
1671
- // Parameter* p = param_size > i ? (*params)[i] : 0;
1672
- // List* list = dynamic_cast<List*>(expr);
1660
+ // Parameter_Obj p = param_size > i ? (*params)[i] : 0;
1661
+ // List_Ptr list = SASS_MEMORY_CAST(List, expr);
1673
1662
  // if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
1674
1663
  // }
1675
1664
  if (arglist->is_arglist()) {
1676
- Argument* arg = dynamic_cast<Argument*>((*arglist)[i]);
1677
- *args << SASS_MEMORY_NEW(ctx.mem, Argument,
1678
- pstate,
1679
- expr,
1680
- arg ? arg->name() : "",
1681
- arg ? arg->is_rest_argument() : false,
1682
- arg ? arg->is_keyword_argument() : false);
1665
+ Expression_Obj obj = arglist->at(i);
1666
+ Argument_Obj arg = (Argument_Ptr)&obj;
1667
+ args->append(SASS_MEMORY_NEW(Argument,
1668
+ pstate,
1669
+ expr,
1670
+ arg ? arg->name() : "",
1671
+ arg ? arg->is_rest_argument() : false,
1672
+ arg ? arg->is_keyword_argument() : false));
1683
1673
  } else {
1684
- *args << SASS_MEMORY_NEW(ctx.mem, Argument, pstate, expr);
1674
+ args->append(SASS_MEMORY_NEW(Argument, pstate, expr));
1685
1675
  }
1686
1676
  }
1687
- Function_Call* func = SASS_MEMORY_NEW(ctx.mem, Function_Call, pstate, name, args);
1677
+ Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, &args);
1688
1678
  Expand expand(ctx, &d_env, backtrace, &selector_stack);
1679
+ func->via_call(true); // calc invoke is allowed
1689
1680
  return func->perform(&expand.eval);
1690
1681
 
1691
1682
  }
@@ -1696,7 +1687,9 @@ namespace Sass {
1696
1687
 
1697
1688
  Signature not_sig = "not($value)";
1698
1689
  BUILT_IN(sass_not)
1699
- { return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, ARG("$value", Expression)->is_false()); }
1690
+ {
1691
+ return SASS_MEMORY_NEW(Boolean, pstate, ARG("$value", Expression)->is_false());
1692
+ }
1700
1693
 
1701
1694
  Signature if_sig = "if($condition, $if-true, $if-false)";
1702
1695
  // BUILT_IN(sass_if)
@@ -1704,8 +1697,9 @@ namespace Sass {
1704
1697
  BUILT_IN(sass_if)
1705
1698
  {
1706
1699
  Expand expand(ctx, &d_env, backtrace, &selector_stack);
1707
- bool is_true = !ARG("$condition", Expression)->perform(&expand.eval)->is_false();
1708
- Expression* res = ARG(is_true ? "$if-true" : "$if-false", Expression);
1700
+ Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
1701
+ bool is_true = !cond->is_false();
1702
+ Expression_Ptr res = ARG(is_true ? "$if-true" : "$if-false", Expression);
1709
1703
  res = res->perform(&expand.eval);
1710
1704
  res->set_delayed(false); // clone?
1711
1705
  return res;
@@ -1732,11 +1726,11 @@ namespace Sass {
1732
1726
  Signature inspect_sig = "inspect($value)";
1733
1727
  BUILT_IN(inspect)
1734
1728
  {
1735
- Expression* v = ARG("$value", Expression);
1729
+ Expression_Ptr v = ARG("$value", Expression);
1736
1730
  if (v->concrete_type() == Expression::NULL_VAL) {
1737
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "null");
1738
- } else if (v->concrete_type() == Expression::BOOLEAN && *v == 0) {
1739
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "false");
1731
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "null");
1732
+ } else if (v->concrete_type() == Expression::BOOLEAN && v->is_false()) {
1733
+ return SASS_MEMORY_NEW(String_Quoted, pstate, "false");
1740
1734
  } else if (v->concrete_type() == Expression::STRING) {
1741
1735
  return v;
1742
1736
  } else {
@@ -1749,101 +1743,103 @@ namespace Sass {
1749
1743
  i.in_declaration = false;
1750
1744
  v->perform(&i);
1751
1745
  ctx.c_options.output_style = old_style;
1752
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, i.get_buffer());
1746
+ return SASS_MEMORY_NEW(String_Quoted, pstate, i.get_buffer());
1753
1747
  }
1754
1748
  // return v;
1755
1749
  }
1756
1750
  Signature selector_nest_sig = "selector-nest($selectors...)";
1757
1751
  BUILT_IN(selector_nest)
1758
1752
  {
1759
- List* arglist = ARG("$selectors", List);
1753
+ List_Ptr arglist = ARG("$selectors", List);
1760
1754
 
1761
1755
  // Not enough parameters
1762
1756
  if( arglist->length() == 0 )
1763
- error("$selectors: At least one selector must be passed", pstate);
1757
+ error("$selectors: At least one selector must be passed for `selector-nest'", pstate);
1764
1758
 
1765
1759
  // Parse args into vector of selectors
1766
- std::vector<CommaSequence_Selector*> parsedSelectors;
1760
+ std::vector<Selector_List_Obj> parsedSelectors;
1767
1761
  for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1768
- Expression* exp = dynamic_cast<Expression*>(arglist->value_at_index(i));
1762
+ Expression_Obj exp = SASS_MEMORY_CAST(Expression, arglist->value_at_index(i));
1769
1763
  if (exp->concrete_type() == Expression::NULL_VAL) {
1770
1764
  std::stringstream msg;
1771
1765
  msg << "$selectors: null is not a valid selector: it must be a string,\n";
1772
1766
  msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
1773
1767
  error(msg.str(), pstate);
1774
1768
  }
1775
- if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
1769
+ if (String_Constant_Obj str = SASS_MEMORY_CAST(String_Constant, exp)) {
1776
1770
  str->quote_mark(0);
1777
1771
  }
1778
1772
  std::string exp_src = exp->to_string(ctx.c_options) + "{";
1779
- CommaSequence_Selector* sel = Parser::parse_selector(exp_src.c_str(), ctx);
1780
- parsedSelectors.push_back(sel);
1773
+ Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx);
1774
+ parsedSelectors.push_back(&sel);
1781
1775
  }
1782
1776
 
1783
1777
  // Nothing to do
1784
1778
  if( parsedSelectors.empty() ) {
1785
- return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
1779
+ return SASS_MEMORY_NEW(Null, pstate);
1786
1780
  }
1787
1781
 
1788
1782
  // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
1789
- std::vector<CommaSequence_Selector*>::iterator itr = parsedSelectors.begin();
1790
- CommaSequence_Selector* result = *itr;
1783
+ std::vector<Selector_List_Obj>::iterator itr = parsedSelectors.begin();
1784
+ Selector_List_Obj result = *itr;
1791
1785
  ++itr;
1792
1786
 
1793
1787
  for(;itr != parsedSelectors.end(); ++itr) {
1794
- CommaSequence_Selector* child = *itr;
1795
- std::vector<Sequence_Selector*> exploded;
1796
- CommaSequence_Selector* rv = child->resolve_parent_refs(ctx, result);
1788
+ Selector_List_Obj child = *itr;
1789
+ std::vector<Complex_Selector_Obj> exploded;
1790
+ selector_stack.push_back(&result);
1791
+ Selector_List_Obj rv = child->resolve_parent_refs(ctx, selector_stack);
1792
+ selector_stack.pop_back();
1797
1793
  for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
1798
1794
  exploded.push_back((*rv)[m]);
1799
1795
  }
1800
1796
  result->elements(exploded);
1801
1797
  }
1802
1798
 
1803
- Listize listize(ctx.mem);
1799
+ Listize listize;
1804
1800
  return result->perform(&listize);
1805
1801
  }
1806
1802
 
1807
1803
  Signature selector_append_sig = "selector-append($selectors...)";
1808
1804
  BUILT_IN(selector_append)
1809
1805
  {
1810
- List* arglist = ARG("$selectors", List);
1806
+ List_Ptr arglist = ARG("$selectors", List);
1811
1807
 
1812
1808
  // Not enough parameters
1813
1809
  if( arglist->length() == 0 )
1814
- error("$selectors: At least one selector must be passed", pstate);
1810
+ error("$selectors: At least one selector must be passed for `selector-append'", pstate);
1815
1811
 
1816
1812
  // Parse args into vector of selectors
1817
- std::vector<CommaSequence_Selector*> parsedSelectors;
1813
+ std::vector<Selector_List_Obj> parsedSelectors;
1818
1814
  for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1819
- Expression* exp = dynamic_cast<Expression*>(arglist->value_at_index(i));
1815
+ Expression_Obj exp = SASS_MEMORY_CAST(Expression, arglist->value_at_index(i));
1820
1816
  if (exp->concrete_type() == Expression::NULL_VAL) {
1821
1817
  std::stringstream msg;
1822
1818
  msg << "$selectors: null is not a valid selector: it must be a string,\n";
1823
1819
  msg << "a list of strings, or a list of lists of strings for 'selector-append'";
1824
1820
  error(msg.str(), pstate);
1825
1821
  }
1826
- if (String_Constant* str =dynamic_cast<String_Constant*>(exp)) {
1822
+ if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, exp)) {
1827
1823
  str->quote_mark(0);
1828
1824
  }
1829
1825
  std::string exp_src = exp->to_string() + "{";
1830
- CommaSequence_Selector* sel = Parser::parse_selector(exp_src.c_str(), ctx);
1831
- parsedSelectors.push_back(sel);
1826
+ Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx);
1827
+ parsedSelectors.push_back(&sel);
1832
1828
  }
1833
1829
 
1834
1830
  // Nothing to do
1835
1831
  if( parsedSelectors.empty() ) {
1836
- return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
1832
+ return SASS_MEMORY_NEW(Null, pstate);
1837
1833
  }
1838
1834
 
1839
1835
  // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
1840
- std::vector<CommaSequence_Selector*>::iterator itr = parsedSelectors.begin();
1841
- CommaSequence_Selector* result = *itr;
1836
+ std::vector<Selector_List_Obj>::iterator itr = parsedSelectors.begin();
1837
+ Selector_List_Obj result = *itr;
1842
1838
  ++itr;
1843
1839
 
1844
1840
  for(;itr != parsedSelectors.end(); ++itr) {
1845
- CommaSequence_Selector* child = *itr;
1846
- std::vector<Sequence_Selector*> newElements;
1841
+ Selector_List_Obj child = *itr;
1842
+ std::vector<Complex_Selector_Obj> newElements;
1847
1843
 
1848
1844
  // For every COMPLEX_SELECTOR in `result`
1849
1845
  // For every COMPLEX_SELECTOR in `child`
@@ -1854,73 +1850,73 @@ namespace Sass {
1854
1850
  // Replace result->elements with newElements
1855
1851
  for (size_t i = 0, resultLen = result->length(); i < resultLen; ++i) {
1856
1852
  for (size_t j = 0, childLen = child->length(); j < childLen; ++j) {
1857
- Sequence_Selector* parentSeqClone = (*result)[i]->cloneFully(ctx);
1858
- Sequence_Selector* childSeq = (*child)[j];
1859
- Sequence_Selector* base = childSeq->tail();
1853
+ Complex_Selector_Obj parentSeqClone = SASS_MEMORY_CLONE((*result)[i]);
1854
+ Complex_Selector_Obj childSeq = (*child)[j];
1855
+ Complex_Selector_Obj base = childSeq->tail();
1860
1856
 
1861
1857
  // Must be a simple sequence
1862
- if( childSeq->combinator() != Sequence_Selector::Combinator::ANCESTOR_OF ) {
1863
- std::string msg("Can't append `");
1858
+ if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
1859
+ std::string msg("Can't append \"");
1864
1860
  msg += childSeq->to_string();
1865
- msg += "` to `";
1861
+ msg += "\" to \"";
1866
1862
  msg += parentSeqClone->to_string();
1867
- msg += "`";
1863
+ msg += "\" for `selector-append'";
1868
1864
  error(msg, pstate, backtrace);
1869
1865
  }
1870
1866
 
1871
1867
  // Cannot be a Universal selector
1872
- Element_Selector* pType = dynamic_cast<Element_Selector*>(childSeq->head()->first());
1868
+ Element_Selector_Obj pType = SASS_MEMORY_CAST(Element_Selector, childSeq->head()->first());
1873
1869
  if(pType && pType->name() == "*") {
1874
- std::string msg("Can't append `");
1870
+ std::string msg("Can't append \"");
1875
1871
  msg += childSeq->to_string();
1876
- msg += "` to `";
1872
+ msg += "\" to \"";
1877
1873
  msg += parentSeqClone->to_string();
1878
- msg += "`";
1874
+ msg += "\" for `selector-append'";
1879
1875
  error(msg, pstate, backtrace);
1880
1876
  }
1881
1877
 
1882
1878
  // TODO: Add check for namespace stuff
1883
1879
 
1884
1880
  // append any selectors in childSeq's head
1885
- *(parentSeqClone->innermost()->head()) += (base->head());
1881
+ parentSeqClone->innermost()->head()->concat(&base->head());
1886
1882
 
1887
1883
  // Set parentSeqClone new tail
1888
1884
  parentSeqClone->innermost()->tail( base->tail() );
1889
1885
 
1890
- newElements.push_back(parentSeqClone);
1886
+ newElements.push_back(&parentSeqClone);
1891
1887
  }
1892
1888
  }
1893
1889
 
1894
1890
  result->elements(newElements);
1895
1891
  }
1896
1892
 
1897
- Listize listize(ctx.mem);
1893
+ Listize listize;
1898
1894
  return result->perform(&listize);
1899
1895
  }
1900
1896
 
1901
1897
  Signature selector_unify_sig = "selector-unify($selector1, $selector2)";
1902
1898
  BUILT_IN(selector_unify)
1903
1899
  {
1904
- CommaSequence_Selector* selector1 = ARGSEL("$selector1", CommaSequence_Selector, p_contextualize);
1905
- CommaSequence_Selector* selector2 = ARGSEL("$selector2", CommaSequence_Selector, p_contextualize);
1900
+ Selector_List_Obj selector1 = ARGSEL("$selector1", Selector_List_Obj, p_contextualize);
1901
+ Selector_List_Obj selector2 = ARGSEL("$selector2", Selector_List_Obj, p_contextualize);
1906
1902
 
1907
- CommaSequence_Selector* result = selector1->unify_with(selector2, ctx);
1908
- Listize listize(ctx.mem);
1903
+ Selector_List_Obj result = selector1->unify_with(&selector2, ctx);
1904
+ Listize listize;
1909
1905
  return result->perform(&listize);
1910
1906
  }
1911
1907
 
1912
1908
  Signature simple_selectors_sig = "simple-selectors($selector)";
1913
1909
  BUILT_IN(simple_selectors)
1914
1910
  {
1915
- SimpleSequence_Selector* sel = ARGSEL("$selector", SimpleSequence_Selector, p_contextualize);
1911
+ Compound_Selector_Obj sel = ARGSEL("$selector", Compound_Selector_Obj, p_contextualize);
1916
1912
 
1917
- List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), sel->length(), SASS_COMMA);
1913
+ List_Ptr l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
1918
1914
 
1919
1915
  for (size_t i = 0, L = sel->length(); i < L; ++i) {
1920
- Simple_Selector* ss = (*sel)[i];
1916
+ Simple_Selector_Obj ss = (*sel)[i];
1921
1917
  std::string ss_string = ss->to_string() ;
1922
1918
 
1923
- *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, ss->pstate(), ss_string);
1919
+ l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));
1924
1920
  }
1925
1921
 
1926
1922
  return l;
@@ -1929,51 +1925,50 @@ namespace Sass {
1929
1925
  Signature selector_extend_sig = "selector-extend($selector, $extendee, $extender)";
1930
1926
  BUILT_IN(selector_extend)
1931
1927
  {
1932
- CommaSequence_Selector* selector = ARGSEL("$selector", CommaSequence_Selector, p_contextualize);
1933
- CommaSequence_Selector* extendee = ARGSEL("$extendee", CommaSequence_Selector, p_contextualize);
1934
- CommaSequence_Selector* extender = ARGSEL("$extender", CommaSequence_Selector, p_contextualize);
1928
+ Selector_List_Obj selector = ARGSEL("$selector", Selector_List_Obj, p_contextualize);
1929
+ Selector_List_Obj extendee = ARGSEL("$extendee", Selector_List_Obj, p_contextualize);
1930
+ Selector_List_Obj extender = ARGSEL("$extender", Selector_List_Obj, p_contextualize);
1935
1931
 
1936
- ExtensionSubsetMap subset_map;
1932
+ Subset_Map subset_map;
1937
1933
  extender->populate_extends(extendee, ctx, subset_map);
1938
1934
 
1939
- CommaSequence_Selector* result = Extend::extendSelectorList(selector, ctx, subset_map, false);
1935
+ Selector_List_Obj result = Extend::extendSelectorList(selector, ctx, subset_map, false);
1940
1936
 
1941
- Listize listize(ctx.mem);
1937
+ Listize listize;
1942
1938
  return result->perform(&listize);
1943
1939
  }
1944
1940
 
1945
1941
  Signature selector_replace_sig = "selector-replace($selector, $original, $replacement)";
1946
1942
  BUILT_IN(selector_replace)
1947
1943
  {
1948
- CommaSequence_Selector* selector = ARGSEL("$selector", CommaSequence_Selector, p_contextualize);
1949
- CommaSequence_Selector* original = ARGSEL("$original", CommaSequence_Selector, p_contextualize);
1950
- CommaSequence_Selector* replacement = ARGSEL("$replacement", CommaSequence_Selector, p_contextualize);
1951
-
1952
- ExtensionSubsetMap subset_map;
1944
+ Selector_List_Obj selector = ARGSEL("$selector", Selector_List_Obj, p_contextualize);
1945
+ Selector_List_Obj original = ARGSEL("$original", Selector_List_Obj, p_contextualize);
1946
+ Selector_List_Obj replacement = ARGSEL("$replacement", Selector_List_Obj, p_contextualize);
1947
+ Subset_Map subset_map;
1953
1948
  replacement->populate_extends(original, ctx, subset_map);
1954
1949
 
1955
- CommaSequence_Selector* result = Extend::extendSelectorList(selector, ctx, subset_map, true);
1950
+ Selector_List_Obj result = Extend::extendSelectorList(selector, ctx, subset_map, true);
1956
1951
 
1957
- Listize listize(ctx.mem);
1952
+ Listize listize;
1958
1953
  return result->perform(&listize);
1959
1954
  }
1960
1955
 
1961
1956
  Signature selector_parse_sig = "selector-parse($selector)";
1962
1957
  BUILT_IN(selector_parse)
1963
1958
  {
1964
- CommaSequence_Selector* sel = ARGSEL("$selector", CommaSequence_Selector, p_contextualize);
1959
+ Selector_List_Obj sel = ARGSEL("$selector", Selector_List_Obj, p_contextualize);
1965
1960
 
1966
- Listize listize(ctx.mem);
1961
+ Listize listize;
1967
1962
  return sel->perform(&listize);
1968
1963
  }
1969
1964
 
1970
1965
  Signature is_superselector_sig = "is-superselector($super, $sub)";
1971
1966
  BUILT_IN(is_superselector)
1972
1967
  {
1973
- CommaSequence_Selector* sel_sup = ARGSEL("$super", CommaSequence_Selector, p_contextualize);
1974
- CommaSequence_Selector* sel_sub = ARGSEL("$sub", CommaSequence_Selector, p_contextualize);
1968
+ Selector_List_Obj sel_sup = ARGSEL("$super", Selector_List_Obj, p_contextualize);
1969
+ Selector_List_Obj sel_sub = ARGSEL("$sub", Selector_List_Obj, p_contextualize);
1975
1970
  bool result = sel_sup->is_superselector_of(sel_sub);
1976
- return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, result);
1971
+ return SASS_MEMORY_NEW(Boolean, pstate, result);
1977
1972
  }
1978
1973
 
1979
1974
  Signature unique_id_sig = "unique-id()";
@@ -1983,7 +1978,7 @@ namespace Sass {
1983
1978
  std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8
1984
1979
  uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
1985
1980
  ss << "u" << std::setfill('0') << std::setw(8) << std::hex << distributed;
1986
- return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, ss.str());
1981
+ return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());
1987
1982
  }
1988
1983
 
1989
1984
  }