• Start from the examples in the documentation – My first attempt at a top-level production was incorrect and failed to match anything, so nothing matched. I eventually resorted to reusing the entire wisent-graphviz-dot-mode parsing code with one added production for RELAX NG compact syntax namespace declarations and built it up from there until I’d sufficiently got the hang of the productions to remove the remaining wisent-graphviz-dot-mode training wheels and go it alone.
• Make sure your syntax table is correct – The mode was initially based on rnc-mode by David Rosenberg of Pantor Engineering AB and used the syntax table defined in it. At one point when things weren’t working, I remembered that the wisent-graphviz-dot-mode code that I’d been using as an example included a comment about needing to modify the syntax table of graphviz-dot-mode. Sure enough, rnc-mode was missing a syntax-table entry that was needed for Semantic parsing of .rnc files. And just today I had to set the “?” character as a symbol character to get one more part working properly.
• Use the debug functions – Forgive me for restating the very, very obvious, but you will find these useful. For example, `semantic-show-unmatched-syntax-mode‘ is useful, though initially disheartening, for showing which parts of the file are not being matched by displaying a red line under the unmatched parts. Occasionally, you may also note the absence of the red line under parts that you don’t expect to be matched yet.

(require 'flymake)
(defun flymake-rnc-init ()
  (let* ((temp-file (flymake-init-create-temp-buffer-copy
		     'flymake-create-temp-inplace))
     	 (local-file (file-relative-name
		      temp-file
		      (file-name-directory buffer-file-name))))
    (list "jing" (list "-c" local-file))))
(add-to-list 'flymake-allowed-file-name-masks
      '(".+\\.rnc$"
	flymake-rnc-init
	flymake-simple-cleanup
	flymake-get-real-file-name))
(add-hook 'rnc-mode-hook
	  'flymake-mode)

Emacs’ “Imenu” feature puts in the menu-bar a menu whose each menu item (or sub-menu item) jumps you to a location in the current buffer. Emacs being Emacs, Imenu is highly configurable, and quite often an Emacs mode will set up the Imenu menu to point to locations in the buffer that are significant for that mode/file-type. For example, my xslide and tdtd modes each set up very different Imenu menus.

`imenu-generic-expression` is a variable that, at its simplest, contains a list of three-item lists that each specify a menu title, a regular expression, and the number corresponding to the subexpression of the regular expression to use as the resulting menu item’s name. When `imenu-generic-expression` is set and the Imenu menu bar item is enabled (using `imenu-add-to-menubar`, naturally), Emacs constructs a buffer index by searching the buffer using each of the regular expressions in turn and then builds up the menu based on the matches found.

For example, here’s the `rnc-mode-hook' that I use to add a “RNC” menu when using `rnc-mode' to edit RELAX NG compact syntax (RNC) files. The hook sets `imenu-generic-expression` with patterns that match significant declarations in a RNC file (with separate sub-menus for include, namespace, and datatypes declaration types) then enables Imenu with `imenu-add-to-menubar`. A screenshot of the resulting menu is action is shown after the code.

