Das deutsche Python-Forum

Code: Alles auswählen

public errordomain ParseError {
    UNEXPECTED
}


private static void throw_parse_error (
    Scanner scanner, TokenType expected_token
)
    throws ParseError
{
    scanner.unexp_token (expected_token, null, null, null, null, true);
    throw new ParseError.UNEXPECTED ("unexpected token");
}


public interface Evaluable : Object {
    public abstract int evaluate ();
}


public class Value : Object, Evaluable {
    private int value;
    
    public Value (int value) { this.value = value; }
    
    public Value.from_scanner (Scanner scanner) throws ParseError {
        if (scanner.get_next_token () != TokenType.INT) {
            throw_parse_error (scanner, TokenType.INT);
        }
        
        this ((int) scanner.value.int);
    }
    
    public int evaluate () { return this.value; }
}


public class BinaryOperation : Object, Evaluable {
    delegate int BinaryFunction(int a, int b);
    
    private BinaryFunction operation;
    private Evaluable operand_a;
    private Evaluable operand_b;
    
    public BinaryOperation (
        char symbol, Evaluable operand_a, Evaluable operand_b)
    {
        switch (symbol) {
            case '+':
                this.operation = (a, b) => a + b;
                break;
            case '-':
                this.operation = (a, b) => a - b;
                break;
            default:
                assert_not_reached ();
        }
        this.operand_a = operand_a;
        this.operand_b = operand_b;
    }
    
    public int evaluate () {
        return this.operation (
            this.operand_a.evaluate (), this.operand_b.evaluate ()
        );
    }
}


private static char parse_operator (Scanner scanner) throws ParseError
    ensures (result in '+' || result == '-')
{
    var symbol = scanner.get_next_token ();
    
    if (symbol != '+' && symbol != '-') {
        throw_parse_error (scanner, TokenType.SYMBOL);
    }
    
    return symbol;
}


private static Evaluable parse_expression (string source) throws ParseError {
    var scanner = new Scanner(null);
    scanner.input_name = "<expression>";
    scanner.input_text (source, source.length);
    /* 
     * TODO The default config of `Scanner` skips whitespace and allows numbers
     * in hex and octal notation.  If that's not wanted the config needs to be
     * changed here.
     */
    Evaluable result = new Value.from_scanner (scanner);
    while (scanner.peek_next_token () != TokenType.EOF) {
        result = new BinaryOperation (
            parse_operator (scanner), result, new Value.from_scanner (scanner)
        );
    }
    return result;
}


public static int main (string[] args) {
    var source = (args.length == 1) ? "5+6-4+3+9" : args[1];
    try {
        print ("%s = %d\n", source, parse_expression (source).evaluate ());
    } catch (ParseError error) {
        /*
         * The error information was already reported at the source of the
         * exception.
         */
        return 1;
    }
    return 0;
}

Code: Alles auswählen

$ ./forum18.py 5+6-4+3+9
5+6-4+3+9 = 19
$ ./forum18.py "1_000 - (0b11 + 0x0b) - 0o15  # comment"
1_000 - (0b11 + 0x0b) - 0o15  # comment = 973

Code: Alles auswählen

#!/usr/bin/env python3
import ast
import sys
from functools import singledispatch
from operator import add, sub

AST_TYPE_TO_OPERATION = {ast.Add: add, ast.Sub: sub}


def get_type_name(value):
    return type(value).__name__


class ParseError(RuntimeError):
    pass


@singledispatch
def validate_ast(node):
    raise ParseError(f"unsupported node type {get_type_name(node)}")


@validate_ast.register(ast.BinOp)
def validate_binary_operation(node):
    validate_ast(node.left)
    if type(node.op) not in AST_TYPE_TO_OPERATION:
        raise ParseError(f"unsupported operator {get_type_name(node.op)}")
    validate_ast(node.right)
    return node

#
# TODO Remove when Python 3.7 reaches end of life.
#
@validate_ast.register(ast.Num)
def validate_number(node):
    if not isinstance(node.n, int):
        raise ParseError(f"unsupported number type {get_type_name(node.n)}")
    return node


@validate_ast.register(ast.Constant)
def validate_constant(node):
    if not isinstance(node.value, int):
        raise ParseError(
            f"unsupported number type {get_type_name(node.value)}"
        )
    return node


