~indicator-multiload/indicator-multiload/trunk

/******************************************************************************

 * Copyright (C) 2011-2013  Michael Hofmann <mh21@mh21.de>                    *

 *                                                                            *

 * This program is free software; you can redistribute it and/or modify       *

 * it under the terms of the GNU General Public License as published by       *

 * the Free Software Foundation; either version 3 of the License, or          *

 * (at your option) any later version.                                        *

 *                                                                            *

 * This program is distributed in the hope that it will be useful,            *

 * but WITHOUT ANY WARRANTY; without even the implied warranty of             *

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *

 * GNU General Public License for more details.                               *

 *                                                                            *

 * You should have received a copy of the GNU General Public License along    *

 * with this program; if not, write to the Free Software Foundation, Inc.,    *

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.                *

 ******************************************************************************/

internal class ExpressionTokenizer {

    private char *last;

    private char *current;

    private string[] result;

    public string[] tokenize(string expression) {

        this.result = null;

        this.last = null;

        int level = 0;

        bool inexpression = false;

        bool instringsingle = false;

        bool instringdouble = false;

        for (this.current = (char*)expression; *this.current != '\0';

                this.current = this.current + 1) {

            if (!inexpression) {

                if (*this.current == '$') {

                    this.save();

                    this.addcurrent();

                    inexpression = true;

                } else {

                    this.expand();

                }

                continue;

            }

            // inexpression

            if (level == 0) {

                if (this.isvariable()) {

                    this.expand();

                } else if (this.last == null && *this.current == '(') {

                    this.addcurrent();

                    ++level;

                } else {

                    this.add('(');

                    this.save();

                    this.add(')');

                    this.expand();

                    inexpression = false;

                }

                continue;

            }

            // level > 0

            if (instringsingle) {

                this.expand();

                if (*this.current == '\'') {

                    this.savewithcurrent();

                    instringsingle = false;

                }

                continue;

            }

            if (instringdouble) {

                this.expand();

                if (*this.current == '"') {

                    this.savewithcurrent();

                    instringdouble = false;

                }

                continue;

            }

            // !instring

            if (*this.current == '\'') {

                this.save();

                this.expand();

                instringsingle = true;

            } else if (*this.current == '"') {

                this.save();

                this.expand();

                instringdouble = true;

            } else if (*this.current == '(') {

                this.save();

                this.addcurrent();

                ++level;

            } else if (*this.current == ')') {

                this.save();

                this.addcurrent();

                --level;

                if (level == 0)

                    inexpression = false;

            } else if (this.isspace()) {

                this.save();

            } else if (!this.isvariable()) {

                this.save();

                this.addcurrent();

            } else {

                this.expand();

            }

        }

        // fixup open strings, parentheses

        if (instringdouble)

            this.savewith('"');

        else if (instringsingle)

            this.savewith('\'');

        else

            this.save();

        while (level > 0) {

            this.add(')');

            --level;

        }

        return this.result;

    }

    private void expand() {

        if (this.last == null)

            this.last = this.current;

        // stderr.printf("Expanding token to '%s'\n", strndup(last, current - last + 1));

    }

    // add the current character as a new token

    private void addcurrent() {

        this.add(*this.current);

    }

    // add a character as a new token

    private void add(char what) {

        var token = what.to_string();

        // stderr.printf("Adding token '%s'\n", token);

        this.result += token;

    }

    // if the current token is not empty, push it to the token list and set the

    // current token to empty; this will not include the current character

    private void save() {

        if (this.last != null) {

            var token = strndup(this.last, this.current - this.last);

            // stderr.printf("Saving token '%s'\n", token);

            this.result += token;

            this.last = null;

        } else {

            // stderr.printf("Not saving empty token\n");

        }

    }

    private void savewithcurrent() {

        this.savewith(*this.current);

    }

    // add a character to the current token, push it to the token list

    // and set the current token to empty

    private void savewith(char what) {

        string token = (this.last != null ?

                strndup(this.last, this.current - this.last) : "") + what.to_string();

        // stderr.printf("Saving token '%s'\n", token);

        this.result += token;

        this.last = null;

    }

    private bool isspace() {

        return *this.current == ' ';

    }

    private bool isvariable() {

        return

            *this.current >= 'a' && *this.current <= 'z' ||

            *this.current >= '0' && *this.current <= '9' ||

            *this.current == '.';

    }

}

internal class ExpressionEvaluator {

    private Providers providers;

    private uint index;

    private string[] tokens;

    public ExpressionEvaluator(Providers providers) {

        this.providers = providers;

    }

    private static Error error(uint index, string message) {

        return new Error(Quark.from_string("expression-error-quark"),

                (int)index, "%s", message);

    }

    private string parens_or_identifier() throws Error {

        if (this.index >= this.tokens.length)

            throw error(this.index, "empty expression");

        if (this.tokens[this.index] == "(")

            return parens();

        return identifier();

    }

    private string times() throws Error {

        string result = null;

        bool div = false;

        for (;;) {

            if (this.index >= this.tokens.length)

                throw error(this.index, "expression expected");

            var value = parens_or_identifier();

            if (result == null)

                result = value;

            else if (!div)

                result = (double.parse(result) * double.parse(value)).to_string();

            else

                result = (double.parse(result) / double.parse(value)).to_string();

            if (this.index >= this.tokens.length)

                return result;

            switch (this.tokens[this.index]) {

            case "*":

                div = false;

                ++this.index;

                continue;

            case "/":

                div = true;

                ++this.index;

                continue;

            default:

                return result;

            }

        }

    }

