#include "sass.hpp"
#include <iostream>
#include <typeinfo>
#include "ast.hpp"
#include "expand.hpp"
#include "bind.hpp"
#include "eval.hpp"
#include "backtrace.hpp"
#include "context.hpp"
#include "parser.hpp"
#include "sass_functions.hpp"
namespace Sass {
// simple endless recursion protection
const size_t maxRecursion = 500;
Expand::Expand(Context& ctx, Env* env, Backtrace* bt, std::vector<Selector_List_Obj>* stack)
: ctx(ctx),
eval(Eval(*this)),
recursions(0),
in_keyframes(false),
at_root_without_rule(false),
old_at_root_without_rule(false),
env_stack(std::vector<Env*>()),
block_stack(std::vector<Block_Ptr>()),
call_stack(std::vector<AST_Node_Obj>()),
selector_stack(std::vector<Selector_List_Obj>()),
media_block_stack(std::vector<Media_Block_Ptr>()),
backtrace_stack(std::vector<Backtrace*>())
{
env_stack.push_back(0);
env_stack.push_back(env);
block_stack.push_back(0);
call_stack.push_back(0);
if (stack == NULL) { selector_stack.push_back(0); }
else { selector_stack.insert(selector_stack.end(), stack->begin(), stack->end()); }
media_block_stack.push_back(0);
backtrace_stack.push_back(0);
backtrace_stack.push_back(bt);
}
Env* Expand::environment()
{
if (env_stack.size() > 0)
return env_stack.back();
return 0;
}
Selector_List_Obj Expand::selector()
{
if (selector_stack.size() > 0)
return selector_stack.back();
return 0;
}
Backtrace* Expand::backtrace()
{
if (backtrace_stack.size() > 0)
return backtrace_stack.back();
return 0;
}
// blocks create new variable scopes
Block_Ptr Expand::operator()(Block_Ptr b)
{
// create new local environment
// set the current env as parent
Env env(environment());
// copy the block object (add items later)
Block_Obj bb = SASS_MEMORY_NEW(Block,
b->pstate(),
b->length(),
b->is_root());
// setup block and env stack
this->block_stack.push_back(bb);
this->env_stack.push_back(&env);
// operate on block
// this may throw up!
this->append_block(b);
// revert block and env stack
this->block_stack.pop_back();
this->env_stack.pop_back();
// return copy
return bb.detach();
}
Statement_Ptr Expand::operator()(Ruleset_Ptr r)
{
LOCAL_FLAG(old_at_root_without_rule, at_root_without_rule);
if (in_keyframes) {
Block_Ptr bb = operator()(r->block());
Keyframe_Rule_Obj k = SASS_MEMORY_NEW(Keyframe_Rule, r->pstate(), bb);
if (r->selector()) {
if (Selector_List_Ptr s = r->selector()) {
selector_stack.push_back(0);
k->name(s->eval(eval));
selector_stack.pop_back();
}
}
return k.detach();
}
// reset when leaving scope
LOCAL_FLAG(at_root_without_rule, false);
// `&` is allowed in `@at-root`!
bool has_parent_selector = false;
for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {
Selector_List_Obj ll = selector_stack.at(i);
has_parent_selector = ll != 0 && ll->length() > 0;
}
Selector_List_Obj sel = r->selector();
if (sel) sel = sel->eval(eval);
// check for parent selectors in base level rules
if (r->is_root()) {
if (Selector_List_Ptr selector_list = Cast<Selector_List>(r->selector())) {
for (Complex_Selector_Obj complex_selector : selector_list->elements()) {
Complex_Selector_Ptr tail = complex_selector;
while (tail) {
if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {
Parent_Selector_Ptr ptr = Cast<Parent_Selector>(header);
if (ptr == NULL || (!ptr->real() || has_parent_selector)) continue;
std::string sel_str(complex_selector->to_string(ctx.c_options));
error("Base-level rules cannot contain the parent-selector-referencing character '&'.", header->pstate(), backtrace());
}
tail = tail->tail();
}
}
}
}
else {
if (sel->length() == 0 || sel->has_parent_ref()) {
if (sel->has_real_parent_ref() && !has_parent_selector) {
error("Base-level rules cannot contain the parent-selector-referencing character '&'.", sel->pstate(), backtrace());
}
}
}
selector_stack.push_back(sel);
Env env(environment());
if (block_stack.back()->is_root()) {
env_stack.push_back(&env);
}
sel->set_media_block(media_block_stack.back());
Block_Obj blk = 0;
if (r->block()) blk = operator()(r->block());
Ruleset_Ptr rr = SASS_MEMORY_NEW(Ruleset,
r->pstate(),
sel,
blk);
selector_stack.pop_back();
if (block_stack.back()->is_root()) {
env_stack.pop_back();
}
rr->is_root(r->is_root());
rr->tabs(r->tabs());
return rr;
}
Statement_Ptr Expand::operator()(Supports_Block_Ptr f)
{
Expression_Obj condition = f->condition()->perform(&eval);
Supports_Block_Obj ff = SASS_MEMORY_NEW(Supports_Block,
f->pstate(),
Cast<Supports_Condition>(condition),
operator()(f->block()));
return ff.detach();
}
Statement_Ptr Expand::operator()(Media_Block_Ptr m)
{
Media_Block_Obj cpy = SASS_MEMORY_COPY(m);
// Media_Blocks are prone to have circular references
// Copy could leak memory if it does not get picked up
// Looks like we are able to reset block reference for copy
// Good as it will ensure a low memory overhead for this fix
// So this is a cheap solution with a minimal price
ctx.ast_gc.push_back(cpy); cpy->block(0);
Expression_Obj mq = eval(m->media_queries());
std::string str_mq(mq->to_string(ctx.c_options));
char* str = sass_copy_c_string(str_mq.c_str());
ctx.strings.push_back(str);
Parser p(Parser::from_c_str(str, ctx, mq->pstate()));
mq = p.parse_media_queries(); // re-assign now
cpy->media_queries(mq);
media_block_stack.push_back(cpy);
Block_Obj blk = operator()(m->block());
Media_Block_Ptr mm = SASS_MEMORY_NEW(Media_Block,
m->pstate(),
mq,
blk);
media_block_stack.pop_back();
mm->tabs(m->tabs());
return mm;
}
Statement_Ptr Expand::operator()(At_Root_Block_Ptr a)
{
Block_Obj ab = a->block();
Expression_Obj ae = a->expression();
if (ae) ae = ae->perform(&eval);
else ae = SASS_MEMORY_NEW(At_Root_Query, a->pstate());
LOCAL_FLAG(at_root_without_rule, true);
LOCAL_FLAG(in_keyframes, false);
;
Block_Obj bb = ab ? operator()(ab) : NULL;
At_Root_Block_Obj aa = SASS_MEMORY_NEW(At_Root_Block,
a->pstate(),
bb,
Cast<At_Root_Query>(ae));
return aa.detach();
}
Statement_Ptr Expand::operator()(Directive_Ptr a)
{
LOCAL_FLAG(in_keyframes, a->is_keyframes());
Block_Ptr ab = a->block();
Selector_List_Ptr as = a->selector();
Expression_Ptr av = a->value();
selector_stack.push_back(0);
if (av) av = av->perform(&eval);
if (as) as = eval(as);
selector_stack.pop_back();
Block_Ptr bb = ab ? operator()(ab) : NULL;
Directive_Ptr aa = SASS_MEMORY_NEW(Directive,
a->pstate(),
a->keyword(),
as,
bb,
av);
return aa;
}
Statement_Ptr Expand::operator()(Declaration_Ptr d)
{
Block_Obj ab = d->block();
String_Obj old_p = d->property();
Expression_Obj prop = old_p->perform(&eval);
String_Obj new_p = Cast<String>(prop);
// we might get a color back
if (!new_p) {
std::string str(prop->to_string(ctx.c_options));
new_p = SASS_MEMORY_NEW(String_Constant, old_p->pstate(), str);
}
Expression_Obj value = d->value()->perform(&eval);
Block_Obj bb = ab ? operator()(ab) : NULL;
if (!bb) {
if (!value || (value->is_invisible() && !d->is_important())) return 0;
}
Declaration_Ptr decl = SASS_MEMORY_NEW(Declaration,
d->pstate(),
new_p,
value,
d->is_important(),
bb);
decl->tabs(d->tabs());
return decl;
}
Statement_Ptr Expand::operator()(Assignment_Ptr a)
{
Env* env = environment();
const std::string& var(a->variable());
if (a->is_global()) {
if (a->is_default()) {
if (env->has_global(var)) {
Expression_Obj e = Cast<Expression>(env->get_global(var));
if (!e || e->concrete_type() == Expression::NULL_VAL) {
env->set_global(var, a->value()->perform(&eval));
}
}
else {
env->set_global(var, a->value()->perform(&eval));
}
}
else {
env->set_global(var, a->value()->perform(&eval));
}
}
else if (a->is_default()) {
if (env->has_lexical(var)) {
auto cur = env;
while (cur && cur->is_lexical()) {
if (cur->has_local(var)) {
if (AST_Node_Obj node = cur->get_local(var)) {
Expression_Obj e = Cast<Expression>(node);
if (!e || e->concrete_type() == Expression::NULL_VAL) {
cur->set_local(var, a->value()->perform(&eval));
}
}
else {
throw std::runtime_error("Env not in sync");
}
return 0;
}
cur = cur->parent();
}
throw std::runtime_error("Env not in sync");
}
else if (env->has_global(var)) {
if (AST_Node_Obj node = env->get_global(var)) {
Expression_Obj e = Cast<Expression>(node);
if (!e || e->concrete_type() == Expression::NULL_VAL) {
env->set_global(var, a->value()->perform(&eval));
}
}
}
else if (env->is_lexical()) {
env->set_local(var, a->value()->perform(&eval));
}
else {
env->set_local(var, a->value()->perform(&eval));
}
}
else {
env->set_lexical(var, a->value()->perform(&eval));
}
return 0;
}
Statement_Ptr Expand::operator()(Import_Ptr imp)
{
Import_Obj result = SASS_MEMORY_NEW(Import, imp->pstate());
if (imp->import_queries() && imp->import_queries()->size()) {
Expression_Obj ex = imp->import_queries()->perform(&eval);
result->import_queries(Cast<List>(ex));
}
for ( size_t i = 0, S = imp->urls().size(); i < S; ++i) {
result->urls().push_back(imp->urls()[i]->perform(&eval));
}
// all resources have been dropped for Input_Stubs
// for ( size_t i = 0, S = imp->incs().size(); i < S; ++i) {}
return result.detach();
}
Statement_Ptr Expand::operator()(Import_Stub_Ptr i)
{
// get parent node from call stack
AST_Node_Obj parent = call_stack.back();
if (Cast<Block>(parent) == NULL) {
error("Import directives may not be used within control directives or mixins.", i->pstate());
}
// we don't seem to need that actually afterall
Sass_Import_Entry import = sass_make_import(
i->imp_path().c_str(),
i->abs_path().c_str(),
0, 0
);
ctx.import_stack.push_back(import);
const std::string& abs_path(i->resource().abs_path);
append_block(ctx.sheets.at(abs_path).root);
sass_delete_import(ctx.import_stack.back());
ctx.import_stack.pop_back();
return 0;
}
Statement_Ptr Expand::operator()(Warning_Ptr w)
{
// eval handles this too, because warnings may occur in functions
w->perform(&eval);
return 0;
}
Statement_Ptr Expand::operator()(Error_Ptr e)
{
// eval handles this too, because errors may occur in functions
e->perform(&eval);
return 0;
}
Statement_Ptr Expand::operator()(Debug_Ptr d)
{
// eval handles this too, because warnings may occur in functions
d->perform(&eval);
return 0;
}
Statement_Ptr Expand::operator()(Comment_Ptr c)
{
if (ctx.output_style() == COMPRESSED) {
// comments should not be evaluated in compact
// https://github.com/sass/libsass/issues/2359
if (!c->is_important()) return NULL;
}
eval.is_in_comment = true;
Comment_Ptr rv = SASS_MEMORY_NEW(Comment, c->pstate(), Cast<String>(c->text()->perform(&eval)), c->is_important());
eval.is_in_comment = false;
// TODO: eval the text, once we're parsing/storing it as a String_Schema
return rv;
}
Statement_Ptr Expand::operator()(If_Ptr i)
{
Env env(environment(), true);
env_stack.push_back(&env);
call_stack.push_back(i);
Expression_Obj rv = i->predicate()->perform(&eval);
if (*rv) {
append_block(i->block());
}
else {
Block_Ptr alt = i->alternative();
if (alt) append_block(alt);
}
call_stack.pop_back();
env_stack.pop_back();
return 0;
}
// For does not create a new env scope
// But iteration vars are reset afterwards
Statement_Ptr Expand::operator()(For_Ptr f)
{
std::string variable(f->variable());
Expression_Obj low = f->lower_bound()->perform(&eval);
if (low->concrete_type() != Expression::NUMBER) {
throw Exception::TypeMismatch(*low, "integer");
}
Expression_Obj high = f->upper_bound()->perform(&eval);
if (high->concrete_type() != Expression::NUMBER) {
throw Exception::TypeMismatch(*high, "integer");
}
Number_Obj sass_start = Cast<Number>(low);
Number_Obj sass_end = Cast<Number>(high);
// check if units are valid for sequence
if (sass_start->unit() != sass_end->unit()) {
std::stringstream msg; msg << "Incompatible units: '"
<< sass_start->unit() << "' and '"
<< sass_end->unit() << "'.";
error(msg.str(), low->pstate(), backtrace());
}
double start = sass_start->value();
double end = sass_end->value();
// only create iterator once in this environment
Env env(environment(), true);
env_stack.push_back(&env);
call_stack.push_back(f);
Block_Ptr body = f->block();
if (start < end) {
if (f->is_inclusive()) ++end;
for (double i = start;
i < end;
++i) {
Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());
env.set_local(variable, it);
append_block(body);
}
} else {
if (f->is_inclusive()) --end;
for (double i = start;
i > end;
--i) {
Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());
env.set_local(variable, it);
append_block(body);
}
}
call_stack.pop_back();
env_stack.pop_back();
return 0;
}
// Eval does not create a new env scope
// But iteration vars are reset afterwards
Statement_Ptr Expand::operator()(Each_Ptr e)
{
std::vector<std::string> variables(e->variables());
Expression_Obj expr = e->list()->perform(&eval);
List_Obj list = 0;
Map_Obj map;
if (expr->concrete_type() == Expression::MAP) {
map = Cast<Map>(expr);
}
else if (Selector_List_Ptr ls = Cast<Selector_List>(expr)) {
Listize listize;
Expression_Obj rv = ls->perform(&listize);
list = Cast<List>(rv);
}
else if (expr->concrete_type() != Expression::LIST) {
list = SASS_MEMORY_NEW(List, expr->pstate(), 1, SASS_COMMA);
list->append(expr);
}
else {
list = Cast<List>(expr);
}
// remember variables and then reset them
Env env(environment(), true);
env_stack.push_back(&env);
call_stack.push_back(e);
Block_Ptr body = e->block();
if (map) {
for (auto key : map->keys()) {
Expression_Obj k = key->perform(&eval);
Expression_Obj v = map->at(key)->perform(&eval);
if (variables.size() == 1) {
List_Obj variable = SASS_MEMORY_NEW(List, map->pstate(), 2, SASS_SPACE);
variable->append(k);
variable->append(v);
env.set_local(variables[0], variable);
} else {
env.set_local(variables[0], k);
env.set_local(variables[1], v);
}
append_block(body);
}
}
else {
// bool arglist = list->is_arglist();
if (list->length() == 1 && Cast<Selector_List>(list)) {
list = Cast<List>(list);
}
for (size_t i = 0, L = list->length(); i < L; ++i) {
Expression_Obj item = list->at(i);
// unwrap value if the expression is an argument
if (Argument_Obj arg = Cast<Argument>(item)) item = arg->value();
// check if we got passed a list of args (investigate)
if (List_Obj scalars = Cast<List>(item)) {
if (variables.size() == 1) {
List_Obj var = scalars;
// if (arglist) var = (*scalars)[0];
env.set_local(variables[0], var);
} else {
for (size_t j = 0, K = variables.size(); j < K; ++j) {
Expression_Obj res = j >= scalars->length()
? SASS_MEMORY_NEW(Null, expr->pstate())
: (*scalars)[j]->perform(&eval);
env.set_local(variables[j], res);
}
}
} else {
if (variables.size() > 0) {
env.set_local(variables.at(0), item);
for (size_t j = 1, K = variables.size(); j < K; ++j) {
Expression_Obj res = SASS_MEMORY_NEW(Null, expr->pstate());
env.set_local(variables[j], res);
}
}
}
append_block(body);
}
}
call_stack.pop_back();
env_stack.pop_back();
return 0;
}
Statement_Ptr Expand::operator()(While_Ptr w)
{
Expression_Obj pred = w->predicate();
Block_Ptr body = w->block();
Env env(environment(), true);
env_stack.push_back(&env);
call_stack.push_back(w);
Expression_Obj cond = pred->perform(&eval);
while (!cond->is_false()) {
append_block(body);
cond = pred->perform(&eval);
}
call_stack.pop_back();
env_stack.pop_back();
return 0;
}
Statement_Ptr Expand::operator()(Return_Ptr r)
{
error("@return may only be used within a function", r->pstate(), backtrace());
return 0;
}
void Expand::expand_selector_list(Selector_Obj s, Selector_List_Obj extender) {
if (Selector_List_Obj sl = Cast<Selector_List>(s)) {
for (Complex_Selector_Obj complex_selector : sl->elements()) {
Complex_Selector_Obj tail = complex_selector;
while (tail) {
if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {
if (Cast<Parent_Selector>(header) == NULL) continue; // skip all others
std::string sel_str(complex_selector->to_string(ctx.c_options));
error("Can't extend " + sel_str + ": can't extend parent selectors", header->pstate(), backtrace());
}
tail = tail->tail();
}
}
}
Selector_List_Obj contextualized = Cast<Selector_List>(s->perform(&eval));
if (contextualized == false) return;
for (auto complex_sel : contextualized->elements()) {
Complex_Selector_Obj c = complex_sel;
if (!c->head() || c->tail()) {
std::string sel_str(contextualized->to_string(ctx.c_options));
error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
}
Compound_Selector_Obj target = c->head();
if (contextualized->is_optional()) target->is_optional(true);
for (size_t i = 0, L = extender->length(); i < L; ++i) {
Complex_Selector_Obj sel = (*extender)[i];
if (!(sel->head() && sel->head()->length() > 0 &&
Cast<Parent_Selector>((*sel->head())[0])))
{
Compound_Selector_Obj hh = SASS_MEMORY_NEW(Compound_Selector, (*extender)[i]->pstate());
hh->media_block((*extender)[i]->media_block());
Complex_Selector_Obj ssel = SASS_MEMORY_NEW(Complex_Selector, (*extender)[i]->pstate());
ssel->media_block((*extender)[i]->media_block());
if (sel->has_line_feed()) ssel->has_line_feed(true);
Parent_Selector_Obj ps = SASS_MEMORY_NEW(Parent_Selector, (*extender)[i]->pstate());
ps->media_block((*extender)[i]->media_block());
hh->append(ps);
ssel->tail(sel);
ssel->head(hh);
sel = ssel;
}
// if (c->has_line_feed()) sel->has_line_feed(true);
ctx.subset_map.put(target, std::make_pair(sel, target));
}
}
}
Statement* Expand::operator()(Extension_Ptr e)
{
if (Selector_List_Ptr extender = selector()) {
Selector_List_Ptr sl = e->selector();
// abort on invalid selector
if (sl == NULL) return NULL;
if (Selector_Schema_Ptr schema = sl->schema()) {
if (schema->has_real_parent_ref()) {
// put root block on stack again (ignore parents)
// selector schema must not connect in eval!
block_stack.push_back(block_stack.at(1));
sl = eval(sl->schema());
block_stack.pop_back();
} else {
selector_stack.push_back(0);
sl = eval(sl->schema());
selector_stack.pop_back();
}
}
for (Complex_Selector_Obj cs : sl->elements()) {
if (!cs.isNull() && !cs->head().isNull()) {
cs->head()->media_block(media_block_stack.back());
}
}
selector_stack.push_back(0);
expand_selector_list(sl, extender);
selector_stack.pop_back();
}
return 0;
}
Statement_Ptr Expand::operator()(Definition_Ptr d)
{
Env* env = environment();
Definition_Obj dd = SASS_MEMORY_COPY(d);
env->local_frame()[d->name() +
(d->type() == Definition::MIXIN ? "[m]" : "[f]")] = dd;
if (d->type() == Definition::FUNCTION && (
Prelexer::calc_fn_call(d->name().c_str()) ||
d->name() == "element" ||
d->name() == "expression" ||
d->name() == "url"
)) {
deprecated(
"Naming a function \"" + d->name() + "\" is disallowed",
"This name conflicts with an existing CSS function with special parse rules.",
d->pstate()
);
}
// set the static link so we can have lexical scoping
dd->environment(env);
return 0;
}
Statement_Ptr Expand::operator()(Mixin_Call_Ptr c)
{
if (recursions > maxRecursion) {
throw Exception::StackError(*c);
}
recursions ++;
Env* env = environment();
std::string full_name(c->name() + "[m]");
if (!env->has(full_name)) {
error("no mixin named " + c->name(), c->pstate(), backtrace());
}
Definition_Obj def = Cast<Definition>((*env)[full_name]);
Block_Obj body = def->block();
Parameters_Obj params = def->parameters();
if (c->block() && c->name() != "@content" && !body->has_content()) {
error("Mixin \"" + c->name() + "\" does not accept a content block.", c->pstate(), backtrace());
}
Expression_Obj rv = c->arguments()->perform(&eval);
Arguments_Obj args = Cast<Arguments>(rv);
Backtrace new_bt(backtrace(), c->pstate(), ", in mixin `" + c->name() + "`");
backtrace_stack.push_back(&new_bt);
ctx.callee_stack.push_back({
c->name().c_str(),
c->pstate().path,
c->pstate().line + 1,
c->pstate().column + 1,
SASS_CALLEE_MIXIN,
{ env }
});
Env new_env(def->environment());
env_stack.push_back(&new_env);
if (c->block()) {
// represent mixin content blocks as thunks/closures
Definition_Obj thunk = SASS_MEMORY_NEW(Definition,
c->pstate(),
"@content",
SASS_MEMORY_NEW(Parameters, c->pstate()),
c->block(),
Definition::MIXIN);
thunk->environment(env);
new_env.local_frame()["@content[m]"] = thunk;
}
bind(std::string("Mixin"), c->name(), params, args, &ctx, &new_env, &eval);
Block_Obj trace_block = SASS_MEMORY_NEW(Block, c->pstate());
Trace_Obj trace = SASS_MEMORY_NEW(Trace, c->pstate(), c->name(), trace_block);
block_stack.push_back(trace_block);
for (auto bb : body->elements()) {
Statement_Obj ith = bb->perform(this);
if (ith) trace->block()->append(ith);
}
block_stack.pop_back();
env_stack.pop_back();
backtrace_stack.pop_back();
ctx.callee_stack.pop_back();
recursions --;
return trace.detach();
}
Statement_Ptr Expand::operator()(Content_Ptr c)
{
Env* env = environment();
// convert @content directives into mixin calls to the underlying thunk
if (!env->has("@content[m]")) return 0;
if (block_stack.back()->is_root()) {
selector_stack.push_back(0);
}
Mixin_Call_Obj call = SASS_MEMORY_NEW(Mixin_Call,
c->pstate(),
"@content",
SASS_MEMORY_NEW(Arguments, c->pstate()));
Trace_Obj trace = Cast<Trace>(call->perform(this));
if (block_stack.back()->is_root()) {
selector_stack.pop_back();
}
return trace.detach();
}
// produce an error if something is not implemented
inline Statement_Ptr Expand::fallback_impl(AST_Node_Ptr n)
{
std::string err =std:: string("`Expand` doesn't handle ") + typeid(*n).name();
String_Quoted_Obj msg = SASS_MEMORY_NEW(String_Quoted, ParserState("[WARN]"), err);
error("unknown internal error; please contact the LibSass maintainers", n->pstate(), backtrace());
return SASS_MEMORY_NEW(Warning, ParserState("[WARN]"), msg);
}
// process and add to last block on stack
inline void Expand::append_block(Block_Ptr b)
{
if (b->is_root()) call_stack.push_back(b);
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement_Ptr stm = b->at(i);
Statement_Obj ith = stm->perform(this);
if (ith) block_stack.back()->append(ith);
}
if (b->is_root()) call_stack.pop_back();
}
}