コード例 #1
0
        private static List <ExpressionToken> SplitToken(string exp)
        {
            List <ExpressionToken> list = new List <ExpressionToken> {
                ExpressionToken.LpaToken
            };
            int    index    = 0;
            string strToken = string.Empty;

            while (index < exp.Length)
            {
                char c    = exp[index];
                bool flag = false;
                switch (c)
                {
                case '"':
                    SkipGroup('"', '"', ref strToken, exp, ref index);
                    flag = true;
                    list.Add(ExpressionToken.CreateToken(strToken));
                    strToken = string.Empty;
                    break;

                case '[':
                    SkipGroup('[', ']', ref strToken, exp, ref index);
                    flag = true;
                    break;
                }
                if (!flag)
                {
                    if (char.IsWhiteSpace(c))
                    {
                        if (!string.IsNullOrEmpty(strToken))
                        {
                            list.Add(ExpressionToken.CreateToken(strToken));
                        }
                        strToken = string.Empty;
                        index++;
                        continue;
                    }
                    ExpressionToken item = ExpressionToken.FindOperator(exp, index);
                    if (item == null)
                    {
                        strToken = strToken + c;
                        index++;
                        continue;
                    }
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        ExpressionToken token2 = ExpressionToken.CreateToken(strToken);
                        list.Add(token2);
                    }
                    bool flag2 = (list.Count > 0) && list[list.Count - 1].IsValueType;
                    if (!flag2 && (item.Name == "-"))
                    {
                        list.Add(ExpressionToken.UniMinus);
                    }
                    else if (!flag2 && (item.Name == "+"))
                    {
                        list.Add(ExpressionToken.UniPlus);
                    }
                    else
                    {
                        list.Add(item);
                    }
                    strToken = string.Empty;
                    index   += item.Name.Length;
                }
            }
            if (!string.IsNullOrEmpty(strToken))
            {
                list.Add(ExpressionToken.CreateToken(strToken));
            }
            list.Add(ExpressionToken.RpaToken);
            return(list);
        }
コード例 #2
0
        // 式を演算要素別に分解
        static List <ExpressionToken> SplitToken(string exp)
        {
            List <ExpressionToken> tokens = new List <ExpressionToken>();            //演算式

            tokens.Add(ExpressionToken.LpaToken);
            int    index       = 0;
            string strToken    = "";                            //直前の文字列
            bool   isValueMode = false;                         //直前のトークンが数値(変数)か、演算子か

            while (index < exp.Length)
            {
                char c = exp[index];
                if (char.IsWhiteSpace(c) || c == ',')
                {
                    //空白・区切り文字なので、直前の文字列をトークンとして分割
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        tokens.Add(ExpressionToken.CreateToken(strToken));
                        isValueMode = true;
                    }
                    strToken = "";
                    index++;
                    continue;
                }

                //演算子が来たかチェック
                ExpressionToken operatior = ExpressionToken.FindOperator(exp, index);
                if (operatior == null)
                {
                    //演算子はなかった。一文字シフト
                    strToken += c;
                    index++;
                }
                else
                {
                    //演算子発見・直前の文字列をトークンとして分割
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        tokens.Add(ExpressionToken.CreateToken(strToken));
                        isValueMode = true;
                    }

                    //演算子をトークンとして追加
                    if (!isValueMode && operatior.Name == ExpressionToken.Minus)
                    {
                        //単項演算子のマイナスとして登録(二項演算子ではなく)
                        tokens.Add(ExpressionToken.UniMinus);
                        isValueMode = true;
                    }
                    else if (!isValueMode && operatior.Name == ExpressionToken.Plus)
                    {
                        //単項演算子のプラスとして登録(二項演算子ではなく)
                        tokens.Add(ExpressionToken.UniPlus);
                        isValueMode = true;
                    }
                    else
                    {
                        //見つかった演算子を追加
                        tokens.Add(operatior);
                        if (operatior.Type != ExpressionToken.TokenType.Lpa && operatior.Type != ExpressionToken.TokenType.Rpa)
                        {
                            isValueMode = false;
                        }
                    }
                    strToken = "";
                    index   += operatior.Name.Length;
                }
            }
            if (!string.IsNullOrEmpty(strToken))
            {
                tokens.Add(ExpressionToken.CreateToken(strToken));
            }
            tokens.Add(ExpressionToken.RpaToken);
            return(tokens);
        }
