Irreal

Over at the Emacs Reddit, wadcann posts a nice idea. The problem is to have abbreviations that touch their surrounding text. The canonical example is punctuation like the em-dash:

Many national security professionals—those in the CIA, NSA, and similar...

You can’t (conveniently) use the normal abbreviation expansion mechanisms here because they expect the symbol to be delimited from the rest of the text by white space.

Wadcann solves that problem with a bit of Elisp. His post is short so you should take a look before continuing. I liked his idea but thought that the Elisp could be cleaned up a bit. Suppose, as Wadcann does, that you use /--- as the abbreviation for the em-dash. The idea is to search backwards to the slash, mark it as the beginning of the abbreviation, return to the original position to mark the end of the abbreviation, and call expand-abbrev to expand it.

That seemed simple enough. Here’s my first attempt:

(global-set-key (kbd "M-\"")
                (lambda ()
                  (interactive)
                  (let ((pt (point)))
                    (when (search-backward "/" nil t)
                      (abbrev-prefix-mark t)
                      (goto-char pt)
                      (expand-abbrev)))))

It didn’t work. After adding some debugging statements, I discovered that the (goto pt) placed the point at one character short of where it should. When I fixed that up, everything worked just fine:

(global-set-key (kbd "M-\"")
                (lambda ()
                  (interactive)
                  (let ((pt (1+ (point))))
                    (when (search-backward "/" nil t)
                      (abbrev-prefix-mark t)
                      (goto-char pt)
                      (expand-abbrev)))))

The problem was I couldn’t figure out why the first solution wasn’t correct. Even though the second solution worked it was really just treating the symptoms, not the problem. So I rewrote it using markers instead.

(global-set-key (kbd "M-\"")
                (lambda ()
                  (interactive)
                  (let ((pt (point-marker)))
                    (when (search-backward "/" nil t)
                      (abbrev-prefix-mark t)
                      (goto-char pt)
                      (expand-abbrev))
                    (set-marker pt nil))))

I don’t like this solution as much because you have to deactivate the marker at the end. Still, at least this solution made sense. I checked the appropriate Emacs code and as far as I can see, the first solution does pretty much what the third one does.

Does anyone understand what’s happening here? I have two working solutions so now it’s just a matter of an annoying anomaly that I don’t understand. If you’ve got a clue, please leave a comment.

The challenge was to convert the output from dstat so that all the bytes values (some of which are given as kilobytes or megabytes) to just bytes. Thus, 2k would become 2048 and 3M would become 3145728. Similarly, dstat outputs bytes with a B suffix so 123B would become 123.

Here’s my code:

(defun to-bytes ()
  (interactive)
  (while (search-forward-regexp "\\([0-9]+\\)\\(B\\|k\\|M\\)")
    (let ((val   (string-to-number (match-string 1)))
          (units (match-string 2)))
      (cond
       ((string= units "B") (replace-match "\\1"))
       ((string= units "k") (replace-match (format "%d" (* 1024 val))))
       ((string= units "M") (replace-match (format "%d" (* 1048576 val))))))))

It makes only one pass through the data so it’s reasonably efficient. Nothing earth shattering but it gives us a chance to keep our Elisp skills sharp.

Over at What keramida said…, Giorgos Keramidas poses an interesting problem. Given the following output from dstat, get rid of the B, k, and M suffixes by converting them into bytes.

----system---- ----total-cpu-usage---- --net/eth0- -dsk/total- sda-
     time     |usr sys idl wai hiq siq| recv  send| read  writ|util
16-05 08:36:15|  2   3  96   0   0   0|  66B  178B|   0     0 |   0
16-05 08:36:16| 42  14  37   0   0   7|  92M 1268k|   0     0 |   0
16-05 08:36:17| 45  11  36   0   0   7|  76M 1135k|   0     0 |   0
16-05 08:36:18| 27  55   8   0   0  11|  67M  754k|   0    99M|79.6
16-05 08:36:19| 29  41  16   5   0  10| 113M 2079k|4096B   63M|59.6
16-05 08:36:20| 28  48  12   4   0   8|  58M  397k|   0    95M|76.0
16-05 08:36:21| 38  37  14   1   0  10| 114M 2620k|4096B   52M|23.2
16-05 08:36:22| 37  54   0   1   0   8|  76M 1506k|8192B   76M|33.6

Keramidas also wants to do a bit of reformatting of the table, which we’ll ignore for this post. He does the conversion with three invocations of replace-regexp but given that he titles his post Powerful Regular Expressions Combined with Lisp in Emacs, I thought it would be an interesting challenge to write some Elisp to get rid of those suffixes and convert the entries into bytes.

Obviously, for a one-off task, Keramidas’ solution is the best but if this is something that has to be done regularly a bit of Elisp is just what’s needed. My solution is a Lisp function that converts the table with a single call. Leave your solution in the comments and I’ll post mine in a few days.