more merge cleanup

Author: lmasroca

core/src/main/antlr4/org/evomaster/core/parser/RegexJava.g4

@@ -125,11 +125,21 @@ CharacterEscape
  | SLASH HexEscapeSequence
  | SLASH UnicodeEscapeSequence
  | SLASH OctalEscapeSequence
- | SLASH 'p' BRACE_open PosixCharacterClassLabel BRACE_close // this is only implemented in Java at the moment as on JS this
-                                                             // is allowed only while certain flags are enabled
+ | SLASH ('p' | 'P') BRACE_open PCharacterClassEscapeLabel BRACE_close // this is only implemented in Java at the moment
+                                                        // as on JS this is allowed only while certain flags are enabled
+
  //| IdentityEscape
  ;
 
+fragment PCharacterClassEscapeLabel
+ : PosixCharacterClassLabel
+ | UnicodeCategoriesLabel
+ ;
+
+fragment UnicodeCategoriesLabel
+ : 'Pe'
+ ;
+
 // basic US-ASCII only predefined POSIX character classes
 // https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#:~:text=character%3A%20%5B%5E%5Cw%5D-,POSIX,-character%20classes%20(US
 fragment PosixCharacterClassLabel
@@ -146,7 +156,6 @@ fragment PosixCharacterClassLabel
  | 'Cntrl'
  | 'XDigit'
  | 'Space'
- | 'Pe'
  ;
 
 fragment ControlEscape

core/src/main/kotlin/org/evomaster/core/search/gene/regex/CharacterClassEscapeRxGene.kt

@@ -61,30 +61,45 @@ class CharacterClassEscapeRxGene(
         private val nonHorizontalSpaceMultiCharRange = MultiCharacterRange(true, horizontalSpaceSet)
         private val nonVerticalSpaceMultiCharRange = MultiCharacterRange(true, verticalSpaceSet)
 
-        // US-ASCII POSIX character classes (\p{X})
-        private val posixMultiCharRanges = mapOf(
-            "Lower" to listOf(CharacterRange('a', 'z')),
-            "Upper" to listOf(CharacterRange('A', 'Z')),
-            "ASCII" to listOf(CharacterRange(0, 0x7f)),
-            "Alpha" to asciiLetterSet,
-            "Digit" to digitSet,
-            "Alnum" to digitSet + asciiLetterSet,
-            "Punct" to punctuationSet,
-            "Graph" to digitSet + asciiLetterSet + punctuationSet,
-            "Print" to digitSet + asciiLetterSet + punctuationSet + stringToListOfCharacterRanges("\u0020"),
-            "Blank" to stringToListOfCharacterRanges(" \t"),
-            "Cntrl" to listOf(CharacterRange(0, 0x1f)) + stringToListOfCharacterRanges("\u007f"),
-            "XDigit" to listOf(CharacterRange('0', '9'), CharacterRange('a', 'f'), CharacterRange('A', 'F')),
-            "Space" to spaceSet,
-            "Pe" to stringToListOfCharacterRanges(")]}")
-        ).mapValues { (_, value) -> MultiCharacterRange(false, value) }
+        private val pEscapesMultiCharRanges: Map<String, MultiCharacterRange> = run {
+            // US-ASCII POSIX character classes (\p{X})
+            val posixAsciiSets = mapOf(
+                "Lower"  to listOf(CharacterRange('a', 'z')),
+                "Upper"  to listOf(CharacterRange('A', 'Z')),
+                "ASCII"  to listOf(CharacterRange(0, 0x7f)),
+                "Alpha"  to asciiLetterSet,
+                "Digit"  to digitSet,
+                "Alnum"  to digitSet + asciiLetterSet,
+                "Punct"  to punctuationSet,
+                "Graph"  to digitSet + asciiLetterSet + punctuationSet,
+                "Print"  to digitSet + asciiLetterSet + punctuationSet + stringToListOfCharacterRanges("\u0020"),
+                "Blank"  to stringToListOfCharacterRanges(" \t"),
+                "Cntrl"  to listOf(CharacterRange(0, 0x1f)) + stringToListOfCharacterRanges("\u007f"),
+                "XDigit" to listOf(CharacterRange('0', '9'), CharacterRange('a', 'f'), CharacterRange('A', 'F')),
+                "Space"  to spaceSet,
+            )
+
+            // Unicode category character classes (\p{X})
+            val unicodeCategorySets = mapOf(
+                "Pe" to stringToListOfCharacterRanges(")]}")
+                // more Unicode categories will be added here
+            )
+
+            // create both normal and negated version for all
+            (posixAsciiSets + unicodeCategorySets).flatMap { (key, value) ->
+                listOf(
+                    key     to MultiCharacterRange(false, value),
+                    "^$key" to MultiCharacterRange(true,  value)
+                )
+            }.toMap()
+        }
     }
 
     var value: String = ""
     var multiCharRange: MultiCharacterRange
 
     init {
-        if (type[0] !in "wWdDsSvVhHp") {
+        if (type[0] !in "wWdDsSvVhHpP") {
             throw IllegalArgumentException("Invalid type: $type")
         }
 
@@ -99,12 +114,16 @@ class CharacterClassEscapeRxGene(
             'V' -> nonVerticalSpaceMultiCharRange
             'h' -> horizontalSpaceMultiCharRange
             'H' -> nonHorizontalSpaceMultiCharRange
-            'p' ->
-                if (type.substring(2, type.length - 1) !in posixMultiCharRanges){
-                    throw IllegalArgumentException("$type invalid/unsupported POSIX character class")
+            'p', 'P' -> {
+                val pLabel = type.substring(2, type.length - 1)
+                val negated = type[0].isUpperCase()
+                val lookupKey = if (negated) "^$pLabel" else pLabel
+                if (lookupKey !in pEscapesMultiCharRanges) {
+                    throw IllegalArgumentException("$type invalid/unsupported \\p escape character class")
                 } else {
-                    posixMultiCharRanges[type.substring(2, type.length - 1)]!!
+                    pEscapesMultiCharRanges[lookupKey]!!
                 }
+            }
             else -> //this should never happen due to check in init
                 throw IllegalStateException("Type '\\$type' not supported yet")
         }

core/src/test/kotlin/org/evomaster/core/parser/GeneRegexJavaVisitorTest.kt

@@ -97,11 +97,24 @@ class GeneRegexJavaVisitorTest : GeneRegexEcma262VisitorTest() {
             |\p{Print}\p{Blank}\p{Cntrl}\p{XDigit}\p{Space}""".trimMargin())
     }
 
+    @Test
+    fun testUnicodeCategories(){
+        checkSameAsJava("""\p{Pe}""")
+        checkSameAsJava("""Pe""")
+    }
+
     @Test
     fun testPredefinedCharClassInsideCharClass(){
-        checkSameAsJava("""[\V\p{Lower}\P{Upper}\W\d]""")
+        checkSameAsJava("""[\V\p{Lower}\p{Upper}\W\d]""")
         checkSameAsJava("""[a\p{Pe}]""")
         checkSameAsJava("""[\u00BB\u2019\u201D\u203A"'\p{Pe}\u0002¹²³]""")
         checkCanSample("""[a\p{Pe}b]""", ")", 100_000)
     }
+
+    @Test
+    fun testPEscapesComplements(){
+        checkSameAsJava("""\P{Lower}\P{Upper}\P{ASCII}\P{Alpha}\P{Digit}\P{Alnum}\P{Punct}\P{Graph}
+            |\P{Print}\P{Blank}\P{Cntrl}\P{XDigit}\P{Space}""".trimMargin())
+        checkSameAsJava("""\P{Pe}""")
+    }
 }