Twig_Lexer Class Reference

Lexes a template string. More...

Inheritance diagram for Twig_Lexer:

Collaboration diagram for Twig_Lexer:

Public Member Functions
	__construct (Twig_Environment $env, array $options=array())
	tokenize ($code, $name=null)
	Tokenizes a source code. More...

Data Fields
const	STATE_DATA = 0
const	STATE_BLOCK = 1
const	STATE_VAR = 2
const	STATE_STRING = 3
const	STATE_INTERPOLATION = 4
const	REGEX_NAME = '/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A'
const	REGEX_NUMBER = '/[0-9]+(?:\.[0-9]+)?/A'
const	REGEX_STRING = '/"([^#"\\\\]*(?:\\\\.[^#"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As'
const	REGEX_DQ_STRING_DELIM = '/"/A'
const	REGEX_DQ_STRING_PART = '/[^#"\\\\]*(?:(?:\\\\.|#(?!\{))[^#"\\\\]*)*/As'
const	PUNCTUATION = '()[]{}?:.,|'

Protected Member Functions
	lexData ()
	lexBlock ()
	lexVar ()
	lexExpression ()
	lexRawData ($tag)
	lexComment ()
	lexString ()
	lexInterpolation ()
	pushToken ($type, $value='')
	moveCursor ($text)
	getOperatorRegex ()
	pushState ($state)
	popState ()

Protected Attributes
	$tokens
	$code
	$cursor
	$lineno
	$end
	$state
	$states
	$brackets
	$env
	$filename
	$options
	$regexes
	$position
	$positions
	$currentVarBlockLine

Private Attributes
	$source

Detailed Description

Lexes a template string.

Author

Fabien Potencier fabie.nosp@m.n@sy.nosp@m.mfony.nosp@m..com

Definition at line 18 of file Lexer.php.

Constructor & Destructor Documentation

__construct()

Twig_Lexer::__construct	(	Twig_Environment	$env,
		array	$options = array()
	)

Definition at line 52 of file Lexer.php.

References $env, $options, array, and getOperatorRegex().

    {
        $this->env = $env;

        $this->options = array_merge(array(
            'tag_comment' => array('{#', '#}'),
            'tag_block' => array('{%', '%}'),
            'tag_variable' => array('{{', '}}'),
            'whitespace_trim' => '-',
            'interpolation' => array('#{', '}'),
        ), $options);

        $this->regexes = array(
            'lex_var' => '/\s*'.preg_quote($this->options['whitespace_trim'].$this->options['tag_variable'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_variable'][1], '/').'/A',
            'lex_block' => '/\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')\n?/A',
            'lex_raw_data' => '/('.preg_quote($this->options['tag_block'][0].$this->options['whitespace_trim'], '/').'|'.preg_quote($this->options['tag_block'][0], '/').')\s*(?:end%s)\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')/s',
            'operator' => $this->getOperatorRegex(),
            'lex_comment' => '/(?:'.preg_quote($this->options['whitespace_trim'], '/').preg_quote($this->options['tag_comment'][1], '/').'\s*|'.preg_quote($this->options['tag_comment'][1], '/').')\n?/s',
            'lex_block_raw' => '/\s*(raw|verbatim)\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')/As',
            'lex_block_line' => '/\s*line\s+(\d+)\s*'.preg_quote($this->options['tag_block'][1], '/').'/As',
            'lex_tokens_start' => '/('.preg_quote($this->options['tag_variable'][0], '/').'|'.preg_quote($this->options['tag_block'][0], '/').'|'.preg_quote($this->options['tag_comment'][0], '/').')('.preg_quote($this->options['whitespace_trim'], '/').')?/s',
            'interpolation_start' => '/'.preg_quote($this->options['interpolation'][0], '/').'\s*/A',
            'interpolation_end' => '/\s*'.preg_quote($this->options['interpolation'][1], '/').'/A',
        );
    }

Here is the call graph for this function:

Member Function Documentation

getOperatorRegex()

Twig_Lexer::getOperatorRegex ( )

protected

Definition at line 381 of file Lexer.php.