def parse_expression(source):
    try:
        return validate_ast(ast.parse(source, "<expression>", "eval").body)
    except SyntaxError as error:
        raise ParseError(error.msg)


@singledispatch
def evaluate_ast(node):
    raise NotImplementedError(
        f"evaluation of {get_type_name(node)} not implemented"
    )


@evaluate_ast.register(ast.BinOp)
def evaluate_binary_operation(node):
    return AST_TYPE_TO_OPERATION[type(node.op)](
        evaluate_ast(node.left), evaluate_ast(node.right)
    )

#
# TODO Remove when Python 3.7 reaches end of life.
#
@evaluate_ast.register(ast.Num)
def evaluate_number(node):
    return node.n


@evaluate_ast.register(ast.Constant)
def evaluate_constant(node):
    return node.value


def main(arguments):
    source = "5+6-4+3+9" if len(arguments) <= 1 else arguments[1]
    try:
        tree = parse_expression(source)
    except ParseError as error:
        print(f"Error: {error}\n{source}")
        return 1

    # print(ast.dump(tree, False))
    print(f"{source} = {evaluate_ast(tree)}")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Code: Alles auswählen

#ifndef MAIN_H
#define MAIN_H

#include <QtCore>

class Evaluable : public QObject
{
    Q_OBJECT
public:
    virtual int evaluate() const = 0;
};


class Number : public Evaluable
{
    const int value;

    Q_OBJECT
public:
    Number(int value) : value(value) {}
    virtual int evaluate() const { return value; }
};


class BinaryOperation : public Evaluable
{
    const QScopedPointer<const Evaluable> left;
    const QScopedPointer<const Evaluable> right;

    Q_OBJECT
public:
    BinaryOperation(const Evaluable* left, const Evaluable* right)
        : left(left), right(right) {}

    virtual int evaluate() const {
        return op(left->evaluate(), right->evaluate());
    }
protected:
    virtual int op(int a, int b) const = 0;
};


class Add : public BinaryOperation
{
    Q_OBJECT
public:
    Add(const Evaluable* left, const Evaluable* right)
        : BinaryOperation(left, right) {}
protected:
    virtual int op(int a, int b) const { return a + b; }
};


class Sub : public BinaryOperation
{
    Q_OBJECT
public:
    Sub(const Evaluable* left, const Evaluable* right)
        : BinaryOperation(left, right) {}
protected:
    virtual int op(int a, int b) const { return a - b; }
};


class ParseError {};


class Lexer : public QObject
{
    QString source;
    int index = 0;

    Q_OBJECT
public:
    Lexer(QString source) : source(source) {}
    virtual ~Lexer() {}
    bool eol() const { return index >= source.length(); }
    uint parseNumber();
    QChar parseOperator();
private:
    QChar getNextChar();
};

#endif // MAIN_H

Code: Alles auswählen

#include "main.h"

QChar Lexer::getNextChar()
{
    if (eol()) throw ParseError();
    return source.at(index++);
}

uint Lexer::parseNumber()
{
    QChar c = getNextChar();
    if (!c.isDigit()) throw ParseError();
    return c.digitValue();
}

QChar Lexer::parseOperator()
{
    QChar c = getNextChar();
    if (!QString("+-").contains(c)) throw ParseError();
    return c;
}

const Evaluable* parseExpression(QString source)
{
    Lexer lexer(source);
    QScopedPointer<Evaluable> result(new Number(lexer.parseNumber()));
    while (!lexer.eol()) {
        QChar symbol = lexer.parseOperator();
        QScopedPointer<Evaluable> left(new Number(lexer.parseNumber()));
        if (symbol == '+') {
            result.reset(new Add(result.take(), left.take()));
        } else if (symbol == '-') {
            result.reset(new Sub(result.take(), left.take()));
        }
    }
    return result.take();
}

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    QTextStream stream(stdout);
    QStringList arguments = app.arguments();
    QString source = (arguments.length() <= 1) ? "5+6-4+3+9" : arguments.at(1);
    try {
        QScopedPointer<const Evaluable> tree(parseExpression(source));
        stream << source << " = " << tree->evaluate() << endl;
    } catch (ParseError) {
        stream << "Syntax error in '" << source << "'." << endl;
    }
    return 0;
}