示例#1
0
        /// <summary>
        /// Main method to parse for offsets.
        /// </summary>
        /// <remarks>
        /// This may be called recursively, but is designed to do a single loop parse (O)N
        /// </remarks>
        /// <param name="markup"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        private OffsetItem ParseOffsets(string markup, ParseContext context, XmlReader reader)
        {
            if (String.IsNullOrEmpty(markup))
            {
                return(null);
            }

            TracePosition trace = CreateTracePosition(context);


            while (reader.Read())
            {
                //skip declaration
                if (XmlNodeType.XmlDeclaration == reader.NodeType ||
                    XmlNodeType.Whitespace == reader.NodeType)
                {
                    continue;
                }

                this.HandleContextParse(reader, markup, trace);
                continue;
            }

            return(trace.RootOffset);
        }
示例#2
0
        private TracePosition CreateTracePosition(ParseContext context)
        {
            TracePosition trace = new TracePosition();

            trace.ParseContextStack.Push(context);
//			trace.RootOffset = MyControlFactory.CreateRootOffset(context);
            return(trace);
        }
示例#3
0
        /// <summary>
        /// Adjusts the trace object to ascend back up the parsing tree,
        /// since this is the closing element for the current section.
        /// </summary>
        /// <param name="markup"></param>
        /// <param name="trace"></param>
        private void SetAscendTraceTree(string markup, TracePosition trace, bool isContextClose)
        {
            OffsetItem tmpOffset;
            int        endPos = GetEndOfTagPosition(markup, trace.CurrentPosition);

            tmpOffset = trace.CurrentOffset;
            //move to content block
            trace.CurrentOffset = trace.CurrentOffset.ParentOffset;
            trace.ContainerTagStack.Pop();
            if (isContextClose)
            {
                trace.ParseContextStack.Pop();
            }

            tmpOffset.EndPosition = trace.GetLocalPosition(endPos);
            //advance CurrentPosition
            trace.CurrentPosition = endPos;
        }
