private D_PieceWrap makePieceWrap(PieceTokenizer f)
        {
            var g = f.reStart();

            D_PieceWrap piece = new D_PieceWrap();
            D_PieceInformation c;
            D_PieceExtras d;
            if ((c = makePieceInformation(f)) != null)
            {
                piece.PieceInformation = c;
                if ((d = makePieceExtras(f)) != null)
                {
                    piece.HasPieceExtras = true;
                    piece.PieceExtras = d;
                }
                else
                    piece.HasPieceExtras = false;

            }
            else
            {
                f.goBack(g);
                return null;
            }
            return piece;
        }
        private D_PieceKernalOr makePieceKernalOr(PieceTokenizer f)
        {
            var g = f.reStart();

            D_PieceKernalOr piece = new D_PieceKernalOr();

            while (true)
            {
                D_PieceKernalAddition c;
                if ((c = makePieceKernalAddition(f)) != null)
                {
                    piece.PieceKernalAdditions.Add(c);
                    if (isToken(f, "|"))
                    {
                        continue;
                    }
                    return piece;
                }
                else
                {
                    f.goBack(g);
                    return null;
                }
            }
        }
        private D_PieceWithParam makePieceWithParam(PieceTokenizer f)
        {
            var g = f.reStart();

            D_PieceWithParam piece = new D_PieceWithParam();
            D_Piece c;
            D_Piece d;
            if (isToken(f, "("))
            {
                if ((c = makePiece(f)) != null)
                {
                    piece.Piece1 = c;
                    if (isToken(f, ","))
                    {
                        if ((d = makePiece(f)) != null)
                        {
                            piece.Piece2 = d;
                            if (isToken(f, ")"))
                            {
                                return piece;
                            }
                        }
                    }
                }
            }
            f.goBack(g);
            return null;
        }
        private D_PieceExtras makePieceExtras(PieceTokenizer f)
        {
            var g = f.reStart();

            D_PieceExtras piece = new D_PieceExtras();
            if (isToken(f, "?"))
            {
                piece.PieceExtrasClause = D_PieceExtras.D_PieceExtrasClause.QuestionMark;
            }
            else if (isToken(f, ".") && isToken(f, "."))
            {
                piece.PieceExtrasClause = D_PieceExtras.D_PieceExtrasClause.DotDot;
            }
            else
            {
                f.goBack(g);
                return null;
            }
            return piece;
        }
 private D_PieceInformation makePieceInformation(PieceTokenizer f)
 {
     var g = f.reStart();
     D_JustPiece c;
     D_PieceWithParam d;
     D_PieceInformation piece = new D_PieceInformation();
     if ((c = makeJustPiece(f)) != null)
     {
         piece.PieceInformationClause = D_PieceInformation.D_PieceInformationClause.JustPiece;
         piece.JustPiece = c;
     }
     else if ((d = makePieceWithParam(f)) != null)
     {
         piece.PieceInformationClause = D_PieceInformation.D_PieceInformationClause.PieceWithParam;
         piece.PieceWithParam = d;
     }
     else
     {
         f.goBack(g);
         return null;
     }
     return piece;
 }
        private D_PieceContent makePieceContent(PieceTokenizer f)
        {
            var g = f.reStart();

            D_PieceContent piece = new D_PieceContent();
            D_Piece c;

            string w1;
            if ((w1 = getWord(f)) != null)
            {
                piece.PieceContentClause = D_PieceContent.D_PieceContentClause.Word;
                piece.Word = new D_Word();
                piece.Word.Value = w1;
            }
            else if (isString(f))
            {
                piece.PieceContentClause = D_PieceContent.D_PieceContentClause.String;
                piece.String = new D_String();
                piece.String.Value = f.CurrentPiece();
            }
            else if ((c = makePiece(f)) != null)
            {
                piece.PieceContentClause = D_PieceContent.D_PieceContentClause.Piece;
                piece.Piece = c;
            }
            else
            {
                f.goBack(g);
                return null;
            }
            return piece;
        }
        private D_Piece makePiece(PieceTokenizer f)
        {
            var g = f.reStart();

            D_Piece piece = new D_Piece();
            D_PieceWrap d; D_PieceKernalOr c;
            if ((d = makePieceWrap(f)) != null)
            {
                piece.PieceClause = D_Piece.D_PieceClause.PieceWrap;
                piece.PieceWrap = d;
            }
            else if ((c = makePieceKernalOr(f)) != null)
            {
                piece.PieceClause = D_Piece.D_PieceClause.PieceKernalOr;
                piece.PieceKernalOr = c;
            }
            else return null;
            return piece;
        }
        private D_JustPiece makeJustPiece(PieceTokenizer f)
        {
            var g = f.reStart();

            D_JustPiece piece = new D_JustPiece();
            D_Piece c;
            if (isToken(f, "("))
            {
                if ((c = makePiece(f)) != null)
                {
                    piece.Piece = c;
                    if (isToken(f, ")"))
                    {
                        return piece;
                    }
                }
            }
            f.goBack(g);
            return null;
        }
        private D_Item makeItem(PieceTokenizer f)
        {
            var g = f.reStart();
            D_Item item = new D_Item();
            string w1;
            if ((w1 = getWord(f)) != null)
            {
                item.Word = new D_Word();
                item.Word.Value = w1;

                if (isToken(f, "="))
                {
                    if ((item.Piece = makePiece(f)) != null)
                    {
                        return item;
                    }
                }
            }
            f.goBack(g);
            return null;
        }
Example #10
0
 private D_Document makeDocument(PieceTokenizer f)
 {
     var g = f.reStart();
     D_Document doc = new D_Document();
     while (true)
     {
         D_Item c;
         if ((c = makeItem(f)) != null)
         {
             doc.Items.Add(c);
             if (isToken(f, "\n"))
                 continue;
             else continue;
             return doc;
         }
         else
             return doc;
     }
 }