Пример #1
0
            private IOperation parseVar()
            {
                Operations.OperationVariableAccess va = new Operations.OperationVariableAccess();

                var  cc        = _reader.Peek();
                bool blockMode = (cc == '{');

                StringBuilder sb = new StringBuilder();

                if (!blockMode)
                {
                    while ((cc = _reader.Peek()) != -1)
                    {
                        var ch = (char)cc;
                        if (!char.IsLetterOrDigit(ch) && _parser._tokenSpecialCharacters.IndexOf(ch) == -1)
                        {
                            break;
                        }

                        sb.Append(ch);
                        _reader.Read();
                    }
                    va.AddName(sb.ToString());
                    return(new Operations.OperationExpression(new IOperation[] { va }));
                }
                _reader.Read();  // Read {
                var v = _parser.ParseMulti(_reader);

                _reader.SkipWhiteSpaceAndComments();
                _reader.ReadAndThrowIfNot('}'); // eat }
                return(v);
            }
Пример #2
0
 /// Evaluate string and return the result of the evaluation, casted to the type T
 public T Eval <T>(string st)
 {
     using (var sr = new ParsingReader(new StringReader(st)))
     {
         var o = Eval <T>(sr);
         sr.SkipWhiteSpaceAndComments();
         sr.ReadAndThrowIfNot(-1);
         return(o);
     }
 }
Пример #3
0
 /// Returns null if str is not a number, or its value otherwise
 public static ValueType TryParseNumber(string stringToParse)
 {
     if (stringToParse == null)
     {
         return(null);
     }
     using (var sr = new ParsingReader(stringToParse))
     {
         sr.SkipWhiteSpaceAndComments();
         ValueType o = sr.ReadNumber();
         if (o == null)
         {
             return(null);
         }
         sr.SkipWhiteSpaceAndComments();
         if (sr.Peek() != -1)
         {
             return(null);
         }
         return(o);
     }
 }
Пример #4
0
 /// Parse string to a number. 10 and hex numbers (like 0x222) are allowed. Suffixes like 20.3f are also allowed.
 public static ValueType ParseNumber(string str)
 {
     if (str == null)
     {
         throw new ArgumentNullException("str");
     }
     using (var sr = new ParsingReader(str))
     {
         sr.SkipWhiteSpaceAndComments();
         ValueType o = sr.ReadNumber();
         if (o == null)
         {
             throw new ParsingException("Invalid numeric expression at " + sr.ReadLine());
         }
         sr.SkipWhiteSpaceAndComments();
         if (sr.Peek() != -1)
         {
             throw new ParsingException("Invalid numeric expression, unexpected characters at " + sr.ReadLine());
         }
         return(o);
     }
 }
Пример #5
0
        /// <summary>
        /// Parse stream and return the expression tree
        /// </summary>
        /// <param name="r">Stream</param>
        /// <returns>Parsed expression or null if no expression is found on stream</returns>
        public IOperation Parse(ParsingReader r)
        {
            List <IOperation> data = new List <IOperation>();

            while (!r.IsEOF)
            {
                TokenQueue tokenQueue = new TokenQueue(this, r);
                var        ex         = parseSingleStatement(tokenQueue, -1);
                if (ex == null)
                {
                    break;
                }
                if (data.Count > 0)
                {
                    data.Add(new Operations.OperationPop());
                }
                data.Add(ex);
                r.SkipWhiteSpaceAndComments();
                if (r.Peek() != ';')
                {
                    break;
                }
                do
                {
                    r.Read();
                    r.SkipWhiteSpaceAndComments();
                } while (r.Peek() == ';');
            }
            if (data.Count == 0)
            {
                return(null);
            }
            if (data.Count == 1)
            {
                return(data[0]);
            }
            return(new Operations.OperationExpression(data.ToArray()));
        }
Пример #6
0
 /// True if str is a number
 public static bool IsNumber(string str)
 {
     if (str == null)
     {
         throw new ArgumentNullException("str");
     }
     using (var sr = new ParsingReader(str))
     {
         if (sr.ReadNumber() == null)
         {
             return(false);
         }
         sr.SkipWhiteSpaceAndComments();
         if (sr.Peek() != -1)
         {
             return(false);
         }
     }
     return(true);
 }
Пример #7
0
        /// Parse multi-expression, like ${a|b|=2+3}
        public IOperation ParseMulti(ParsingReader reader)
        {
            Operations.OperationVariableAccess va = new Operations.OperationVariableAccess();
            StringBuilder sb    = new StringBuilder();
            bool          orMet = true;
            int           n;

            while ((n = reader.Peek()) != -1)
            {
                var q = (char)n;
                if (q == '}' || q == ')' || q == ']')
                {
                    break;
                }
                switch (q)
                {
                case '|':
                    reader.Read();
                    va.AddName(sb.ToString());
                    sb.Length = 0;
                    orMet     = true;
                    break;

                case '\'':
                case '\"':
                case '`':
                    orMet = false;
                    if (sb.Length != 0)
                    {
                        reader.ThrowParsingException("Quote must be a first character");
                    }
                    va.AddValue(reader.ReadQuote());
                    reader.SkipWhiteSpaceAndComments();
                    if (reader.Peek() != '}' && reader.Peek() != '|')
                    {
                        reader.ThrowParsingException("Unexpected character '" + (char)reader.Peek() + "'");
                    }
                    sb.Length = 0;
                    break;

                case '=':
                    orMet = false;
                    reader.Read();
                    var v = Parse(reader);
                    if (v != null)
                    {
                        va.AddExpression(v);
                    }
                    else
                    {
                        va.AddValue(null);
                    }
                    break;

                default:
                    orMet = false;
                    sb.Append(q);
                    reader.Read();
                    break;
                }
            }
            if (sb.Length > 0 || orMet)
            {
                va.AddName(sb.ToString());
            }
            return(va);
        }