Geany's documentation on negative assertions makes it look like they're possible.
For reference, this works and gives me results:
pcregrep -r "(?<!= )function\(" src/main-js/
But the same regex, or any regex with a negative lookbehind, gives me no result when launched from Geany (v 1.24.1)
Where is the problem? Is the documentation wrong?
Precision: the topic isn't about how to avoid doing a negative look behind, but about how to do any standard PCRE negative look behind.
I got support from the Geany developers on Freenode, and it was very helpful. Here is what they told me:
The documented RE syntax only applies to the RE engine directly used by
Geany (e.g. in Find), but the Find in Files features calls the grep tool
(as configured in preferences->tools->grep), which has its own syntax.
For GNU grep, you can add "-P" to the "Extra options" field in the
dialog
However, after you tried it, you had this error:
/bin/grep: conflicting matchers specified
... to which I was told this was a Geany bug. Geany calls grep -E, and -P is not compatible with it.
Your only workaround is to have a shell script calling grep with -P instead of -E, and use this script. You should be able to configure the grep tool to call in Geany preferences.
An example of said shell script:
#!/bin/sh
matchopts=$(echo "$1" | tr E P)
shift
exec grep $matchopts "$#"
Geany uses either -F or -E (these are the only available engines in POSIX grep) for grep, hence why you can't pass -P.
I've reported the bug to the Geany developers.
Another workaround is to avoid the negative lookbehind assertion… but it's a lot uglier:
(^.?|[^=] |=[^ ]|[^=][^ ])function
Related
Either I cannot get git-log's regexp grep functionality to search using perl based regexp (pcre) or I can but it is not working with negative lookbehind.
git log -p -P -G'(?<!-)title'
results in output
fatal: invalid regex: Invalid preceding regular expression
However, pcre support and negative lookbehind seems to be working, if git-grep is any indicator.
E.g. git grep -P '(?<!-)title' returns expected results.
git version 2.21.0 (Apple Git-122.2)
The -P doesn't influence -G. You can verify it by replacing -P with -F (or --fixed-string): you'll still get the same error, even if there's no look-around at all in fixed strings.
The documentation of -P says
Consider the limiting patterns to be Perl-compatible regular expressions.
Note the word "patterns". Indeed, the --grep options mentions it:
--grep=<pattern>
On the other hand, -G doesn't:
-G<regex>
I'm trying to use SED to extract text from a log file. I can do a search-and-replace without too much trouble:
sed 's/foo/bar/' mylog.txt
However, I want to make the search case-insensitive. From what I've googled, it looks like appending i to the end of the command should work:
sed 's/foo/bar/i' mylog.txt
However, this gives me an error message:
sed: 1: "s/foo/bar/i": bad flag in substitute command: 'i'
What's going wrong here, and how do I fix it?
Update: Starting with macOS Big Sur (11.0), sed now does support the I flag for case-insensitive matching, so the command in the question should now work (BSD sed doesn't reporting its version, but you can go by the date at the bottom of the man page, which should be March 27, 2017 or more recent); a simple example:
# BSD sed on macOS Big Sur and above (and GNU sed, the default on Linux)
$ sed 's/ö/#/I' <<<'FÖO'
F#O # `I` matched the uppercase Ö correctly against its lowercase counterpart
Note: I (uppercase) is the documented form of the flag, but i works as well.
Similarly, starting with macOS Big Sur (11.0) awk now is locale-aware (awk --version should report 20200816 or more recent):
# BSD awk on macOS Big Sur and above (and GNU awk, the default on Linux)
$ awk 'tolower($0)' <<<'FÖO'
föo # non-ASCII character Ö was properly lowercased
The following applies to macOS up to Catalina (10.15):
To be clear: On macOS, sed - which is the BSD implementation - does NOT support case-insensitive matching - hard to believe, but true. The formerly accepted answer, which itself shows a GNU sed command, gained that status because of the perl-based solution mentioned in the comments.
To make that Perl solution work with foreign characters as well, via UTF-8, use something like:
perl -C -Mutf8 -pe 's/öœ/oo/i' <<< "FÖŒ" # -> "Foo"
-C turns on UTF-8 support for streams and files, assuming the current locale is UTF-8-based.
-Mutf8 tells Perl to interpret the source code as UTF-8 (in this case, the string passed to -pe) - this is the shorter equivalent of the more verbose -e 'use utf8;'.Thanks, Mark Reed
(Note that using awk is not an option either, as awk on macOS (i.e., BWK awk and BSD awk) appears to be completely unaware of locales altogether - its tolower() and toupper() functions ignore foreign characters (and sub() / gsub() don't have case-insensitivity flags to begin with).)
A note on the relationship of sed and awk to the POSIX standard:
BSD sed and awk limit their functionality mostly to what the POSIX sed and
POSIX awk specs mandate, whereas their GNU counterparts implement many more extensions.
Editor's note: This solution doesn't work on macOS (out of the box), because it only applies to GNU sed, whereas macOS comes with BSD sed.
Capitalize the 'I'.
sed 's/foo/bar/I' file
Another work-around for sed on Mac OS X is to install gsedfrom MacPorts or HomeBrew and then create the alias sed='gsed'.
If you are doing pattern matching first, e.g.,
/pattern/s/xx/yy/g
then you want to put the I after the pattern:
/pattern/Is/xx/yy/g
Example:
echo Fred | sed '/fred/Is//willma/g'
returns willma; without the I, it returns the string untouched (Fred).
The sed FAQ addresses the closely related case-insensitive search. It points out that a) many versions of sed support a flag for it and b) it's awkward to do in sed, you should rather use awk or Perl.
But to do it in POSIX sed, they suggest three options (adapted for substitution here):
Convert to uppercase and store original line in hold space; this won't work for substitutions, though, as the original content will be restored before printing, so it's only good for insert or adding lines based on a case-insensitive match.
Maybe the possibilities are limited to FOO, Foo and foo. These can be covered by
s/FOO/bar/;s/[Ff]oo/bar/
To search for all possible matches, one can use bracket expressions for each character:
s/[Ff][Oo][Oo]/bar/
The Mac version of sed seems a bit limited. One way to work around this is to use a linux container (via Docker) which has a useable version of sed:
cat your_file.txt | docker run -i busybox /bin/sed -r 's/[0-9]{4}/****/Ig'
Use following to replace all occurrences:
sed 's/foo/bar/gI' mylog.txt
I had a similar need, and came up with this:
this command to simply find all the files:
grep -i -l -r foo ./*
this one to exclude this_shell.sh (in case you put the command in a script called this_shell.sh), tee the output to the console to see what happened, and then use sed on each file name found to replace the text foo with bar:
grep -i -l -r --exclude "this_shell.sh" foo ./* | tee /dev/fd/2 | while read -r x; do sed -b -i 's/foo/bar/gi' "$x"; done
I chose this method, as I didn't like having all the timestamps changed for files not modified. feeding the grep result allows only the files with target text to be looked at (thus likely may improve performance / speed as well)
be sure to backup your files & test before using. May not work in some environments for files with embedded spaces. (?)
Following should be fine:
sed -i 's/foo/bar/gi' mylog.txt
This question already has an answer here:
Sed doesn't work in command line however regular expression in online test regex101 works
(1 answer)
Closed 4 years ago.
What I'm trying to do
Bash script to replace the uncommented php_version: "7.2" with the a user-entered version:
#!/bin/bash
# Ask desired PHP version
read -p "What version of PHP should be used? (5.6, 7.0, 7.1, or 7.2): " phpVersion
# Replace default php version with desired php version
sed -i "s/^php_version: \"[0-9]+\.[0-9]+\"/php_version: \"${phpVersion}\"/g" fileToSearchReplace.txt
Contents of fileToSearchReplace.txt which vim reports is a unix file:
APIVersion: v1.0.0
name: alpha-local
type: typo3
docroot: public
# php_version: "7.1" # PHP version to use, "5.6", "7.0", "7.1", "7.2"
php_version: "7.2"
router_http_port: "80"
router_https_port: "443"
xdebug_enabled: false
additional_hostnames: []
additional_fqdns: []
provider: default
Diagnostics
This worked: I checked the RegEx here using ^php_version: "[0-9]+\.[0-9]+" for search and php_version: "7.0" for replace (you can find replace and paste in the text a tab below. Notice I could only get the search to work using the /gm at the end. I have no idea how to get multiline to work in sed???
Environment
Windows 10 Pro host
Using MINGW64 git bash terminal
These files are part of a Docker container
I tried running this sed both in my MINGW64 git bash terminal and also inside the Ubuntu container
You cannot use + with sed by default. Either do your own + like that:
sed -i "s/^php_version: \"[0-9][0-9]*\.[0-9][0-9]*\"/php_version: \"${phpVersion}\"/g" fileToSearchReplace.txt
Or use the extended regex option -r:
sed -r -i "s/^php_version: \"[0-9]+\.[0-9]+\"/php_version: \"${phpVersion}\"/g" fileToSearchReplace.txt
Example: https://repl.it/repls/PowderblueFoolishEquipment
I don't think its a good idea to try out a regex from a site which doesn't say which class of regex it is supporting and re-using the same in your command.
You have a classic case of mix-up in which the regex pattern from the site, is of the Extended Regular Expressions and the one in your sed uses Basic Regular expression construct which does not support your [0-9]+ expression. Simply enable the ERE support with the -E switch in your sed
sed -Ei "s/^php_version: \"[0-9]+\.[0-9]+\"/php_version: \"${phpVersion}\"/g" fileToSearchReplace.txt
See the [ POSIX | GNU ] variants of the same solution, with the POSIX version using the BRE and the GNU version using ERE. Do read through this useful article on POSIX Regular Expressions on how the two variants of the regular expressions work.
You may use this script with select that lets user select a version from a menu list. You can then pass selected option to a simplified sed command:
select ver in "5.6" "7.0" "7.1" "7.2"; do
sed -i "s/^\(php_version: \).\+/\1\"$ver\"/" fileToSearchReplace.txt
break
done
I was trying to use the following grep command:
grep '(.*)(?=(png|html|jpg|js|css)(?:\s*))(png|html|jpg|js|css.*\s)' file
File contains the following:
http://manage.bostonglobe.com/GiftTheGlobe/LandingPage.html
https://manage.bostonglobe.com/cs/mc/login.aspx?p1=BGFooter
https://www.bostonglobe.com/bgcs
/newsletters?p1=BGFooter_Newsletters
https://bostonglobe.custhelp.com/app/home?p1=BGFooter
https://bostonglobe.custhelp.com/app/answers/list?p1=BGFooter
/tools/help/stafflist?p1=BGFooter
https://www.bostonglobemedia.com/
https://manage.bostonglobe.com/Order/newspaper/Newspaper.aspx
https://www.facebook.com/globe
https://twitter.com/#!/BostonGlobe
https://plus.google.com/108227564341535363126/about
https://epaper.bostonglobe.com/launch.aspx?pbid=2c60291d-c20c-4780-9829- b3d9a12687cf
http://nieonline.com/bostonglobe/
https://secure.pqarchiver.com/boston-sub/no_default.html?ss=1&url=%2Fboston-sub%2Fadvancedsearch.html
/tools/help/privacy?p1=BGFooter
/tools/help/terms-service?p1=BGFooter
/termsofpurchase?p1=BGFooter
https://www.bostonglobemedia.com/careers
/css/globe-print.css?v=19256I1935
//meter.bostonglobe.com/css/style.css
/css/globe-print.css?v=19256I1935
//cdn.blueconic.net/bostonglobemedia.js
/js/lib/rwd-images.js,lib/respond.min.js,lib/modernizr.custom.min.js,globe- define.js,globe-controller.js?v=19256I1935
data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==
/js/lib/jquery.js,lib/lo-dash-custom-2.4.1.js,lib/a9.js,lib/pb.js,dist/ad- init.js,globe-newsletter.js,globe-profile-page.js,dist/globe-topic-nav.js,dist/rakuten.js?v=19256I1935
//dc8xl0ndzn2cb.cloudfront.net/js/bostonglobe/v0/keywee.min.js
For some reason it doesn't select anything from that file, Ive tried different flags but cant seem to figure out whats wrong
You are using a PCRE regex with the POSIX BRE engine that is default grep engine.
To make those patterns work, you should use -P option (available in GNU grep):
grep -P 'YOUR_PCRE_PATTERN'
^^
To develop and test PCRE patterns, a well-known regex101.com is usually recommended.
Note that on Mac OS, you may install GNU grep via brew.
GNU grep 2.5.4 on bash 4.1.5(1) on Ubuntu 10.04
This matches
$ echo "this is a line" | grep 'a[[:space:]]\+line'
this is a line
But this doesn't
$ echo "this is a line" | grep 'a\s\+line'
But this matches too
$ echo "this is a line" | grep 'a\s\+\bline'
this is a line
I don't understand why #2 does not match (whereas # 1 does) and #3 also shows a match. Whats the difference here?
Take a look at your grep manpage. Perl added a lot of regular expression extensions that weren't in the original specification. However, because they proved so useful, many programs adopted them.
Unfortunately, grep is sometimes stuck in the past because you want to make sure your grep command remains compatible with older versions of grep.
Some systems have egrep with some extensions. Others allow you to use grep -E to get them. Still others have a grep -P that allows you to use Perl extensions. I believe Linux systems' grep command can use the -P extension which is not available in most Unix systems unless someone has replaced the grep with the GNU version. Newer versions of Mac OS X also support the -P switch, but not older versions.
grep doesn't support the complete set of regular expressions, so try using -P to enable perl regular expressions. You don't need to escape the + i.e.
echo "this is a line" | grep -P 'a\s+line'