Statement* Cssize::bubble(Media_Block* m)
{
Ruleset* parent = static_cast<Ruleset*>(shallow_copy(this->parent()));
Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, parent->block()->pstate());
Ruleset* new_rule = SASS_MEMORY_NEW(ctx.mem, Ruleset,
parent->pstate(),
parent->selector(),
bb);
new_rule->tabs(parent->tabs());
for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
*new_rule->block() << (*m->block())[i];
}
Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
*wrapper_block << new_rule;
Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
m->pstate(),
m->media_queries(),
wrapper_block,
0);
mm->tabs(m->tabs());
Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
return bubble;
}
/* static function, throws OperationError, has no traces but optional pstate for returned value */
Value_Ptr op_number_color(enum Sass_OP op, const Number& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
{
double lval = lhs.value();
switch (op) {
case Sass_OP::ADD:
case Sass_OP::MUL: {
return SASS_MEMORY_NEW(Color,
pstate,
ops[op](lval, rhs.r()),
ops[op](lval, rhs.g()),
ops[op](lval, rhs.b()),
rhs.a());
}
case Sass_OP::SUB:
case Sass_OP::DIV: {
std::string color(rhs.to_string(opt));
return SASS_MEMORY_NEW(String_Quoted,
pstate,
lhs.to_string(opt)
+ sass_op_separator(op)
+ color);
}
default: break;
}
throw Exception::UndefinedOperation(&lhs, &rhs, op);
}
Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert, Context& ctx) {
if (toConvert.isNil()) {
return NULL;
}
if (!toConvert.isCollection()) {
throw "The node to convert to a Complex_Selector_Ptr must be a collection type or nil.";
}
NodeDeque& childNodes = *toConvert.collection();
std::string noPath("");
Position noPosition(-1, -1, -1);
Complex_Selector_Obj pFirst = SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL);
Complex_Selector_Obj pCurrent = pFirst;
if (toConvert.isSelector()) pFirst->has_line_feed(toConvert.got_line_feed);
if (toConvert.isCombinator()) pFirst->has_line_feed(toConvert.got_line_feed);
for (NodeDeque::iterator childIter = childNodes.begin(), childIterEnd = childNodes.end(); childIter != childIterEnd; childIter++) {
Node& child = *childIter;
if (child.isSelector()) {
// JMA - need to clone the selector, because they can end up getting shared across Node
// collections, and can result in an infinite loop during the call to parentSuperselector()
pCurrent->tail(SASS_MEMORY_COPY(child.selector()));
// if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
pCurrent = pCurrent->tail();
} else if (child.isCombinator()) {
pCurrent->combinator(child.combinator());
if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
// if the next node is also a combinator, create another Complex_Selector to hold it so it doesn't replace the current combinator
if (childIter+1 != childIterEnd) {
Node& nextNode = *(childIter+1);
if (nextNode.isCombinator()) {
pCurrent->tail(SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);
pCurrent = pCurrent->tail();
}
}
} else {
throw "The node to convert's children must be only combinators or selectors.";
}
}
// Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass
Compound_Selector_Ptr fakeHead = SASS_MEMORY_NEW(Compound_Selector, ParserState("[NODE]"), 1);
Parent_Selector_Ptr selectorRef = SASS_MEMORY_NEW(Parent_Selector, ParserState("[NODE]"));
fakeHead->elements().push_back(selectorRef);
if (toConvert.got_line_feed) pFirst->has_line_feed(toConvert.got_line_feed);
// pFirst->has_line_feed(pFirst->has_line_feed() || pFirst->tail()->has_line_feed() || toConvert.got_line_feed);
pFirst->head(fakeHead);
return SASS_MEMORY_COPY(pFirst);
}
Expression* Listize::operator()(Selector_List* sel)
{
List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), sel->length(), SASS_COMMA);
for (size_t i = 0, L = sel->length(); i < L; ++i) {
if (!(*sel)[i]) continue;
*l << (*sel)[i]->perform(this);
}
if (l->length()) return l;
return SASS_MEMORY_NEW(mem, Null, l->pstate());
}
Statement* Cssize::shallow_copy(Statement* s)
{
switch (s->statement_type())
{
case Statement::RULESET:
return SASS_MEMORY_NEW(ctx.mem, Ruleset, *static_cast<Ruleset*>(s));
case Statement::MEDIA:
return SASS_MEMORY_NEW(ctx.mem, Media_Block, *static_cast<Media_Block*>(s));
case Statement::BUBBLE:
return SASS_MEMORY_NEW(ctx.mem, Bubble, *static_cast<Bubble*>(s));
case Statement::DIRECTIVE:
return SASS_MEMORY_NEW(ctx.mem, At_Rule, *static_cast<At_Rule*>(s));
case Statement::SUPPORTS:
return SASS_MEMORY_NEW(ctx.mem, Supports_Block, *static_cast<Supports_Block*>(s));
case Statement::ATROOT:
return SASS_MEMORY_NEW(ctx.mem, At_Root_Block, *static_cast<At_Root_Block*>(s));
case Statement::KEYFRAMERULE:
return SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule, *static_cast<Keyframe_Rule*>(s));
case Statement::NONE:
default:
error("unknown internal error; please contact the LibSass maintainers", s->pstate(), backtrace);
String_Quoted* msg = SASS_MEMORY_NEW(ctx.mem, String_Quoted, ParserState("[WARN]"), std::string("`CSSize` can't clone ") + typeid(*s).name());
return SASS_MEMORY_NEW(ctx.mem, Warning, ParserState("[WARN]"), msg);
}
}
Expression_Ptr Listize::operator()(Selector_List_Ptr sel)
{
List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
l->from_selector(true);
for (size_t i = 0, L = sel->length(); i < L; ++i) {
if (!sel->at(i)) continue;
l->append(sel->at(i)->perform(this));
}
if (l->length()) return l.detach();
return SASS_MEMORY_NEW(Null, l->pstate());
}
Media_Query_Ptr Cssize::merge_media_query(Media_Query_Ptr mq1, Media_Query_Ptr mq2)
{
std::string type;
std::string mod;
std::string m1 = std::string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
std::string t1 = mq1->media_type() ? mq1->media_type()->to_string(ctx.c_options) : "";
std::string m2 = std::string(mq2->is_restricted() ? "only" : mq2->is_negated() ? "not" : "");
std::string t2 = mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
if (t1.empty()) t1 = t2;
if (t2.empty()) t2 = t1;
if ((m1 == "not") ^ (m2 == "not")) {
if (t1 == t2) {
return 0;
}
type = m1 == "not" ? t2 : t1;
mod = m1 == "not" ? m2 : m1;
}
else if (m1 == "not" && m2 == "not") {
if (t1 != t2) {
return 0;
}
type = t1;
mod = "not";
}
else if (t1 != t2) {
return 0;
} else {
type = t1;
mod = m1.empty() ? m2 : m1;
}
Media_Query_Ptr mm = SASS_MEMORY_NEW(Media_Query,
mq1->pstate(),
0,
mq1->length() + mq2->length(),
mod == "not",
mod == "only");
if (!type.empty()) {
mm->media_type(SASS_MEMORY_NEW(String_Quoted, mq1->pstate(), type));
}
mm->concat(mq2);
mm->concat(mq1);
return mm;
}
Media_Query* Cssize::merge_media_query(Media_Query* mq1, Media_Query* mq2)
{
To_String to_string(&ctx);
std::string type;
std::string mod;
std::string m1 = std::string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
std::string t1 = mq1->media_type() ? mq1->media_type()->perform(&to_string) : "";
std::string m2 = std::string(mq2->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
std::string t2 = mq2->media_type() ? mq2->media_type()->perform(&to_string) : "";
if (t1.empty()) t1 = t2;
if (t2.empty()) t2 = t1;
if ((m1 == "not") ^ (m2 == "not")) {
if (t1 == t2) {
return 0;
}
type = m1 == "not" ? t2 : t1;
mod = m1 == "not" ? m2 : m1;
}
else if (m1 == "not" && m2 == "not") {
if (t1 != t2) {
return 0;
}
type = t1;
mod = "not";
}
else if (t1 != t2) {
return 0;
} else {
type = t1;
mod = m1.empty() ? m2 : m1;
}
Media_Query* mm = SASS_MEMORY_NEW(ctx.mem, Media_Query,
mq1->pstate(), 0,
mq1->length() + mq2->length(), mod == "not", mod == "only"
);
if (!type.empty()) {
mm->media_type(SASS_MEMORY_NEW(ctx.mem, String_Quoted, mq1->pstate(), type));
}
*mm += mq2;
*mm += mq1;
return mm;
}
Statement_Ptr Cssize::operator()(Directive_Ptr r)
{
if (!r->block() || !r->block()->length()) return r;
if (parent()->statement_type() == Statement::RULESET)
{
return (r->is_keyframes()) ? SASS_MEMORY_NEW(Bubble, r->pstate(), r) : bubble(r);
}
p_stack.push_back(r);
Directive_Obj rr = SASS_MEMORY_NEW(Directive,
r->pstate(),
r->keyword(),
r->selector(),
r->block() ? operator()(r->block()) : 0);
if (r->value()) rr->value(r->value());
p_stack.pop_back();
bool directive_exists = false;
size_t L = rr->block() ? rr->block()->length() : 0;
for (size_t i = 0; i < L && !directive_exists; ++i) {
Statement_Obj s = r->block()->at(i);
if (s->statement_type() != Statement::BUBBLE) directive_exists = true;
else {
Bubble_Obj s_obj = Cast<Bubble>(s);
s = s_obj->node();
if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;
else directive_exists = (Cast<Directive>(s)->keyword() == rr->keyword());
}
}
Block_Ptr result = SASS_MEMORY_NEW(Block, rr->pstate());
if (!(directive_exists || rr->is_keyframes()))
{
Directive_Ptr empty_node = Cast<Directive>(rr);
empty_node->block(SASS_MEMORY_NEW(Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
result->append(empty_node);
}
Block_Obj db = rr->block();
if (db.isNull()) db = SASS_MEMORY_NEW(Block, rr->pstate());
Block_Obj ss = debubble(db, rr);
for (size_t i = 0, L = ss->length(); i < L; ++i) {
result->append(ss->at(i));
}
return result;
}
/* static function, throws OperationError, has no traces but optional pstate for returned value */
Value_Ptr op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
{
enum Sass_OP op = operand.operand;
String_Quoted_Ptr lqstr = Cast<String_Quoted>(&lhs);
String_Quoted_Ptr rqstr = Cast<String_Quoted>(&rhs);
std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
if (Cast<Null>(&lhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
if (Cast<Null>(&rhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
std::string sep;
switch (op) {
case Sass_OP::ADD: sep = ""; break;
case Sass_OP::SUB: sep = "-"; break;
case Sass_OP::DIV: sep = "/"; break;
case Sass_OP::EQ: sep = "=="; break;
case Sass_OP::NEQ: sep = "!="; break;
case Sass_OP::LT: sep = "<"; break;
case Sass_OP::GT: sep = ">"; break;
case Sass_OP::LTE: sep = "<="; break;
case Sass_OP::GTE: sep = ">="; break;
default:
throw Exception::UndefinedOperation(&lhs, &rhs, op);
break;
}
if (op == Sass_OP::ADD) {
// create string that might be quoted on output (but do not unquote what we pass)
return SASS_MEMORY_NEW(String_Quoted, pstate, lstr + rstr, 0, false, true);
}
// add whitespace around operator
// but only if result is not delayed
if (sep != "" && delayed == false) {
if (operand.ws_before) sep = " " + sep;
if (operand.ws_after) sep = sep + " ";
}
if (op == Sass_OP::SUB || op == Sass_OP::DIV) {
if (lqstr && lqstr->quote_mark()) lstr = quote(lstr);
if (rqstr && rqstr->quote_mark()) rstr = quote(rstr);
}
return SASS_MEMORY_NEW(String_Constant, pstate, lstr + sep + rstr);
}
Statement_Ptr Cssize::operator()(At_Root_Block_Ptr m)
{
bool tmp = false;
for (size_t i = 0, L = p_stack.size(); i < L; ++i) {
Statement_Ptr s = p_stack[i];
tmp |= m->exclude_node(s);
}
if (!tmp && m->block())
{
Block_Ptr bb = operator()(m->block());
for (size_t i = 0, L = bb->length(); i < L; ++i) {
// (bb->elements())[i]->tabs(m->tabs());
Statement_Obj stm = bb->at(i);
if (bubblable(stm)) stm->tabs(stm->tabs() + m->tabs());
}
if (bb->length() && bubblable(bb->last())) bb->last()->group_end(m->group_end());
return bb;
}
if (m->exclude_node(parent()))
{
return SASS_MEMORY_NEW(Bubble, m->pstate(), m);
}
return bubble(m);
}
// Selector_List is converted to a string
Value* To_Value::operator()(Selector_List* s)
{
To_String to_string(ctx.c_options);
return SASS_MEMORY_NEW(mem, String_Quoted,
s->pstate(),
s->perform(&to_string));
}
// Binary_Expression is converted to a string
Value* To_Value::operator()(Binary_Expression* s)
{
To_String to_string(ctx.c_options);
return SASS_MEMORY_NEW(mem, String_Quoted,
s->pstate(),
s->perform(&to_string));
}
Statement* Cssize::operator()(At_Root_Block* m)
{
bool tmp = false;
for (size_t i = 0, L = p_stack.size(); i < L; ++i) {
Statement* s = p_stack[i];
tmp |= m->exclude_node(s);
}
if (!tmp)
{
Block* bb = m->block()->perform(this)->block();
for (size_t i = 0, L = bb->length(); i < L; ++i) {
// (bb->elements())[i]->tabs(m->tabs());
if (bubblable((*bb)[i])) (*bb)[i]->tabs((*bb)[i]->tabs() + m->tabs());
}
if (bb->length() && bubblable(bb->last())) bb->last()->group_end(m->group_end());
return bb;
}
if (m->exclude_node(parent()))
{
return SASS_MEMORY_NEW(ctx.mem, Bubble, m->pstate(), m);
}
return bubble(m);
}
Statement* Cssize::operator()(At_Rule* r)
{
if (!r->block() || !r->block()->length()) return r;
if (parent()->statement_type() == Statement::RULESET)
{
return (r->is_keyframes()) ? SASS_MEMORY_NEW(ctx.mem, Bubble, r->pstate(), r) : bubble(r);
}
p_stack.push_back(r);
At_Rule* rr = SASS_MEMORY_NEW(ctx.mem, At_Rule,
r->pstate(),
r->keyword(),
r->selector(),
r->block() ? r->block()->perform(this)->block() : 0);
if (r->value()) rr->value(r->value());
p_stack.pop_back();
bool directive_exists = false;
size_t L = rr->block() ? rr->block()->length() : 0;
for (size_t i = 0; i < L && !directive_exists; ++i) {
Statement* s = (*r->block())[i];
if (s->statement_type() != Statement::BUBBLE) directive_exists = true;
else {
s = static_cast<Bubble*>(s)->node();
if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;
else directive_exists = (static_cast<At_Rule*>(s)->keyword() == rr->keyword());
}
}
Block* result = SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate());
if (!(directive_exists || rr->is_keyframes()))
{
At_Rule* empty_node = static_cast<At_Rule*>(rr);
empty_node->block(SASS_MEMORY_NEW(ctx.mem, Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
*result << empty_node;
}
Statement* ss = debubble(rr->block() ? rr->block() : SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate()), rr);
for (size_t i = 0, L = ss->block()->length(); i < L; ++i) {
*result << (*ss->block())[i];
}
return result;
}
Expression_Ptr Listize::operator()(Compound_Selector_Ptr sel)
{
std::string str;
for (size_t i = 0, L = sel->length(); i < L; ++i) {
Expression_Ptr e = (*sel)[i]->perform(this);
if (e) str += e->to_string();
}
return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
}
Block_Ptr Cssize::operator()(Block_Ptr b)
{
Block_Obj bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());
// bb->tabs(b->tabs());
block_stack.push_back(bb);
append_block(b, bb);
block_stack.pop_back();
return bb.detach();
}
Statement* Cssize::operator()(Block* b)
{
Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, b->pstate(), b->length(), b->is_root());
// bb->tabs(b->tabs());
block_stack.push_back(bb);
append_block(b);
block_stack.pop_back();
return bb;
}
Statement* Cssize::operator()(Ruleset* r)
{
p_stack.push_back(r);
Ruleset* rr = SASS_MEMORY_NEW(ctx.mem, Ruleset,
r->pstate(),
r->selector(),
r->block()->perform(this)->block());
// rr->tabs(r->block()->tabs());
p_stack.pop_back();
Block* props = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
Block* rules = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
for (size_t i = 0, L = rr->block()->length(); i < L; i++)
{
Statement* s = (*rr->block())[i];
if (bubblable(s)) *rules << s;
if (!bubblable(s)) *props << s;
}
if (props->length())
{
Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
*bb += props;
rr->block(bb);
for (size_t i = 0, L = rules->length(); i < L; i++)
{
(*rules)[i]->tabs((*rules)[i]->tabs() + 1);
}
rules->unshift(rr);
}
rules = debubble(rules)->block();
if (!(!rules->length() ||
!bubblable(rules->last()) ||
parent()->statement_type() == Statement::RULESET))
{
rules->last()->group_end(true);
}
return rules;
}
Expression* Listize::operator()(Compound_Selector* sel)
{
To_String to_string;
std::string str;
for (size_t i = 0, L = sel->length(); i < L; ++i) {
Expression* e = (*sel)[i]->perform(this);
if (e) str += e->perform(&to_string);
}
return SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), str);
}
Expression* Listize::operator()(Complex_Selector* sel)
{
List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), 2);
Compound_Selector* head = sel->head();
if (head && !head->is_empty_reference())
{
Expression* hh = head->perform(this);
if (hh) *l << hh;
}
To_String to_string;
std::string reference = ! sel->reference() ? ""
: sel->reference()->perform(&to_string);
switch(sel->combinator())
{
case Complex_Selector::PARENT_OF:
*l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), ">");
break;
case Complex_Selector::ADJACENT_TO:
*l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "+");
break;
case Complex_Selector::REFERENCE:
*l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "/" + reference + "/");
break;
case Complex_Selector::PRECEDES:
*l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "~");
break;
case Complex_Selector::ANCESTOR_OF:
break;
}
Complex_Selector* tail = sel->tail();
if (tail)
{
Expression* tt = tail->perform(this);
if (tt && tt->concrete_type() == Expression::LIST)
{ *l += static_cast<List*>(tt); }
else if (tt) *l << static_cast<List*>(tt);
}
if (l->length() == 0) return 0;
return l;
}
Statement_Ptr Cssize::operator()(Keyframe_Rule_Ptr r)
{
if (!r->block() || !r->block()->length()) return r;
Keyframe_Rule_Obj rr = SASS_MEMORY_NEW(Keyframe_Rule,
r->pstate(),
operator()(r->block()));
if (!r->name().isNull()) rr->name(r->name());
return debubble(rr->block(), rr);
}
Statement* Cssize::operator()(Media_Block* m)
{
if (parent()->statement_type() == Statement::RULESET)
{ return bubble(m); }
if (parent()->statement_type() == Statement::MEDIA)
{ return SASS_MEMORY_NEW(ctx.mem, Bubble, m->pstate(), m); }
p_stack.push_back(m);
Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
m->pstate(),
m->media_queries(),
m->block()->perform(this)->block());
mm->tabs(m->tabs());
p_stack.pop_back();
return debubble(mm->block(), mm)->block();
}
Statement_Ptr Cssize::operator()(Media_Block_Ptr m)
{
if (parent()->statement_type() == Statement::RULESET)
{ return bubble(m); }
if (parent()->statement_type() == Statement::MEDIA)
{ return SASS_MEMORY_NEW(Bubble, m->pstate(), m); }
p_stack.push_back(m);
Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
m->pstate(),
m->media_queries(),
operator()(m->block()));
mm->tabs(m->tabs());
p_stack.pop_back();
return debubble(mm->block(), mm);
}
Statement_Ptr Cssize::bubble(Directive_Ptr m)
{
Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
new_rule->block(bb);
new_rule->tabs(this->parent()->tabs());
new_rule->block()->concat(m->block());
Block_Obj wrapper_block = SASS_MEMORY_NEW(Block, m->block() ? m->block()->pstate() : m->pstate());
wrapper_block->append(new_rule);
Directive_Obj mm = SASS_MEMORY_NEW(Directive,
m->pstate(),
m->keyword(),
m->selector(),
wrapper_block);
if (m->value()) mm->value(m->value());
Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
return bubble;
}
Statement* Cssize::bubble(At_Root_Block* m)
{
Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, this->parent()->pstate());
Has_Block* new_rule = static_cast<Has_Block*>(shallow_copy(this->parent()));
new_rule->block(bb);
new_rule->tabs(this->parent()->tabs());
for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
*new_rule->block() << (*m->block())[i];
}
Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
*wrapper_block << new_rule;
At_Root_Block* mm = SASS_MEMORY_NEW(ctx.mem, At_Root_Block,
m->pstate(),
wrapper_block,
m->expression());
Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
return bubble;
}
Statement* Cssize::operator()(Keyframe_Rule* r)
{
if (!r->block() || !r->block()->length()) return r;
Keyframe_Rule* rr = SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule,
r->pstate(),
r->block()->perform(this)->block());
if (r->selector()) rr->selector(r->selector());
return debubble(rr->block(), rr)->block();
}
Statement_Ptr Cssize::bubble(At_Root_Block_Ptr m)
{
if (!m || !m->block()) return NULL;
Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
if (new_rule) {
new_rule->block(bb);
new_rule->tabs(this->parent()->tabs());
new_rule->block()->concat(m->block());
wrapper_block->append(new_rule);
}
At_Root_Block_Ptr mm = SASS_MEMORY_NEW(At_Root_Block,
m->pstate(),
wrapper_block,
m->expression());
Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
return bubble;
}
Expression_Ptr Listize::operator()(Complex_Selector_Ptr sel)
{
List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);
l->from_selector(true);
Compound_Selector_Obj head = sel->head();
if (head && !head->is_empty_reference())
{
Expression_Ptr hh = head->perform(this);
if (hh) l->append(hh);
}
std::string reference = ! sel->reference() ? ""
: sel->reference()->to_string();
switch(sel->combinator())
{
case Complex_Selector::PARENT_OF:
l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), ">"));
break;
case Complex_Selector::ADJACENT_TO:
l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "+"));
break;
case Complex_Selector::REFERENCE:
l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "/" + reference + "/"));
break;
case Complex_Selector::PRECEDES:
l->append(SASS_MEMORY_NEW(String_Quoted, sel->pstate(), "~"));
break;
case Complex_Selector::ANCESTOR_OF:
break;
}
Complex_Selector_Obj tail = sel->tail();
if (tail)
{
Expression_Obj tt = tail->perform(this);
if (List_Ptr ls = SASS_MEMORY_CAST(List, tt))
{ l->concat(ls); }
}
if (l->length() == 0) return 0;
return l.detach();
}
// List is a valid value
Value* To_Value::operator()(List* l)
{
List* ll = SASS_MEMORY_NEW(mem, List,
l->pstate(),
l->length(),
l->separator(),
l->is_arglist());
for (size_t i = 0, L = l->length(); i < L; ++i) {
*ll << (*l)[i]->perform(this);
}
return ll;
}
