Exemple #1
0
        public static TemporaryGroup CreateRootGroup(IParsingTreeNode oldNode, ParserNode omitPatternRoot, Location locFrom, Location locTo, out ParserNode prevGrammarNode, out bool insideOmittedFragment)
        {
            insideOmittedFragment = false;
            var oldGroup = oldNode as IParsingTreeGroup;

            if (oldGroup == null || oldGroup.Location > locFrom)
            {
                throw new InvalidOperationException();
            }

            prevGrammarNode = null;
            var newGroup      = new TemporaryReparsingGroup(oldNode, (oldNode as ParsingTreeNode).GrammarNode, locFrom, locTo, null, null);
            var newGroupChild = CreateItemToReparse(oldGroup, newGroup, locFrom, locTo);
            int depth         = 0;

            while (newGroupChild != null)
            {
                if (newGroupChild.GrammarNode == omitPatternRoot)
                {
                    insideOmittedFragment = true;
                }

                prevGrammarNode = newGroup.GrammarNode;
                oldGroup        = newGroupChild.OldGroup;
                newGroup        = newGroupChild;
                newGroupChild   = CreateItemToReparse(oldGroup, newGroup, locFrom, locTo);
                depth++;
            }

            // TODO: [Portable.Parser.Impl.ParsingTreeNode.CreateRootGroup] to think about possible parsing directions when reparsing
            //var lastTakenChild = newGroup.Childs.LastOrDefault();
            //if (lastTakenChild != null)
            //    prevGrammarNode = ((ParsingTreeNode)lastTakenChild).GrammarNode;

            prevGrammarNode = newGroup.Parent.GrammarNode;
            return(newGroup);
        }
Exemple #2
0
        private static TemporaryReparsingGroup CreateItemToReparse(IParsingTreeGroup oldGroup, TemporaryReparsingGroup parent, Location fromLoc, Location toLoc)
        {
            IParsingTreeGroup prevGroup = null;

            foreach (var oldChild in oldGroup.Childs)
            {
                if (oldChild.Location <= fromLoc)
                {
                    var childTerm  = oldChild as IParsingTreeTerminal;
                    var childGroup = oldChild as IParsingTreeGroup;

                    if (childTerm != null)
                    {
                        prevGroup = null;

                        if (childTerm.To > fromLoc)
                        {
                            break; // this term need to be reparsed and so forth
                        }
                        else
                        {
                            // skip
                        }
                    }
                    else if (childGroup != null)
                    {
                        prevGroup = childGroup;
                    }
                    else
                    {
                        throw new NotImplementedException("");
                    }
                }
                else
                {
                    break; // prev child item need to be processed
                }
            }

            return(prevGroup == null ? null : new TemporaryReparsingGroup(
                       prevGroup, (prevGroup as ParsingTreeNode).GrammarNode, fromLoc, toLoc, parent, null
                       ));
        }