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

Read the next character.
public ReadChar ( ) : 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 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();
        }
 /// <summary>
 /// Parse a name.
 /// </summary>
 ///
 /// <param name="parser">The parser to use.</param>
 /// <returns>The name.</returns>
 private static String ParseName(SimpleParser parser)
 {
     var result = new StringBuilder();
     parser.EatWhiteSpace();
     while (parser.IsIdentifier())
     {
         result.Append(parser.ReadChar());
     }
     return result.ToString();
 }
Пример #5
0
 private static string xe1cd55dd1e3e1253(SimpleParser xbce90b56ab411c23)
 {
     StringBuilder builder = new StringBuilder();
     xbce90b56ab411c23.EatWhiteSpace();
     while (xbce90b56ab411c23.IsIdentifier())
     {
         builder.Append(xbce90b56ab411c23.ReadChar());
     }
     return builder.ToString();
 }
Пример #6
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();
 }