FM / Components

/usr/share/php/PhpMyAdmin/SqlParser/Components/

/usr/share/php/PhpMyAdmin/SqlParser/Components

Name	Size	Mode	Actions
AlterOperation.php	9606	0644	edit dl rm
Array2d.php	3645	0644	edit dl rm
ArrayObj.php	5065	0644	edit dl rm
CaseExpression.php	10070	0644	edit dl rm
Condition.php	6053	0644	edit dl rm
CreateDefinition.php	10853	0644	edit dl rm
DataType.php	4674	0644	edit dl rm
Expression.php	15359	0644	edit dl rm
ExpressionArray.php	4094	0644	edit dl rm
FunctionCall.php	2999	0644	edit dl rm
GroupKeyword.php	3447	0644	edit dl rm
IndexHint.php	6475	0644	edit dl rm
IntoKeyword.php	8131	0644	edit dl rm
JoinKeyword.php	6449	0644	edit dl rm
Key.php	5555	0644	edit dl rm
Limit.php	3186	0644	edit dl rm
LockExpression.php	5836	0644	edit dl rm
OptionsArray.php	12439	0644	edit dl rm
OrderKeyword.php	3595	0644	edit dl rm
ParameterDefinition.php	4712	0644	edit dl rm
PartitionDefinition.php	7102	0644	edit dl rm
Reference.php	3922	0644	edit dl rm
RenameOperation.php	4909	0644	edit dl rm
SetOperation.php	4260	0644	edit dl rm
UnionKeyword.php	696	0644	edit dl rm

Edit: /usr/share/php/PhpMyAdmin/SqlParser/Components/LockExpression.php (5836B)

<?php
/**
 * Parses a reference to a LOCK expression.
 */

declare(strict_types=1);

namespace PhpMyAdmin\SqlParser\Components;

use PhpMyAdmin\SqlParser\Component;
use PhpMyAdmin\SqlParser\Parser;
use PhpMyAdmin\SqlParser\Token;
use PhpMyAdmin\SqlParser\TokensList;
use function implode;
use function is_array;

/**
 * Parses a reference to a LOCK expression.
 */
class LockExpression extends Component
{
    /**
     * The table to be locked.
     *
     * @var Expression
     */
    public $table;

/**
     * The type of lock to be applied.
     *
     * @var string
     */
    public $type;

/**
     * @param Parser     $parser  the parser that serves as context
     * @param TokensList $list    the list of tokens that are being parsed
     * @param array      $options parameters for parsing
     *
     * @return LockExpression
     */
    public static function parse(Parser $parser, TokensList $list, array $options = [])
    {
        $ret = new static();

/**
         * The state of the parser.
         *
         * Below are the states of the parser.
         *
         *      0 ---------------- [ tbl_name ] -----------------> 1
         *      1 ---------------- [ lock_type ] ----------------> 2
         *      2 -------------------- [ , ] --------------------> break
         *
         * @var int
         */
        $state = 0;

$prevToken = null;

for (; $list->idx < $list->count; ++$list->idx) {
            /**
             * Token parsed at this moment.
             *
             * @var Token
             */
            $token = $list->tokens[$list->idx];

// End of statement.
            if ($token->type === Token::TYPE_DELIMITER
                || ($token->type === Token::TYPE_OPERATOR
                && $token->value === ',')
            ) {
                break;
            }

if ($state === 0) {
                $ret->table = Expression::parse($parser, $list, ['parseField' => 'table']);
                $state = 1;
            } elseif ($state === 1) {
                // parse lock type
                $ret->type = self::parseLockType($parser, $list);
                $state = 2;
            }

$prevToken = $token;
        }

// 2 is the only valid end state
        if ($state !== 2) {
            $parser->error('Unexpected end of LOCK expression.', $prevToken);
        }

--$list->idx;

return $ret;
    }

/**
     * @param LockExpression|LockExpression[] $component the component to be built
     * @param array                           $options   parameters for building
     *
     * @return string
     */
    public static function build($component, array $options = [])
    {
        if (is_array($component)) {
            return implode(', ', $component);
        }

return $component->table . ' ' . $component->type;
    }

private static function parseLockType(Parser $parser, TokensList $list)
    {
        $lockType = '';

/**
         * The state of the parser while parsing for lock type.
         *
         * Below are the states of the parser.
         *
         *      0 ---------------- [ READ ] -----------------> 1
         *      0 ------------- [ LOW_PRIORITY ] ------------> 2
         *      0 ---------------- [ WRITE ] ----------------> 3
         *      1 ---------------- [ LOCAL ] ----------------> 3
         *      2 ---------------- [ WRITE ] ----------------> 3
         *
         * @var int
         */
        $state = 0;

$prevToken = null;

// End of statement.
            if ($token->type === Token::TYPE_DELIMITER
                || ($token->type === Token::TYPE_OPERATOR
                && $token->value === ',')
            ) {
                --$list->idx;
                break;
            }

// Skipping whitespaces and comments.
            if ($token->type === Token::TYPE_WHITESPACE || $token->type === Token::TYPE_COMMENT) {
                continue;
            }

// We only expect keywords
            if ($token->type !== Token::TYPE_KEYWORD) {
                $parser->error('Unexpected token.', $token);
                break;
            }

if ($state === 0) {
                if ($token->keyword === 'READ') {
                    $state = 1;
                } elseif ($token->keyword === 'LOW_PRIORITY') {
                    $state = 2;
                } elseif ($token->keyword === 'WRITE') {
                    $state = 3;
                } else {
                    $parser->error('Unexpected keyword.', $token);
                    break;
                }

$lockType .= $token->keyword;
            } elseif ($state === 1) {
                if ($token->keyword === 'LOCAL') {
                    $lockType .= ' ' . $token->keyword;
                    $state = 3;
                } else {
                    $parser->error('Unexpected keyword.', $token);
                    break;
                }
            } elseif ($state === 2) {
                if ($token->keyword === 'WRITE') {
                    $lockType .= ' ' . $token->keyword;
                    $state = 3; // parsing over
                } else {
                    $parser->error('Unexpected keyword.', $token);
                    break;
                }
            }

$prevToken = $token;
        }

// Only  two possible end states
        if ($state !== 1 && $state !== 3) {
            $parser->error('Unexpected end of Lock expression.', $prevToken);
        }

return $lockType;
    }
}

cmd: