/vqdr/trunk

using Vee;

namespace VQDR.Expression {

  public enum CharType {

    INVALID = 0,

    NULL = 1,

    DIGIT,

    UOP,

    OP,

    ALPHA,

    DOT,

    POP,

    PCL,

    COM,

    UNKNOWN,

    _NUM_VAL;

    public string to_string () {

      // We add one as we have an invalid case.

      static_assert (CharType._NUM_VAL == 10 + 1);

      switch (this) {

        case (NULL): 

          return "NULL";

        case (DIGIT):

          return "DIGIT";

        case (UOP):

          return "UOP";

        case (OP):

          return "OP";

        case (ALPHA):

          return "ALPHA";

        case (DOT):

          return "DOT";

        case (POP):

          return "POP";

        case (PCL):

          return "PLC";

        case (COM):

          return "COM";

        case (UNKNOWN):

          return "UNKNOWN";

        default:

          assert_not_reached ();

      }

    }

  /**

   * Determine character type.

   * @param ch Character to be checked.

   * @return The character type.

   */

    public static CharType from_char (char ch) {

      switch (ch) {

        case '0': case '1':

        case '2': case '3':

        case '4': case '5':

        case '6': case '7':

        case '8': case '9':

          return DIGIT;

        case '+': case '-':

          return UOP;

        case '*': case '/':

          return OP;

        case '.':

          return DOT;

        case '(':

          return POP;

        case ')':

          return PCL;

        case ',':

          return COM;

        case ' ': case 0:

          return NULL;

        default:

          if ((ch >= 'a' && ch <= 'z') || (ch>= 'A' && ch <= 'Z' )) {

            return ALPHA;

          }

          return UNKNOWN;

      }

    }

  }

  public class Parser {

    private static string[] EMPTY_VAR_KEYS = new string[0];

    private Context context = null;

    /** Contains the used variable names. */

    private string[] variable_keys;

    /** contains the used variables and their last value. */

    private HashTable<string, Variable?> variable_cache; 

    /** Will contain the Root of the token tree.

     * Asumes that there it has no parents.*/

    private Token root_token;

    private Token root;

    private bool parsed = false;

    private bool evaluated_once;

    private string internal_experisson;

    public string expression {

      get {return internal_experisson;}

      set {internal_experisson = value;

           expression_size = value.length;

           reset ();}

    }

    private size_t expression_size = 0;

    private char cur_char = 0;

    private int32 index = -1;

    private FastNumber result_value;

    private FastNumber result_max_value;

    private FastNumber result_min_value;

    private string result_string;

    private Error? error;

    public Parser (string expression) {

      this.expression = expression;

      this.expression_size = expression.length;

      this.cur_char = expression[0];

      this.index = 0;

    }

    public Parser.empty () {

      expression = "";

    }

    public void reset () {

      root_token = null;

      root = null;

      parsed = false;

      evaluated_once = false;

      result_value = FastNumber (0);

      result_min_value = FastNumber (0);

      result_max_value = FastNumber (0);

      result_string = "";

      variable_cache.remove_all ();

      variable_keys = EMPTY_VAR_KEYS;

      error = null;

      index = 0;

    }

    /**

     * Parse the expersson string.

     */

    public void parse () throws ParseError {

      if (parsed) {

        throw new ParseError.ALLREADY_PARSED 

              ("Data has allparsed been parsed.");

      }

      while (this.index <= this.expression_size) {

        switch (CharType.from_char (this.cur_char)) {

          case CharType.NULL:

            this.parse_advance ();

            break;

          default:

            assert_not_reached ();

        }

      }

      this.parsed = true;

    } // end parse ()

    /*

     * advance the parser. 

     */

    private void parse_advance () {

      if (this.index < this.expression_size && this.cur_char != '\0') {

        this.index++;

        this.cur_char = this.expression[this.index];

      }

    }

    protected bool valid_bounds () {

      if (!evaluated_once) {

        return false;

      }

      if (context != null) {

        try {

          foreach (var key in variable_keys) {

            if (!context.has_name (key) ||

                !variable_cache.get (key).equals (context.get_variable (key))) {

              return false;

            }

          }

        } catch (Error e) {

          err_print_ln ("Something went wrong: (%: %)", e.domain, e.message);

          assert_not_reached ();

        }

      }

      return true;

    }

    protected void set_variable_cach_values () {

      if (context != null) {

        try {

          foreach (var key in variable_keys) {

            variable_cache.insert (key, Variable.copy

                                   (context.get_variable (key)));

          }

        } catch (Error e) {

          err_print_ln ("Something went wrong: (%: %)", e.domain, e.message);

          assert_not_reached ();

        }

      }

    }

    protected void set_error (Error e) {

      expression = "";

      result_string = "Error";

      set_variable_cach_values ();

      error = e;

    }

    protected void set_result (Token root_token) {

      // evaluate = true;

      evaluated_once = true;

      result_value = root_token.result_value;

      result_max_value = root_token.result_max_value;

      result_min_value = root_token.result_min_value;

      result_string = root_token.result_string;

      set_variable_cach_values ();

      error = null;

    }

    protected void evaluate () throws Error {

      try {

        parse ();

        if (root_token == null) {

          root_token = new RootToken (root);

        }

        root_token.evaluate (context);

        set_result (root_token);

      } catch (Error e) {

        set_error (e);

        throw e;

      }

    }

    /**

     * Add a note (operator) to the stack after popping it's parameters.

     * @param operand_stack stack

     * @param operator operator.

     */

    protected void add_node (Stack<Token> operand_stack,

                             Token operator) throws Error {

      if (operator is FunctionToken) {

        FunctionToken funk = (FunctionToken) operator;

        int32 param_num = funk.next_child_num;

        for (var i = 0; i < param_num; i++) {

          Token param_child = operand_stack.pop ();

          funk.set_child (param_num - 1, param_child);

          operand_stack.push (funk);

        }

      } else if (operator is UnaryOperator &&

                 ((UnaryOperator) operator).is_unary) {

        if (operand_stack.elements < 1) {

          throw new OperandError.MISSING_OPERAND

                    (@"Missing operand. Position: $(operator.position)");

        }

      } else {

        if (operand_stack.elements < 2) {

          throw new OperandError.MISSING_OPERAND

                    (@"Missing operand. Position: $(operator.position)");

        }

        operator.set_right_child (operand_stack.pop ());

        operator.set_left_child (operand_stack.pop ());

        operand_stack.push (operator);

      }

    }

  } // end of Parser class

}