    private string plus() throws Error {

        string result = null;

        bool minus = false;

        for (;;) {

            if (this.index >= this.tokens.length)

                throw error(this.index, "expression expected");

            var value = times();

            if (result == null)

                result = value;

            else if (!minus)

                result = (double.parse(result) + double.parse(value)).to_string();

            else

                result = (double.parse(result) - double.parse(value)).to_string();

            if (this.index >= this.tokens.length)

                return result;

            switch (this.tokens[this.index]) {

            case "+":

                minus = false;

                ++this.index;

                continue;

            case "-":

                minus = true;

                ++this.index;

                continue;

            default:

                return result;

            }

        }

    }

    private string parens() throws Error {

        if (this.index >= this.tokens.length ||

                this.tokens[this.index] != "(")

            throw error(this.index, "'(' expected");

        ++this.index;

        var result = plus();

        if (this.index >= this.tokens.length ||

                this.tokens[this.index] != ")")

            throw error(this.index, "')' expected");

        ++this.index;

        return result;

    }

    private string[] params() throws Error {

        string[] result = null;

        if (this.index >= this.tokens.length ||

                this.tokens[this.index] != "(")

            throw error(this.index, "'(' expected");

        ++this.index;

        if (this.index >= this.tokens.length)

            throw error(this.index, "parameters expected");

        if (this.tokens[this.index] != ")") {

            for (;;) {

                result += plus();

                if (this.index >= this.tokens.length)

                    throw error(this.index, "')' expected");

                if (this.tokens[this.index] != ",")

                    break;

                ++this.index;

            }

        }

        if (this.index >= this.tokens.length ||

                this.tokens[this.index] != ")")

            throw error(this.index, "')' expected");

        ++this.index;

        return result;

    }

    private string identifier() throws Error {

        if (this.index >= this.tokens.length)

            throw error(this.index, "identifier expected");

        double sign = 1;

        if (this.tokens[this.index] == "+") {

            ++this.index;

            if (this.index >= this.tokens.length)

                throw error(this.index, "identifier expected");

        } else if (this.tokens[this.index] == "-") {

            sign = -1.0;

            ++this.index;

            if (this.index >= this.tokens.length)

                throw error(this.index, "identifier expected");

        }

        var token = this.tokens[this.index];

        if (token.length > 0 && (token[0] == '\'' || token[0] == '"')) {

            ++this.index;

            return (sign == -1 ? "-" : "") + token[1:token.length - 1];

        }

        if (token.length > 0 && (token[0] >= '0' && token[0] <= '9' || token[0] == '.')) {

            ++this.index;

            if (sign == -1)

                return "-" + token;

            return token;

        }

        var varparts = token.split(".", 2);

        var nameindex = this.index;

        ++this.index;

        switch (varparts.length) {

        case 1:

            bool found = false;

            try {

                var result = this.providers.call(token, this.params(),

                        out found);

                if (!found)

                    throw error(nameindex, "unknown function");

                return (sign == -1 ? "-" : "") + result;

            } catch (Error e) {

                // TODO: this is not the right error position, maybe it is one

                // of the parameters so how to we transport this, maybe add

                // nameindex + e.errorcode?

                throw error(nameindex, e.message);

            }

        case 2:

            bool found = false;

            var result = (sign * this.providers.value(token, out found)).to_string();

            if (!found)

                throw error(nameindex, "unknown variable");

            return result;

        default:

            // not reached

            throw error(nameindex, "too many identifier parts");

        }

    }

    private string text() throws Error {

        string[] result = {};

        while (this.index < this.tokens.length) {

            string current = this.tokens[this.index];

            if (current == "$") {

                ++this.index;

                result += parens_or_identifier();

            } else {

                result += current;

                ++this.index;

            }

        }

        return string.joinv("", result);

    }

    public string evaluate(string[] tokens) {

        this.index = 0;

        this.tokens = tokens;

        try {

            return text();

        } catch (Error e) {

            stderr.printf("Expression error: %s\n", e.message);

            string errormessage = "";

            int errorpos = -1;

            for (uint i = 0, isize = this.tokens.length; i < isize; ++i) {

                if (e.code == i)

                    errorpos = errormessage.length;

                errormessage += " " + this.tokens[i];

            }

            if (errorpos < 0)

                errorpos = errormessage.length;

            stderr.printf("%s\n%s^\n", errormessage, string.nfill(errorpos, '-'));

            return "";

        }

    }

}

public class ExpressionCache : Object {

    public Providers providers { get; construct; }

    private string[] _tokens;

    private string _label;

    private string _expression;

    public string expression {

        get {

            return this._expression;

        }

        construct set {

            this._expression = value;

            this._tokens = null;

            this._label = null;

        }

    }

    public ExpressionCache(Providers providers, string expression) {

        Object(providers: providers, expression: expression);

    }

    public void update() {

        this._label = null;

    }

    public string[] tokens() {

        if (this._tokens == null)

            this._tokens = new ExpressionTokenizer().tokenize(this._expression);

        return this._tokens;

    }

    public string label() {

        if (this._label == null)

            this._label = new ExpressionEvaluator(this.providers).evaluate(this.tokens());

        return this._label;

    }

}