Newbie needs helps
Daniel May last edited by
I’m searching a document with lines and each line ends with “1.4,1,1)” (minus the quotations). Out of 20,000 lines one of them is missing the closing parenthesis. Does anyone know how I can ask NP++ to find the missing parenthesis?
Thanks in advance,
jonandr last edited by
Open find, check “Regular expression”, search for this:
Dot has a special meaning for regular expressions, so it must be escaped with a backslash. Same with parentheses.
[^)] is a so called negated character class and means “any character except right parenthesis”.
$ means “match end of line”.
Daniel May last edited by Daniel May
Wow thanks for the fast response, fortunately we’ve found that the missing parenthesis is not in that specific string of characters but somewhere in the file and now I’ve really gone cross eyed.
Here’s a snipit from the file:
That times 100000 and somewhere is a missing right parenthesis. Can you help?
jonandr last edited by
Maybe it’s possible to build a regexp which finds the line in one go, but personally I would just do it in several steps.
The insight here is that if you remove everything except parentheses, then all good lines will look the same. Since they all look the same, they can be replaced with nothing. That leaves only bad lines.
- Search for ‘(’ or ‘)’ to find the wrong line (note that line numbers stay the same so it can be correlated with the original file)
guy038 last edited by guy038
Hello Daniel and Andreas, and All,
As soon as you’re looking for couples
<>… in a text, containing unlimited nested respective couples
<>, you absolutely need to use a very strong feature of PCRE regex : the recursive patterns. If you don’t, it quite impossible to handle any arbitrary nesting depth !
Generally speaking, you automatically create a recursive pattern, when you add a recursive call to a group, located INSIDE the sub-pattern whose it makes a reference.
For instance, let’s suppose the general regex
....(....(?n)....)....and that the showed group is the group n. Then, the form
(?n), located inside the group n, is a recursive call to that group n
Concerning your problem, Daniel, the solution is the regex, below :
You may use the PCRE_EXTENTED option
(?x)to get the regex :
(?x) ( ^ ([^()\r\n])* ( \( ( (?2) | (?3) )* \) ) (?2)* \r?\n )+
These regexes look for any consecutive sequence of entire lines, with their End of Line character(s), whose each of them :
Is, of the general form,
Contents well-balanced nested couples
(), inside the upper-level block
So, Daniel, if you leave the replace field empty, you’ll get, ONLY, the lines where the number of opening round brackets is different from the number of closing round brackets, or lines without any round bracket at all !
For instance, these regexes, above, don’t match any of these following lines :
But they do match, in one go, the block of these seven following lines, with well-balanced couples of
In short :
The form (?2) is a NON recursive call to the sub-pattern
The form (?3) is a recursive call to the sub-pattern
\( ( (?2) | (?3) )* \)
^, at beginning and
\r?\n,at the end, allow to cover an entire line, which can be repeated, due to the final + sign, applying to group 1
The opening and closing round brackets need to be escaped
\). Just notice that escaping round brackets, inside the class character
[....], at the beginning of the regex, is not mandatory !
Inside the block
\(....\), the regex looks for any sequence, even empty, of :
(?2)Characters different from round brackets and from End of Line characters OR
(?3)Nested other blocks of round brackets
and so on…
I’ll give you any further information, about the recursion concept, if anyone needs to !
To end, I give you an other regex, with a recursive pattern
(?2), which can match the general case of the string
So, this regex, below, matches the tallest sequence of characters, even on several lines, which contains as much as opening round brackets than closing round brackets, with well-nested and/or juxtaposed other blocs
With the PCRE_EXTENTED option
(?x), we get the regex :
(?x) ( [^()]* ( \( ( [^()] | (?2) )* \) ) [^()]* )+
And, if you don’t think to use the group 1, in the replacement part, with the backreference
\1, you may set group 1, as a non-capturing group, with the syntax
?:, in :
(?x) (?: [^()]* ( \( ( [^()] | (?1) )* \) ) [^()]* )+
Of course, because of the first non-capturing group, the old recursive group 2 becomes the recursive group 1