Hacker News Reader

Comment by drblast | Hacker News Reader

There have been various times in my programming career that I've wanted an emacs macro with arguments, so that it would do things like concatenate a number in each line. Things like this in C:

  #define a 0
  #define b 1
  ...
  #define l 10
  #define m 11

Usually I take that as a sign that I need to write some other program to generate the lines of the C program, but for some tasks that's overkill and I want an automated way to create a list of sequential things so I don't have to type 1 down 1 down 1 down 1 down 2 down 2 down 2 down...

Surely this is a solved problem.

View on HN

There is the \# character, which is replaced with the number of times a replacement has been done. So,

   M-x replace-regexp
      Replace regexp: test\(.+\)
      Replace regexp with test\#

You can actually drop arbitrary lisp in the middle of search/replace expressions. So, if you'd like to number from 1 instead of 0,

   M-x replace-regexp
      Replace regexp: test\(.+\)
      Replace regexp with test\,(1+ \#\)

I'm sure with more lisp tricks, you can get delimited lists:

   M-x replace-regexp
      Replace regexp: test\(.+\)
      Replace regexp with test\,(aref ["one", "two", "three"] (mod \# 3))

(Not sure that works, but you get the idea).

Anyway, all of this was basically stolen from Steve Yegge. You should totally go read his article if you're interested: http://steve-yegge.blogspot.com/2006/06/shiny-and-new-emacs-...

You should check out the EmacsWiki macro tricks page:

http://www.emacswiki.org/emacs/KeyboardMacrosTricks

From there:

    If you want to produce this list:

    test1
    test2
    test3
    ...

    Do like this:

    C-x r n q           (store the number 1 in register q)
    C-x (               (start macro recording)
    test C-x r i q      (insert contents of register q)
    C-x r + q           (increment register q by 1)
    RET                 (new line)
    C-x )               (stop macro recording)

Ow, that hurts my brain more than usual. How would one leverage registers with text instead of incremental numbers? (I will have to RTFW later.)

The easy way I do it is to make however many copies of "test0" I want, then make a trivial throwaway macro where I move my cursor to the number I want to increment, and hit M-x rolling-increment-number-at-point. (Of course with autocomplete...)

Here's my definitions:

  (defvar *rolling-counter* 0)
  
  (defun rolling-increment-number-at-point ()
    (interactive)
    (incf *rolling-counter*)
    (skip-chars-backward "0123456789")
    (or (looking-at "[0123456789]+")
        (error "No number at point"))
    (replace-match (number-to-string (+ *rolling-counter*
                                        (string-to-number (match-string 0))))))
  
  (defun clear-rolling-history ()
    (interactive)
    (setf *rolling-counter* 0))

I don't think it's quite what you're talking about, but I have an Emacs function that runs the current region through Python and replaces it with the stdout from running it.

For your example, I write this:

    vars = list('abcdefghijklm')
    for v,i in zip(vars, range(len(vars))):
        print("#define {} {}".format(v, i))

Select it and press Ctrl+Alt+p and have it replaced by:

    #define a 0
    #define b 1
    #define c 2
    #define d 3
    #define e 4
    #define f 5
    #define g 6
    #define h 7
    #define i 8
    #define j 9
    #define k 10
    #define l 11
    #define m 12

https://gist.github.com/1355548

Or just learn a little bit of Elisp, and do this:

    M-: (loop for i from ?a 
              for j below 12 
              do (insert (format "#define %c %d\n" i j)))

Yeah, I considered that, but the situation comes up so infrequently I'd never remember the syntax. I use Python everyday anyway, so it almost comes naturally.

I know exactly what you mean -- but perhaps it doesn't even have to be a macro, but a more powerful search-and-replace, with changing replacements.

My lisp-fu isn't good enough to implement this today, but I would find it really easy to:

* copy `#define a 0` with C-k, M-w, C-y, RET, C-y, RET, C-y, RET, ... (so copy the line and paste N times)

* begin interactive search-and-replace, with usual keybindings (Y for replace, N for skip, . for replace and stop)

* but with additional keybinding, e.g. + for change replacement and apply

Alternatively, the replace argument in M-% would be a [somehow-delimited] list of replacements, and + or capital Y would pop off the next replacement and begin using that.

There is a keyboard macro counter, which I've been able to use in situations like this. It's described in the manual[1] and on this Stackoverflow question[2].

[1] http://www.gnu.org/s/libtool/manual/emacs/Keyboard-Macro-Cou...

[2]http://stackoverflow.com/questions/1509688/emacs-macro-to-ge...

The newest emacs keybindings should help sort this out. Use <F3> to make it easy. Might as well just go C-h k <F3> to see what it does, but the function name `kmacro-start-macro-or-insert-counter' might give you a clue.

Here's what I'd do for your example, starting in an empty buffer:

abcdefghijklm C-a C-SPC C-e C-w <F3> #define SPC C-y M-b C-f C-SPC C-e C-w SPC <F3> RET <F4>

Then press F4 until you reach `m'. (You may find that the sequence ends with `m' being 12.)

(NOTE you should totally use `enum' for this; your debugger may on occasion permit you to use the names when you are entering an expression, and you'll get sensible error messages in the event of a conflict. Unlikely in this case I suppose since nobody uses variables called `i' or `j'.)

In the past, I've used 2 buffers to solve this problem.

I'll fill one buffer with the text I'm editing, and the other buffer with any 'arguments'. Then I'll just write the macro to switch between buffers and grab arguments as necessary.

I don’t know Emacs, but I know a way to do that in Vim, and Emacs might support a similar method. In Vim, Ctrl-A and Ctrl-X increment and decrement the number the cursor is over. You can generate a list by recording a macro that duplicates the current line and then increments its number (qqVyp ^a q), and running that macro repeatedly (10@q). Emacs might also have a function for incrementing characters, not just numbers.

Emacs has this feature [for all values of 'this feature' :)]

The documentation for the most convenient way to do it (there are others) is at:

http://www.gnu.org/software/emacs/manual/html_node/emacs/Key...

I find that copy rectangle works wonders for lots of problems like this. It's simple to type

and then using copy rectangle I can quickly assemble long lists of numbers.

I do use keyboard macros quite frequently too, but mostly for more complex operations (e.g. start of line, search for char, set point, search for next char, kill-ring-save, move to end, set point, yank, uppercase region)

Reply on news.ycombinator.com