Пример #1
0
        public bool parse(ref char[] buffer, int count, ref MarkupNode rootNode)
        {
            if (buffer == null || count < 0 || count > buffer.Count())
            {
                throw new Exception("缓存为空或者索引越界");
            }
            if (count == 0)
            {
                return(false);
            }

            {
                int curIdx = 0;

                Stack <MarkupNode> stackNode = new Stack <MarkupNode>();
                MarkupNode         newNode   = null;
                stackNode.Push(rootNode);

                while (stackNode.Count() > 0)
                {
                    MarkupNode curNode = stackNode.Peek();

                    {
                        // 解析结束标签
                        curIdx = skipWhiteSpace(ref buffer, curIdx);
                        if (buffer[curIdx] == (char)0)
                        {
                            return(true);
                        }
                        if (buffer[curIdx] == '<' && buffer[curIdx + 1] == '/')
                        {
                            // 找到结点结束标签,栈顶结点出栈
                            curNode = stackNode.Pop();

                            curIdx += 2;
                            string nodeName = "";
                            curIdx = parseIdentifier(ref buffer, curIdx, out nodeName);
                            if (curNode.getName() != nodeName)
                            {
                                throw new Exception("结束标签名称不匹配");
                            }
                            if (buffer[curIdx] != '>')
                            {
                                throw new Exception("结束标签名称不匹配");
                            }
                            curIdx += 1;
                            curIdx  = skipWhiteSpace(ref buffer, curIdx);
                            continue;
                        }
                    }

                    {
                        // 解析开始标志
                        curIdx = skipWhiteSpace(ref buffer, curIdx);
                        if (buffer[curIdx] == (char)0)
                        {
                            return(true);
                        }
                        if (buffer[curIdx] != '<')
                        {
                            throw new Exception("找不到开始标签 <");
                        }
                        curIdx++;
                    }


                    {
                        // 过滤注释
                        int lastIdx = curIdx;

                        curIdx = skipComment(ref buffer, curIdx);

                        if (lastIdx != curIdx)
                        {
                            curIdx = skipWhiteSpace(ref buffer, curIdx);
                            continue;
                        }
                    }

                    {
                        // 解析节点名字
                        curIdx = skipWhiteSpace(ref buffer, curIdx);
                        if (newNode == null)
                        {
                            string nodeName = "";
                            curIdx = parseIdentifier(ref buffer, curIdx, out nodeName);
                            if (buffer[curIdx] == (char)0)
                            {
                                throw new Exception("无法解析节点名字");
                            }

                            curNode.setName(nodeName);
                            newNode = curNode;
                        }
                        else
                        {
                            string nodeName = "";
                            curIdx = parseIdentifier(ref buffer, curIdx, out nodeName);
                            if (buffer[curIdx] == (char)0)
                            {
                                throw new Exception("无法解析节点名字");
                            }

                            newNode = new MarkupNode(curNode);
                            newNode.setName(nodeName);
                            stackNode.Push(newNode);
                            curNode = newNode;
                        }
                    }

                    {
                        // 解析节点属性值
                        bool result = parseAttributes(ref buffer, ref curIdx, ref curNode);
                        if (result == false)
                        {
                            return(false);
                        }

                        // 解析节点结束标签
                        curIdx = skipWhiteSpace(ref buffer, curIdx);
                        if (buffer[curIdx] == '/' && buffer[curIdx + 1] == '>')
                        {
                            curIdx += 2;
                            stackNode.Pop();
                        }
                        else
                        {
                            // 解析节点关闭标签
                            if (buffer[curIdx] != '>')
                            {
                                throw new Exception("找不到关闭标签 >");
                            }
                            {
                                // 解析节点值
                                curIdx++;
                                string value       = "";
                                bool   parseResult = parseData(ref buffer, ref curIdx, '<', out value);
                                if (parseResult == false)
                                {
                                    return(false);
                                }
                                if (isWhiteSpace(value))
                                {
                                    value = "";
                                }
                                curNode.setValue(value);
                            }
                            {
                                if (buffer[curIdx] == (char)0)
                                {
                                    return(true);
                                }
                                if (buffer[curIdx] != '<')
                                {
                                    throw new Exception("找不到子节点开始标签 <");
                                }
                            }
                        }
                    }
                }

                stackNode.Clear();
                stackNode = null;
            }

            return(true);
        }