help-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Emacs equivalent of the ":g" command in vi


From: Andreas Röhler
Subject: Re: Emacs equivalent of the ":g" command in vi
Date: Fri, 22 Jul 2011 22:37:04 +0200
User-agent: Mozilla/5.0 (X11; U; Linux i686; de; rv:1.9.2.18) Gecko/20110616 SUSE/3.1.11 Thunderbird/3.1.11

Am 22.07.2011 22:27, schrieb MBR:
On 7/22/2011 4:42 AM, C K Kashyap wrote:
Hi,
Could someone please tell me how I could go about something like this -
I need to perform a certain action (such as delete the line) on each
line of a buffer if the line matches a regular expression. In vim, we
can use the :g command for this.
Regards,
Kashyap

I looked for the same thing ages ago when I switched from vi to emacs.
Eventually I figured out that:

:g/regular expression/operation

reflects an 'ed' mindset, and that an Emacs macro with a repeat count is
actually far more powerful . (In case you're wondering what 'ed' is, it
was the original, line-oriented, Unix editor. 'vi' was Bill Joy's visual
mode version of 'ex', which was his enhanced version of 'ed'.)

An Emacs macro is a series of emacs commands that you can replay. You
use C-( and C-) as follows to create a macro:

C-(
type any commands you want Emacs to remember
C-)

Then, whenever you type C-x e, Emacs will replay the commands.

At this point, you're probably wondering how this can substitute for
vi's g//. Simple. Just start your macro off with a regular expression
search, do whatever you want, and then replay it multiple times with:

C-u /count/ C-x e

Specify a large enough repeat count, and you can make your macro apply
to the whole file.

For example, to delete each line of a buffer if the line matches a
regular expression, you'd define the macro with:

C-( ;; Begin recording macro
C-M-s regexp ;; Search for regular expression
C-a ;; Go to beginning of line
C-k ;; Kill one line by typing C-k twice
C-k ;;
C-) ;; End recording macro

Then you'd execute the macro with:

C-u 10000 C-x e

Of course, there's an easier way to delete lines that match a regular
expression:

M-x delete-matching-lines

But you described the general problem as needing to perform a certain
action on each line of a buffer if the line matches a regular
expression. And the approach of defining a macro to do what you want and
then executing it with a large repeat count gives you a general purpose
mechanism to do arbitrary operations rather than just delete the line.

For example, if I have a file of lines of the format:

zip,street address,city,state,phone,name

That I wanted to rearrange to:

name,phone,street address,city,state,zip

I could run:

M-x replace-regexp
^\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\)$
\6,\5,\2,\3,\4,\1

which is the equivalent of vi's:

:g/^\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\)$/s//\6,\5,\2,\3,\4,\1/g


But making sure you've got that regular expression right can be tricky.
It can be much easier to just do it with emacs commands applied to a
single line. Although the following is difficult to read, I think if you
try it out you'll find it pretty straightforward. First fill an emacs
buffer with lots of lines of the form:

name,phone,street address,city,state,zip

Then type these emacs keystrokes (omitting the comments):

;; Begin recording macro
C-(
;; Narrow the buffer to the current line:
C-SPC C-n C-x n n M-<
;; Move the part after the fifth ","
;; to the beginning of the line
C-s , C-s C-s C-s C-s C-b C-k C-a C-y , C-a C-d
;; Move the part that's now after the fifth ","
;; to the second comma-delimited position
C-s , 4*C-s C-b C-k C-a M-f C-y
;; Move the third comma-delimited part to the end
M-d C-e C-y
;; Move forward over the newline to the next line
C-f
;; Widen so you can see the whole buffer
C-x n w
;; End recording macro
C-)

Replay it 10,000 times with:

C-u 10000 C-x e

It will stop as soon as it runs out of matching lines.

The point is that the operations you can repeat this way are limited
only by your imagination.

There's a variant of this that I use frequently. I often find that a
non-emacs application wants me to type lots of information into
individual fields of an input screen. It's a pain to have to type all
that data, especially when I have that data in a text file. In emacs I
can organize the data into the same order as the input fields in the
application, putting each field's data on a separate line of the emacs
buffer. Then I do the following in emacs:

;; Begin recording macro
C-(
;; Mark region from beginning to end of line
C-aC-SPCC-e
;; Copy region so it can be pasted into another application
C-w
;; Move forward over the newline to the next line
C-f
;; End recording macro
C-)

Once I've defined that macro, I can repeatedly type:

;; This is not an Emacs command. It tells the window manager
;; to give keyboard focus to the other application.
ALT-TAB
;; Paste into the input field
C-v
;; Move focus to the next input field
TAB
;; Give keyboard focus to Emacs.
ALT-TAB
;; Repeat the macro, which copies the next line.
C-x e

At that point, I repeatedly type:

C-x e ALT-TAB C-v TAB ALT-TAB

While it's not fully automated, If I've got lots of data that has to be
entered through a GUI interface, it makes things go a whole lot faster.

If you should want to save a macro you've created this way so you can
use it in future Emacs sessions:

Open your .emacs file: C-x C-f ~/.emacs
Give it a name by with:M-x name-last-kbd-macro
Insert it into your .emacs with: M-x insert-kbd-macro
Save your .emacs file: C-x C-s

Mark Rosenthal
address@hidden <mailto:address@hidden>

P.S. - Interesting side-note. Did you know that the ed command:

g/regular expression/operation

is where the name "grep" came from? In ed and ex, the "g" means do a
global search for the immediately following regular expression, and
apply the operation to every matching line. One such operation is "p"
meaning "print". Using "re" as shorthand for "regular expression", the
ed command to print every line that matches a particular regular
expression is:

g/re/p




Hi,

from my feeling: finally much easier then fighting which recorded keyboard-macros is writing it's own little functions.

Running them under edebug then and a breakpoint set allows neatly control

Keyboard macros are good for really limited and easy repeats.

Andreas




reply via email to

[Prev in Thread] Current Thread [Next in Thread]