ast.php

博客系统源码 博客系统源码 博客系统源码

    {
        parent::__construct($lineno);
        $this->expr = $expr;
    }

    public function compile($compiler)
    {
        $compiler->addDebugInfo($this);
        $compiler->raw('echo url(');
        $this->expr->compile($compiler);
        $compiler->raw(');'."\n");
    }
}


class Twig_AdminURL extends Twig_Node
{
    public $expr;

    public function __construct($expr, $lineno)
    {
        parent::__construct($lineno);
        $this->expr = $expr;
    }

    public function compile($compiler)
    {
        $compiler->addDebugInfo($this);
        $compiler->raw('echo fix(Config::current()->chyrp_url."/admin/?action=".(');
        $this->expr->compile($compiler);
        $compiler->raw('));'."\n");
    }
}


class Twig_Expression extends Twig_Node
{

}


class Twig_ConditionalExpression extends Twig_Expression
{
    public $expr1;
    public $expr2;
    public $expr3;

    public function __construct($expr1, $expr2, $expr3, $lineno)
    {
        parent::__construct($lineno);
        $this->expr1 = $expr1;
        $this->expr2 = $expr2;
        $this->expr3 = $expr3;
    }

    public function compile($compiler)
    {
        $compiler->raw('(');
        $this->expr1->compile($compiler);
        $compiler->raw(') ? (');
        $this->expr2->compile($compiler);
        $compiler->raw(') ; (');
        $this->expr3->compile($compiler);
        $compiler->raw(')');
    }
}


class Twig_BinaryExpression extends Twig_Expression
{
    public $left;
    public $right;

    public function __construct($left, $right, $lineno)
    {
        parent::__construct($lineno);
        $this->left = $left;
        $this->right = $right;
    }

    public function compile($compiler)
    {
        $compiler->raw('(');
        $this->left->compile($compiler);
        $compiler->raw(') ');
        $this->operator($compiler);
        $compiler->raw(' (');
        $this->right->compile($compiler);
        $compiler->raw(')');
    }
}


class Twig_OrExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('||');
    }
}


class Twig_AndExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('&&');
    }
}


class Twig_AddExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('+');
    }
}


class Twig_SubExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('-');
    }
}


class Twig_ConcatExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('.');
    }
}


class Twig_MulExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('*');
    }
}


class Twig_DivExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('/');
    }
}


class Twig_ModExpression extends Twig_BinaryExpression
{
    public function operator($compiler)
    {
        return $compiler->raw('%');
    }
}


class Twig_CompareExpression extends Twig_Expression
{
    public $expr;
    public $ops;

    public function __construct($expr, $ops, $lineno)
    {
        parent::__construct($lineno);
        $this->expr = $expr;
        $this->ops = $ops;
    }

    public function compile($compiler)
    {
        $this->expr->compile($compiler);
        $i = 0;
        foreach ($this->ops as $op) {
            if ($i)
                $compiler->raw(' && ($tmp' . $i);
            list($op, $node) = $op;
            $compiler->raw(' ' . $op . ' ');
            $compiler->raw('($tmp' . ++$i . ' = ');
            $node->compile($compiler);
            $compiler->raw(')');
        }
        if ($i > 1)
            $compiler->raw(')');
    }
}


class Twig_UnaryExpression extends Twig_Expression
{
    public $node;

    public function __construct($node, $lineno)
    {
        parent::__construct($lineno);
        $this->node = $node;
    }

    public function compile($compiler)
    {
        $compiler->raw('(');
        $this->operator($compiler);
        $this->node->compile($compiler);
        $compiler->raw(')');
    }
}


class Twig_NotExpression extends Twig_UnaryExpression
{
    public function operator($compiler)
    {
        $compiler->raw('!');
    }
}


class Twig_NegExpression extends Twig_UnaryExpression
{
    public function operator($compiler)
    {
        $compiler->raw('-');
    }
}


class Twig_PosExpression extends Twig_UnaryExpression
{
    public function operator($compiler)
    {
        $compiler->raw('+');
    }
}


class Twig_Constant extends Twig_Expression
{
    public $value;

    public function __construct($value, $lineno)
    {
        parent::__construct($lineno);
        $this->value = $value;
    }

    public function compile($compiler)
    {
        $compiler->repr($this->value);
    }
}


class Twig_NameExpression extends Twig_Expression
{
    public $name;

    public function __construct($name, $lineno)
    {
        parent::__construct($lineno);
        $this->name = $name;
    }

    public function compile($compiler)
    {
        $compiler->format('(isset($context[\'%s\']) ? $context[\'%s\'] ' .
                  ': NULL)', $this->name, $this->name);
    }
}


class Twig_AssignNameExpression extends Twig_NameExpression
{

    public function compile($compiler)
    {
        $compiler->format('$context[\'%s\']', $this->name);
    }
}


class Twig_GetAttrExpression extends Twig_Expression
{
    public $node;
    public $attr;

    public function __construct($node, $attr, $lineno, $token_value)
    {
        parent::__construct($lineno);
        $this->node = $node;
        $this->attr = $attr;
        $this->token_value = $token_value;
    }

    public function compile($compiler)
    {
        $compiler->raw('twig_get_attribute(');
        $this->node->compile($compiler);
        $compiler->raw(', ');
        $this->attr->compile($compiler);
        if ($this->token_value == "[") # Don't look for functions if they're using foo[bar]
            $compiler->raw(', false');
        $compiler->raw(')');
    }
}


class Twig_MethodCallExpression extends Twig_Expression
{
    public $node;
    public $method;
    public $arguments;

    public function __construct($node, $method, $arguments, $lineno)
    {
        parent::__construct($lineno);
        $this->node = $node;
        $this->method = $method;
        $this->arguments = $arguments;
    }

    public function compile($compiler)
    {
        $compiler->raw('call_user_func(array(');
        $this->node->compile($compiler);
        $compiler->raw(', ');
        $this->method->compile($compiler);
        $compiler->raw(')');
        foreach ($this->arguments as $argument) {
            $compiler->raw(', ');
            $argument->compile($compiler);
        }
        $compiler->raw(')');
    }
}


class Twig_FilterExpression extends Twig_Expression
{
    public $node;
    public $filters;

    public function __construct($node, $filters, $lineno)
    {
        parent::__construct($lineno);
        $this->node = $node;
        $this->filters = $filters;
    }

    public function compile($compiler)
    {
        global $twig_filters;
        $postponed = array();
        for ($i = count($this->filters) - 1; $i >= 0; --$i) {
            list($name, $attrs) = $this->filters[$i];
            if (!isset($twig_filters[$name])) {
                $compiler->raw('twig_missing_filter(');
                $compiler->repr($name);
                $compiler->raw(', ');
            }
            else
                $compiler->raw($twig_filters[$name] . '(');
            $postponed[] = $attrs;
        }
        $this->node->compile($compiler);
        foreach (array_reverse($postponed) as $attributes) {
            foreach ($attributes as $node) {
                $compiler->raw(', ');
                $node->compile($compiler);
            }
            $compiler->raw(')');
        }
    }
}