Каков алгоритм для парсинга выражений в инфиксной нотации?

Компания под названием Zynamics предлагает семантический дифференциальный инструмент двоичного уровня. Он использует мета-монтажный язык, называемый Reil для выполнения теоретического анализа графиков 2 версий двоичных и создает график с цветовой кодировкой для иллюстрации различий между ними. Я не уверен в цене, но я сомневаюсь, что это бесплатно.

Я реализовал шунтирующий алгоритм двора, как предложено плинтусом. Тем не менее, этот алгоритм просто дает вам постфикс, ака обратного польского языка (RNP). Вы все еще должны оценить его, но это довольно легко, как только у вас есть выражение в RNP (описано, например здесь ).

Код ниже может быть не хороший стиль PHP, мои знания PHP несколько ограничены. Это должно быть достаточно, чтобы получить идею, хотя.

$operators = array("and", "or", "not");
$num_operands = array("and" => 2, "or" => 2, "not" => 1);
$parenthesis  = array("(", ")");

function is_operator($token) {
    global $operators;
    return in_array($token, $operators);
}

function is_right_parenthesis($token) {
    global $parenthesis;
    return $token == $parenthesis[1];
}

function is_left_parenthesis($token) {
    global $parenthesis;
    return $token == $parenthesis[0];
}

function is_parenthesis($token) {
    return is_right_parenthesis($token) || is_left_parenthesis($token);
}

// check whether the precedence if $a is less than or equal to that of $b
function is_precedence_less_or_equal($a, $b) {
    // "not" always comes first
    if ($b == "not")
        return true;

    if ($a == "not")
        return false;

    if ($a == "or" and $b == "and")
        return true;

    if ($a == "and" and $b == "or")
        return false;

    // otherwise they're equal
    return true;
}


function shunting_yard($input_tokens) {
    $stack = array();
    $output_queue = array();

    foreach ($input_tokens as $token) {
        if (is_operator($token)) {
            while (is_operator($stack[count($stack)-1]) && is_precedence_less_or_equal($token, $stack[count($stack)-1])) {
                    $o2 = array_pop($stack);
                    array_push($output_queue, $o2);
            }
            array_push($stack, $token);

        } else if (is_parenthesis($token)) {
            if (is_left_parenthesis($token)) {
                array_push($stack, $token);
            } else {
                while (!is_left_parenthesis($stack[count($stack)-1]) && count($stack) > 0) {
                    array_push($output_queue, array_pop($stack));
                }
                if (count($stack) == 0) {
                    echo ("parse error");
                    die();
                }
                $lp = array_pop($stack);
            }
        } else {
            array_push($output_queue, $token);  
        }
    }

    while (count($stack) > 0) {
        $op = array_pop($stack);
        if (is_parenthesis($op))
            die("mismatched parenthesis");
        array_push($output_queue, $op);
    }

    return $output_queue;
}

function str2bool($s) {
    if ($s == "true")
        return true;
    if ($s == "false")
        return false;
    die('$s doesn\'t contain valid boolean string: '.$s.'\n');
}

function apply_operator($operator, $a, $b) {
    if (is_string($a))
        $a = str2bool($a);
    if (!is_null($b) and is_string($b))
        $b = str2bool($b);

    if ($operator == "and")
        return $a and $b;
    else if ($operator == "or")
        return $a or $b;
    else if ($operator == "not")
        return ! $a;
    else die("unknown operator `$function'");
}

function get_num_operands($operator) {
    global $num_operands;
    return $num_operands[$operator];
}

function is_unary($operator) {
    return get_num_operands($operator) == 1;
}

function is_binary($operator) {
    return get_num_operands($operator) == 2;
}

function eval_rpn($tokens) {
    $stack = array();
    foreach ($tokens as $t) {
        if (is_operator($t)) {
            if (is_unary($t)) {
                $o1 = array_pop($stack);
                $r = apply_operator($t, $o1, null);
                array_push($stack, $r);
            } else { // binary
                $o1 = array_pop($stack);
                $o2 = array_pop($stack);
                $r = apply_operator($t, $o1, $o2);
                array_push($stack, $r);
            }
        } else { // operand
            array_push($stack, $t);
        }
    }

    if (count($stack) != 1)
        die("invalid token array");

    return $stack[0];
}