示例#4
0
        /// <summary>
        /// Handle processing within markup contexts consisting only of defined-tag context.
        /// For processing markup which may contain custom tag templates or recognizes Literal sections,
        /// use the method <c>HandleOsContainerTagParse</c>.
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="markup"></param>
        /// <param name="trace"></param>
        private void HandleContextParse(XmlReader reader, string markup, TracePosition trace)
        {
            bool isStartElement = (XmlNodeType.Element == reader.NodeType);
            bool isEndElement   = (XmlNodeType.EndElement == reader.NodeType);

            if (XmlNodeType.Whitespace == reader.NodeType)
            {
                return;
            }

            TraceContainerTagInfo containerInfo = trace.GetCurrentContainerTag();
            Type t = typeof(GadgetLiteral);             //default control type for current tag

            if (isStartElement || isEndElement)
            {
                //if null tag, this is in a ContentBlock ??
                //if (String.IsNullOrEmpty(containerInfo.Tag))
                //{
                //    containerInfo.Tag = "Content";
                //}
                if (isEndElement)
                {
                    int prevCurrentPosition = trace.CurrentPosition;
                    trace.CurrentPosition = markup.IndexOf("</" + reader.Name, trace.CurrentPosition);
                    if (prevCurrentPosition == trace.CurrentPosition &&
                        !trace.PriorLoopWasStartElement &&
                        reader.Name == trace.PreviousEndTag)
                    {
                        trace.CurrentPosition = markup.IndexOf("</" + reader.Name, trace.CurrentPosition + 1);
                    }

                    trace.PreviousStartTag         = null;
                    trace.PriorLoopWasStartElement = false;
                    trace.PreviousEndTag           = reader.Name;

                    //check for non-container tag
                    if (trace.InNonContainerControl)
                    {
                        if (reader.Name == trace.CurrentNonContainerTagInfo.Tag &&
                            reader.Depth == trace.CurrentNonContainerTagInfo.NodeDepth)
                        {
                            trace.CurrentPosition = GetEndOfTagPosition(markup, trace.CurrentPosition);
                            trace.FlushNonContainerTagOffset();
                            return;
                        }
                        else
                        {
                            return;
                        }
                    }


                    ControlMap curMap;
                    if (trace.IsInitialized())
                    {
                        curMap = MyControlFactory.GetControlMap(trace.CurrentOffset.OffsetKey);
                    }
                    else
                    {
                        //special case for CustomTag parsing
                        //Add in a missing context and container
                        if (trace.InStaticTag && trace.StaticTagStartPosition == 0)
                        {
                            trace.StaticTagStartPosition = GetEndOfTagPosition(markup, 0);
                        }
                        trace.AddChildOffset(0, MyControlFactory.GetContextGroupOffsetKey(trace.Context));
                        //push first element as container tag, if empty
                        if (null == containerInfo.Tag)
                        {
                            trace.AddCurrentNodeAsContainerTag(ControlFactory.GetTagName(markup), 0);
                            containerInfo = trace.GetCurrentContainerTag();
                        }
                        //this is questionable
                        //curMap = MyControlFactory.GetControlMap(GadgetLiteral.DefaultOffsetKey);
                        curMap = MyControlFactory.GetControlMap(t);
                    }

                    if (reader.Name == containerInfo.Tag && reader.Depth == containerInfo.NodeDepth)
                    {
                        //if (AllowLiteralTags(trace.Context))
                        //{
                        //check for final static tag
                        if (trace.InStaticTag)
                        {
                            trace.FlushLiteralControlOffset();
                        }
                        //						}
                        //set closing position
                        SetAscendTraceTree(markup, trace, curMap.IsContextGroupContainer);
                        return;
                    }
                    else if (MyControlFactory.AllowCustomTags(trace.Context) && IsCustomTagDefined(reader.Name))
                    {
                        //handle closing custom tag so it isn't interpreted as a static
                        t = typeof(CustomTag);
                    }
                    else
                    {
                        //advance to end of current close tag to handle final static script tag
                        //we're in a nested tag that is a static, but the same as the container tag
                        //watch to make sure this is not in error
                        if (reader.Name == containerInfo.Tag)
                        {
                            trace.CurrentPosition = GetEndOfTagPosition(markup, trace.CurrentPosition);
                        }
                    }
                }
                else if (isStartElement)
                {
                    int prevCurrentPosition = trace.CurrentPosition;
                    trace.CurrentPosition = markup.IndexOf("<" + reader.Name, trace.CurrentPosition);
                    if (prevCurrentPosition == trace.CurrentPosition &&
                        trace.PriorLoopWasStartElement &&
                        reader.Name == trace.PreviousStartTag)
                    {
                        trace.CurrentPosition = markup.IndexOf("<" + reader.Name, trace.CurrentPosition + 1);
                    }

                    trace.PreviousStartTag         = reader.Name;
                    trace.PriorLoopWasStartElement = true;
                    trace.PreviousEndTag           = null;

                    if (trace.InNonContainerControl)
                    {
                        return;
                    }


                    string fullTag = markup.Substring(trace.CurrentPosition, GetEndOfTagPosition(markup, trace.CurrentPosition) - trace.CurrentPosition);

                    t = MyControlFactory.GetControlType(fullTag, trace.Context);
                    //if custom tag, register it
                    if (ControlFactory.InheritsFromType(t, typeof(CustomTagTemplate)))
                    {
                        string custTag = ControlFactory.GetTagAttributeValue(fullTag, CustomTagTemplate.ATTRIBUTE_TAGDEF);
                        RegisterCustomTag(custTag);
                    }

                    //Look for a custom tag if it is a literal.  Then continue or exit
                    if (t == typeof(GadgetLiteral))
                    {
                        if (MyControlFactory.AllowCustomTags(trace.Context))
                        {
                            if (IsCustomTagDefined(reader.Name))
                            {
                                t = typeof(CustomTag);
                            }
                        }
                        if (!MyControlFactory.AllowLiteralTags(trace.Context) && t != typeof(CustomTag))
                        {
                            return;
                        }
                    }

                    //Look for a non-container control and set value, if required
                    if (t != typeof(GadgetLiteral))
                    {
                        if (!ControlFactory.InheritsFromType(t, typeof(BaseContainerControl)) &&
                            !trace.InNonContainerControl && !reader.IsEmptyElement)
                        {
                            trace.SetCurrentNodeAsNonContainerTag(reader.Name, reader.Depth, MyControlFactory.GetOffsetKey(t, trace.Context));
                            return;
                        }
                        else if (trace.InStaticTag)                         //Flush a pending static tag
                        {
                            trace.FlushLiteralControlOffset();
                        }

                        OffsetItem tempOffset = trace.AddChildOffset(trace.GetLocalPosition(), MyControlFactory.GetOffsetKey(t, trace.Context));

                        trace.CurrentPosition = GetEndOfTagPosition(markup, trace.CurrentPosition);
                        if (reader.IsEmptyElement)
                        {
                            tempOffset.EndPosition         = (trace.GetLocalPosition());
                            trace.PreviousStartTag         = null;
                            trace.PriorLoopWasStartElement = false;
                        }
                        else
                        {
                            //check to see if we're moving into a new context
                            ControlMap curMap = MyControlFactory.GetControlMap(tempOffset.OffsetKey);
                            if (curMap.IsContextGroupContainer)
                            {
                                if (trace.Context.ContainerControlType != curMap.ControlType)
                                {
                                    trace.ParseContextStack.Push(new ParseContext(curMap.ControlType));
                                }
                                //push current as container tag, if empty
                                trace.AddCurrentNodeAsContainerTag(reader.Name, reader.Depth);
                            }
                            else if (ControlFactory.InheritsFromType(curMap.ControlType, typeof(BaseContainerControl)))
                            {
                                trace.AddCurrentNodeAsContainerTag(reader.Name, reader.Depth);
                            }
                        }
                    }
                }
            }
            else
            {
                trace.PreviousEndTag           = null;
                trace.PreviousStartTag         = null;
                trace.PriorLoopWasStartElement = false;
            }


            //Look for non-container controls
            if (trace.InNonContainerControl)
            {
                return;
            }


            //Look for static elements
            if (!MyControlFactory.AllowLiteralTags(trace.Context))
            {
                return;
            }
            else if (t == typeof(GadgetLiteral))
            {
                if (!trace.InStaticTag)
                {
                    trace.StaticTagStartPosition = trace.CurrentPosition;
                    trace.InStaticTag            = true;
                }
                return;
            }
        }