/// <summary> /// CheckParms( Parser.Token, CValue) - This method makes certain the single argument is non-null. /// Raises an exception if it is. /// </summary> /// <param name="oToken">Parser.Token object</param> /// <param name="arg1">CValue argument</param> private void CheckParms(Parser.Token oToken, CValue arg1) { if (arg1 == null) { throw new ApplicationException("Argument not supplied near " + oToken.ToString() + " operation."); } }
private static void RenderErrorInfoAsJson(ExportCommand command, Exception exception) { List <Exception> exceptions = new List <Exception>(); if (exception != null) { if (exception is Parser.MultiParserException) { exceptions.AddRange(((Parser.MultiParserException)exception).ParseExceptions); } else { exceptions.Add(exception); } } System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append("{ \"errors\": ["); for (int i = 0; i < exceptions.Count; ++i) { if (i > 0) { sb.Append(','); } Parser.FileScope fileInfo = null; Parser.Token tokenInfo = null; string message = exceptions[i].Message; Parser.ParserException parserException = exceptions[i] as Parser.ParserException; if (parserException != null) { fileInfo = parserException.File; tokenInfo = parserException.TokenInfo; message = parserException.OriginalMessage; } sb.Append("\n {"); if (fileInfo != null) { sb.Append("\n \"file\": \""); sb.Append(fileInfo.Name.Replace("\\", "\\\\")); sb.Append("\","); } if (tokenInfo != null) { sb.Append("\n \"col\": "); sb.Append(tokenInfo.Col + 1); sb.Append(","); sb.Append("\n \"line\": "); sb.Append(tokenInfo.Line + 1); sb.Append(","); } sb.Append("\n \"message\": \""); sb.Append(message.Replace("\\", "\\\\").Replace("\"", "\\\"")); sb.Append("\"\n }"); } sb.Append(" ] }"); string output = sb.ToString(); WriteCompileInformation(output); }
/// <summary> /// SetFunction(string): Sets the current function to a passed string. /// </summary> /// <param name="sEquation">string representing the function being used</param> public void SetFunction(string sEquation) { m_currentToken = null; m_nextToken = null; m_sEquation = sEquation; m_Function = null; InitFunctions(); }
public void TestParseToken() { Parser.Token token = Parser.ParseToken("(name)"); Assert.AreEqual(Parser.TokenType.Variable, token.type); Assert.AreEqual("name", token.value); token = Parser.ParseToken("\"string\""); Assert.AreEqual(Parser.TokenType.String, token.type); Assert.AreEqual("string", token.value); }
/// <summary> /// OpFactor(...): Reads the passed operator, identifies the associated implementation object /// and requests an operation object to be used in evaluating the equation. /// </summary> /// <param name="oSourceOp">Parser.Token object representing the operator in question.</param> /// <param name="oValue1">The first value object to be operated on.</param> /// <param name="oValue2">The second value object to be operated on.</param> /// <returns>CValue object representing an operation.</returns> private CValue OpFactory(Parser.Token oSourceOp, CValue oValue1, CValue oValue2) { foreach (COperator oOp in m_aOps) { if (oOp.IsMatch(oSourceOp)) { return(oOp.Factory(oValue1, oValue2)); } } throw new ApplicationException("Invalid operator in equation."); }
/// <summary> /// AddSub(): Detects the operation to perform addition or substraction. /// </summary> /// <returns>CValue object representing an operation.</returns> private CValue AddSub() { CValue oValue = MultDiv(); while (m_currentToken == "+" || m_currentToken == "-") { Parser.Token oOp = m_currentToken; PositionNextToken(); CValue oNextVal = MultDiv(); CheckParms(oOp, oValue, oNextVal); oValue = OpFactory(oOp, oValue, oNextVal); } return(oValue); }
/// <summary> /// Power(): Detects the operation to raise one number to the power /// of another (a^2). /// </summary> /// <returns>CValue object representing an operation.</returns> private CValue Power() { CValue oValue = Sign(); while (m_currentToken == "^") { Parser.Token oOp = m_currentToken; PositionNextToken(); CValue oNextVal = Sign(); CheckParms(oOp, oValue, oNextVal); oValue = OpFactory(oOp, oValue, oNextVal); } return(oValue); }
/// <summary> /// PositionNextToken(): Manipulates the current Token position forward in the chain of tokens /// discovered by the parser. /// </summary> private void PositionNextToken() { if (m_currentToken == null) { if (!m_enumTokens.MoveNext()) { throw new ApplicationException("Invalid equation."); } m_nextToken = (Parser.Token)m_enumTokens.Current; } m_currentToken = m_nextToken; if (!m_enumTokens.MoveNext()) { m_nextToken = new Parser.Token(); } else { m_nextToken = (Parser.Token)m_enumTokens.Current; } }
/// <summary> /// Sign(): This method detects the existence of sign operators before /// a number or variable. /// </summary> /// <returns>CValue object representing an operation.</returns> private CValue Sign() { bool bNeg = false; Parser.Token oToken = null; if (m_currentToken == "+" || m_currentToken == "-") { oToken = m_currentToken; bNeg = (m_currentToken == "-"); PositionNextToken(); } //CValue oFunc = Function(); // sdh: should be function when ready. CValue oFunc = Paren(); if (bNeg) { CheckParms(oToken, oFunc); oFunc = new CSignNeg(oFunc); } return(oFunc); }
public void TestGetBinding() { Parser.Binding binding = Parser.GetBinding("is (something)"); Assert.AreEqual("is %s", binding.key); Parser.Token token = binding.tokens[0]; Assert.AreEqual(Parser.TokenType.Variable, token.type); Assert.AreEqual("something", token.value); binding = Parser.GetBinding("(someone) is (something)"); Parser.Token token1 = binding.tokens[0]; Parser.Token token2 = binding.tokens[1]; Assert.AreEqual(Parser.TokenType.Variable, token1.type); Assert.AreEqual("someone", token1.value); Assert.AreEqual(Parser.TokenType.Variable, token2.type); Assert.AreEqual("something", token2.value); binding = Parser.GetBinding("(someone) is \"a big meanie\""); token1 = binding.tokens[0]; token2 = binding.tokens[1]; Assert.AreEqual(Parser.TokenType.Variable, token1.type); Assert.AreEqual(Parser.TokenType.String, token2.type); Assert.AreEqual("someone", token1.value); Assert.AreEqual("a big meanie", token2.value); }
/// <summary> /// Relational(): Detects the operation to perform a relational operator (>, <, <=, etc.). /// </summary> /// <returns>CValue object representing an operation.</returns> private CValue Relational() { CValue oValue = AddSub(); while (m_currentToken == "&&" || m_currentToken == "||" || m_currentToken == "==" || m_currentToken == "<" || m_currentToken == ">" || m_currentToken == "<=" || m_currentToken == ">=" || m_currentToken == "!=" || m_currentToken == "<>") { Parser.Token oOp = m_currentToken; PositionNextToken(); CValue oNextVal = Relational(); CheckParms(oOp, oValue, oNextVal); oValue = OpFactory(oOp, oValue, oNextVal); } return(oValue); }
public Evaluator(Parser.Token Tokens) { token = Tokens; }
public PostfixExpression(IExpression left, Parser.Token tokenId) { Left = left; TokenId = tokenId; }
public BinaryOperatorExpression(IExpression left, Parser.Token tokenId, IExpression right) { Left = left; TokenId = tokenId; Right = right; }
public PrefixExpression(Parser.Token tokenId, IExpression right) { TokenId = tokenId; Right = right; }
/// <summary> /// Initializes a new instance of the <see cref="Evaluator" /> class. /// </summary> /// <param name="Tokens">The tokens.</param> public Evaluator(Parser.Token Tokens) { token = Tokens; }
private bool Eval(Parser.TokenItems Parameters, out Parser.TokenItem Result, out string ErrorMsg) { // initialize the outgoing variables ErrorMsg = ""; Result = null; // make sure we have at least 1 parameter if (Parameters.Count != 1) { ErrorMsg = "Eval[] Operand Function requires 1 parameter."; return false; } // get the expression to be evaluated string expression = Support.DataTypeCheck.RemoveTextQuotes(Parameters[0].TokenName); // create the tokens Parser.Token tokens = new Parser.Token(expression); if (tokens.AnyErrors == true) { ErrorMsg = tokens.LastErrorMessage; return false; } // create the evaluator object Evaluator e = new Evaluator(tokens); string value = ""; if (e.Evaluate(out value, out ErrorMsg) == false) return false; if (Support.DataTypeCheck.IsInteger(value) == true) Result = new Parser.TokenItem(value, Parser.TokenType.Token_Operand, Parser.TokenDataType.Token_DataType_Int, false); else if (Support.DataTypeCheck.IsDouble(value) == true) Result = new Parser.TokenItem(value, Parser.TokenType.Token_Operand, Parser.TokenDataType.Token_DataType_Double, false); else if (Support.DataTypeCheck.IsDate(value) == true) Result = new Parser.TokenItem(value, Parser.TokenType.Token_Operand, Parser.TokenDataType.Token_DataType_Date, false); else Result = new Parser.TokenItem(value, Parser.TokenType.Token_Operand, Parser.TokenDataType.Token_DataType_String, false); return true; }
public AnnoNode(Parser.Token token) : base(token) { }
public override bool IsMatch(Parser.Token tkn) { return(tkn.ToString() == "<="); }
/// <summary> /// IsMatch(): accepts an operation token and identifies if the implemented /// operator class is responsible for it. This allows for multiple operators /// to represent a given operation (i.e. != and <> both represent the "not-equal" case. /// </summary> /// <param name="tkn">Parser.Token containing the operator in question</param> /// <returns>bool returning true if the object is reponsible for implementing the operator at hand.</returns> public abstract bool IsMatch(Parser.Token tkn);