(require 'rnc-mode)
(add-hook 'rnc-mode-hook
 (lambda ()
   (set-variable
    'imenu-generic-expression
    (list
     (list
      nil
      "^\\([a-zA-Z][-a-zA-Z0-9._]*\\)\\s-*[&|]?=" 1)
     (list
      "include"
      "^include\\s-+['\"]\\([a-zA-Z][-a-zA-Z0-9._]*\\)['\"]" 1)
     (list
      "namespace"
      "^\\(default\\s-+\\)?namespace\\s-+\\([a-zA-Z][-a-zA-Z0-9._]*\\)\\s-*=" 2)
     (list
      "dataypes"
      "^datatypes\\s-+\\([a-zA-Z][-a-zA-Z0-9._]*\\)\\s-*=" 1)))
   (imenu-add-to-menubar "RNC")))

The only downside to using `imenu-add-to-menubar` compared to doing more of it yourself is that `imenu-add-to-menubar` doesn’t provide a way to sort the menu items, so the order of the matches in the file is the order of the items in the menu or sub-menu. I wrote both xslide and tdtd before I knew of `imenu-add-to-menubar`, but the recently revived xslide for XSLT 2.0 still uses a custom function to make the Imenu index because I also like to sort the index entries alphabetically within each menu or sub-menu.

Future development is happening on the Trac and Subversion for the xslide SourceForge project.  See https://sourceforge.net/apps/trac/xslide/wiki/WikiStart.

Several upgrades and much thrashing later, the solution by Gregory Grubbs at http://gregorygrubbs.com/development/get-remote-x-working-in-karmic/ works for me, and the script in the fifth comment by Ben Hyde for running emacsclient makes things even easier than I was used to.

My usual technique was to “ssh -X laptop” from the desktop machine to the laptop and then run `make-frame-on-display' in the Emacs running on the laptop so I can check mail on the bigger screen, but it works (or worked) equally well the other way when I want to, say, take my development environment, open buffers and all, away from my desk.

When you use X11 forwarding with ssh (either by using the -X or -Y option or setting ForwardX11 to "yes“), the connection to the local (desktop) X11 display is forwarded to the remote (laptop) side, but ssh creates a “proxy” X server on the remote machine and sets up Xauthority data in ~/.Xauthority with a random authorization cookie. The shell on the remote machine started by ssh sees the proxy X11 display as, e.g., localhost:10. In the already-running Emacs on the laptop, M-x make-frame-on-display ret localhost:10 ret gets Emacs to use the proxy X11 display to put a frame on the desktop machine. At least that’s how it used to work.

The problem is that recent Ubuntu/Xubuntu releases, probably for your own good, use separate Xauthority data for each login. The laptop’s local login has its Xauthority in /var/run/gdm/auth-for-login-random/database (where “login” is your login name and “random” is a random string), with XAUTHORITY set to point to it. The ssh login, however, still uses (and modifies) ~/.Xauthority.

The workaround, or the driving of a truck straight through the security measures, is to merge the Xauthority data added by the ssh login with the Xauthority data seen by the laptop console login. My brute-strength-and-ignorance approach was a straight merge: from a shell on the laptop (remote) machine, run “xauth merge ~/.Xauthority“.

The script by Gregory Grubb is rather more subtle since it doesn’t jigger with the Xauthority data for the local display, only for displays not ending in :0, and the script in the comment by Ben Hyde takes that one step further by using emacsclient to do the merge, so you can do it all from the shell from the ssh login, so you don’t need physical access to the laptop (remote) machine.

The classic way is using James Clark’s utility.  This involves: (a) working out if you need “Jing” or “Trang” (you need Trang); (b) getting the .jar or the executable; and (c) running it.  Fairly simple, though it’s a pain that although it’s bundled with Ubuntu, etc., it’s not installed by default.  I backup my data between OS re-installs (who doesn’t?) but not the OS-installed programs, so when I need it on a new machine or after a re-install, I, at least, have to go through the Jing/Trang confusion and then fire up the package manager to install it.

I wanted an alternative, but writing a RNG schema loader function for nxml-mode isn’t the work of an afternoon (interesting as it would be to bootstrap it using nxml-mode’s tokenizing of the RNG XML), so I found David Rosenborg’s “RNG to RNC Converter” (http://www.pantor.com/download.html).  The current version works with XSLT 1.0 but not XSLT 2.0 (because it expects the XSLT processor to have a node-set() furnction), but you can add the following to RngToRncProcessorConfig.xsl so the XSLT works with both XSLT 1.0 and XSLT 2.0:

<!-- XSLT 2.0 or later. -->
<xsl:when test="system-property('xsl:version') >= 2">
  <xsl:variable name="body">
    <xsl:for-each select="$schema">
      <xsl:call-template name="make-body"/>
    </xsl:for-each>
  </xsl:variable>
  <xsl:sequence select="$body"/>
</xsl:when>

My only other quibble with the stylesheet is that it doesn’t preserve comments that are in the RNG (more straightforward to do in XSLT 2.0 than XSLT 1.0, I admit).

I don’t yet know if I’ll stick to using RNG to RNC Converter in preference to Trang.  The XSLT is easier to keep with the other stuff that I backup between installs or keep in the Subversion repository for machine configurations, but Trang is easier to use once it is installed and on your path.  The best thing is that now I have the choice of more than one way to do it.

For a more complete list of ways to do it that is maintained by MURATA Makoto, see http://relaxng.org/#conversion.

(defun use-xml-model ()
  "Hook function for `nxml-mode' to use  PI for locating a
RNC schema."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (if (search-forward "" nil t)
                           (match-beginning 0)))
                 (filename (save-excursion
                             (re-search-forward "href=\"\\([^\"]+\.rnc\\)\""
                                                pi-end t)
                             (match-string 1))))
;;            (message "pi-end: %d; filename: %s
;;                     pi-end filename)
            (if (and filename (file-readable-p filename))
                (rng-set-schema-file filename)))))))

(add-hook 'nxml-mode-hook
          'use-xml-model)

(setq auto-mode-alist
 (append
 (list
 '("\\.epub$" . archive-mode))
 auto-mode-alist))
(setq auto-coding-alist
 (append
 (list
 '("\\.epub$" . no-conversion))
 auto-coding-alist))

Along the way, I found an interesting history of the design of the Emacs logo.

At one a week, there’s probably several years’ worth in the index of the Emacs Lisp manual, but I’m really not planning on doing this every week: this just seemed like a catchy title for a one-off post.

The code (if WordPress hasn’t done too much damage to it) is:

(defvar trac-base "http://xmlroff.org"
  "Base to use when inserting links to trac tickets in email.")

(defun trac-base-xmlroff ()
  (interactive)
  (setq trac-base "http://xmlroff.org")
  (message trac-base))

(defun insert-trac-links ()
  "Insert links for Trac links."
  (interactive)
  (let ((ticket-alist)
         (changeset-alist '()))
    (goto-char (point-min))
    (while
        (re-search-forward
         "#([0-9]+)" nil t)
      (setq ticket-alist
              (add-to-list 'ticket-alist
 		 (string-to-number
 		  (buffer-substring-no-properties
 		   (match-beginning 1)
 		   (match-end 1))))))
    (goto-char (point-max))
    (insert "\\n")
    (dolist (ticket (sort ticket-alist '<))
      (insert (format
        "#%s %s/ticket/%s\\n"
        ticket trac-base ticket)))))

I have a separate `trac-base-xxx' function for setting `trac-base' for each Trac that I regularly use, and I use GNUS customizations to call the appropriate `trac-base-xxx' function when I enter specific email folders.