Beispiel #1
0
        public void Parse(string expr, string[] variables)
        {
            //string S;
            List <AleToken> list, rpn_list;
            AleTerm         T;

            //lblInfo.Text = "";

            AP.Options = (AP.IgnoreCase ? AleExpressionParser.OPTION_IGNORECASE : 0) +
                         (/*chkStrictSyntax.Checked ?*/ AleExpressionParser.OPTION_STRICTSYNTAX /*: 0*/) +
                         AleExpressionParser.OPTION_ALLOWEMPTYPARAMS +
                         AleExpressionParser.OPTION_ALLOWEMPTYINDEX +
                         AleExpressionParser.OPTION_ALLOWMULTIDIMINDEXES +
                         AleExpressionParser.OPTION_STRICTINDEXES;

            AP.Text            = expr;
            AP.VarPrefix       = /*cboPrefix.Text == "" ?*/ '\0' /*: cboPrefix.Text[0]*/;
            AP.EndOfExpression = "; 'end of expression' 'stoṕ herẽ'";

            AP.Constants = new Dictionary <string, object>(AP.IgnoreCase ? StringComparer.CurrentCultureIgnoreCase : StringComparer.CurrentCulture);
            AP.Constants.Add("true", true);
            AP.Constants.Add("false", false);
            AP.Constants.Add("pi", Math.PI);
            AP.Constants.Add("π", Math.PI);
            //AP.Constants.Add("2pi", 2 * Math.PI);
            //AP.Constants.Add("2π", 2 * Math.PI);
            AP.Constants.Add("e", Math.E);
            AP.Constants.Add("null", null);

            AP.SemanticsValidate += OnSemanticsValidate;

            int res = 0;

            while (res < AP.Text.Length)
            {
                res = AP.Tokenize(out list, res);

                if (AP.ErrorCode == AleExpressionParser.ERROR_OK)
                {
                    T = AP.Parse(list);

                    if (AP.ErrorCode == AleExpressionParser.ERROR_OK)
                    {
                        ShowTokens(list);

                        rpn_list = AP.ToReversePolishNotation(list); // this is for demonstation only. there is no need to call AP.ToReversePolishNotation for parsing and evaluation
                        ShowRPNList(rpn_list);

                        if (T != null)
                        {
                            //txtResult.Text += "--> Prefix form \u000d\u000a" + T.DebugPrint() + "\u000d\u000a--> End of prefix form\u000d\u000a\u000d\u000a";
                            //S = "";

                            List <Tuple <int, string> > vars = T.Variables;

                            // list unknown variables if existing
                            List <string> unknownVars = new List <string>();
                            foreach (Tuple <int, string> hashVar in vars)
                            {
                                string curVariable = hashVar.Item2;

                                // fetch expected parameter
                                bool found = false;
                                foreach (string variable in variables)
                                {
                                    if (curVariable.ToUpper() == variable.ToUpper())
                                    {
                                        found = true;
                                        break;
                                    }
                                }

                                // unknown variable
                                if (!found)
                                {
                                    unknownVars.Add(curVariable);
                                }
                            }

                            if (unknownVars.Count > 0)
                            {
                                throw new Exception("Unknown variables");
                            }

                            //foreach (Tuple<int, string> variable in vars) S += "Hash=" + variable.Item1 + "; Name=" + variable.Item2 + "\u000d\u000a";
                            //txtResult.Text += "--> Variables list\u000d\u000a" + S + "--> End of variables list\u000d\u000a\u000d\u000a";
                        }
                    }
                    else
                    {
                        throw new Exception("Invalid expression");
                    }
                }
                else
                {
                    ShowError(AP);
                    break;
                }
            }
        }