With the release of Snow Leopard, the included Emacs binary was not compiled with Carbon or Cocoa support. So, if a native OS X GUI is desired, compiling your own Emacs.app may be worthwhile. That’s the route I’ve taken. The Emacs developers are making improvements to the Cocoa version while dropping support for Carbon, and a 64-bit version should be able to compile from source. I’ll update this post as I tweak my Emacs.app on Snow Leopard.

64-bit Version

Download the the “latest” source from http://savannah.gnu.org/projects/emacs (I personally used git. Known checkouts to work: Oct 12, 2009, Oct 24, 2009):

$ git clone git://git.savannah.gnu.org/emacs.git

Run ‘./configure’:

$ cd emacs
$ ./configure --with-ns

Compile and create Emacs.app:

$ make install

Move ‘./emacs/nextstep/Emacs.app’ to ‘/Applications/’:

$ mv ./nextstep/Emacs.app /Applications/

32-bit Version

If the 64-bit version doesn’t compile, you can compile a 32-bit version by doing:

$ CC="gcc -arch i386" ./configure --with-ns

Note: There is more information about compiling a 64-bit version of Emacs.app at this blog post, this mailing list thread, and this blog post.

I didn’t find Apple’s documentation to be completely clear on how to grant an Mac OS X application authorization to run system-level commands. The best solution and only solution I could find was to use the function AuthorizationExecuteWithPrivileges. I wrote two simple Xcode projects, OSXSimpleAuth and OSXSlightlyBetterAuth, for OS X Leopard (10.5) to demonstrate its use, and I hope it will help others get something working quickly and gain a basic understanding, so they can concentrate on adding more robust functionality.

Simple Example

A simple example of how to use AuthorizationExecuteWithPrivileges is as follows:

1. Create a Authorization Reference (AuthorizationCreate)
2. Run your tool with the authorization reference (AuthorizationExecuteWithPrivileges)

For this example, OSXSimpleAuth, I created a Foundation Tool and added the Security framework to it.

// Create authorization reference
AuthorizationRef authorizationRef;
OSStatus status;
status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment,
                             kAuthorizationFlagDefaults, &authorizationRef);

// Run the tool using the authorization reference
char *tool = "/sbin/dmesg";
char *args[] = {NULL};
FILE *pipe = NULL;
status = AuthorizationExecuteWithPrivileges(authorizationRef, tool,
                                            kAuthorizationFlagDefaults, args, &pipe);

Slightly Better Example

A slightly better example that uses more options to run AuthorizationExecuteWithPrivileges and has links to some explanations from Apple’s documentation can be found in OSXSlightlyBetterAuth.

// Create authorization reference
OSStatus status;
AuthorizationRef authorizationRef;

// AuthorizationCreate and pass NULL as the initial
// AuthorizationRights set so that the AuthorizationRef gets created
// successfully, and then later call AuthorizationCopyRights to
// determine or extend the allowable rights.
// http://developer.apple.com/qa/qa2001/qa1172.html
status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment,
                             kAuthorizationFlagDefaults, &authorizationRef);
if (status != errAuthorizationSuccess)
    NSLog(@"Error Creating Initial Authorization: %d", status);

// kAuthorizationRightExecute == "system.privilege.admin"
AuthorizationItem right = {kAuthorizationRightExecute, 0, NULL, 0};
AuthorizationRights rights = {1, &right};
AuthorizationFlags flags = kAuthorizationFlagDefaults |
                           kAuthorizationFlagInteractionAllowed |
                           kAuthorizationFlagPreAuthorize |
                           kAuthorizationFlagExtendRights;

// Call AuthorizationCopyRights to determine or extend the allowable rights.
status = AuthorizationCopyRights(authorizationRef, &rights, NULL, flags, NULL);
if (status != errAuthorizationSuccess)
    NSLog(@"Copy Rights Unsuccessful: %d", status);

NSLog(@"\n\n** %@ **\n\n", @"This command should work.");
char *tool = "/sbin/dmesg";
char *args[] = {NULL};
FILE *pipe = NULL;

status = AuthorizationExecuteWithPrivileges(authorizationRef, tool,
                                            kAuthorizationFlagDefaults, args, &pipe);
if (status != errAuthorizationSuccess)
    NSLog(@"Error: %d", status);

