Merge pull request #1106 from bushixuanqi/master

整合优化修复

app/src/main/java/io/legado/app/model/analyzeRule/AnalyzeByJSoup.kt

@@ -137,11 +137,10 @@ class AnalyzeByJSoup(doc: Any) {
             }
         } else {
             for (ruleStr in ruleStrS) {
-                //将原getElementsSingle函数调用的函数的部分代码内联过来，方便简化getElementsSingle函数
 
                 val rsRule = RuleAnalyzer(ruleStr)
 
-                if( rsRule.peek() =='@' || rsRule.peek() < '!' ) rsRule.advance()  // 修剪当前规则之前的"@"或者空白符
+                rsRule.trim()  // 修剪当前规则之前的"@"或者空白符
 
                 val rs = rsRule.splitRule("@")
 
@@ -157,7 +156,7 @@ class AnalyzeByJSoup(doc: Any) {
                         el.addAll(es)
                     }
                     el
-                }else getElementsSingle(temp,ruleStr)
+                }else ElementsSingle().getElementsSingle(temp,ruleStr)
 
                 elementsList.add(el)
                 if (el.size > 0 && ruleAnalyzes.elementsType == "||") {
@@ -183,173 +182,6 @@ class AnalyzeByJSoup(doc: Any) {
         return elements
     }
 
-    /**
-     * 1.支持阅读原有写法，':'分隔索引，!或.表示筛选方式，索引可为负数
-     *
-     * 例如 tag.div.-1:10:2 或 tag.div!0:3
-     *
-     * 2. 支持与jsonPath类似的[]索引写法
-     *
-     * 格式形如 [it,it，。。。] 或 [!it,it，。。。] 其中[!开头表示筛选方式为排除，it为单个索引或区间。
-     *
-     * 区间格式为 start:end 或 start:end:step，其中start为0可省略，end为-1可省略。
-     *
-     * 索引，区间两端及间隔都支持负数
-     *
-     * 例如 tag.div[-1, 3:-2:-10, 2]
-     *
-     * 特殊用法 tag.div[-1:0] 可在任意地方让列表反向
-     *
-     * */
-
-    fun findIndexSet( rule:String ): IndexSet {
-
-        val indexSet = IndexSet()
-        val rus = rule.trim{ it <= ' '}
-
-        var len = rus.length
-        var curInt: Int? //当前数字
-        var curMinus = false //当前数字是否为负
-        val curList = mutableListOf<Int?>() //当前数字区间
-        var l = "" //暂存数字字符串
-
-        val head = rus.last() == ']' //是否为常规索引写法
-
-        if(head){ //常规索引写法[index...]
-
-            len-- //跳过尾部']'
-
-            while (len-- >= 0) { //逆向遍历,可以无前置规则
-
-                var rl = rus[len]
-                if (rl == ' ') continue //跳过空格
-
-                if (rl in '0'..'9') l += rl //将数值累接入临时字串中，遇到分界符才取出
-                else if (rl == '-') curMinus = true
-                else {
-
-                    curInt = if (l.isEmpty()) null else if (curMinus) -l.toInt() else l.toInt() //当前数字
-
-                    when (rl) {
-
-                        ':' -> curList.add(curInt) //区间右端或区间间隔
-
-                        else -> {
-
-                            //为保证查找顺序，区间和单个索引都添加到同一集合
-                            if(curList.isEmpty()) {
-
-                                if(curInt == null) break //是jsoup选择器而非索引列表，跳出
-
-                                indexSet.indexs.add(curInt)
-                            }
-                            else{
-
-                                //列表最后压入的是区间右端，若列表有两位则最先压入的是间隔
-                                indexSet.indexs.add( Triple(curInt, curList.last(), if(curList.size == 2) curList.first() else 1) )
-
-                                curList.clear() //重置临时列表，避免影响到下个区间的处理
-
-                            }
-
-                            if(rl == '!'){
-                                indexSet.split='!'
-                                do{ rl = rus[--len] } while (len > 0 && rl == ' ')//跳过所有空格
-                            }
-
-                            if(rl == '[') return indexSet.apply {
-                                beforeRule = rus.substring(0, len)
-                            } //遇到索引边界，返回结果
-
-                            if(rl != ',') break //非索引结构，跳出
-
-                        }
-                    }
-
-                    l = "" //清空
-                    curMinus = false //重置
-                }
-            }
-        } else while (len-- >= 0) { //阅读原本写法，逆向遍历,可以无前置规则
-
-            val rl = rus[len]
-            if (rl == ' ') continue //跳过空格
-
-            if (rl in '0'..'9') l += rl //将数值累接入临时字串中，遇到分界符才取出
-            else if (rl == '-') curMinus = true
-            else {
-
-                if(rl == '!'  || rl == '.' || rl == ':') { //分隔符或起始符
-
-                    indexSet.indexDefault.add(if (curMinus) -l.toInt() else l.toInt()) // 当前数字追加到列表
-
-                    if (rl != ':') return indexSet.apply { //rl == '!'  || rl == '.'
-                        split = rl
-                        beforeRule = rus.substring(0, len)
-                    }
-
-                }else break //非索引结构，跳出循环
-
-                l = "" //清空
-                curMinus = false //重置
-            }
-
-        }
-
-        return indexSet.apply{
-            split = ' '
-            beforeRule = rus } //非索引格式
-    }
-
-    /**
-     * 获取Elements按照一个规则
-     */
-    private fun getElementsSingle(temp: Element, rule: String): Elements {
-
-        var elements = Elements()
-
-        val fi = findIndexSet(rule) //执行索引列表处理器
-
-        val (filterType,ruleStr) = fi //获取操作类型及非索引部分的规则字串
-
-//        val rulePc = rulePcx[0].trim { it <= ' ' }.split(">")
-//        jsoup中，当前节点是参与选择的，tag.div 与 tag.div@tag.div 结果相同
-//        此处">"效果和“@”完全相同，且容易让人误解成选择子节点，实际并不是。以后不允许这种无意义的写法
-
-        val rules = ruleStr.split(".")
-
-        elements.addAll(
-            if(ruleStr.isEmpty()) temp.children() //允许索引直接作为根元素，此时前置规则为空，效果与children相同
-            else when (rules[0]) {
-                "children" -> temp.children() //允许索引直接作为根元素，此时前置规则为空，效果与children相同
-                "class" -> temp.getElementsByClass(rules[1])
-                "tag" -> temp.getElementsByTag(rules[1])
-                "id" -> Collector.collect(Evaluator.Id(rules[1]), temp)
-                "text" -> temp.getElementsContainingOwnText(rules[1])
-                else -> temp.select(ruleStr)
-            } )
-
-        val indexSet = fi.getIndexs(elements.size) //传入元素数量，处理负数索引及索引越界问题，生成可用索引集合。
-
-        if(filterType == '!'){ //排除
-
-            for (pcInt in indexSet) elements[pcInt] = null
-
-            elements.removeAll(listOf(null)) //测试过，这样就行
-
-        }else if(filterType == '.'){ //选择
-
-            val es = Elements()
-
-            for (pcInt in indexSet) es.add(elements[pcInt])
-
-            elements = es
-
-        }
-
-        return elements
-    }
-
     /**
      * 获取内容列表
      */
@@ -363,7 +195,7 @@ class AnalyzeByJSoup(doc: Any) {
 
         val rule = RuleAnalyzer(ruleStr) //创建解析
 
-        while( rule.peek() =='@' || rule.peek() < '!' ) rule.advance()  // 修剪当前规则之前的"@"或者空白符
+        rule.trim() //修建前置赘余符号
 
         val rules = rule.splitRule("@") // 切割成列表
 
@@ -371,7 +203,7 @@ class AnalyzeByJSoup(doc: Any) {
         for (i in 0 until last) {
             val es = Elements()
             for (elt in elements) {
-                es.addAll(getElementsSingle(elt, rules[i]))
+                es.addAll(ElementsSingle().getElementsSingle(elt, rules[i]))
             }
             elements.clear()
             elements = es
@@ -426,12 +258,174 @@ class AnalyzeByJSoup(doc: Any) {
         return textS
     }
 
-    data class IndexSet(var split:Char = '.',
-                        var beforeRule:String = "",
-                        val indexDefault:MutableList<Int> = mutableListOf(),
-                        val indexs:MutableList<Any> = mutableListOf()){
+    data class ElementsSingle(var split:Char = '.',
+                              var beforeRule:String = "",
+                              val indexDefault:MutableList<Int> = mutableListOf(),
+                              val indexs:MutableList<Any> = mutableListOf()){
+
+        /**
+         * 获取Elements按照一个规则
+         */
+        fun getElementsSingle(temp: Element, rule: String): Elements {
+
+            var elements = Elements()
+
+            findIndexSet(rule) //执行索引列表处理器
+
+            val rules = beforeRule.split(".")
+
+            elements.addAll(
+                if(beforeRule.isEmpty()) temp.children() //允许索引直接作为根元素，此时前置规则为空，效果与children相同
+                else when (rules[0]) {
+                    "children" -> temp.children() //允许索引直接作为根元素，此时前置规则为空，效果与children相同
+                    "class" -> temp.getElementsByClass(rules[1])
+                    "tag" -> temp.getElementsByTag(rules[1])
+                    "id" -> Collector.collect(Evaluator.Id(rules[1]), temp)
+                    "text" -> temp.getElementsContainingOwnText(rules[1])
+                    else -> temp.select(beforeRule)
+                } )
+
+            val indexSet = getIndexs(elements.size) //传入元素数量，处理负数索引及索引越界问题，生成可用索引集合。
+
+            if(split == '!'){ //排除
+
+                for (pcInt in indexSet) elements[pcInt] = null
+
+                elements.removeAll(listOf(null)) //测试过，这样就行
+
+            }else if(split == '.'){ //选择
+
+                val es = Elements()
+
+                for (pcInt in indexSet) es.add(elements[pcInt])
+
+                elements = es
+
+            }
+
+            return elements
+
+        }
+
+        /**
+         * 1.支持阅读原有写法，':'分隔索引，!或.表示筛选方式，索引可为负数
+         *
+         * 例如 tag.div.-1:10:2 或 tag.div!0:3
+         *
+         * 2. 支持与jsonPath类似的[]索引写法
+         *
+         * 格式形如 [it,it，。。。] 或 [!it,it，。。。] 其中[!开头表示筛选方式为排除，it为单个索引或区间。
+         *
+         * 区间格式为 start:end 或 start:end:step，其中start为0可省略，end为-1可省略。
+         *
+         * 索引，区间两端及间隔都支持负数
+         *
+         * 例如 tag.div[-1, 3:-2:-10, 2]
+         *
+         * 特殊用法 tag.div[-1:0] 可在任意地方让列表反向
+         *
+         * */
+        fun findIndexSet( rule:String ): ElementsSingle {
+
+            val rus = rule.trim{ it <= ' '}
+
+            var len = rus.length
+            var curInt: Int? //当前数字
+            var curMinus = false //当前数字是否为负
+            val curList = mutableListOf<Int?>() //当前数字区间
+            var l = "" //暂存数字字符串
+
+            val head = rus.last() == ']' //是否为常规索引写法
+
+            if(head){ //常规索引写法[index...]
+
+                len-- //跳过尾部']'
+
+                while (len-- >= 0) { //逆向遍历,可以无前置规则
+
+                    var rl = rus[len]
+                    if (rl == ' ') continue //跳过空格
+
+                    if (rl in '0'..'9') l += rl //将数值累接入临时字串中，遇到分界符才取出
+                    else if (rl == '-') curMinus = true
+                    else {
+
+                        curInt = if (l.isEmpty()) null else if (curMinus) -l.toInt() else l.toInt() //当前数字
+
+                        when (rl) {
+
+                            ':' -> curList.add(curInt) //区间右端或区间间隔
+
+                            else -> {
+
+                                //为保证查找顺序，区间和单个索引都添加到同一集合
+                                if(curList.isEmpty()) {
+
+                                    if(curInt == null) break //是jsoup选择器而非索引列表，跳出
+
+                                    indexs.add(curInt)
+                                }
+                                else{
+
+                                    //列表最后压入的是区间右端，若列表有两位则最先压入的是间隔
+                                    indexs.add( Triple(curInt, curList.last(), if(curList.size == 2) curList.first() else 1) )
+
+                                    curList.clear() //重置临时列表，避免影响到下个区间的处理
+
+                                }
+
+                                if(rl == '!'){
+                                    split='!'
+                                    do{ rl = rus[--len] } while (len > 0 && rl == ' ')//跳过所有空格
+                                }
+
+                                if(rl == '[') {
+                                    beforeRule = rus.substring(0, len) //遇到索引边界，返回结果
+                                    return this
+                                }
+
+                                if(rl != ',') break //非索引结构，跳出
+
+                            }
+                        }
+
+                        l = "" //清空
+                        curMinus = false //重置
+                    }
+                }
+            } else while (len-- >= 0) { //阅读原本写法，逆向遍历,可以无前置规则
+
+                val rl = rus[len]
+                if (rl == ' ') continue //跳过空格
+
+                if (rl in '0'..'9') l += rl //将数值累接入临时字串中，遇到分界符才取出
+                else if (rl == '-') curMinus = true
+                else {
+
+                    if(rl == '!'  || rl == '.' || rl == ':') { //分隔符或起始符
+
+                        indexDefault.add(if (curMinus) -l.toInt() else l.toInt()) // 当前数字追加到列表
+
+                        if (rl != ':'){ //rl == '!'  || rl == '.'
+                            split = rl
+                            beforeRule = rus.substring(0, len)
+                            return this
+                        }
+
+                    }else break //非索引结构，跳出循环
+
+                    l = "" //清空
+                    curMinus = false //重置
+                }
+
+            }
+
+            split = ' '
+            beforeRule = rus
+            return this //非索引格式
+        }
 
-        fun getIndexs(len:Int): MutableSet<Int> {
+        private fun getIndexs(len:Int): MutableSet<Int> {
 
             val indexSet = mutableSetOf<Int>()
 

app/src/main/java/io/legado/app/model/analyzeRule/RuleAnalyzer.kt

@@ -6,15 +6,22 @@ class RuleAnalyzer(data: String) {
 
     private var queue: String = data //被处理字符串
     private var pos = 0 //处理到的位置
+    private var rule  = arrayOf<String>()
 
     private var start = 0 //每次处理字段的开始
+    private var startX = 0 //规则的开始
     private var step:Int = 0 //分割字符的长度
 
     var elementsType = ""
 
     //当前平衡字段
     fun currBalancedString( stepStart:Int = 1 , stepEnd:Int = 1): String { //stepStart平衡字符的起始分隔字串长度，stepEnd平衡字符的结束分隔字串长度
-        return queue.substring(start+stepStart,pos-stepEnd) //当前平衡字段
+        return queue.substring(startX+stepStart,pos-stepEnd) //当前平衡字段
+    }
+
+
+    fun trim(){ // 修剪当前规则之前的"@"或者空白符
+        while (queue[pos] == '@' || queue[pos] < '!') pos++
     }
 
     //将pos重置为0，方便复用
@@ -34,21 +41,6 @@ class RuleAnalyzer(data: String) {
         return queue.substring(start)
     }
 
-    /**
-     * pos位置回退
-     */
-    fun back(num :Int = 0) {
-        if(num == 0)pos = start  //回退
-        else pos -= num
-    }
-
-    /**
-     * pos位置后移
-     */
-    fun advance(num :Int = 1) {
-        pos+=num
-    }
-
     /**
      * 是否已无剩余字符?
      * @return 若剩余字串中已无字符则返回true
@@ -56,14 +48,6 @@ class RuleAnalyzer(data: String) {
     val isEmpty: Boolean
         get() = queue.length - pos  == 0 //是否处理到最后
 
-    /**
-     * 检索并返回首字符,但pos不变
-     * @return 首字符：若为空则为 0 号字符
-     */
-    fun peek(): Char { //检索首字符
-        return if (isEmpty) 0.toChar() else queue[pos]
-    }
-
     /**
      * 消耗剩余字串中一个字符。
      * @return 返回剩余字串中的下个字符。
@@ -109,9 +93,8 @@ class RuleAnalyzer(data: String) {
         while (pos != queue.length) {
 
             for (s in seq) {
-                if (matches(s)) {
+                if (queue.regionMatches(pos, s, 0, s.length)) {
                     step = s.length //间隔数
-                    start = this.pos //匹配成功, 设置规则下次起始位置
                     this.pos = pos //匹配成功, 同步处理位置到类
                     return true //匹配就返回 true
                 }
@@ -163,7 +146,7 @@ class RuleAnalyzer(data: String) {
         var commits = false //多行注释
 
         do {
-            if (isEmpty) break
+            if (pos == queue.length) break
             var c = queue[pos++]
             if (c != '\\') { //非转义字符
                 if (c == '\'' && !commits && !commit && !regex && !inDoubleQuote && !inOtherQuote) inSingleQuote = !inSingleQuote //匹配具有语法功能的单引号
@@ -192,22 +175,15 @@ class RuleAnalyzer(data: String) {
                         ']' -> bracketsDepth-- //闭合一层嵌套[]
                     }
 
-                }
+                }else if(c == '\n') commit = false
 
                 if (commits || commit || regex || inSingleQuote  || inDoubleQuote || inOtherQuote) continue //语法单元未匹配结束，直接进入下个循环
 
                 val fn = f(c) ?: continue
                 if (fn) depth++ else depth-- //嵌套或者闭合
 
-            }else { //转义字符
-                var next = queue[pos++] //拉出被转义字符
-                if(commit && next == 'n') commit = false //匹配单行注释终点。当前为\,下个为n，表示换行
-                else if (!commits && !commit && next == '\\') {
-                    queue[pos++] //当前为\,下个为\，双重转义中"\\"表示转义字符本身，根据if条件"\\"字串不在注释中，则只能在字串或正则中
-                    next = queue[pos++] //拉出下个字符，因为在双重转义的字串或正则中，类似于 \\/ 这样的结构才是转义结构
-                    if(next == '\\')queue[pos++] //若为转义字符则继续拉出，因为双重转义中转义字符成对存在,即 \\\\
-                }
-            }
+            }else pos++
+
         } while (depth > 0 || bracketsDepth >0) //拉出全部符合js语法的字段
 
         return if(depth > 0 || bracketsDepth > 0) false else {
@@ -217,9 +193,9 @@ class RuleAnalyzer(data: String) {
     }
 
     /**
-     * 在双重转义字串中拉出一个规则平衡组
+     * 拉出一个代码平衡组，存在转义文本，没有实体字符，通常以{}作为模块
      */
-    fun chompRuleBalanced(open: Char = '[', close: Char = ']',f: ((Char) ->Boolean?)? = null ): Boolean {
+    fun chompCodeBalanced(open: Char = '{', close: Char = '}'): Boolean {
 
         var pos = pos //声明临时变量记录匹配位置，匹配成功后才同步到类的pos
 
@@ -230,7 +206,7 @@ class RuleAnalyzer(data: String) {
         var inDoubleQuote = false //双引号
 
         do {
-            if (isEmpty) break
+            if (pos == queue.length) break
             val c = queue[pos++]
             if (c != ESC) { //非转义字符
                 if (c == '\'' && !inDoubleQuote) inSingleQuote = !inSingleQuote //匹配具有语法功能的单引号
@@ -238,24 +214,50 @@ class RuleAnalyzer(data: String) {
 
                 if (inSingleQuote  || inDoubleQuote) continue //语法单元未匹配结束，直接进入下个循环
 
-                if ( c == open )depth++ //开始嵌套一层
-                else if ( c== close) depth-- //闭合一层嵌套
-                else if(depth == 0 && f != null) { //处于默认嵌套中的非默认字符不需要平衡，仅depth为0时默认嵌套全部闭合，此字符才进行嵌套
-                    val fn = f(c) ?: continue
-                    if (fn) otherDepth++ else otherDepth--
+                if ( c == '[' )depth++ //开始嵌套一层
+                else if ( c== ']') depth-- //闭合一层嵌套
+                else if(depth == 0 ) {
+                    //处于默认嵌套中的非默认字符不需要平衡，仅depth为0时默认嵌套全部闭合，此字符才进行嵌套
+                    if(c == open)otherDepth++
+                    else if(c == close)otherDepth--
                 }
 
-            }else { //转义字符
-                var next = queue[pos++] //拉出被转义字符，匹配\/、\"、\'等
-                if (next == ESC) {
-                    queue[pos++] //当前为\,下个为\，双重转义中"\\"表示转义字符本身，根据语法特征当前字段在字串或正则中
-                    next = queue[pos++] //拉出下个字符，因为在双重转义的字串或正则中，类似于 \\/ 这样的结构才是转义结构
-                    if(next == ESC)queue[pos++] //若为转义字符则继续拉出，因为双重转义中转义字符成对存在,即 \\\\
-                }
-            }
+            }else pos++
+
         } while (depth > 0 || otherDepth > 0) //拉出一个平衡字串
 
         return if(depth > 0 || otherDepth > 0) false else {
+            startX = this.pos //内嵌规则起始
+            this.pos = pos //同步位置
+            true
+        }
+    }
+
+    /**
+     * 拉出一个规则平衡组，没有转义文本，有实体字符，通常以[]作为选择器
+     */
+    fun chompRuleBalanced(open: Char = '[', close: Char = ']'): Boolean {
+
+        var pos = pos //声明临时变量记录匹配位置，匹配成功后才同步到类的pos
+        var depth = 0 //嵌套深度
+        var inSingleQuote = false //单引号
+        var inDoubleQuote = false //双引号
+
+        do {
+            if (pos == queue.length) break
+            val c = queue[pos++]
+
+            if (c == '\'' && !inDoubleQuote) inSingleQuote = !inSingleQuote //匹配具有语法功能的单引号
+            else if (c == '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote //匹配具有语法功能的双引号
+
+            if (inSingleQuote  || inDoubleQuote) continue //语法单元未匹配结束，直接进入下个循环
+
+            if ( c == open )depth++ //开始嵌套一层
+            else if ( c== close) depth-- //闭合一层嵌套
+
+        } while (depth > 0 ) //拉出一个平衡字串
+
+        return if(depth > 0) false else {
             this.pos = pos //同步位置
             true
         }
@@ -269,96 +271,142 @@ class RuleAnalyzer(data: String) {
 
         if(split.size == 1) {
             elementsType = split[0] //设置分割字串
-            step = elementsType.length //设置分隔符长度
-            return splitRule(arrayOf()) //仅一个分隔字串时，直接二段解析更快
-        }else if (!consumeToAny(* split)) return arrayOf(queue) //未找到分隔符
+            return if(!consumeTo(elementsType)) {
+                rule += queue.substring(startX)
+                rule
+            }else {
+                step = elementsType.length //设置分隔符长度
+                splitRule()
+            } //递归匹配
+        }else if (!consumeToAny(* split)) { //未找到分隔符
+            rule += queue.substring(startX)
+            return rule
+        }
 
-        val st = findToAny( '[','(' ) //查找筛选器
+        val end = pos //记录分隔位置
+        pos = start //重回开始，启动另一种查找
 
-        if(st == -1) {
+        do{
+            val st = findToAny('[', '(') //查找筛选器位置
 
-            var rule = arrayOf(queue.substring(0, pos)) //压入分隔的首段规则到数组
+            if (st == -1) {
 
-            elementsType = queue.substring(pos, pos + step) //设置组合类型
-            pos += step //跳过分隔符
+                rule = arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
 
-            while (consumeToAny(* split)) { //循环切分规则压入数组
-                rule += queue.substring(start, pos)
-                pos += step //跳过分隔符
-            }
+                elementsType = queue.substring(end, end + step) //设置组合类型
+                pos = end + step //跳过分隔符
 
-            rule += queue.substring(pos) //将剩余字段压入数组末尾
+                while (consumeTo(elementsType)) { //循环切分规则压入数组
+                    rule += queue.substring(start, pos)
+                    pos += step //跳过分隔符
+                }
 
-            return rule
-        }
+                rule += queue.substring(pos) //将剩余字段压入数组末尾
+
+                return rule
+            }
 
-        val rule = if(st >pos ){ //先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
+            if (st > end) { //先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
 
-            var rule = arrayOf(queue.substring(0, pos)) //压入分隔的首段规则到数组
+                rule = arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
 
-            elementsType = queue.substring(pos, pos + step) //设置组合类型
-            pos += step //跳过分隔符
+                elementsType = queue.substring(end, end + step) //设置组合类型
+                pos = end + step //跳过分隔符
+
+                while (consumeTo(elementsType) && pos < st) { //循环切分规则压入数组
+                    rule += queue.substring(start, pos)
+                    pos += step //跳过分隔符
+                }
 
-            while (consumeToAny( * split ) && pos < st ) { //循环切分规则压入数组
-                rule += queue.substring(start, pos)
-                pos += step //跳过分隔符
+                return if(pos > st) {
+                    startX = start
+                    splitRule() //首段已匹配,但当前段匹配未完成,调用二段匹配
+                }
+                else { //执行到此，证明后面再无分隔字符
+                    rule += queue.substring(pos) //将剩余字段压入数组末尾
+                    rule
+                }
             }
 
-            rule
+            pos = st //位置推移到筛选器处
+            val next = if (queue[pos] == '[') ']' else ')' //平衡组末尾字符
 
-        }else null
+            if (!chompRuleBalanced(queue[pos], next)) throw Error(
+                queue.substring(
+                    0,
+                    start
+                ) + "后未平衡"
+            ) //拉出一个筛选器,不平衡则报错
 
-        pos = st //位置推移到筛选器处
-        val next = if(queue[pos] == '[' ) ']' else ')' //平衡组末尾字符
+        }while( end > pos )
 
-        return if (rule == null) { //rule为空,首段未匹配完成
+        start = pos //设置开始查找筛选器位置的起始位置
 
-            if(!chompRuleBalanced(queue[pos],next)) throw Error(queue.substring(0, start)+"后未平衡") //拉出一个筛选器,不平衡则报错
-            splitRule(* split) //递归调用首段匹配
+        return splitRule(* split) //递归调用首段匹配
+    }
 
-        }  else {
+    @JvmName("splitRuleNext")
+    private tailrec fun splitRule(): Array<String>{ //二段匹配被调用,elementsType非空(已在首段赋值),直接按elementsType查找,比首段采用的方式更快
 
-            if(!chompRuleBalanced(queue[pos],next)) throw Error(queue.substring(0, start)+"后未平衡") //拉出一个筛选器,不平衡则报错
-            splitRule(rule) //首段已匹配,但当前段匹配未完成,调用二段匹配
+        val end = pos //记录分隔位置
+        pos = start //重回开始，启动另一种查找
 
-        }
+        do{
+            val st = findToAny('[', '(') //查找筛选器位置
 
-    }
+            if (st == -1) {
 
-    @JvmName("splitRuleNext")
-    private tailrec fun splitRule(rules:Array<String>): Array<String>{ //二段匹配被调用,elementsType非空(已在首段赋值),直接按elementsType查找,比首段采用的方式更快
+                rule += arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
+                pos = end + step //跳过分隔符
 
-        if (!consumeTo(elementsType,false)) return rules + queue.substring(start) //此处consumeTo(...)开始位置不是规则的开始位置,start沿用上次设置
+                while (consumeTo(elementsType)) { //循环切分规则压入数组
+                    rule += queue.substring(start, pos)
+                    pos += step //跳过分隔符
+                }
 
-        val st = findToAny( '[','(' ) //查找筛选器
+                rule += queue.substring(pos) //将剩余字段压入数组末尾
 
-        if(st == -1) {
-            var rule = rules + queue.substring(start, pos) //压入本次分隔的首段规则到数组
-            pos += step //跳过分隔符
-            while (consumeTo(elementsType)) { //循环切分规则压入数组
-                rule += queue.substring(start, pos)
-                pos += step //跳过分隔符
+                return rule
             }
-            rule += queue.substring(pos) //将剩余字段压入数组末尾
-            return rule
-        }
 
-        val rule = if(st > pos ){//先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
-            var rule = rules + queue.substring(start, pos) //压入本次分隔的首段规则到数组
-            pos += step //跳过分隔符
-            while (consumeTo(elementsType) && pos < st) { //循环切分规则压入数组
-                rule += queue.substring(start, pos)
-                pos += step //跳过分隔符
+            if (st > end) { //先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
+
+                rule += arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
+                pos = end + step //跳过分隔符
+
+                while (consumeTo(elementsType) && pos < st) { //循环切分规则压入数组
+                    rule += queue.substring(start, pos)
+                    pos += step //跳过分隔符
+                }
+
+                return if(pos > st) {
+                    startX = start
+                    splitRule() //首段已匹配,但当前段匹配未完成,调用二段匹配
+                }
+                else { //执行到此，证明后面再无分隔字符
+                    rule += queue.substring(pos) //将剩余字段压入数组末尾
+                    rule
+                }
             }
-            rule
-        }else rules
 
-        pos = st //位置推移到筛选器处
-        val next = if(queue[pos] == '[' ) ']' else ')' //平衡组末尾字符
+            pos = st //位置推移到筛选器处
+            val next = if (queue[pos] == '[') ']' else ')' //平衡组末尾字符
 
-        if(!chompRuleBalanced(queue[pos],next)) throw Error(queue.substring(0, start)+"后未平衡") //拉出一个筛选器,不平衡时返回true,表示未平衡
+            if (!chompRuleBalanced(queue[pos], next)) throw Error(
+                queue.substring(
+                    0,
+                    start
+                ) + "后未平衡"
+            ) //拉出一个筛选器,不平衡则报错
 
-        return splitRule(rule) //递归匹配
+        }while( end > pos )
+
+        start = pos //设置开始查找筛选器位置的起始位置
+
+        return if(!consumeTo(elementsType)) {
+            rule += queue.substring(startX)
+            rule
+        }else splitRule() //递归匹配
 
     }
 
@@ -379,16 +427,9 @@ class RuleAnalyzer(data: String) {
 
         while (!isEmpty && consumeTo(inner)) { //拉取成功返回true，ruleAnalyzes里的字符序列索引变量pos后移相应位置，否则返回false,且isEmpty为true
             val posPre = pos //记录上次结束位置
-            if (chompRuleBalanced {//拉出一个以[]为默认嵌套、以{}为补充嵌套的平衡字段
-                        when (it) {
-                            '{' -> true
-                            '}' -> false
-                            else -> null
-                        }
-                    }) {
+            if (chompCodeBalanced()) {
                 val frv= fr(currBalancedString(startStep,endStep))
                 if(frv != null) {
-
                     st.append(queue.substring(start,posPre)+frv) //压入内嵌规则前的内容，及内嵌规则解析得到的字符串
                     continue //获取内容成功，继续选择下个内嵌规则