예제 #1
0
        /// Read expression from string, evaluate it and return the value
        public object Eval(string expression)
        {
            if (expression == null)
            {
                return(null);
            }

            if (_exprCache == null)
            {
                _exprCache = new PrecompiledCache(128);
            }

            IOperation ex = _exprCache[expression];

            if (ex == null)
            {
                using (var sr = new ParsingReader(new StringReader(expression)))
                {
                    ex = new Parser(TokenSpecialCharacters).Parse(sr);
                    sr.SkipWhiteSpace();
                    sr.ReadAndThrowIfNot(-1);
                    _exprCache[expression] = ex;
                }
            }
            if (ex == null)
            {
                return(null);
            }
            return(Eval(ex));
        }
예제 #2
0
        /// <summary>
        /// Try to get variable value
        /// </summary>
        /// <param name="key">Variable name</param>
        /// <param name="value">Where to store found variable value</param>
        /// <returns>true if variable is set</returns>
        public override bool TryGetValue(string key, out object value)
        {
            if (!IsCalculated(key))
            {
                return(base.TryGetValue(key, out value));
            }
            using (var sr = new ParsingReader(key))
            {
                sr.SkipWhiteSpace();
                value = sr.ReadNumber();
                if (value != null)
                {
                    sr.SkipWhiteSpace();
                    sr.ReadAndThrowIfNot(-1);
                    return(true);
                }
            }

            value = EvalMulti(key);
            return(true);
        }
예제 #3
0
파일: Script.cs 프로젝트: xsharper/xsharper
        /// <summary>
        /// Load script from string
        /// </summary>
        /// <param name="scriptXml">script as XML</param>
        public void Load(string scriptXml)
        {
            Items.Clear();
            bool close = true;
            var  r     = new ParsingReader(new StringReader(scriptXml));

            try
            {
                r.SkipWhiteSpace();
                if (r.Peek() == '<')
                {
                    // Get a script file
                    XmlReaderSettings rs = new XmlReaderSettings();
                    rs.IgnoreWhitespace = false;
                    rs.ValidationType   = ValidationType.None;

                    using (XmlReader xr = XmlReader.Create(r, new XmlReaderSettings()
                    {
                        ConformanceLevel = ConformanceLevel.Fragment
                    }))
                    {
                        close = false;
                        Load(xr);
                        return;
                    }
                }


                if (r.Peek() == '=')
                {
                    r.Read();
                    Items.Add(new Eval {
                        Value = r.ReadToEnd()
                    });
                    return;
                }
                Items.Add(new Code {
                    Value = r.ReadToEnd()
                });
                return;
            }
            finally
            {
                if (close)
                {
                    r.Close();
                }
            }
        }
예제 #4
0
        /// <summary>
        /// Try to get variable value
        /// </summary>
        /// <param name="key">Variable name</param>
        /// <param name="value">Where to store found variable value</param>
        /// <returns>true if variable is set</returns>
        public override bool TryGetValue(string key, out object value)
        {
            if (!IsCalculated(key))
            {
                return(base.TryGetValue(key, out value));
            }
            using (var sr = new ParsingReader(key))
            {
                sr.SkipWhiteSpace();
                value = sr.ReadNumber();
                if (value != null)
                {
                    sr.SkipWhiteSpace();
                    sr.ReadAndThrowIfNot(-1);
                    return(true);
                }
            }


            if (!string.IsNullOrEmpty(key))
            {
                switch (key[0])
                {
                case '%':
                    EnvironmentVariableTarget target = getTarget(ref key);
                    value = Environment.GetEnvironmentVariable(key, target);
                    return(value != null);

                case '~':
                    value = Find(key.Substring(1), true);
                    return(true);
                }
            }
            value = EvalMulti(key);
            return(true);
        }
예제 #5
0
        /// Read multi-expression (like ${a|b|=3+5}) from the string, evaluate it and return the value
        public object EvalMulti(string multiExpression)
        {
            if (multiExpression == null)
            {
                return(null);
            }
            if (_exprCache == null)
            {
                _exprCache = new PrecompiledCache(128);
            }
            IOperation o = _exprCache[multiExpression];

            if (o == null)
            {
                using (var sr = new ParsingReader(new StringReader(multiExpression)))
                {
                    o = new Parser(TokenSpecialCharacters).ParseMulti(sr);
                    sr.SkipWhiteSpace();
                    sr.ReadAndThrowIfNot(-1);
                    _exprCache[multiExpression] = o;
                }
            }
            return(Eval(o));
        }
