/// <summary> /// Add events, as they are pased. /// </summary> /// <param name="parser">The parser.</param> /// <param name="results">The events found.</param> /// <param name="delim">The delimiter to use.</param> private void AddEvents(SimpleParser parser, IList<ParsedEvent> results, String delim) { bool done = false; StringBuilder l = new StringBuilder(); while (!done && !parser.EOL()) { char ch = parser.Peek(); if (delim.IndexOf(ch) != -1) { if (ch == ')' || ch == '|') done = true; ParsedEvent parsedEvent; // deal with a value specified by + or - if (l.Length > 0 && l[0] == '+') { String l2 = l.ToString().Substring(1); parsedEvent = new ParsedEvent(l2.Trim()); parsedEvent.Value = "true"; } else if (l.Length > 0 && l[0] == '-') { String l2 = l.ToString().Substring(1); parsedEvent = new ParsedEvent(l2.Trim()); parsedEvent.Value = "false"; } else { String l2 = l.ToString(); parsedEvent = new ParsedEvent(l2.Trim()); } // parse choices if (ch == '[') { parser.Advance(); int index = 0; while (ch != ']' && !parser.EOL()) { String labelName = parser.ReadToChars(":,]"); if (parser.Peek() == ':') { parser.Advance(); parser.EatWhiteSpace(); double min = double.Parse(parser.ReadToWhiteSpace()); parser.EatWhiteSpace(); if (!parser.LookAhead("to", true)) { throw new BayesianError("Expected \"to\" in probability choice range."); } parser.Advance(2); double max = CSVFormat.EgFormat.Parse(parser.ReadToChars(",]")); parsedEvent.ChoiceList.Add(new ParsedChoice(labelName, min, max)); } else { parsedEvent.ChoiceList.Add(new ParsedChoice(labelName, index++)); } parser.EatWhiteSpace(); ch = parser.Peek(); if (ch == ',') { parser.Advance(); } } } // deal with a value specified by = if (parser.Peek() == '=') { parser.ReadChar(); String value = parser.ReadToChars(delim); // BayesianEvent evt = this.network.getEvent(parsedEvent.getLabel()); parsedEvent.Value = value; } if (ch == ',') { parser.Advance(); } if (ch == ']') { parser.Advance(); } if (parsedEvent.Label.Length > 0) { results.Add(parsedEvent); } l.Length = 0; } else { parser.Advance(); l.Append(ch); } } }
/// <summary> /// Read the specified parameter. /// </summary> /// <param name="parser">The parser to use.</param> /// <returns>The parsed parameter.</returns> private ParamTemplate ReadParam(SimpleParser parser) { var result = new ParamTemplate(); if (!parser.LookAhead("{", true)) { throw new EACompileError("Expected {"); } parser.Advance(); bool done = false; var buffer = new StringBuilder(); while (!done) { if (parser.Peek() == '}') { done = true; parser.Advance(); } else if (parser.Peek() == '{') { throw new EACompileError("Unexpected {"); } else if (parser.Peek() == '{') { done = true; parser.Advance(); } else if (parser.Peek() == ',') { result.AddType(buffer.ToString().Trim().ToLower()); parser.Advance(); buffer.Length = 0; } else { buffer.Append(parser.ReadChar()); } } String s = buffer.ToString().Trim(); if (s.Length > 0) { result.AddType(s); } return result; }
/// <summary> /// Parse the given line. /// </summary> /// <param name="line">The line to parse.</param> /// <returns>The parsed probability.</returns> public ParsedProbability Parse(String line) { ParsedProbability result = new ParsedProbability(); SimpleParser parser = new SimpleParser(line); parser.EatWhiteSpace(); if (!parser.LookAhead("P(", true)) { throw new EncogError("Bayes table lines must start with P("); } parser.Advance(2); // handle base AddEvents(parser, result.BaseEvents, "|,)=[]"); // handle conditions if (parser.Peek() == '|') { parser.Advance(); AddEvents(parser, result.GivenEvents, ",)=[]"); } if (parser.Peek() != ')') { throw new BayesianError("Probability not properly terminated."); } return result; }
/// <summary> /// Construct a basic template object. /// </summary> /// <param name="thePrecedence">The precedence.</param> /// <param name="theSignature">The opcode signature.</param> /// <param name="theType">The opcode type.</param> /// <param name="isVariable">True, if this opcode is a variable.</param> /// <param name="theDataSize">The data size kept for this opcode.</param> /// <param name="theEvaluate">The evaluator delegate.</param> /// <param name="theIsPossibleReturnType">The return type delegate.</param> /// <param name="theRandomize">The randomizer delegate.</param> public BasicTemplate(int thePrecedence, String theSignature, NodeType theType, bool isVariable, int theDataSize, DelEvaluate theEvaluate, DelIsPossibleReturnType theIsPossibleReturnType, DelRandomize theRandomize) { _precedence = thePrecedence; _signature = theSignature; _varValue = isVariable; _dataSize = theDataSize; _nodeType = theType; _delEvaluate = theEvaluate; _delIsPossibleReturnType = theIsPossibleReturnType; _delRandomize = theRandomize; if (theSignature.Trim().Equals("(")) { // special case, we add a left-paren for the shunting yard alg. _name = theSignature; _returnValue = null; } else { // non-special case, find the name of the function/operator var parser = new SimpleParser(theSignature); bool pass = false; parser.EatWhiteSpace(); _name = parser.ReadToChars("(").Trim(); parser.Advance(); bool done = false; while (!done) { if (parser.Peek() == ')') { parser.Advance(); done = true; } else if (parser.Peek() == ':') { parser.Advance(); pass = true; } else if (parser.Peek() == '{') { ParamTemplate temp = ReadParam(parser); temp.PassThrough = pass; pass = false; _param.Add(temp); } else { parser.Advance(); if (parser.EOL()) { throw new EncogError("Invalid opcode template."); } } } // get the return type parser.EatWhiteSpace(); if (!parser.LookAhead(":", true)) { throw new EACompileError("Return type not specified."); } parser.Advance(); parser.EatWhiteSpace(); _returnValue = ReadParam(parser); } }
private static List<string> x5dc02619c7b497cb(string x311e7a92306d7199) { List<string> list = new List<string>(); SimpleParser parser = new SimpleParser(x311e7a92306d7199); if (0 == 0) { goto Label_0036; } Label_0012: list.Add((parser.Peek() == '"') ? parser.ReadQuotedString() : parser.ReadToWhiteSpace()); parser.EatWhiteSpace(); Label_0036: if (!parser.EOL()) { goto Label_0012; } return list; }
/// <summary> /// Parse a value. /// </summary> /// /// <param name="parser">The parser to use.</param> /// <returns>The newly parsed value.</returns> private static String ParseValue(SimpleParser parser) { bool quoted = false; var str = new StringBuilder(); parser.EatWhiteSpace(); if (parser.Peek() == '\"') { quoted = true; parser.Advance(); } while (!parser.EOL()) { if (parser.Peek() == '\"') { if (quoted) { parser.Advance(); if (parser.Peek() == '\"') { str.Append(parser.ReadChar()); } else { break; } } else { str.Append(parser.ReadChar()); } } else if (!quoted && (parser.IsWhiteSpace() || (parser.Peek() == ','))) { break; } else { str.Append(parser.ReadChar()); } } return str.ToString(); }
public ProgramNode Parse(String expression) { this.parser = new SimpleParser(expression); this.unary = true; while (!parser.EOL()) { parser.EatWhiteSpace(); char ch = parser.Peek(); if (ch == '.' || char.IsDigit(ch)) { HandleNumeric(); this.unary = false; } else if (char.IsLetter(ch)) { handleAlpha(false); this.unary = false; } else if (ch == '(') { this.parser.Advance(); this.functionStack.Push(LEFT_PAREN); this.unary = true; } else if (ch == ')') { handleRightParen(); this.unary = false; } else if ("<>^*/+-=&|".IndexOf(ch) != -1) { handleSymbol(); this.unary = true; } else if (ch == '\"') { handleString(); this.unary = false; } else if (ch == ',') { HandleFunctionSeparator(); this.unary = true; } else { throw new EACompileError("Unparsable character: " + ch); } } // pop off any functions still on the stack while (this.functionStack.Count > 0) { IProgramExtensionTemplate f = this.functionStack.Pop(); OutputQueue(f); } // were there no operators? if (this.rootNode == null) { this.rootNode = this.outputStack.Pop(); } return this.rootNode; }
private static string x0738845e2abbf3d2(SimpleParser xbce90b56ab411c23) { bool flag = false; StringBuilder builder = new StringBuilder(); xbce90b56ab411c23.EatWhiteSpace(); if (0 == 0) { goto Label_001E; } goto Label_0160; Label_000F: builder.Append(xbce90b56ab411c23.ReadChar()); goto Label_002B; Label_001E: if (xbce90b56ab411c23.Peek() == '"') { goto Label_0160; } Label_002B: if (!xbce90b56ab411c23.EOL()) { goto Label_00AE; } goto Label_01A9; Label_0061: if (((uint) flag) >= 0) { goto Label_000F; } Label_008C: if (!flag) { if (xbce90b56ab411c23.IsWhiteSpace()) { goto Label_01A9; } if (xbce90b56ab411c23.Peek() != ',') { goto Label_0061; } if (0 != 0) { goto Label_008C; } if ((((uint) flag) - ((uint) flag)) <= uint.MaxValue) { goto Label_01A9; } goto Label_000F; } if (-2 != 0) { goto Label_000F; } Label_00AE: if (xbce90b56ab411c23.Peek() == '"') { goto Label_0109; } if ((((uint) flag) - ((uint) flag)) <= uint.MaxValue) { goto Label_008C; } goto Label_000F; Label_00D2: if ((((uint) flag) + ((uint) flag)) < 0) { goto Label_001E; } goto Label_002B; Label_0109: if (!flag) { builder.Append(xbce90b56ab411c23.ReadChar()); goto Label_002B; } xbce90b56ab411c23.Advance(); if (xbce90b56ab411c23.Peek() != '"') { goto Label_01A9; } builder.Append(xbce90b56ab411c23.ReadChar()); goto Label_00D2; Label_0160: flag = true; if ((((uint) flag) + ((uint) flag)) <= uint.MaxValue) { if ((((uint) flag) | 15) == 0) { if (((uint) flag) >= 0) { goto Label_0061; } goto Label_008C; } xbce90b56ab411c23.Advance(); goto Label_002B; } if ((((uint) flag) - ((uint) flag)) >= 0) { goto Label_0109; } goto Label_00D2; Label_01A9: return builder.ToString(); }