Update RuleAnalyzer.kt

原来的规则还有点问题，有些情况下会跳过不分隔规则。

原因是拿一个变量记录了两个状态，有时忘记回退切换状态，导致队列位置处理混乱。

我重新梳理了一遍，更改了所有所有相关规则，新增了类成员变量保存另一种状态。

然后测试了我自己写的那几个书源，和其它用大量采用“||”、“&&”、“%%”分隔规则的书源，总算搞定。

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

@@ -6,8 +6,10 @@ 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 = ""
@@ -17,6 +19,11 @@ class RuleAnalyzer(data: String) {
         return queue.substring(start+stepStart,pos-stepEnd) //当前平衡字段
     }
 
+
+    fun trim(){ // 修剪当前规则之前的"@"或者空白符
+        while (queue[pos] == '@' || queue[pos] < '!') pos++
+    }
+
     //将pos重置为0，方便复用
     fun reSetPos() {
         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
@@ -109,9 +101,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 +154,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 +183,23 @@ 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 { //转义字符
+            }else pos++
-                var next = queue[pos++] //拉出被转义字符
+//            { //转义字符
-                if(commit && next == 'n') commit = false //匹配单行注释终点。当前为\,下个为n，表示换行
+//                var next = queue[pos++] //拉出被转义字符
-                else if (!commits && !commit && next == '\\') {
+//                if(commit && next == 'n') commit = false //匹配单行注释终点。当前为\,下个为n，表示换行
-                    queue[pos++] //当前为\,下个为\，双重转义中"\\"表示转义字符本身，根据if条件"\\"字串不在注释中，则只能在字串或正则中
+//                else if (!commits && !commit && next == '\\') {
-                    next = queue[pos++] //拉出下个字符，因为在双重转义的字串或正则中，类似于 \\/ 这样的结构才是转义结构
+//                    queue[pos++] //当前为\,下个为\，双重转义中"\\"表示转义字符本身，根据if条件"\\"字串不在注释中，则只能在字串或正则中
-                    if(next == '\\')queue[pos++] //若为转义字符则继续拉出，因为双重转义中转义字符成对存在,即 \\\\
+//                    next = queue[pos++] //拉出下个字符，因为在双重转义的字串或正则中，类似于 \\/ 这样的结构才是转义结构
-                }
+//                    if(next == '\\')queue[pos++] //若为转义字符则继续拉出，因为双重转义中转义字符成对存在,即 \\\\
-            }
+//                }
+//            }
         } while (depth > 0 || bracketsDepth >0) //拉出全部符合js语法的字段
 
         return if(depth > 0 || bracketsDepth > 0) false else {
@@ -230,7 +222,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 //匹配具有语法功能的单引号
@@ -245,14 +237,15 @@ class RuleAnalyzer(data: String) {
                     if (fn) otherDepth++ else otherDepth--
                 }
 
-            }else { //转义字符
+            }else pos++
-                var next = queue[pos++] //拉出被转义字符，匹配\/、\"、\'等
+//            { //转义字符
-                if (next == ESC) {
+//                var next = queue[pos++] //拉出被转义字符，匹配\/、\"、\'等
-                    queue[pos++] //当前为\,下个为\，双重转义中"\\"表示转义字符本身，根据语法特征当前字段在字串或正则中
+//                if (next == ESC) {
-                    next = queue[pos++] //拉出下个字符，因为在双重转义的字串或正则中，类似于 \\/ 这样的结构才是转义结构
+//                    queue[pos++] //当前为\,下个为\，双重转义中"\\"表示转义字符本身，根据语法特征当前字段在字串或正则中
-                    if(next == ESC)queue[pos++] //若为转义字符则继续拉出，因为双重转义中转义字符成对存在,即 \\\\
+//                    next = queue[pos++] //拉出下个字符，因为在双重转义的字串或正则中，类似于 \\/ 这样的结构才是转义结构
-                }
+//                    if(next == ESC)queue[pos++] //若为转义字符则继续拉出，因为双重转义中转义字符成对存在,即 \\\\
-            }
+//                }
+//            }
         } while (depth > 0 || otherDepth > 0) //拉出一个平衡字串
 
         return if(depth > 0 || otherDepth > 0) false else {
@@ -269,96 +262,142 @@ class RuleAnalyzer(data: String) {
 
         if(split.size == 1) {
             elementsType = split[0] //设置分割字串
-            step = elementsType.length //设置分隔符长度
+            return if(!consumeTo(elementsType)) {
-            return splitRule(arrayOf()) //仅一个分隔字串时，直接二段解析更快
+                rule += queue.substring(startX)
-        }else if (!consumeToAny(* split)) return arrayOf(queue) //未找到分隔符
+                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) //设置组合类型
+                rule = arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
-            pos += step //跳过分隔符
 
-            while (consumeToAny(* split)) { //循环切分规则压入数组
+                elementsType = queue.substring(end, end + step) //设置组合类型
-                rule += queue.substring(start, pos)
+                pos = end + step //跳过分隔符
-                pos += step //跳过分隔符
+
-            }
+                while (consumeTo(elementsType)) { //循环切分规则压入数组
+                    rule += queue.substring(start, pos)
+                    pos += step //跳过分隔符
+                }
 
-            rule += queue.substring(pos) //将剩余字段压入数组末尾
+                rule += queue.substring(pos) //将剩余字段压入数组末尾
 
-            return rule
+                return rule
-        }
+            }
+
+            if (st > end) { //先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
 
-        val rule = if(st >pos ){ //先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
+                rule = arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
 
-            var rule = arrayOf(queue.substring(0, pos)) //压入分隔的首段规则到数组
+                elementsType = queue.substring(end, end + step) //设置组合类型
+                pos = end + step //跳过分隔符
 
-            elementsType = queue.substring(pos, pos + step) //设置组合类型
+                while (consumeTo(elementsType) && pos < st) { //循环切分规则压入数组
-            pos += step //跳过分隔符
+                    rule += queue.substring(start, pos)
+                    pos += step //跳过分隔符
+                }
 
-            while (consumeToAny( * split ) && pos < st ) { //循环切分规则压入数组
+                return if(pos > st) {
-                rule += queue.substring(start, pos)
+                    startX = start
-                pos += step //跳过分隔符
+                    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 //位置推移到筛选器处
+        }while( end > pos )
-        val next = if(queue[pos] == '[' ) ']' else ')' //平衡组末尾字符
 
-        return if (rule == null) { //rule为空,首段未匹配完成
+        start = pos //设置开始查找筛选器位置的起始位置
 
-            if(!chompRuleBalanced(queue[pos],next)) throw Error(queue.substring(0, start)+"后未平衡") //拉出一个筛选器,不平衡则报错
+        return splitRule(* split) //递归调用首段匹配
-            splitRule(* split) //递归调用首段匹配
+    }
 
-        }  else {
+    @JvmName("splitRuleNext")
+    private tailrec fun splitRule(): Array<String>{ //二段匹配被调用,elementsType非空(已在首段赋值),直接按elementsType查找,比首段采用的方式更快
 
-            if(!chompRuleBalanced(queue[pos],next)) throw Error(queue.substring(0, start)+"后未平衡") //拉出一个筛选器,不平衡则报错
+        val end = pos //记录分隔位置
-            splitRule(rule) //首段已匹配,但当前段匹配未完成,调用二段匹配
+        pos = start //重回开始，启动另一种查找
 
-        }
+        do{
+            val st = findToAny('[', '(') //查找筛选器位置
 
-    }
+            if (st == -1) {
 
-    @JvmName("splitRuleNext")
+                rule += arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
-    private tailrec fun splitRule(rules:Array<String>): Array<String>{ //二段匹配被调用,elementsType非空(已在首段赋值),直接按elementsType查找,比首段采用的方式更快
+                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) {
+                return rule
-            var rule = rules + queue.substring(start, pos) //压入本次分隔的首段规则到数组
-            pos += step //跳过分隔符
-            while (consumeTo(elementsType)) { //循环切分规则压入数组
-                rule += queue.substring(start, pos)
-                pos += step //跳过分隔符
             }
-            rule += queue.substring(pos) //将剩余字段压入数组末尾
-            return rule
-        }
 
-        val rule = if(st > pos ){//先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
+            if (st > end) { //先匹配到st1pos，表明分隔字串不在选择器中，将选择器前分隔字串分隔的字段依次压入数组
-            var rule = rules + queue.substring(start, pos) //压入本次分隔的首段规则到数组
+
-            pos += step //跳过分隔符
+                rule += arrayOf(queue.substring(startX, end)) //压入分隔的首段规则到数组
-            while (consumeTo(elementsType) && pos < st) { //循环切分规则压入数组
+                pos = end + step //跳过分隔符
-                rule += queue.substring(start, pos)
+
-                pos += 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 //位置推移到筛选器处
+            pos = st //位置推移到筛选器处
-        val next = if(queue[pos] == '[' ) ']' else ')' //平衡组末尾字符
+            val next = if (queue[pos] == '[') ']' else ')' //平衡组末尾字符
+
+            if (!chompRuleBalanced(queue[pos], next)) throw Error(
+                queue.substring(
+                    0,
+                    start
+                ) + "后未平衡"
+            ) //拉出一个筛选器,不平衡则报错
 
-        if(!chompRuleBalanced(queue[pos],next)) throw Error(queue.substring(0, start)+"后未平衡") //拉出一个筛选器,不平衡时返回true,表示未平衡
+        }while( end > pos )
 
-        return splitRule(rule) //递归匹配
+        start = pos //设置开始查找筛选器位置的起始位置
+
+        return if(!consumeTo(elementsType)) {
+            rule += queue.substring(startX)
+            rule
+        }else splitRule() //递归匹配
 
     }
 
@@ -380,12 +419,12 @@ class RuleAnalyzer(data: String) {
         while (!isEmpty && consumeTo(inner)) { //拉取成功返回true，ruleAnalyzes里的字符序列索引变量pos后移相应位置，否则返回false,且isEmpty为true
             val posPre = pos //记录上次结束位置
             if (chompRuleBalanced {//拉出一个以[]为默认嵌套、以{}为补充嵌套的平衡字段
-                        when (it) {
+                    when (it) {
-                            '{' -> true
+                        '{' -> true
-                            '}' -> false
+                        '}' -> false
-                            else -> null
+                        else -> null
-                        }
+                    }
-                    }) {
+                }) {
                 val frv= fr(currBalancedString(startStep,endStep))
                 if(frv != null) {