public virtual bool LineStats(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> adds = null;
            OMetaList <HostExpression> subs = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(Number, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                adds = result2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\t").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                if (!MetaRules.Apply(Number, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                subs = result2;
                result2 = (Sugar.Cons(adds, subs)).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
        public virtual bool EscapeChar(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> c = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\\").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                if (!MetaRules.Apply(Character, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                c = result2;
                result2 = (c).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
        public virtual bool FullFile(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> files = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Many1(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(FileStats, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    return(MetaRules.Success());
                }
                        , modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                files = result2;
                result2 = (files).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
        public virtual bool Filename(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> name = null;
            OMetaList <HostExpression> ext  = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Many1(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(LetterOrDigit, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    return(MetaRules.Success());
                }
                        , modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                name = result2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, (".").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                if (!MetaRules.Many1(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(LetterOrDigit, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    return(MetaRules.Success());
                }
                        , modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                ext = result2;
                result2 = (name.As <string>() + "." + ext.As <string>()).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
 public virtual bool Number(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
 {
     modifiedStream = inputStream;
     if (!MetaRules.Many1(
             delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.Apply(Digit, modifiedStream2, out result2, out modifiedStream2))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
             , modifiedStream, out result, out modifiedStream))
     {
         return(MetaRules.Fail(out result, out modifiedStream));
     }
     return(MetaRules.Success());
 }
        public virtual bool List(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> xs = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("(").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                if (!MetaRules.Many(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(SExpression, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    return(MetaRules.Success());
                }
                        , modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                xs = result2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, (")").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                result2 = (new SExprList(xs.ToIEnumerable <ISExpression>())).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
 public virtual bool NewLine(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
 {
     modifiedStream = inputStream;
     if (!MetaRules.Apply(
             delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\r").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\n").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }, modifiedStream, out result, out modifiedStream))
     {
         return(MetaRules.Fail(out result, out modifiedStream));
     }
     return(MetaRules.Success());
 }
        public virtual bool FileStats(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> lines = null;
            OMetaList <HostExpression> name  = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(LineStats, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                lines = result2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\t").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                if (!MetaRules.Apply(Filename, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                name = result2;
                if (!MetaRules.Apply(NewLine, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                result2 = (new FileStats(lines[0].As <int>(), lines[1].As <int>(), name.As <string>())).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
        public virtual bool SExpression(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> a = null;
            OMetaList <HostExpression> l = null;

            modifiedStream = inputStream;
            if (!MetaRules.Or(modifiedStream, out result, out modifiedStream,
                              delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(Spaces, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    if (!MetaRules.Apply(Atom, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    a = result3;
                    if (!MetaRules.Apply(Spaces, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    result3 = (a).AsHostExpressionList();
                    return(MetaRules.Success());
                }, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                return(MetaRules.Success());
            }
                              , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(Spaces, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    if (!MetaRules.Apply(List, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    l = result3;
                    if (!MetaRules.Apply(Spaces, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    result3 = (l.As <SExprList>()).AsHostExpressionList();
                    return(MetaRules.Success());
                }, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                return(MetaRules.Success());
            }
                              ))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
        public virtual bool String(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> s = null;

            modifiedStream = inputStream;
            if (!MetaRules.Apply(
                    delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\"").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                if (!MetaRules.Many(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Or(modifiedStream3, out result3, out modifiedStream3,
                                      delegate(OMetaStream <char> inputStream4, out OMetaList <HostExpression> result4, out OMetaStream <char> modifiedStream4)
                    {
                        modifiedStream4 = inputStream4;
                        if (!MetaRules.Apply(EscapeChar, modifiedStream4, out result4, out modifiedStream4))
                        {
                            return(MetaRules.Fail(out result4, out modifiedStream4));
                        }
                        return(MetaRules.Success());
                    }
                                      , delegate(OMetaStream <char> inputStream4, out OMetaList <HostExpression> result4, out OMetaStream <char> modifiedStream4)
                    {
                        modifiedStream4 = inputStream4;
                        if (!MetaRules.Apply(
                                delegate(OMetaStream <char> inputStream5, out OMetaList <HostExpression> result5, out OMetaStream <char> modifiedStream5)
                        {
                            modifiedStream5 = inputStream5;
                            if (!MetaRules.Not(
                                    delegate(OMetaStream <char> inputStream6, out OMetaList <HostExpression> result6, out OMetaStream <char> modifiedStream6)
                            {
                                modifiedStream6 = inputStream6;
                                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream6, out result6, out modifiedStream6, ("\"").AsHostExpressionList()))
                                {
                                    return(MetaRules.Fail(out result6, out modifiedStream6));
                                }
                                return(MetaRules.Success());
                            }
                                    , modifiedStream5, out result5, out modifiedStream5))
                            {
                                return(MetaRules.Fail(out result5, out modifiedStream5));
                            }
                            if (!MetaRules.Apply(Character, modifiedStream5, out result5, out modifiedStream5))
                            {
                                return(MetaRules.Fail(out result5, out modifiedStream5));
                            }
                            return(MetaRules.Success());
                        }, modifiedStream4, out result4, out modifiedStream4))
                        {
                            return(MetaRules.Fail(out result4, out modifiedStream4));
                        }
                        return(MetaRules.Success());
                    }
                                      ))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    return(MetaRules.Success());
                }
                        , modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                s = result2;
                if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("\"").AsHostExpressionList()))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                result2 = (s).AsHostExpressionList();
                return(MetaRules.Success());
            }, modifiedStream, out result, out modifiedStream))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }
 public virtual bool Symbol(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
 {
     modifiedStream = inputStream;
     if (!MetaRules.Or(modifiedStream, out result, out modifiedStream,
                       delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(FirstAndRest, modifiedStream2, out result2, out modifiedStream2, ("Letter").AsHostExpressionList(), ("LetterOrDigit").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
                       , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("+").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
                       , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("-").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
                       , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("*").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
                       , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("/").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
                       , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
     {
         modifiedStream2 = inputStream2;
         if (!MetaRules.ApplyWithArgs(Exactly, modifiedStream2, out result2, out modifiedStream2, ("^").AsHostExpressionList()))
         {
             return(MetaRules.Fail(out result2, out modifiedStream2));
         }
         return(MetaRules.Success());
     }
                       ))
     {
         return(MetaRules.Fail(out result, out modifiedStream));
     }
     return(MetaRules.Success());
 }
        public virtual bool Atom(OMetaStream <char> inputStream, out OMetaList <HostExpression> result, out OMetaStream <char> modifiedStream)
        {
            OMetaList <HostExpression> s  = null;
            OMetaList <HostExpression> n  = null;
            OMetaList <HostExpression> sy = null;

            modifiedStream = inputStream;
            if (!MetaRules.Or(modifiedStream, out result, out modifiedStream,
                              delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(String, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    s = result3;
                    result3 = (new SExprAtomString(s.ToString())).AsHostExpressionList();
                    return(MetaRules.Success());
                }, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                return(MetaRules.Success());
            }
                              , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(Number, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    n = result3;
                    result3 = (new SExprAtomNumber(n.ToString())).AsHostExpressionList();
                    return(MetaRules.Success());
                }, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                return(MetaRules.Success());
            }
                              , delegate(OMetaStream <char> inputStream2, out OMetaList <HostExpression> result2, out OMetaStream <char> modifiedStream2)
            {
                modifiedStream2 = inputStream2;
                if (!MetaRules.Apply(
                        delegate(OMetaStream <char> inputStream3, out OMetaList <HostExpression> result3, out OMetaStream <char> modifiedStream3)
                {
                    modifiedStream3 = inputStream3;
                    if (!MetaRules.Apply(Symbol, modifiedStream3, out result3, out modifiedStream3))
                    {
                        return(MetaRules.Fail(out result3, out modifiedStream3));
                    }
                    sy = result3;
                    result3 = (new SExprAtomSymbol(sy.ToString())).AsHostExpressionList();
                    return(MetaRules.Success());
                }, modifiedStream2, out result2, out modifiedStream2))
                {
                    return(MetaRules.Fail(out result2, out modifiedStream2));
                }
                return(MetaRules.Success());
            }
                              ))
            {
                return(MetaRules.Fail(out result, out modifiedStream));
            }
            return(MetaRules.Success());
        }