// The only way to guarantee that a credential acquired when you
// request a right is not shared with other authorization instances is
// to destroy the credential.  To do so, call the AuthorizationFree
// function with the flag kAuthorizationFlagDestroyRights.
// http://developer.apple.com/documentation/Security/Conceptual/authorization_concepts/02authconcepts/chapter_2_section_7.html
status = AuthorizationFree(authorizationRef, kAuthorizationFlagDestroyRights);

Notice the “Right” label in the authorization dialog box screenshot. The AuthorizationItem was set with “system.privilege.admin” via the kAuthorizationRightExecute constant.

Conclusion

Apple recommends only using AuthorizationExecuteWithPrivileges in two cases. One is to create an installer. The other is to repair your helper tool by setting the setuid bit. The helper tool is supposed to encapsulate the root privileged portion of the code. Be aware that I didn’t do this in the examples. Go to the OSXSimpleAuth project page and the OSXSlightlyBetterAuth project page to download the example Xcode projects.

#!/bin/sh

pushd . > /dev/null

until [ -d .git ] || [ `pwd` = '/' ]; do
    cd ..;
done

if [ `pwd` = '/' ]; then  # try to go to a project directory
    if [ -z $PREV_PROJECT_ROOT ]; then
        popd > /dev/null
        echo "Project directory not found.";
    else
        cd $PREV_PROJECT_ROOT
    fi
else  # at a project directory
    export PREV_PROJECT_ROOT=`pwd`
fi

I saved this in my “~/bin” directory and made an alias to it called cdp. It’s important to source the script, otherwise the shell variables will not retain their values when the script terminates.

alias cdp=". cd-to-project-root"

This allows me to type cdp to set the project directory, which is under git version control. Anytime I want to get back to the project directory, I type cdp.

Phil Hagelberg gave an interesting talk about getting more feedback from the tools you use while you’re writing code, especially from your editor.  After his talk, I chatted with him about Emacs, and we setup a time for an Emacs group meetup. I told Matz about the meetup, and he was kind enough to stop by for a few minutes after his keynote. He told us an interesting anecdote about how he added the keyword ‘end’ to Ruby so that Emacs could properly auto indent the code. This goes for any editor/tool. Also, he said that he uses elisp to help him develop Ruby.

Ryan Davis’ talk “Hurting Code for Fun and Profit” was entertaining. It’s an interesting concept. Basically, if you love the code, nurture it and enjoy it. Otherwise, hate the code and hurt it, rip it out and rewrite it or fix it, be ruthless and mean, laugh at it, bend it to your will. So, I guess if loving the code doesn’t work, become a code sadist. Actually, in this case, a Ruby Sadist.

Laurent Sansonetti’s talk “Mac OS X Loves Ruby” was awesome. I liked the RubyCocoa demo. He showed how to use Xcode to bind Ruby code to a form textbox and a form button by just dragging the file to each one and selecting the appropriate inputs and outputs. He, also, showed a demo of using Ruby to manipulate an already running application, such as TextEdit. His other demos were good, too. The audience couldn’t help but break out into applause as they watched him manipulate Leopard by using Ruby, and he did this mostly at the command line.

I’ve been using Mac OS X Leopard for about a day now. The unfortunate thing that I discovered was that Leopard’s X11 support is not quite working yet. There are issues with Inkscape and Gimp, and I couldn’t get Emacs to work in X11. This encouraged me to find a better way to get Emacs into a windowed environment, and I ended up being able to create (uh, copy) an Emacs.app.

To create an Emacs.app, do the following:

Download the Emacs source code. Note: Leopard comes with emacs 22.1.1 (uses Carbon), so you want to download emacs-22.1.tar.gz. However, instead of downloading the entire source code, you can download just the Emacs.app from me here to save GNU 36MB of bandwidth.

Extract the files.

$ tar zxvf emacs-22.1.tar.gz

Go to the ‘emacs-22.1/mac’ directory

$ cd emacs-22.1/mac

Copy ‘Emacs.app’ to ‘/Applications/’

$ sudo cp -r Emacs.app /Applications/

Symlink /usr/bin/emacs to /Applications/Emacs.app/Contents/MacOS/emacs

$ ln -s /usr/bin/emacs /Applications/Emacs.app/Contents/MacOS/emacs

And, you may want to change the ownership on the Emacs.app

$ sudo chown -R root:admin /Applications/Emacs.app

That’s it. You should now be able to launch Emacs.app as a regular Mac application.