Example #1
0
        static private Rule Parse(string rulename, string text, bool trace)
        {
            if (rulename == null)
            {
                throw new ArgumentNullException("null rulename");
            }
            if (text == null)
            {
                throw new ArgumentException("null string");
            }

            ParserContext context = new ParserContext(text, trace);

            Rule rule = null;

            if (rulename.ToLower().Equals("geo-URI".ToLower()))
            {
                rule = Rule_geo_URI.Parse(context);
            }
            else if (rulename.ToLower().Equals("geo-scheme".ToLower()))
            {
                rule = Rule_geo_scheme.Parse(context);
            }
            else if (rulename.ToLower().Equals("geo-path".ToLower()))
            {
                rule = Rule_geo_path.Parse(context);
            }
            else if (rulename.ToLower().Equals("coordinates".ToLower()))
            {
                rule = Rule_coordinates.Parse(context);
            }
            else if (rulename.ToLower().Equals("coord-a".ToLower()))
            {
                rule = Rule_coord_a.Parse(context);
            }
            else if (rulename.ToLower().Equals("coord-b".ToLower()))
            {
                rule = Rule_coord_b.Parse(context);
            }
            else if (rulename.ToLower().Equals("coord-c".ToLower()))
            {
                rule = Rule_coord_c.Parse(context);
            }
            else if (rulename.ToLower().Equals("p".ToLower()))
            {
                rule = Rule_p.Parse(context);
            }
            else if (rulename.ToLower().Equals("crsp".ToLower()))
            {
                rule = Rule_crsp.Parse(context);
            }
            else if (rulename.ToLower().Equals("crslabel".ToLower()))
            {
                rule = Rule_crslabel.Parse(context);
            }
            else if (rulename.ToLower().Equals("uncp".ToLower()))
            {
                rule = Rule_uncp.Parse(context);
            }
            else if (rulename.ToLower().Equals("uval".ToLower()))
            {
                rule = Rule_uval.Parse(context);
            }
            else if (rulename.ToLower().Equals("parameter".ToLower()))
            {
                rule = Rule_parameter.Parse(context);
            }
            else if (rulename.ToLower().Equals("pname".ToLower()))
            {
                rule = Rule_pname.Parse(context);
            }
            else if (rulename.ToLower().Equals("pvalue".ToLower()))
            {
                rule = Rule_pvalue.Parse(context);
            }
            else if (rulename.ToLower().Equals("paramchar".ToLower()))
            {
                rule = Rule_paramchar.Parse(context);
            }
            else if (rulename.ToLower().Equals("labeltext".ToLower()))
            {
                rule = Rule_labeltext.Parse(context);
            }
            else if (rulename.ToLower().Equals("pnum".ToLower()))
            {
                rule = Rule_pnum.Parse(context);
            }
            else if (rulename.ToLower().Equals("num".ToLower()))
            {
                rule = Rule_num.Parse(context);
            }
            else if (rulename.ToLower().Equals("unreserved".ToLower()))
            {
                rule = Rule_unreserved.Parse(context);
            }
            else if (rulename.ToLower().Equals("mark".ToLower()))
            {
                rule = Rule_mark.Parse(context);
            }
            else if (rulename.ToLower().Equals("pct-encoded".ToLower()))
            {
                rule = Rule_pct_encoded.Parse(context);
            }
            else if (rulename.ToLower().Equals("p-unreserved".ToLower()))
            {
                rule = Rule_p_unreserved.Parse(context);
            }
            else if (rulename.ToLower().Equals("alphanum".ToLower()))
            {
                rule = Rule_alphanum.Parse(context);
            }
            else if (rulename.ToLower().Equals("DIGIT".ToLower()))
            {
                rule = Rule_DIGIT.Parse(context);
            }
            else if (rulename.ToLower().Equals("HEXDIG".ToLower()))
            {
                rule = Rule_HEXDIG.Parse(context);
            }
            else if (rulename.ToLower().Equals("ALPHA".ToLower()))
            {
                rule = Rule_ALPHA.Parse(context);
            }
            else
            {
                throw new ArgumentException("unknown rule");
            }

            if (rule == null)
            {
                throw new ParserException(
                          "rule \"" + context.GetErrorStack().Peek() + "\" failed",
                          context.text,
                          context.GetErrorIndex(),
                          context.GetErrorStack());
            }

            if (context.text.Length > context.index)
            {
                ParserException primaryError =
                    new ParserException(
                        "extra data found",
                        context.text,
                        context.index,
                        new Stack <string>());

                if (context.GetErrorIndex() > context.index)
                {
                    ParserException secondaryError =
                        new ParserException(
                            "rule \"" + context.GetErrorStack().Peek() + "\" failed",
                            context.text,
                            context.GetErrorIndex(),
                            context.GetErrorStack());

                    primaryError.SetCause(secondaryError);
                }

                throw primaryError;
            }

            return(rule);
        }