References $r, and array.

Referenced by __construct().

    {
        $operators = array_merge(
            array('='),
            array_keys($this->env->getUnaryOperators()),
            array_keys($this->env->getBinaryOperators())
        );

        $operators = array_combine($operators, array_map('strlen', $operators));
        arsort($operators);

        $regex = array();
        foreach ($operators as $operator => $length) {
            // an operator that ends with a character must be followed by
            // a whitespace or a parenthesis
            if (ctype_alpha($operator[$length - 1])) {
                $r = preg_quote($operator, '/').'(?=[\s()])';
            } else {
                $r = preg_quote($operator, '/');
            }

            // an operator with a space can be any amount of whitespaces
            $r = preg_replace('/\s+/', '\s+', $r);

            $regex[] = $r;
        }

        return '/'.implode('|', $regex).'/A';
    }

Here is the caller graph for this function:

lexBlock()

Twig_Lexer::lexBlock ( )

protected

Definition at line 209 of file Lexer.php.

References Twig_Token\BLOCK_END_TYPE, lexExpression(), moveCursor(), popState(), and pushToken().

Referenced by tokenize().

    {
        if (empty($this->brackets) && preg_match($this->regexes['lex_block'], $this->code, $match, null, $this->cursor)) {
            $this->pushToken(Twig_Token::BLOCK_END_TYPE);
            $this->moveCursor($match[0]);
            $this->popState();
        } else {
            $this->lexExpression();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexComment()

Twig_Lexer::lexComment ( )

protected

Definition at line 319 of file Lexer.php.

References moveCursor().

Referenced by lexData().

    {
        if (!preg_match($this->regexes['lex_comment'], $this->code, $match, PREG_OFFSET_CAPTURE, $this->cursor)) {
            throw new Twig_Error_Syntax('Unclosed comment.', $this->lineno, $this->source);
        }

        $this->moveCursor(substr($this->code, $this->cursor, $match[0][1] - $this->cursor).$match[0][0]);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexData()

Twig_Lexer::lexData ( )

protected

Definition at line 153 of file Lexer.php.

References $end, $lineno, $position, $text, Twig_Token\BLOCK_START_TYPE, lexComment(), lexRawData(), moveCursor(), pushState(), pushToken(), Twig_Token\TEXT_TYPE, and Twig_Token\VAR_START_TYPE.

Referenced by tokenize().

    {
        // if no matches are left we return the rest of the template as simple text token
        if ($this->position == count($this->positions[0]) - 1) {
            $this->pushToken(Twig_Token::TEXT_TYPE, substr($this->code, $this->cursor));
            $this->cursor = $this->end;

            return;
        }

        // Find the first token after the current cursor
        $position = $this->positions[0][++$this->position];
        while ($position[1] < $this->cursor) {
            if ($this->position == count($this->positions[0]) - 1) {
                return;
            }
            $position = $this->positions[0][++$this->position];
        }

        // push the template text first
        $text = $textContent = substr($this->code, $this->cursor, $position[1] - $this->cursor);
        if (isset($this->positions[2][$this->position][0])) {
            $text = rtrim($text);
        }
        $this->pushToken(Twig_Token::TEXT_TYPE, $text);
        $this->moveCursor($textContent.$position[0]);

        switch ($this->positions[1][$this->position][0]) {
            case $this->options['tag_comment'][0]:
                $this->lexComment();
                break;

            case $this->options['tag_block'][0]:
                // raw data?
                if (preg_match($this->regexes['lex_block_raw'], $this->code, $match, null, $this->cursor)) {
                    $this->moveCursor($match[0]);
                    $this->lexRawData($match[1]);
                // {% line \d+ %}
                } elseif (preg_match($this->regexes['lex_block_line'], $this->code, $match, null, $this->cursor)) {
                    $this->moveCursor($match[0]);
                    $this->lineno = (int) $match[1];
                } else {
                    $this->pushToken(Twig_Token::BLOCK_START_TYPE);
                    $this->pushState(self::STATE_BLOCK);
                    $this->currentVarBlockLine = $this->lineno;
                }
                break;

            case $this->options['tag_variable'][0]:
                $this->pushToken(Twig_Token::VAR_START_TYPE);
                $this->pushState(self::STATE_VAR);
                $this->currentVarBlockLine = $this->lineno;
                break;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexExpression()

Twig_Lexer::lexExpression ( )

protected

Definition at line 231 of file Lexer.php.

References $cursor, $lineno, array, moveCursor(), Twig_Token\NAME_TYPE, Twig_Token\NUMBER_TYPE, Twig_Token\OPERATOR_TYPE, Twig_Token\PUNCTUATION_TYPE, pushState(), pushToken(), and Twig_Token\STRING_TYPE.

Referenced by lexBlock(), lexInterpolation(), and lexVar().

    {
        // whitespace
        if (preg_match('/\s+/A', $this->code, $match, null, $this->cursor)) {
            $this->moveCursor($match[0]);

            if ($this->cursor >= $this->end) {
                throw new Twig_Error_Syntax(sprintf('Unclosed "%s".', self::STATE_BLOCK === $this->state ? 'block' : 'variable'), $this->currentVarBlockLine, $this->source);
            }
        }

        // operators
        if (preg_match($this->regexes['operator'], $this->code, $match, null, $this->cursor)) {
            $this->pushToken(Twig_Token::OPERATOR_TYPE, preg_replace('/\s+/', ' ', $match[0]));
            $this->moveCursor($match[0]);
        }
        // names
        elseif (preg_match(self::REGEX_NAME, $this->code, $match, null, $this->cursor)) {
            $this->pushToken(Twig_Token::NAME_TYPE, $match[0]);
            $this->moveCursor($match[0]);
        }
        // numbers
        elseif (preg_match(self::REGEX_NUMBER, $this->code, $match, null, $this->cursor)) {
            $number = (float) $match[0];  // floats
            if (ctype_digit($match[0]) && $number <= PHP_INT_MAX) {
                $number = (int) $match[0]; // integers lower than the maximum
            }
            $this->pushToken(Twig_Token::NUMBER_TYPE, $number);
            $this->moveCursor($match[0]);
        }
        // punctuation
        elseif (false !== strpos(self::PUNCTUATION, $this->code[$this->cursor])) {
            // opening bracket
            if (false !== strpos('([{', $this->code[$this->cursor])) {
                $this->brackets[] = array($this->code[$this->cursor], $this->lineno);
            }
            // closing bracket
            elseif (false !== strpos(')]}', $this->code[$this->cursor])) {
                if (empty($this->brackets)) {
                    throw new Twig_Error_Syntax(sprintf('Unexpected "%s".', $this->code[$this->cursor]), $this->lineno, $this->source);
                }

                list($expect, $lineno) = array_pop($this->brackets);
                if ($this->code[$this->cursor] != strtr($expect, '([{', ')]}')) {
                    throw new Twig_Error_Syntax(sprintf('Unclosed "%s".', $expect), $lineno, $this->source);
                }
            }

            $this->pushToken(Twig_Token::PUNCTUATION_TYPE, $this->code[$this->cursor]);
            ++$this->cursor;
        }
        // strings
        elseif (preg_match(self::REGEX_STRING, $this->code, $match, null, $this->cursor)) {
            $this->pushToken(Twig_Token::STRING_TYPE, stripcslashes(substr($match[0], 1, -1)));
            $this->moveCursor($match[0]);
        }
        // opening double quoted string
        elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, null, $this->cursor)) {
            $this->brackets[] = array('"', $this->lineno);
            $this->pushState(self::STATE_STRING);
            $this->moveCursor($match[0]);
        }
        // unlexable
        else {
            throw new Twig_Error_Syntax(sprintf('Unexpected character "%s".', $this->code[$this->cursor]), $this->lineno, $this->source);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexInterpolation()

Twig_Lexer::lexInterpolation ( )

protected

Definition at line 352 of file Lexer.php.

References Twig_Token\INTERPOLATION_END_TYPE, lexExpression(), moveCursor(), popState(), and pushToken().

Referenced by tokenize().

    {
        $bracket = end($this->brackets);
        if ($this->options['interpolation'][0] === $bracket[0] && preg_match($this->regexes['interpolation_end'], $this->code, $match, null, $this->cursor)) {
            array_pop($this->brackets);
            $this->pushToken(Twig_Token::INTERPOLATION_END_TYPE);
            $this->moveCursor($match[0]);
            $this->popState();
        } else {
            $this->lexExpression();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexRawData()

Twig_Lexer::lexRawData (   $tag )

protected

Definition at line 299 of file Lexer.php.

References $tag, $text, moveCursor(), pushToken(), and Twig_Token\TEXT_TYPE.

Referenced by lexData().

    {
        if ('raw' === $tag) {
            @trigger_error(sprintf('Twig Tag "raw" is deprecated since version 1.21. Use "verbatim" instead in %s at line %d.', $this->filename, $this->lineno), E_USER_DEPRECATED);
        }

        if (!preg_match(str_replace('%s', $tag, $this->regexes['lex_raw_data']), $this->code, $match, PREG_OFFSET_CAPTURE, $this->cursor)) {
            throw new Twig_Error_Syntax(sprintf('Unexpected end of file: Unclosed "%s" block.', $tag), $this->lineno, $this->source);
        }

        $text = substr($this->code, $this->cursor, $match[0][1] - $this->cursor);
        $this->moveCursor($text.$match[0][0]);

        if (false !== strpos($match[1][0], $this->options['whitespace_trim'])) {
            $text = rtrim($text);
        }

        $this->pushToken(Twig_Token::TEXT_TYPE, $text);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexString()

Twig_Lexer::lexString ( )

protected

Definition at line 328 of file Lexer.php.

References $cursor, $lineno, array, Twig_Token\INTERPOLATION_START_TYPE, moveCursor(), popState(), pushState(), pushToken(), and Twig_Token\STRING_TYPE.

Referenced by tokenize().

    {
        if (preg_match($this->regexes['interpolation_start'], $this->code, $match, null, $this->cursor)) {
            $this->brackets[] = array($this->options['interpolation'][0], $this->lineno);
            $this->pushToken(Twig_Token::INTERPOLATION_START_TYPE);
            $this->moveCursor($match[0]);
            $this->pushState(self::STATE_INTERPOLATION);
        } elseif (preg_match(self::REGEX_DQ_STRING_PART, $this->code, $match, null, $this->cursor) && strlen($match[0]) > 0) {
            $this->pushToken(Twig_Token::STRING_TYPE, stripcslashes($match[0]));
            $this->moveCursor($match[0]);
        } elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, null, $this->cursor)) {
            list($expect, $lineno) = array_pop($this->brackets);
            if ('"' != $this->code[$this->cursor]) {
                throw new Twig_Error_Syntax(sprintf('Unclosed "%s".', $expect), $lineno, $this->source);
            }

            $this->popState();
            ++$this->cursor;
        } else {
            // unlexable
            throw new Twig_Error_Syntax(sprintf('Unexpected character "%s".', $this->code[$this->cursor]), $this->lineno, $this->source);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

lexVar()

Twig_Lexer::lexVar ( )

protected

Definition at line 220 of file Lexer.php.

References lexExpression(), moveCursor(), popState(), pushToken(), and Twig_Token\VAR_END_TYPE.

Referenced by tokenize().

    {
        if (empty($this->brackets) && preg_match($this->regexes['lex_var'], $this->code, $match, null, $this->cursor)) {
            $this->pushToken(Twig_Token::VAR_END_TYPE);
            $this->moveCursor($match[0]);
            $this->popState();
        } else {
            $this->lexExpression();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

moveCursor()

Twig_Lexer::moveCursor (   $text )

protected

Definition at line 375 of file Lexer.php.

References $text.

Referenced by lexBlock(), lexComment(), lexData(), lexExpression(), lexInterpolation(), lexRawData(), lexString(), and lexVar().

    {
        $this->cursor += strlen($text);
        $this->lineno += substr_count($text, "\n");
    }

Here is the caller graph for this function:

popState()

Twig_Lexer::popState ( )

protected

Definition at line 417 of file Lexer.php.

Referenced by lexBlock(), lexInterpolation(), lexString(), and lexVar().

    {
        if (0 === count($this->states)) {
            throw new Exception('Cannot pop state without a previous state.');
        }

        $this->state = array_pop($this->states);
    }

Here is the caller graph for this function:

pushState()

Twig_Lexer::pushState (   $state )

protected

Definition at line 411 of file Lexer.php.

References $state.

Referenced by lexData(), lexExpression(), and lexString().

    {
        $this->states[] = $this->state;
        $this->state = $state;
    }

Here is the caller graph for this function:

pushToken()

Twig_Lexer::pushToken (   $type,   $value = ''  )

protected

Definition at line 365 of file Lexer.php.

References $type, and Twig_Token\TEXT_TYPE.

Referenced by lexBlock(), lexData(), lexExpression(), lexInterpolation(), lexRawData(), lexString(), lexVar(), and tokenize().

    {
        // do not push empty text tokens
        if (Twig_Token::TEXT_TYPE === $type && '' === $value) {
            return;
        }

        $this->tokens[] = new Twig_Token($type, $value, $this->lineno);
    }

Here is the caller graph for this function:

tokenize()

Twig_Lexer::tokenize	(		$code,
			$name = null
	)

Tokenizes a source code.

Parameters

string | Twig_Source	$code	The source code
string	$name	A unique identifier for the source code

Returns

Twig_TokenStream

Exceptions

Twig_Error_Syntax

When the code is syntactically wrong

Implements Twig_LexerInterface.

Definition at line 78 of file Lexer.php.

References $code, $lineno, $name, array, Twig_Token\EOF_TYPE, lexBlock(), lexData(), lexInterpolation(), lexString(), lexVar(), and pushToken().

    {
        if (!$code instanceof Twig_Source) {
            @trigger_error(sprintf('Passing a string as the $code argument of %s() is deprecated since version 1.27 and will be removed in 2.0. Pass a Twig_Source instance instead.', __METHOD__), E_USER_DEPRECATED);
            $this->source = new Twig_Source($code, $name);
        } else {
            $this->source = $code;
        }

        if (((int) ini_get('mbstring.func_overload')) & 2) {
            @trigger_error('Support for having "mbstring.func_overload" different from 0 is deprecated version 1.29 and will be removed in 2.0.', E_USER_DEPRECATED);
        }

        if (function_exists('mb_internal_encoding') && ((int) ini_get('mbstring.func_overload')) & 2) {
            $mbEncoding = mb_internal_encoding();
            mb_internal_encoding('ASCII');
        } else {
            $mbEncoding = null;
        }

        $this->code = str_replace(array("\r\n", "\r"), "\n", $this->source->getCode());
        $this->filename = $this->source->getName();
        $this->cursor = 0;
        $this->lineno = 1;
        $this->end = strlen($this->code);
        $this->tokens = array();
        $this->state = self::STATE_DATA;
        $this->states = array();
        $this->brackets = array();
        $this->position = -1;

        // find all token starts in one go
        preg_match_all($this->regexes['lex_tokens_start'], $this->code, $matches, PREG_OFFSET_CAPTURE);
        $this->positions = $matches;

        while ($this->cursor < $this->end) {
            // dispatch to the lexing functions depending
            // on the current state
            switch ($this->state) {
                case self::STATE_DATA:
                    $this->lexData();
                    break;

                case self::STATE_BLOCK:
                    $this->lexBlock();
                    break;

                case self::STATE_VAR:
                    $this->lexVar();
                    break;

                case self::STATE_STRING:
                    $this->lexString();
                    break;

                case self::STATE_INTERPOLATION:
                    $this->lexInterpolation();
                    break;
            }
        }

        $this->pushToken(Twig_Token::EOF_TYPE);

        if (!empty($this->brackets)) {
            list($expect, $lineno) = array_pop($this->brackets);
            throw new Twig_Error_Syntax(sprintf('Unclosed "%s".', $expect), $lineno, $this->source);
        }

        if ($mbEncoding) {
            mb_internal_encoding($mbEncoding);
        }

        return new Twig_TokenStream($this->tokens, $this->source);
    }

Here is the call graph for this function:

Field Documentation

$brackets

Twig_Lexer::$brackets

protected

Definition at line 27 of file Lexer.php.

$code

Twig_Lexer::$code

protected

Definition at line 21 of file Lexer.php.

Referenced by tokenize().

$currentVarBlockLine

Twig_Lexer::$currentVarBlockLine

protected

Definition at line 35 of file Lexer.php.

$cursor

Twig_Lexer::$cursor

protected

Definition at line 22 of file Lexer.php.

Referenced by lexExpression(), and lexString().

$end

Twig_Lexer::$end

protected

Definition at line 24 of file Lexer.php.

Referenced by lexData().

$env

Twig_Lexer::$env

protected

Definition at line 28 of file Lexer.php.

Referenced by __construct().

$filename

Twig_Lexer::$filename

protected

Definition at line 30 of file Lexer.php.

$lineno

Twig_Lexer::$lineno

protected

Definition at line 23 of file Lexer.php.

Referenced by lexData(), lexExpression(), lexString(), and tokenize().

$options

Twig_Lexer::$options

protected

Definition at line 31 of file Lexer.php.

Referenced by __construct().

$position

Twig_Lexer::$position

protected

Definition at line 33 of file Lexer.php.

Referenced by lexData().

$positions

Twig_Lexer::$positions

protected

Definition at line 34 of file Lexer.php.

$regexes

Twig_Lexer::$regexes

protected

Definition at line 32 of file Lexer.php.

$source

Twig_Lexer::$source

private

Definition at line 37 of file Lexer.php.

$state

Twig_Lexer::$state

protected

Definition at line 25 of file Lexer.php.

Referenced by pushState().

$states

Twig_Lexer::$states

protected

Definition at line 26 of file Lexer.php.

$tokens

Twig_Lexer::$tokens

protected

Definition at line 20 of file Lexer.php.

PUNCTUATION

const Twig_Lexer::PUNCTUATION = '()[]{}?:.,|'

Definition at line 50 of file Lexer.php.

REGEX_DQ_STRING_DELIM

const Twig_Lexer::REGEX_DQ_STRING_DELIM = '/"/A'

Definition at line 48 of file Lexer.php.

REGEX_DQ_STRING_PART

const Twig_Lexer::REGEX_DQ_STRING_PART = '/[^#"\\\\]*(?:(?:\\\\.|#(?!\{))[^#"\\\\]*)*/As'

Definition at line 49 of file Lexer.php.

REGEX_NAME

const Twig_Lexer::REGEX_NAME = '/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A'

Definition at line 45 of file Lexer.php.

Referenced by Twig_ExpressionParser\parsePrimaryExpression(), and Twig_ExpressionParser\parseSubscriptExpression().

REGEX_NUMBER

const Twig_Lexer::REGEX_NUMBER = '/[0-9]+(?:\.[0-9]+)?/A'

Definition at line 46 of file Lexer.php.

REGEX_STRING

const Twig_Lexer::REGEX_STRING = '/"([^#"\\\\]*(?:\\\\.[^#"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As'

Definition at line 47 of file Lexer.php.

STATE_BLOCK

const Twig_Lexer::STATE_BLOCK = 1

Definition at line 40 of file Lexer.php.

STATE_DATA

const Twig_Lexer::STATE_DATA = 0

Definition at line 39 of file Lexer.php.

STATE_INTERPOLATION

const Twig_Lexer::STATE_INTERPOLATION = 4

Definition at line 43 of file Lexer.php.

STATE_STRING

const Twig_Lexer::STATE_STRING = 3

Definition at line 42 of file Lexer.php.

STATE_VAR

const Twig_Lexer::STATE_VAR = 2

Definition at line 41 of file Lexer.php.

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/twig/twig/lib/Twig/Lexer.php