コード例 #3
0
        // 式を演算要素別に分解
        static List <ExpressionToken> SplitToken(string exp)
        {
            List <ExpressionToken> tokens = new List <ExpressionToken>();            //演算式

            tokens.Add(ExpressionToken.LpaToken);
            int    index    = 0;
            string strToken = "";                               //直前の文字列

            while (index < exp.Length)
            {
                char c = exp[index];
                if (char.IsWhiteSpace(c))
                {
                    //空白・区切り文字なので、直前の文字列をトークンとして分割
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        tokens.Add(ExpressionToken.CreateToken(strToken));
                    }
                    strToken = "";
                    index++;
                    continue;
                }

                //演算子が来たかチェック
                ExpressionToken operatior = ExpressionToken.FindOperator(exp, index);
                if (operatior == null)
                {
                    //演算子はなかった。一文字シフト
                    strToken += c;
                    index++;
                }
                else
                {
                    //演算子発見・直前の文字列をトークンとして分割
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        var token = ExpressionToken.CreateToken(strToken);
                        tokens.Add(token);
                    }

                    bool isValueLastToken = tokens.Count > 0 && tokens[tokens.Count - 1].IsValueType;
                    //演算子をトークンとして追加
                    if (!isValueLastToken && operatior.Name == ExpressionToken.Minus)
                    {
                        //単項演算子のマイナスとして登録(二項演算子ではなく)
                        tokens.Add(ExpressionToken.UniMinus);
                    }
                    else if (!isValueLastToken && operatior.Name == ExpressionToken.Plus)
                    {
                        //単項演算子のプラスとして登録(二項演算子ではなく)
                        tokens.Add(ExpressionToken.UniPlus);
                    }
                    else
                    {
                        //見つかった演算子を追加
                        tokens.Add(operatior);
                    }
                    strToken = "";
                    index   += operatior.Name.Length;
                }
            }
            if (!string.IsNullOrEmpty(strToken))
            {
                tokens.Add(ExpressionToken.CreateToken(strToken));
            }
            tokens.Add(ExpressionToken.RpaToken);
            return(tokens);
        }
コード例 #4
0
        // 式を演算要素別に分解
        static List <ExpressionToken> SplitToken(string exp)
        {
            List <ExpressionToken> tokens = new List <ExpressionToken>();            //演算式

            tokens.Add(ExpressionToken.LpaToken);
            int    index    = 0;
            string strToken = "";                               //直前の文字列

            while (index < exp.Length)
            {
                char c = exp[index];

                bool       isSkipped       = false;
                const char StringSeparator = '\"';
                const char ArraySeparator0 = '[';
                const char ArraySeparator1 = ']';
                switch (c)
                {
                case StringSeparator:
                    SkipGroup(StringSeparator, StringSeparator, ref strToken, exp, ref index);
                    isSkipped = true;
                    tokens.Add(ExpressionToken.CreateToken(strToken));
                    strToken = "";
                    break;

                case ArraySeparator0:
                    SkipGroup(ArraySeparator0, ArraySeparator1, ref strToken, exp, ref index);
                    isSkipped = true;
                    break;

                default:
                    break;
                }
                if (isSkipped)
                {
                    continue;
                }

                if (char.IsWhiteSpace(c))
                {
                    //空白・区切り文字なので、直前の文字列をトークンとして分割
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        tokens.Add(ExpressionToken.CreateToken(strToken));
                    }
                    strToken = "";
                    index++;
                    continue;
                }

                //演算子が来たかチェック
                ExpressionToken operatior = ExpressionToken.FindOperator(exp, index);
                if (operatior == null)
                {
                    //演算子はなかった。一文字シフト
                    strToken += c;
                    index++;
                }
                else
                {
                    //演算子発見・直前の文字列をトークンとして分割
                    if (!string.IsNullOrEmpty(strToken))
                    {
                        var token = ExpressionToken.CreateToken(strToken);
                        tokens.Add(token);
                    }

                    bool isValueLastToken = tokens.Count > 0 && tokens[tokens.Count - 1].IsValueType;
                    //演算子をトークンとして追加
                    if (!isValueLastToken && operatior.Name == ExpressionToken.Minus)
                    {
                        //単項演算子のマイナスとして登録(二項演算子ではなく)
                        tokens.Add(ExpressionToken.UniMinus);
                    }
                    else if (!isValueLastToken && operatior.Name == ExpressionToken.Plus)
                    {
                        //単項演算子のプラスとして登録(二項演算子ではなく)
                        tokens.Add(ExpressionToken.UniPlus);
                    }
                    else
                    {
                        //見つかった演算子を追加
                        tokens.Add(operatior);
                    }
                    strToken = "";
                    index   += operatior.Name.Length;
                }
            }
            if (!string.IsNullOrEmpty(strToken))
            {
                tokens.Add(ExpressionToken.CreateToken(strToken));
            }
            tokens.Add(ExpressionToken.RpaToken);
            return(tokens);
        }