public function isPotentiallyEmpty(ExpressionInterface $expression)
{
/** @var RegexExpression $expression */
$parser = new RegexParser($expression->getRegex());
$able_to_match_empty_string = $parser->parse("") !== null;
return $able_to_match_empty_string;
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var ConcatenatedExpression $expression */
$part_expressions = array();
$mapping = array();
foreach ($expression->getParts() as $key => $part) {
if ($part instanceof ConcatenatedExpression === true && $part !== $expression) {
/** @var ConcatenatedExpression $part */
// $rewritten_inner_parts = array_map(function (ExpressionInterface $inner_part) {
// return $this->getRecursiveHandler()->rewriteExpression($inner_part);
// }, array_values($part->getParts()));
//
// $rewritten_inner_part_expressions = array_map(function (RewrittenExpressionContainer $rewritten) {
// return $rewritten->getExpression();
// }, $rewritten_inner_parts);
$part_expressions = array_merge($part_expressions, array_values($part->getParts()));
// $rewritten_part_expressions = array_map(function (RewrittenExpressionContainer $rewritten) {
// return $rewritten->getExpression();
// }, $rewritten_parts);
$mapping[] = array($key, array_keys($part->getParts()));
} else {
$part_expressions[] = $part;
$mapping[] = $key;
}
}
return new RewrittenExpressionContainer(new ConcatenatedExpression($part_expressions), new ConcatenatedResultFlattenSimplifier($mapping));
}
public function compile(ExpressionInterface $expression)
{
/** @var $expression \PeterVanDommelen\Parser\Expression\Constant\ConstantExpression */
if (strlen($expression->getString()) === 1) {
return new SingleByteParser($expression->getString());
}
return new ConstantParser($expression->getString());
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var ConcatenatedExpression $expression */
$parts = $expression->getParts();
$key = key($parts);
$part = current($parts);
$rewritten_part = $this->getRecursiveHandler()->rewriteExpression($part);
return new RewrittenExpressionContainer($rewritten_part->getExpression(), new ConcatenatedResultSimplifier($key, $rewritten_part->getResultRewriter()));
}
public function flattenExpression(ExpressionInterface $expression)
{
/** @var $expression \PeterVanDommelen\Parser\Expression\Concatenated\ConcatenatedExpression */
$expressions = array($expression);
foreach ($expression->getParts() as $part) {
$expressions = array_merge($expressions, $this->getRecursiveHandler()->flattenExpression($part));
}
return array_unique($expressions, SORT_REGULAR);
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var AlternativeExpression $expression */
$alternatives = $expression->getAlternatives();
$alternative = current($alternatives);
$key = key($alternatives);
$rewritten = $this->getRecursiveHandler()->rewriteExpression($alternative);
return new RewrittenExpressionContainer($rewritten->getExpression(), new AlternativeResultSimplifier($key, $rewritten->getResultRewriter()));
}
public function flattenExpression(ExpressionInterface $expression)
{
/** @var $expression AlternativeExpression */
$expressions = array($expression);
foreach ($expression->getAlternatives() as $alternative) {
$expressions = array_merge($expressions, $this->getRecursiveHandler()->flattenExpression($alternative));
}
return array_unique($expressions, SORT_REGULAR);
}
public function isPotentiallyEmpty(ExpressionInterface $expression)
{
/** @var $expression ConcatenatedExpression */
foreach ($expression->getParts() as $part) {
if ($this->getRecursiveHandler()->isPotentiallyEmpty($part) === false) {
return false;
}
}
return true;
}
public function isPotentiallyEmpty(ExpressionInterface $expression)
{
/** @var $expression AlternativeExpression */
$potentially_empty = false;
foreach ($expression->getAlternatives() as $alternative) {
$alternative_is_potentially_empty = $this->getRecursiveHandler()->isPotentiallyEmpty($alternative) === true;
$potentially_empty = $potentially_empty || $alternative_is_potentially_empty;
}
return $potentially_empty;
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var AlternativeExpression $expression */
$rewritten_alternatives = array_map(array($this->getRecursiveHandler(), "rewriteExpression"), $expression->getAlternatives());
$rewritten_alternative_expressions = array_map(function (RewrittenExpressionContainer $rewritten) {
return $rewritten->getExpression();
}, $rewritten_alternatives);
$rewritten_alternative_result_rewriters = array_map(function (RewrittenExpressionContainer $rewritten) {
return $rewritten->getResultRewriter();
}, $rewritten_alternatives);
return new RewrittenExpressionContainer(new AlternativeExpression($rewritten_alternative_expressions), new AlternativeExpressionResultRewriter($rewritten_alternative_result_rewriters));
}
public function isPotentiallyEmpty(ExpressionInterface $expression)
{
/** @var $expression RepeaterExpression */
//because this method is also used to detect left recursion we always need to access the inner expression
$inner_expression_empty = $this->getRecursiveHandler()->isPotentiallyEmpty($expression->getExpression());
if ($expression->getMinimum() === 0) {
return true;
}
if ($inner_expression_empty === true) {
return true;
}
return false;
}
public function compile(ExpressionInterface $expression)
{
/** @var $expression \PeterVanDommelen\Parser\Expression\Repeater\RepeaterExpression */
if ($expression->isLazy() === true) {
return new LazyRepeaterParser($this->getRecursiveHandler()->compile($expression->getExpression()), $expression->getMinimum(), $expression->getMaximum());
}
return new GreedyRepeaterParser($this->getRecursiveHandler()->compile($expression->getExpression()), $expression->getMinimum(), $expression->getMaximum());
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var JoinedExpression $expression */
$rewritten_inner_expression = $this->getRecursiveHandler()->rewriteExpression($expression->getExpression());
$rewritten_seperator_expression = $this->getRecursiveHandler()->rewriteExpression($expression->getSeperator());
$repeater_part = new ConcatenatedExpression(array($rewritten_seperator_expression->getExpression(), $rewritten_inner_expression->getExpression()));
$maximum = $expression->getMaximum();
if ($maximum !== null) {
$maximum = $maximum - 1;
}
$maybe_part = new ConcatenatedExpression(array($rewritten_inner_expression->getExpression(), new RepeaterExpression($repeater_part, $expression->isLazy(), max(0, $expression->getMinimum() - 1), $maximum)));
return new RewrittenExpressionContainer(new AlternativeExpression(array($maybe_part, new ConstantExpression(""))), new JoinedExpressionResultRewriter($rewritten_inner_expression->getResultRewriter(), $rewritten_seperator_expression->getResultRewriter()));
}
public function flattenExpression(ExpressionInterface $expression)
{
/** @var $expression NotExpression */
return array_unique(array_merge(array($expression), $this->getRecursiveHandler()->flattenExpression($expression->getExpression())), SORT_REGULAR);
}
public function flattenExpression(ExpressionInterface $expression)
{
/** @var $expression \PeterVanDommelen\Parser\Expression\Repeater\RepeaterExpression */
return array_unique(array_merge(array($expression), $this->getRecursiveHandler()->flattenExpression($expression->getExpression())), SORT_REGULAR);
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var NamedExpression $expression */
return $this->getRecursiveHandler()->rewriteExpression($this->grammar->getExpression($expression->getName()));
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var RepeaterExpression $expression */
$rewritten_inner = $this->getRecursiveHandler()->rewriteExpression($expression->getExpression());
return new RewrittenExpressionContainer(new RepeaterExpression($rewritten_inner->getExpression(), $expression->isLazy(), $expression->getMinimum(), $expression->getMaximum()), new RepeaterExpressionResultRewriter($rewritten_inner->getResultRewriter()));
}
public function isPotentiallyEmpty(ExpressionInterface $expression)
{
/** @var $expression \PeterVanDommelen\Parser\Expression\Constant\ConstantExpression */
return $expression->getString() === "";
}
public function compile(ExpressionInterface $expression)
{
/** @var $expression \PeterVanDommelen\Parser\Expression\Concatenated\ConcatenatedExpression */
return new ConcatenatedParser(array_map(array($this->getRecursiveHandler(), "compile"), $expression->getParts()));
}
public function compile(ExpressionInterface $expression)
{
/** @var $expression NotExpression */
return new NotParser($this->getRecursiveHandler()->compile($expression->getExpression()), $this->encoding);
}
public function compile(ExpressionInterface $expression)
{
/** @var RegexExpression $expression */
return new RegexParser($expression->getRegex());
}
public function rewriteExpression(ExpressionInterface $expression)
{
/** @var NotExpression $expression */
$inner = $this->getRecursiveHandler()->rewriteExpression($expression->getExpression());
return new RewrittenExpressionContainer(new NotExpression($inner->getExpression()), new TerminateExpressionResultRewriter());
}
public function compile(ExpressionInterface $expression)
{
/** @var $expression AlternativeExpression */
return new AlternativeParser(array_map(array($this->getRecursiveHandler(), "compile"), $expression->getAlternatives()));
}