Example #2
0
        public static Rule_pvalue Parse(ParserContext context)
        {
            context.Push("pvalue");

            Rule rule;
            bool parsed = true;
            ParserAlternative b;
            int s0 = context.index;
            ParserAlternative a0 = new ParserAlternative(s0);

            List <ParserAlternative> as1 = new List <ParserAlternative>();

            parsed = false;
            {
                int s1 = context.index;
                ParserAlternative a1 = new ParserAlternative(s1);
                parsed = true;
                if (parsed)
                {
                    bool f1 = true;
                    int  c1 = 0;
                    for (int i1 = 0; i1 < 1 && f1; i1++)
                    {
                        rule = Rule_paramchar.Parse(context);
                        if ((f1 = rule != null))
                        {
                            a1.Add(rule, context.index);
                            c1++;
                        }
                    }
                    while (f1)
                    {
                        rule = Rule_paramchar.Parse(context);
                        if ((f1 = rule != null))
                        {
                            a1.Add(rule, context.index);
                            c1++;
                        }
                    }
                    parsed = c1 >= 1;
                }
                if (parsed)
                {
                    as1.Add(a1);
                }
                context.index = s1;
            }

            b = ParserAlternative.GetBest(as1);

            parsed = b != null;

            if (parsed)
            {
                a0.Add(b.rules, b.end);
                context.index = b.end;
            }

            rule = null;
            if (parsed)
            {
                rule = new Rule_pvalue(context.text.Substring(a0.start, a0.end - a0.start), a0.rules);
            }
            else
            {
                context.index = s0;
            }

            context.Pop("pvalue", parsed);

            return((Rule_pvalue)rule);
        }
 public object Visit(Rule_pvalue rule)
 {
     _paramValue = rule.spelling;
     return false;
 }
        public static Rule_pvalue Parse(ParserContext context)
        {
            context.Push("pvalue");

            Rule rule;
            bool parsed = true;
            ParserAlternative b;
            int s0 = context.index;
            ParserAlternative a0 = new ParserAlternative(s0);

            List<ParserAlternative> as1 = new List<ParserAlternative>();
            parsed = false;
            {
                int s1 = context.index;
                ParserAlternative a1 = new ParserAlternative(s1);
                parsed = true;
                if (parsed)
                {
                    bool f1 = true;
                    int c1 = 0;
                    for (int i1 = 0; i1 < 1 && f1; i1++)
                    {
                        rule = Rule_paramchar.Parse(context);
                        if ((f1 = rule != null))
                        {
                            a1.Add(rule, context.index);
                            c1++;
                        }
                    }
                    while (f1)
                    {
                        rule = Rule_paramchar.Parse(context);
                        if ((f1 = rule != null))
                        {
                            a1.Add(rule, context.index);
                            c1++;
                        }
                    }
                    parsed = c1 >= 1;
                }
                if (parsed)
                {
                    as1.Add(a1);
                }
                context.index = s1;
            }

            b = ParserAlternative.GetBest(as1);

            parsed = b != null;

            if (parsed)
            {
                a0.Add(b.rules, b.end);
                context.index = b.end;
            }

            rule = null;
            if (parsed)
            {
                rule = new Rule_pvalue(context.text.Substring(a0.start, a0.end - a0.start), a0.rules);
            }
            else
            {
                context.index = s0;
            }

            context.Pop("pvalue", parsed);

            return (Rule_pvalue)rule;
        }