예제 #6
0
        private object expandVars(TransformRules rules, string s)
        {
            string begin;
            string end;

            if ((rules & TransformRules.ExpandDual) == TransformRules.ExpandDual)
            {
                begin = "${{";
                end   = "}}";
            }
            else if ((rules & TransformRules.ExpandDualSquare) == TransformRules.ExpandDualSquare)
            {
                begin = "[[";
                end   = "]]";
            }
            else if ((rules & TransformRules.ExpandSquare) == TransformRules.ExpandSquare)
            {
                begin = "[";
                end   = "]";
            }
            else if ((rules & TransformRules.Expand) == TransformRules.Expand)
            {
                begin = "${";
                end   = "}";
            }
            else
            {
                return(s);
            }

            if (s.IndexOf(begin, StringComparison.Ordinal) != -1)
            {
                StringBuilder sbNew = new StringBuilder();
                using (var sr = new ParsingReader(new StringReader(s)))
                {
                    int  ptr   = 0;
                    bool first = true;
                    while (!sr.IsEOF)
                    {
                        char ch = (char)sr.Read();
                        if (ch != begin[ptr])
                        {
                            sbNew.Append(begin, 0, ptr);
                            sbNew.Append(ch);
                            ptr   = 0;
                            first = false;
                            continue;
                        }
                        ptr++;
                        if (ptr < begin.Length)
                        {
                            continue;
                        }
                        if (sr.Peek() == '{' || sr.Peek() == '[')
                        {
                            sbNew.Append(begin);
                            ptr   = 0;
                            first = false;
                            continue;
                        }
                        //
                        object sv = EvalMulti(sr);
                        sv = ((rules & TransformRules.ExpandTrimOnly) == TransformRules.ExpandTrimOnly)
                                 ? Utils.TransformStr(Utils.To <string>(sv), rules & TransformRules.TrimMask)
                                 : sv;
                        sv = ((rules & TransformRules.ExpandReplaceOnly) == TransformRules.ExpandReplaceOnly)
                                 ? Utils.TransformStr(Utils.To <string>(sv), rules & TransformRules.ReplaceMask)
                                 : sv;

                        // Now read the trailing stuff
                        sr.SkipWhiteSpace();
                        for (ptr = 0; ptr < end.Length; ++ptr)
                        {
                            sr.ReadAndThrowIfNot(end[ptr]);
                        }
                        if (sr.IsEOF && first)
                        {
                            return(sv);
                        }
                        ptr   = 0;
                        first = false;
                        sbNew.Append(Utils.To <string>(sv));
                    }
                    for (int i = 0; i < ptr; ++i)
                    {
                        sbNew.Append(begin[i]);
                    }
                }


                return(sbNew.ToString());
            }
            return(s);
        }
예제 #7
0
파일: RowSet.cs 프로젝트: xsharper/xsharper
        private IEnumerable <Vars> getTransformedRows(string columnsOverride, string sortOverride, string whereExpression)
        {
            bool overrideSort = (sortOverride != null);

            if (!overrideSort)
            {
                sortOverride = Context.TransformStr(SortColumns, Transform);
            }

            //
            ColumnsInfo ci = new ColumnsInfo();

            // Load CSV, if present
            string text      = GetTransformedValueStr();
            string quote     = Context.TransformStr(Quote, Transform);
            string separator = Context.TransformStr(Separator, Transform);
            char?  quoteChar = string.IsNullOrEmpty(quote) ? (char?)null : quote[0];
            bool   trim      = (Options & RowsetOptions.Trim) != 0;
            string colNames  = Context.TransformStr(Columns, Transform);;
            // Read additional column names from the first CSV row, if specified
            ParsingReader csvReader = null;

            if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text.Trim()))
            {
                csvReader = new ParsingReader(new StringReader(text));
                if ((Options & RowsetOptions.Header) == RowsetOptions.Header)
                {
                    csvReader.SkipWhiteSpace();
                    colNames = Context.TransformStr(csvReader.ReadLine(), Verbatim ? TransformRules.None : Transform);
                }
            }

            char sep = string.IsNullOrEmpty(separator) ? '\0' : separator[0];

            // Add these columns
            if (!string.IsNullOrEmpty(colNames))
            {
                ci.AddParsed(Context, colNames, quoteChar, sep, trim);
            }

            // Add extra columns
            if (Cols != null)
            {
                foreach (var col in Cols)
                {
                    ColumnInfo cc = new ColumnInfo();
                    cc.Name      = Context.TransformStr(col.Name, col.Transform);
                    cc.Value     = Context.TransformStr(col.Value, col.Transform);
                    cc.IsDefault = (col.Default != null);
                    if (cc.IsDefault)
                    {
                        cc.Default = Context.Transform(col.Default, col.Transform);
                    }
                    object t = Context.Transform(col.Type, col.Transform);
                    if (t != null)
                    {
                        if (t is Type)
                        {
                            cc.Type = (Type)t;
                        }
                        else
                        {
                            cc.Type = Context.FindType(t.ToString());
                        }
                    }
                    ci.Add(cc);
                }
            }

            SortInfos si = new SortInfos(sortOverride, quoteChar, sep, trim);

            if (!overrideSort && SortCols != null)
            {
                foreach (var col in SortCols)
                {
                    var ss = new SortInfo
                    {
                        Name = Context.TransformStr(col.Name, col.Transform),
                        Sort = col.Sort
                    };

                    var cmp = Context.Transform(col.Comparer, Transform);
                    if (cmp != null)
                    {
                        object c1 = null;
                        if (cmp is Type)
                        {
                            ss.Comparer = (IComparer)Utils.CreateInstance((Type)cmp);
                        }
                        else if (cmp is string && !string.IsNullOrEmpty((string)cmp))
                        {
                            string smp = (string)cmp;
                            if (smp.ToUpperInvariant() == "IGNORECASE" || smp.ToUpperInvariant() == "NOCASE" || smp.ToUpperInvariant() == "IC")
                            {
                                ss.Comparer = StringComparer.CurrentCultureIgnoreCase;
                            }
                            else if (Utils.TryGetProperty(null, typeof(StringComparer), smp, null, false, out c1))
                            {
                                ss.Comparer = (IComparer)c1;
                            }
                            else
                            {
                                ss.Comparer = (IComparer)Utils.CreateInstance(Context.FindType(smp));
                            }
                        }
                        else
                        {
                            ss.Comparer = (IComparer)cmp;
                        }
                    }
                    si.Add(ss);
                }
            }

            var ret = si.SortAndFilter(Context, columnsOverride, whereExpression, getTransformedRowsInternal(ci, csvReader));

            if (columnsOverride == null)
            {
                return(ret);
            }


            ci = new ColumnsInfo();
            ci.AddParsed(Context, columnsOverride, quoteChar, separator[0], trim);
            return(ci.Process(ret));
        }