/// <summary>
 /// Default constructor - considered a parameterless constructor.
 /// </summary>
 /// <param name="ignored">This parameter is ignored.</param>
 public TokenResult(bool ignored)
 {
     TokenType  = Tokens.Invalid;
     Data       = "";
     OpToken    = OperatorTokens.Invalid;
     Precedence = -1;
 }
Esempio n. 2
0
        private static Token ToToken(string token)
        {
            var ret = new Token {
                Value = token, TokenType = Token.Symbol.Variable
            };

            if (token.Length == 1 && OperatorTokens.Contains(token.First()))
            {
                if (token == "(" || token == ")")
                {
                    ret.TokenType = Token.Symbol.Bracket;
                }
                else
                {
                    ret.TokenType = Token.Symbol.Operator;
                }
            }
            else if (FunctionTokens.ContainsKey(token))
            {
                ret.TokenType = Token.Symbol.Function;
            }
            else if (IsDigit(token.First()))
            {
                ret.TokenType = Token.Symbol.Number;
                ret.Number    = decimal.Parse(token);
            }
            return(ret);
        }
Esempio n. 3
0
        /// <summary>
        /// Converts the expected token to its lexeme equivalent
        /// </summary>
        public static string GetExpectedLexeme(Tokens desired)
        {
            string expected = "";

            if ((int)desired < KeyWords.Count)
            {
                expected = "\"" + KeyWords[(int)desired] + "\"";
            }
            else if (OperatorTokens.Contains(desired))
            {
                expected = "an operator";
            }
            else if (desired == Tokens.IdT)
            {
                expected = "an identifier";
            }
            else if (desired == Tokens.NumT)
            {
                expected = "a number";
            }
            else if (desired == Tokens.LParenT)
            {
                expected = "\"(\"";
            }
            else if (desired == Tokens.RParenT)
            {
                expected = "\")\"";
            }
            else if (desired == Tokens.LBrackT)
            {
                expected = "\"[\"";
            }
            else if (desired == Tokens.RBrackT)
            {
                expected = "\"]\"";
            }
            else if (desired == Tokens.LBraceT)
            {
                expected = "\"{\"";
            }
            else if (desired == Tokens.RBraceT)
            {
                expected = "\"}\"";
            }
            else if (desired == Tokens.CommaT)
            {
                expected = "\",\"";
            }
            else if (desired == Tokens.SemiT)
            {
                expected = "\";\"";
            }
            else if (desired == Tokens.PeriodT)
            {
                expected = "\".\"";
            }

            return(expected);
        }
            /// <summary>
            /// Used when the token is an operator.
            /// </summary>
            /// <param name="operatorString">the string representation of the operator</param>
            public TokenResult(string operatorString)
            {
                TokenType  = Tokens.Operator;
                Data       = "";
                OpToken    = OperatorTokens.Invalid;
                Precedence = -1;

                int i;

                i = 0;
                foreach (string op in Operators1)
                {
                    if (String.Compare(op, operatorString) == 0)
                    {
                        OpToken    = (OperatorTokens)((int)OperatorTokens.LParen + i);
                        Precedence = 30;
                        break;
                    }
                    i++;
                }

                if (OpToken == OperatorTokens.Invalid)
                {
                    i = 0;
                    foreach (string op in Operators2)
                    {
                        if (String.Compare(op, operatorString) == 0)
                        {
                            OpToken    = (OperatorTokens)((int)OperatorTokens.Equal + i);
                            Precedence = 20;
                            break;
                        }
                        i++;
                    }
                }

                if (OpToken == OperatorTokens.Invalid)
                {
                    i = 0;
                    foreach (string op in Operators3)
                    {
                        if (String.Compare(op, operatorString) == 0)
                        {
                            OpToken    = (OperatorTokens)((int)OperatorTokens.And + i);
                            Precedence = 10;
                            break;
                        }
                        i++;
                    }
                }
            }
 /// <summary>
 /// Used when the token is a property name or property value.
 /// </summary>
 /// <param name="data">the string value of the propery name or value</param>
 /// <param name="dataIsProperty">true, if a property name</param>
 public TokenResult(string data, bool dataIsProperty)
 {
     Data = data.Trim();
     if (dataIsProperty)
     {
         TokenType = Tokens.PropertyName;
     }
     else
     {
         TokenType = Tokens.PropertyValue;
     }
     OpToken    = OperatorTokens.Invalid;
     Precedence = -1;
 }
        /// <summary>
        /// Evaluates a subexpression of a whole expression.
        /// </summary>
        /// <param name="media">the media object with the metadata</param>
        /// <param name="prop">the property/attribute metadata to examine</param>
        /// <param name="op">the operator to use for examination</param>
        /// <param name="val">the value to compare against in string form</param>
        /// <returns></returns>
        /// <exception cref="OpenSource.UPnP.AV.CdsMetadata.Error_MalformedSearchCriteria">
        /// Thrown when the expression provided at constructor time could not
        /// be used to evaluate the media because of syntax errors in
        /// the expression.
        /// </exception>
        private bool Evaluate(IUPnPMedia media, string prop, OperatorTokens op, string val)
        {
            bool result = false;

            TagExtractor te = (TagExtractor)this.m_PE[prop];

            IList values = te.Extract(media);


            if (op == OperatorTokens.Exists)
            {
                bool testVal = (string.Compare(val, "true", true) == 0);

                result = (
                    ((values.Count > 0) && (testVal)) ||
                    ((values.Count == 0) && (testVal == false))
                    );
            }
            else
            {
                foreach (object testVal in values)
                {
                    int opCode = (int)op;
                    if ((opCode >= (int)OperatorTokens.Equal) && (opCode <= (int)OperatorTokens.GreaterThanEqualTo))
                    {
                        // Compare using a relational operator
                        //
                        try
                        {
                            int relResult = MetadataValueComparer.CompareTagValues(testVal, val, this.IgnoreCase);

                            if (relResult == 0)
                            {
                                result = true;
                                break;
                            }
                        }
                        catch                         //(Exception e)
                        {
                            string opString = Enum.GetName(typeof(OperatorTokens), opCode);
                            throw new Error_MalformedSearchCriteria("(" + val + ") " + opString + " " + testVal.ToString() + ") could not occur.");
                        }
                    }
                    else if (op == OperatorTokens.Contains)
                    {
                        string tv  = testVal.ToString();
                        int    pos = tv.IndexOf(val);
                        result = (pos >= 0);
                    }
                    else if (op == OperatorTokens.DoesNotContain)
                    {
                        string tv  = testVal.ToString();
                        int    pos = tv.IndexOf(val);
                        result = (pos < 0);
                    }
                    else if (op == OperatorTokens.DerivedFrom)
                    {
                        string tv = testVal.ToString();

                        result = tv.StartsWith(val);
                    }
                }
            }

            return(result);
        }