Example #5
0
        public static Rule_parameter Parse(ParserContext context)
        {
            context.Push("parameter");

            Rule rule;
            bool parsed = true;
            ParserAlternative b;
            int s0 = context.index;
            ParserAlternative a0 = new ParserAlternative(s0);

            List <ParserAlternative> as1 = new List <ParserAlternative>();

            parsed = false;
            {
                int s1 = context.index;
                ParserAlternative a1 = new ParserAlternative(s1);
                parsed = true;
                if (parsed)
                {
                    bool f1 = true;
                    int  c1 = 0;
                    for (int i1 = 0; i1 < 1 && f1; i1++)
                    {
                        rule = Terminal_StringValue.Parse(context, ";");
                        if ((f1 = rule != null))
                        {
                            a1.Add(rule, context.index);
                            c1++;
                        }
                    }
                    parsed = c1 == 1;
                }
                if (parsed)
                {
                    bool f1 = true;
                    int  c1 = 0;
                    for (int i1 = 0; i1 < 1 && f1; i1++)
                    {
                        rule = Rule_pname.Parse(context);
                        if ((f1 = rule != null))
                        {
                            a1.Add(rule, context.index);
                            c1++;
                        }
                    }
                    parsed = c1 == 1;
                }
                if (parsed)
                {
                    bool f1 = true;
                    int  c1 = 0;
                    for (int i1 = 0; i1 < 1 && f1; i1++)
                    {
                        int g1 = context.index;
                        List <ParserAlternative> as2 = new List <ParserAlternative>();
                        parsed = false;
                        {
                            int s2 = context.index;
                            ParserAlternative a2 = new ParserAlternative(s2);
                            parsed = true;
                            if (parsed)
                            {
                                bool f2 = true;
                                int  c2 = 0;
                                for (int i2 = 0; i2 < 1 && f2; i2++)
                                {
                                    rule = Terminal_StringValue.Parse(context, "=");
                                    if ((f2 = rule != null))
                                    {
                                        a2.Add(rule, context.index);
                                        c2++;
                                    }
                                }
                                parsed = c2 == 1;
                            }
                            if (parsed)
                            {
                                bool f2 = true;
                                int  c2 = 0;
                                for (int i2 = 0; i2 < 1 && f2; i2++)
                                {
                                    rule = Rule_pvalue.Parse(context);
                                    if ((f2 = rule != null))
                                    {
                                        a2.Add(rule, context.index);
                                        c2++;
                                    }
                                }
                                parsed = c2 == 1;
                            }
                            if (parsed)
                            {
                                as2.Add(a2);
                            }
                            context.index = s2;
                        }

                        b = ParserAlternative.GetBest(as2);

                        parsed = b != null;

                        if (parsed)
                        {
                            a1.Add(b.rules, b.end);
                            context.index = b.end;
                        }
                        f1 = context.index > g1;
                        if (parsed)
                        {
                            c1++;
                        }
                    }
                    parsed = true;
                }
                if (parsed)
                {
                    as1.Add(a1);
                }
                context.index = s1;
            }

            b = ParserAlternative.GetBest(as1);

            parsed = b != null;

            if (parsed)
            {
                a0.Add(b.rules, b.end);
                context.index = b.end;
            }

            rule = null;
            if (parsed)
            {
                rule = new Rule_parameter(context.text.Substring(a0.start, a0.end - a0.start), a0.rules);
            }
            else
            {
                context.index = s0;
            }

            context.Pop("parameter", parsed);

            return((Rule_parameter)rule);
        }