/vqdr/trunk

using Vee;

using GLib;

namespace VQDR.Expression {

  public abstract class Token : GLib.Object {

    /** Max size of a single token */

    public const int32 MAX_TOKEN_STRING_LENGTH = 64;

    /** Max size of an expression */

    public const int32 MAX_TOTAL_STRING_LENGTH = 200;

    /** Max iteration number for a token (function) */

    public const int32 MAX_TOKEN_ITERATIONS = 500;

    /** Max iteration number for the expression */

    public const int32 MAX_TOTAL_ITERATIONS = 5000;

    /**

     * Operator precedence and associativity

     * 

     * higher number is higher priority, and is to be done befroe those

     * with lower number.

     */

    public enum Prio {

      /** invalid case. Prevents null-trap. */

      INVALID = 0,

      /** Priority for assignment "=" operator */

      ASSIGNMENT = 1,

      /** Priority for conditional OR "||" operator */

      CONDITIONAL_OR,

      /** Priority for conditional AND "&&" operator */

      CONDITIONAL_AND,

      /** Priority for equality "==" and "!=" operators */

      EQUALITY,

      /** Priority for comparison ">", "<", ">=", etc operators */

      COMPARISON,

      /** Priority for addictive "+" and "-" operators */

      ADDICTIVE,

      /** Priority for multiplicative "*" and "/" operators */

      MULTIPLICATIVE,

      /** Priority for unary "+" and "-" and "!" operators */

      UNARY,

      /** Priority for label assignment ":" operator */

      LABEL,

      /** Priority for dice "d" operator */

      DICE,

      /** Priority for functions */

      FUNCTION,

      /** Priority for values */

      VALUE,

      /** The number of values. */

      _NUM_VAL;

      /** get the name of the priority */

      public string to_string () {

        // We have to add 1 as we have an invalid case at zero.

        static_assert (_NUM_VAL == 12 + 1);

        switch (this) {

          case ASSIGNMENT:

            return "ASSIGNMENT";

          case CONDITIONAL_OR:

            return "CONDITIONAL_OR";

          case CONDITIONAL_AND:

            return "CONDITIONAL_AND";

          case EQUALITY:

            return "EQUALITY";

          case COMPARISON:

            return "COMPARISON";

          case ADDICTIVE:

            return "ADDICTIVE";

          case MULTIPLICATIVE:

            return "MULTIPLICATIVE";

          case UNARY:

            return "UNARY";

          case LABEL:

            return "LABEL";

          case DICE:

            return "DICE";

          case FUNCTION:

            return "FUNCTION";

          case VALUE:

            return "VALUE";

          default:

            assert_not_reached ();

        }

      }

      public Prio from_string (string name) {

        // We have to add 1 as we have an invalid case at zero.

        static_assert (_NUM_VAL == 12 + 1);

        var collected = name.up ();

        switch (collected) {

          case "ASSIGMENT":

            return ASSIGNMENT;

          case "CONDITIONAL_OR":

            return CONDITIONAL_OR;

          case "CONDITIONAL_AND":

            return CONDITIONAL_AND;

          case "EQUALITY":

            return EQUALITY;

          case "COMPARISON":

            return COMPARISON;

          case "ADDICTIVE":

            return ADDICTIVE;

          case "MULTIPLICATIVE":

            return MULTIPLICATIVE;

          case "UNARY":

            return UNARY;

          case "LABEL":

            return LABEL;

          case "DICE":

            return DICE;

          case "FUNCTON":

            return FUNCTION;

          case "VALUE":

            return VALUE;

          default:

            assert_not_reached ();

        }

      }

    }

    /** Generation to use to get the root with @link parent */

    protected const int32 ROOT_GENERATION = int.MAX;

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

    /**

     * tells whether the token is right associative or not.

     */

    public bool right_assosiative {get;set; default = false;}

    /** The parent token of this token*/

    protected unowned Token? parent {protected get; protected set;}

    public virtual Prio priority {public get; protected construct set;}

    /** Starting position of the token in the expression */

    public int32 position {public get; protected set;}

    private int internal_next_child_num;

    /** The index of the next child */

    public int next_child_num {get {return internal_next_child_num;}

                 protected set{internal_next_child_num = value;}}

    /** 

     * The optional that this child represents.

     * 

     * 

     */

    public int32 optional_num_child {public get; protected construct set;}

    /** The mandatory number of child this token can have */

    public int32 mandatory_num_child {public get; protected construct set;}

    /** 

     * The maximum number of chidren 

     * 

     * This is calculated at runtime as

     * ''optional_num_child + mandatory_num_child''.

     * 

     * Can not be set.

     */

    public int32 max_num_child {get {

      return optional_num_child + mandatory_num_child;

     }}

    /** all children of this token */

    private (unowned Token?)[] children;

    /*

     * These values should have a protected setter, but I could not get it to

     * work. So we will have to live with this.

     */

    public FastNumber result_value;

    public FastNumber result_max_value;

    public FastNumber result_min_value;

    public string result_string {public get; protected set; default = "";}

    construct {

      children = new Token[max_num_child];

      next_child_num = 0;

      result_value = FastNumber ();

      result_max_value = FastNumber ();

      result_min_value = FastNumber ();

    }

    protected Token (int32 position) {

      this.position = position;

    }

    /**

     * Reorders result_min_value and result_max_value, so that

     * result_max_value is the bigger of the two, and

     * result_min_value is the smaller.

     */

    protected void reorder_max_min_values () {

      if (result_max_value.compare (result_min_value) <= 0) {

        FastNumber tmp = result_max_value;

        result_max_value = result_min_value;

        result_min_value = tmp;

      }

    }

    /**

     * Get a child token to this token.

     * 

     * Child positions are between 1 and max_num_child.

     * 

     * and index of 0 is illegal.

     */

    public unowned Token? get_child (int32 index)

                          requires (index > 0 && index <= max_num_child) {

      return children[index -1 ];

    }

    public void set_next_child (Token child) throws ArgError {

      next_child_num++;

      set_child (next_child_num, child);

    }

    /**

     * Set a child token to this this token.

     * 

     * Child positions are between 1 and max_num_child.

     * 

     * and index of 0 is illegal.

     */

    public void set_child (int32 index, Token? child)

                requires (index > 0 && index <= max_num_child) {

      children[index - 1] = child;

      if (children[index - 1] != null) {

        children[index -1].parent = this;

      }

    }

    /**

     * is functionally equal to get_child (1);

     */

    public Token get_left_child () {

      return get_child (1);

    }

    /**

     * is functionally equal to get_child (2);

     */

    public Token get_right_child () {

      return get_child (2);

    }

    /**

     * is functionally equal to set_child (1, token);

     */

    public void set_left_child (Token token)  {

      set_child (1, token);

    }

    /**

     * is functionally equal to set_child (2, token);

     */

    public void set_right_child (Token token)  {

      set_child (2, token);

    }

    public void evaluate (Context instance) throws GLib.Error {

      evaluate_self (instance);

    }

    /**

     * Evalutates current token tree.

     * 

     * This Method must evaluate the token subtree, and assign proper values to

     * the following properties:

     * 

     *  * result_value

     *  * result_max_value

     *  * result_min_value

     *  * result_string

     * 

     * @param instance The context to be used valfor this tree.

     * @throws GLib.Error an error if an error has orrured in the evaluation of the tree.

     */

    protected abstract void evaluate_self (Context instance) throws GLib.Error;

  }

}