Esempio n. 7
0
			/// <summary>
			/// Used when the token is an operator.
			/// </summary>
			/// <param name="operatorString">the string representation of the operator</param>
			public TokenResult(string operatorString)
			{
				TokenType = Tokens.Operator;
				Data = "";
				OpToken = OperatorTokens.Invalid;
				Precedence = -1;

				int i;
				
				i=0;
				foreach (string op in Operators1)
				{
					if (String.Compare(op, operatorString) == 0)
					{
						OpToken = (OperatorTokens) ((int) OperatorTokens.LParen + i) ;
						Precedence = 30;
						break;
					}
					i++;
				}

				if (OpToken == OperatorTokens.Invalid)
				{
					i=0;
					foreach (string op in Operators2)
					{
						if (String.Compare(op, operatorString) == 0)
						{
							OpToken = (OperatorTokens) ((int) OperatorTokens.Equal + i) ;
							Precedence = 20;
							break;
						}
						i++;
					}
				}

				if (OpToken == OperatorTokens.Invalid)
				{
					i=0;
					foreach (string op in Operators3)
					{
						if (String.Compare(op, operatorString) == 0)
						{
							OpToken = (OperatorTokens) ((int) OperatorTokens.And + i) ;
							Precedence = 10;
							break;
						}
						i++;
					}
				}
			}
Esempio n. 8
0
			/// <summary>
			/// Used when the token is a property name or property value.
			/// </summary>
			/// <param name="data">the string value of the propery name or value</param>
			/// <param name="dataIsProperty">true, if a property name</param>
			public TokenResult(string data, bool dataIsProperty)
			{
				Data = data.Trim();
				if (dataIsProperty)
				{
					TokenType = Tokens.PropertyName;
				}
				else
				{
					TokenType = Tokens.PropertyValue;
				}
				OpToken = OperatorTokens.Invalid;
				Precedence = -1;
			}
Esempio n. 9
0
			/// <summary>
			/// Default constructor - considered a parameterless constructor.
			/// </summary>
			/// <param name="ignored">This parameter is ignored.</param>
			public TokenResult(bool ignored)
			{
				TokenType = Tokens.Invalid;
				Data = "";
				OpToken = OperatorTokens.Invalid;
				Precedence = -1;
			}
Esempio n. 10
0
		/// <summary>
		/// Evaluates a subexpression of a whole expression.
		/// </summary>
		/// <param name="media">the media object with the metadata</param>
		/// <param name="prop">the property/attribute metadata to examine</param>
		/// <param name="op">the operator to use for examination</param>
		/// <param name="val">the value to compare against in string form</param>
		/// <returns></returns>
		/// <exception cref="OpenSource.UPnP.AV.CdsMetadata.Error_MalformedSearchCriteria">
		/// Thrown when the expression provided at constructor time could not
		/// be used to evaluate the media because of syntax errors in 
		/// the expression.
		/// </exception>
		private bool Evaluate(IUPnPMedia media, string prop, OperatorTokens op, string val)
		{
			bool result = false;

			TagExtractor te = (TagExtractor) this.m_PE[prop];

			IList values = te.Extract(media);


			if (op == OperatorTokens.Exists)
			{
				bool testVal = (string.Compare(val, "true", true) == 0);

				result = (
					((values.Count > 0) && (testVal)) ||
					((values.Count == 0) && (testVal == false))
					);
			}
			else
			{
				foreach (object testVal in values)
				{
					int opCode = (int) op;
					if ((opCode >= (int) OperatorTokens.Equal) && (opCode <= (int) OperatorTokens.GreaterThanEqualTo))
					{
						// Compare using a relational operator
						// 
						try
						{
							int relResult = MetadataValueComparer.CompareTagValues(testVal, val, this.IgnoreCase);

							if (relResult == 0)
							{
								result = true;
								break;
							}
						}
						catch //(Exception e)
						{
							string opString = Enum.GetName(typeof(OperatorTokens), opCode);
							throw new Error_MalformedSearchCriteria("("+val+") "+opString+" "+testVal.ToString()+") could not occur.");
						}
					}
					else if (op == OperatorTokens.Contains)
					{
						string tv = testVal.ToString();
						int pos = tv.IndexOf(val);
						result = (pos >= 0);
					}
					else if (op == OperatorTokens.DoesNotContain)
					{
						string tv = testVal.ToString();
						int pos = tv.IndexOf(val);
						result = (pos < 0);
					}
					else if (op == OperatorTokens.DerivedFrom)
					{
						string tv = testVal.ToString();

						result = tv.StartsWith(val);
					}
				}
			}

			return result;
		}