// $input = array("A", "and", "B", "or", "C", "and", "(", "D", "or", "F", "or", "not", "G", ")");
$input = array("false", "and", "true", "or", "true", "and", "(", "false", "or", "false", "or", "not", "true", ")");
$tokens = shunting_yard($input);
$result = eval_rpn($tokens);
foreach($input as $t)
    echo $t." ";
echo "==> ".($result ? "true" : "false")."\n";

Я бы пошел с Pratt Parser. Это почти похоже на рекурсивный спуск, но умнее :) Достойное объяснение Дуглас Крукфорд (из славы jslint) здесь .

Есть URL для HTTP-запросов, которые я хотел бы также спрятаться.

Если ваше приложение делает запрос, нет смысла скрывать это. Запуск приложения, как Fiddler, HTTP Analyzer, или одна из десятков других бесплатных и легко доступных методов, покажет весь трафик вашего приложения.

Самый простой способ - использовать Regexes, которые преобразуют ваше выражение в выражение в синтаксисе PHP, а затем используют Eval, как предложено SymcBean. Но я не уверен, что вы хотите использовать его в продукции.

Другой способ - кодировать свой собственный простой рекурсивный анализатор спуска . Это не так сильно, как это может звучать. Для простой грамматики такие ваши (булевые выражения), вы можете легко код с нуля. Вы также можете использовать генератор анализатора, аналогичный ANTLR для PHP, возможно, поиск генератора PHP-анализатора будет что-то.

Вы можете использовать анализатор LR для создания дерева разбора, а затем оценить дерево для получения результата. Подробное описание, в том числе примеры, можно найти в Википедии . Если вы не закодировали это самостоятельно, я напишу небольшой пример сегодня вечером.

Рекурсивные анализаторы спуска FULL для записи и легко читать . Первый шаг - написать свою грамматику.

Может быть, это грамматика, которую вы хотите.

expr        = and_expr ('or' and_expr)*
and_expr    = not_expr ('and' not_expr)*
not_expr    = simple_expr | 'not' not_expr
simple_expr = term | '(' expr ')'

Включение этого в рекурсивный анализатор спуска - супер легко. Просто напишите одну функцию на нетермину.

def expr():
    x = and_expr()
    while peek() == 'or':
        consume('or')
        y = and_expr()
        x = OR(x, y)
    return x

def and_expr():
    x = not_expr()
    while peek() == 'and':
        consume('and')
        y = not_expr()
        x = AND(x, y)
    return x

def not_expr():
    if peek() == 'not':
        consume('not')
        x = not_expr()
        return NOT(x)
    else:
        return simple_expr()

def simple_expr():
    t = peek()
    if t == '(':
        consume('(')
        result = expr()
        consume(')')
        return result
    elif is_term(t):
        consume(t)
        return TERM(t)
    else:
        raise SyntaxError("expected term or (")

Это не завершено. Вы должны предоставить немного больше кода:

• входные функции. Потребляйте , , , а IS_Term - это функции, которые вы предоставляете. Они будут легко реализовать с использованием регулярных выражений. потребляют (ы) . Считывает следующий токен ввода и бросает ошибку, если она не совпадает S . PEEK () просто возвращает взгляд на следующий токен, не потребляя его. IS_Term (ы) Возвращает true, если - это термин.

• Выходные функции. ИЛИ , , , , , , а , и Термин вызывается каждый раз, когда часть выражения успешно проанализируется. Они могут делать все, что вы хотите.

• Функция обертки. вместо того, чтобы просто звонить EXPR напрямую, вы захотите написать небольшую функцию обертки, которая инициализирует переменные, используемые , потребляемым и PEEK , затем вызовы EXPR и, наконец, проверяет, чтобы убедиться, что нет вклада оставки, который не потреблял.