Peek() публичный Метод

Peek ahead to see the next character. But do not advance beyond it.
public Peek ( ) : char
Результат char
        /// <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);
            }
        }
Пример #5
0
 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;
        }
Пример #8
0
 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();
 }