Snapshot 43

Conflicts:
	src/buffer.c

.gitignore

@@ -3,6 +3,14 @@
 src/MacVim/MacVim.xcodeproj/*.mode1
 src/MacVim/MacVim.xcodeproj/*.mode1v3
 src/MacVim/MacVim.xcodeproj/*.pbxuser
+src/MacVim/icons/*.pyc
+src/MacVim/icons/*.ttf
+src/MacVim/icons/*.reg
+src/MacVim/icons/*.zip
+src/MacVim/icons/*.txt
+src/MacVim/icons/*.so
+src/MacVim/icons/*.egg-info
+src/MacVim/icons/build
 src/MacVim/icons/makeicns/*.o
 src/MacVim/icons/makeicns/makeicns
 src/MacVim/PSMTabBarControl/PSMTabBarControl.xcodeproj/*.mode1

runtime/doc/gui_x11.txt

@@ -63,7 +63,8 @@ already running vim will never fork in MacVim.
 "gvim --nofork" does the same as "gvim -f".
 
 If you want the GUI to run in the foreground always, include the 'f'
-flag in 'guioptions'.  |-f|.
+flag in 'guioptions'.  |-f|.  MacVim does not support this flag in
+'guioptions'.
 
 ==============================================================================
 2. GUI Resources			*gui-resources* *.Xdefaults*

runtime/doc/netbeans.txt

@@ -1,4 +1,4 @@
-*netbeans.txt*  For Vim version 7.2.  Last change: 2008 Jun 28
+*netbeans.txt*  For Vim version 7.2.  Last change: 2009 Jan 06
 
 
 		  VIM REFERENCE MANUAL    by Gordon Prieur et al.
@@ -722,8 +722,10 @@ keyAtPos keyName lnum/col
 		of the cursor.
 		New in version 2.1.
 
-killed		A file was closed by the user.  Only for files that have been
-		assigned a number by the IDE.
+killed		A file was deleted or wiped out by the user and the buffer
+		annotations have been removed.  The bufID number for this
+		buffer has become invalid.  Only for files that have been
+		assigned a bufID number by the IDE.
 
 newDotAndMark off off
 		Reports the position of the cursor being at "off" bytes into

runtime/doc/options.txt

@@ -3490,6 +3490,8 @@ A jump table for the options with a short description can be found at |Q_op|.
 		foreground.  |gui-fork|
 		Note: Set this option in the vimrc file.  The forking may have
 		happened already when the |gvimrc| file is read.
+		MacVim does not support this flag due to limitations with
+		forking on Mac OS X.
 								*'go-i'*
 	  'i'	Use a Vim icon.  For GTK with KDE it is used in the left-upper
 		corner of the window.  It's black&white on non-GTK, because of

src/MacVim/Credits.rtf

@@ -1,4 +1,4 @@
-{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf350
+{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf430
 {\fonttbl\f0\fswiss\fcharset0 Helvetica;}
 {\colortbl;\red255\green255\blue255;}
 \vieww9000\viewh8400\viewkind0
@@ -40,8 +40,6 @@ Thank you to {\field{\*\fldinst{HYPERLINK "http://www.positivespinmedia.com"}}{\
 \
 Toolbar icons by {\field{\*\fldinst{HYPERLINK "http://www.mattballdesign.com/"}}{\fldrslt Matt Ball}} (free Developer Icons), {\field{\*\fldinst{HYPERLINK "http://www.jonasraskdesign.com/"}}{\fldrslt Jonas Rask}} (Danish Royalty Free icon set), and {\field{\*\fldinst{HYPERLINK "http://www.everaldo.com"}}{\fldrslt Everaldo Coelho}} (Crystal Project Icons, released under LGPL license).\
 \
-Vim icons made by {\field{\*\fldinst{HYPERLINK "http://www.cs.princeton.edu/~mtwebb/vim_icon/vim_icons.html"}}{\fldrslt Matthew Webb}}.\
-\
 The default font in MacVim, DejaVu Sans Mono, is based on the Bitstream Vera\'99 and Arev fonts.  Bitstream Vera\'99 is \'a9 2003 by Bitstream, Inc.  Arev is \'a9 2006 by Tavmjong Bah.  The DejaVu changes to these fonts are in the public domain.\
 \
 Thanks to Andy Matuschak for {\field{\*\fldinst{HYPERLINK "http://sparkle.andymatuschak.org/"}}{\fldrslt Sparkle}}.\
@@ -52,4 +50,6 @@ Thanks to Allan Odgaard for making the "Edit in TextMate" input manager source c
 \
 Thanks to Rainer Brockerhoff for RBSplitView.\
 \
-Thanks to Chad Weider for CTGradient.}
+Thanks to Chad Weider for CTGradient.\
+\
+Thanks to Damien Guard for {\field{\*\fldinst{HYPERLINK "http://damieng.com/blog/2008/05/26/envy-code-r-preview-7-coding-font-released"}}{\fldrslt Envy Code R}} (used in MacVim's 16x16 document icons).}

src/MacVim/Info.plist

@@ -1153,7 +1153,7 @@
 		</dict>
 	</array>
 	<key>CFBundleVersion</key>
-	<string>41</string>
+	<string>43</string>
 	<key>NSMainNibFile</key>
 	<string>MainMenu</string>
 	<key>NSPrincipalClass</key>

src/MacVim/MMAppController.m

@@ -341,14 +341,17 @@ fsEventCallback(ConstFSEventStreamRef streamRef,
     // The user default MMUntitledWindow can be set to control whether an
     // untitled window should open on 'Open' and 'Reopen' events.
     int untitledWindowFlag = [ud integerForKey:MMUntitledWindowKey];
-    if ([desc eventID] == kAEOpenApplication
-            && (untitledWindowFlag & MMUntitledWindowOnOpen) == 0)
+
+    BOOL isAppOpenEvent = [desc eventID] == kAEOpenApplication;
+    if (isAppOpenEvent && (untitledWindowFlag & MMUntitledWindowOnOpen) == 0)
         return NO;
-    else if ([desc eventID] == kAEReopenApplication
+
+    BOOL isAppReopenEvent = [desc eventID] == kAEReopenApplication;
+    if (isAppReopenEvent
             && (untitledWindowFlag & MMUntitledWindowOnReopen) == 0)
         return NO;
 
-    // When a process is started from the command line, the 'Open' event will
+    // When a process is started from the command line, the 'Open' event may
     // contain a parameter to surpress the opening of an untitled window.
     desc = [desc paramDescriptorForKeyword:keyAEPropData];
     desc = [desc paramDescriptorForKeyword:keyMMUntitledWindow];
@@ -361,8 +364,12 @@ fsEventCallback(ConstFSEventStreamRef streamRef,
         return NO;
 
     // NOTE!  This way it possible to start the app with the command-line
-    // argument '-nowindow yes' and no window will be opened by default.
-    return ![ud boolForKey:MMNoWindowKey];
+    // argument '-nowindow yes' and no window will be opened by default but
+    // this argument will only be heeded when the application is opening.
+    if (isAppOpenEvent && [ud boolForKey:MMNoWindowKey] == YES)
+        return NO;
+
+    return YES;
 }
 
 - (BOOL)applicationOpenUntitledFile:(NSApplication *)sender
@@ -830,6 +837,17 @@ fsEventCallback(ConstFSEventStreamRef streamRef,
             firstController = vc;
     }
 
+    // The meaning of "layout" is defined by the WIN_* defines in main.c.
+    NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
+    int layout = [ud integerForKey:MMOpenLayoutKey];
+    BOOL splitVert = [ud boolForKey:MMVerticalSplitKey];
+    BOOL openInCurrentWindow = [ud boolForKey:MMOpenInCurrentWindowKey];
+
+    if (splitVert && MMLayoutHorizontalSplit == layout)
+        layout = MMLayoutVerticalSplit;
+    if (layout < 0 || (layout > MMLayoutTabs && openInCurrentWindow))
+        layout = MMLayoutTabs;
+
     if ([filenames count] == 0) {
         // Raise the window containing the first file that was already open,
         // and make sure that the tab containing that file is selected.  Only
@@ -837,10 +855,18 @@ fsEventCallback(ConstFSEventStreamRef streamRef,
         // the window with 'firstFile' will be raised, other times it might be
         // the window that will open with the files in the 'filenames' array.
         firstFile = [firstFile stringByEscapingSpecialFilenameCharacters];
+
+        NSString *bufCmd = @"tab sb";
+        switch (layout) {
+            case MMLayoutHorizontalSplit: bufCmd = @"sb"; break;
+            case MMLayoutVerticalSplit:   bufCmd = @"vert sb"; break;
+            case MMLayoutArglist:         bufCmd = @"b"; break;
+        }
+
         NSString *input = [NSString stringWithFormat:@"<C-\\><C-N>"
                 ":let oldswb=&swb|let &swb=\"useopen,usetab\"|"
-                "tab sb %@|let &swb=oldswb|unl oldswb|"
-                "cal foreground()<CR>", firstFile];
+                "%@ %@|let &swb=oldswb|unl oldswb|"
+                "cal foreground()<CR>", bufCmd, firstFile];
 
         [firstController addVimInput:input];
 
@@ -857,23 +883,13 @@ fsEventCallback(ConstFSEventStreamRef streamRef,
     //
     // b) Open any remaining files
     //
-    MMVimController *vc;
-    NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
-    BOOL openInCurrentWindow = [ud boolForKey:MMOpenInCurrentWindowKey];
-
-    // The meaning of "layout" is defined by the WIN_* defines in main.c.
-    int layout = [ud integerForKey:MMOpenLayoutKey];
-    BOOL splitVert = [ud boolForKey:MMVerticalSplitKey];
-    if (splitVert && MMLayoutHorizontalSplit == layout)
-        layout = MMLayoutVerticalSplit;
-    if (layout < 0 || (layout > MMLayoutTabs && openInCurrentWindow))
-        layout = MMLayoutTabs;
 
     [arguments setObject:[NSNumber numberWithInt:layout] forKey:@"layout"];
     [arguments setObject:filenames forKey:@"filenames"];
     // (Indicate that files should be opened from now on.)
     [arguments setObject:[NSNumber numberWithBool:NO] forKey:@"dontOpen"];
 
+    MMVimController *vc;
     if (openInCurrentWindow && (vc = [self topmostVimController])) {
         // Open files in an already open window.
         [[[vc windowController] window] makeKeyAndOrderFront:self];
@@ -1315,10 +1331,21 @@ fsEventCallback(ConstFSEventStreamRef streamRef,
     }
 
     if (-1 != pid) {
-        // Add a null argument to the pidArguments dictionary.  This is later
-        // used to detect that a process without arguments is being launched.
-        [pidArguments setObject:[NSNull null]
-                         forKey:[NSNumber numberWithInt:pid]];
+        // The 'pidArguments' dictionary keeps arguments to be passed to the
+        // process when it connects (this is in contrast to arguments which are
+        // passed on the command line, like '-f' and '-g').
+        // If this method is called with nil arguments we take this as a hint
+        // that this is an "untitled window" being launched and add a null
+        // object to the 'pidArguments' dictionary.  This way we can detect if
+        // an untitled window is being launched by looking for null objects in
+        // this dictionary.
+        // If this method is called with non-nil arguments then it is assumed
+        // that the caller takes care of adding items to 'pidArguments' as
+        // necessary (only some arguments are passed on connect, e.g. files to
+        // open).
+        if (!args)
+            [pidArguments setObject:[NSNull null]
+                             forKey:[NSNumber numberWithInt:pid]];
     } else {
         NSLog(@"WARNING: %s%@ failed (useLoginShell=%d)", _cmd, args,
                 useLoginShell);

src/MacVim/MMBackend.m

@@ -342,7 +342,7 @@ extern GuiFont gui_mch_retain_font(GuiFont font);
         frontendProxy = [proxy connectBackend:self pid:pid];
         if (frontendProxy) {
             [frontendProxy retain];
-            [frontendProxy setProtocolForProxy:@protocol(MMAppProtocol)];
+            [frontendProxy setProtocolForProxy:@protocol(MMFrontendProtocol)];
             ok = YES;
         }
     }
@@ -1060,9 +1060,11 @@ extern GuiFont gui_mch_retain_font(GuiFont font);
         }
     } else if (TerminateNowMsgID == msgid) {
         // Terminate immediately (the frontend is about to quit or this process
-        // was aborted).
+        // was aborted).  Don't preserve modified files since the user would
+        // already have been presented with a dialog warning if there were any
+        // modified files when we get here.
         isTerminating = YES;
-        mch_exit(0);
+        getout(0);
         return;
     }
 
@@ -2522,9 +2524,7 @@ extern GuiFont gui_mch_retain_font(GuiFont font);
 
     NSString *searchText = [args objectForKey:@"searchText"];
     if (searchText) {
-        // TODO: Searching is an exclusive motion, so if the pattern would
-        // match on row 0 column 0 then this pattern will miss that match.
-        [self addInput:[NSString stringWithFormat:@"<C-\\><C-N>gg/\\c%@<CR>",
+        [self addInput:[NSString stringWithFormat:@"<C-\\><C-N>gg/\\c%@/e<CR>",
                 searchText]];
     }
 }

src/MacVim/MMTextViewHelper.m

@@ -52,7 +52,9 @@ static float MMDragAreaSize = 73.0f;
 
 - (void)dealloc
 {
+    [insertionPointColor release];  insertionPointColor = nil;
     [markedText release];  markedText = nil;
+    [markedTextAttributes release];  markedTextAttributes = nil;
 
     [super dealloc];
 }
@@ -100,14 +102,13 @@ static float MMDragAreaSize = 73.0f;
     int flags = [event modifierFlags];
     if ((flags & NSControlKeyMask) ||
             ((flags & NSAlternateKeyMask) && (flags & NSFunctionKeyMask))) {
-        NSString *unmod = [event charactersIgnoringModifiers];
-        if ([unmod length] == 1 && [unmod characterAtIndex:0] <= 0x7f
-                                && [unmod characterAtIndex:0] >= 0x60) {
-            // HACK! Send Ctrl-letter keys (and C-@, C-[, C-\, C-], C-^, C-_)
-            // as normal text to be added to the Vim input buffer.  This must
-            // be done in order for the backend to be able to separate e.g.
-            // Ctrl-i and Ctrl-tab.
-            [self insertText:[event characters]];
+        NSString *chars = [event characters];
+        if ([chars length] == 1 && [chars characterAtIndex:0] < 0x20) {
+            // HACK! Send unprintable characters (such as C-@, C-[, C-\, C-],
+            // C-^, C-_) as normal text to be added to the Vim input buffer.
+            // This must be done in order for the backend to be able to
+            // separate e.g. Ctrl-i and Ctrl-tab.
+            [self insertText:chars];
         } else {
             [self dispatchKeyEvent:event];
         }
@@ -745,7 +746,7 @@ static float MMDragAreaSize = 73.0f;
     NSString *chars = [event characters];
     NSString *unmodchars = [event charactersIgnoringModifiers];
     unichar c = [chars characterAtIndex:0];
-    unichar imc = [unmodchars characterAtIndex:0];
+    unichar imc = [unmodchars length] > 0 ? [unmodchars characterAtIndex:0] : 0;
     int len = 0;
     const char *bytes = 0;
     int mods = [event modifierFlags];

src/MacVim/MMVimController.m

@@ -252,6 +252,10 @@ static BOOL isUnsafeMessage(int msgid);
     if (layout < 0 || layout > MMLayoutTabs)
         layout = MMLayoutTabs;
 
+    BOOL splitVert = [ud boolForKey:MMVerticalSplitKey];
+    if (splitVert && MMLayoutHorizontalSplit == layout)
+        layout = MMLayoutVerticalSplit;
+
     NSDictionary *args = [NSDictionary dictionaryWithObjectsAndKeys:
             [NSNumber numberWithInt:layout],    @"layout",
             filenames,                          @"filenames",

src/MacVim/MacVim.m

@@ -29,7 +29,7 @@ char *MessageStrings[] =
     "ShowTabBarMsgID",
     "HideTabBarMsgID",
     "SetTextRowsMsgID",
-    "SetTextColumsMsgID",
+    "SetTextColumnsMsgID",
     "SetTextDimensionsMsgID",
     "LiveResizeMsgID",
     "SetTextDimensionsReplyMsgID",

src/MacVim/MacVim.xcodeproj/project.pbxproj

@@ -737,7 +737,7 @@
 					i386,
 				);
 				COPY_PHASE_STRIP = YES;
-				CURRENT_PROJECT_VERSION = 41;
+				CURRENT_PROJECT_VERSION = 43;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(inherited)",
 					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
@@ -778,7 +778,7 @@
 			buildSettings = {
 				ARCHS = "$(NATIVE_ARCH)";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 41;
+				CURRENT_PROJECT_VERSION = 43;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(inherited)",
 					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
@@ -810,7 +810,7 @@
 			buildSettings = {
 				ARCHS = "$(NATIVE_ARCH)";
 				COPY_PHASE_STRIP = YES;
-				CURRENT_PROJECT_VERSION = 41;
+				CURRENT_PROJECT_VERSION = 43;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(inherited)",
 					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",

src/MacVim/gui_macvim.m

@@ -25,7 +25,6 @@ static NSString *MMDefaultFontName = @"DejaVu Sans Mono";
 static int MMDefaultFontSize       = 12;
 static int MMMinFontSize           = 6;
 static int MMMaxFontSize           = 100;
-static BOOL gui_mch_init_has_finished = NO;
 
 
 static GuiFont gui_macvim_font_with_name(char_u *name);
@@ -99,15 +98,6 @@ gui_mch_init(void)
 {
     //NSLog(@"gui_mch_init()");
 
-    // NOTE! Because OS X has to exec after fork we effectively end up doing
-    // the initialization twice (because this function is called before the
-    // fork).  To avoid all this extra work we check if Vim is about to fork,
-    // and if so do nothing for now.
-    //
-    // TODO: Is this check 100% foolproof?
-    if (gui.dofork && (vim_strchr(p_go, GO_FORG) == NULL))
-        return OK;
-
     if (![[MMBackend sharedInstance] checkin]) {
         // TODO: Kill the process if there is no terminal to fall back on,
         // otherwise the process will run outputting to the console.
@@ -140,8 +130,6 @@ gui_mch_init(void)
     // in [g]vimrc.
     gui_mch_adjust_charheight();
 
-    gui_mch_init_has_finished = YES;
-
     return OK;
 }
 
@@ -162,12 +150,6 @@ gui_mch_exit(int rc)
     int
 gui_mch_open(void)
 {
-    //NSLog(@"gui_mch_open()");
-
-    // This check is to avoid doing extra work when we're about to fork.
-    if (!gui_mch_init_has_finished)
-        return OK;
-
     return [[MMBackend sharedInstance] openGUIWindow];
 }
 
@@ -234,13 +216,13 @@ gui_macvim_flush(void)
     if (delta > 1.0)
         delay = 1;
 
-    // We assume that each call corresponds roughly to one line out output.
+    // We assume that each call corresponds roughly to one line of output.
     // When one page has scrolled by we increase the delay before the next
     // flush.
     if (++scrolls > gui.num_rows) {
         delay <<= 1;
-        if (delay > 0x10000)
-            delay = 0x10000;
+        if (delay > 2048)
+            delay = 2048;
         scrolls = 0;
     }
 
@@ -1718,6 +1700,9 @@ gui_mch_leave_fullscreen()
     void
 gui_mch_fuopt_update()
 {
+    if (!gui.in_use)
+        return;
+
     guicolor_T fg, bg;
     if (fuoptions_flags & FUOPT_BGCOLOR_HLGROUP) {
         syn_id2colors(fuoptions_bgcolor, &fg, &bg);

src/MacVim/icons/Makefile

@@ -2,10 +2,25 @@
 
 OUTDIR ?= .
 
-$(OUTDIR)/MacVim-generic.icns: make_icons.py vim-noshadow-512.png
+$(OUTDIR)/MacVim-generic.icns: make_icons.py vim-noshadow-512.png loadfont.so Envy\ Code\ R\ Bold.ttf
 	$(MAKE) -C makeicns
 	/usr/bin/python make_icons.py $(OUTDIR)
 
+loadfont.so: loadfont.c
+	python setup.py install --install-lib .
+
+Envy\ Code\ R\ Bold.ttf: EnvyCodeR.zip
+	unzip -jo EnvyCodeR.zip
+	# unzip uses the file date from the zip file. Change the file date to
+	# "now", so that the zip is not unzipped in every `make` run.`
+	touch Envy\ Code\ R\ Bold.ttf
+
+ENVYCODE_URL=http://download.damieng.com/latest/EnvyCodeR
+EnvyCodeR.zip:
+	curl ${ENVYCODE_URL} --location -o EnvyCodeR.zip
+
 clean:
 	$(MAKE) -C makeicns clean
-	rm -f $(OUTDIR)/MacVim-*.icns
+	rm -f $(OUTDIR)/MacVim-*.icns loadfont.so *.pyc \
+	  EnvyCodeR.zip *.ttf *.reg *.txt
+	rm -rf *.egginfo build  # Created by setup.py

src/MacVim/icons/docerator.py

@@ -0,0 +1,605 @@
+from Foundation import *
+from AppKit import *
+
+import itertools
+import math
+import operator
+import os
+
+from optparse import OptionParser
+
+
+# Resources
+DEFAULT_BACKGROUND = '/System/Library/CoreServices/CoreTypes.bundle/' + \
+    'Contents/Resources/GenericDocumentIcon.icns'  # might require leopard?
+
+
+# Cache both images and background renderers globally
+imageCache = {}
+bgCache = {}
+
+
+# Make us not crash
+# http://www.cocoabuilder.com/archive/message/cocoa/2008/8/6/214964
+NSApplicationLoad()
+
+
+class Surface(object):
+  """Represents a simple bitmapped image."""
+
+  def __init__(self, *p, **kw):
+    if not 'premultiplyAlpha' in kw:
+      kw['premultiplyAlpha'] = True
+    if len(p) == 1 and isinstance(p[0], NSBitmapImageRep):
+      self.bitmapRep = p[0]
+    elif len(p) == 2 and isinstance(p[0], int) and isinstance(p[1], int):
+      format = NSAlphaFirstBitmapFormat
+      if not kw['premultiplyAlpha']:
+        format += NSAlphaNonpremultipliedBitmapFormat
+      self.bitmapRep = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bitmapFormat_bytesPerRow_bitsPerPixel_(
+          None, p[0], p[1], 8, 4, True, False, NSDeviceRGBColorSpace,
+          format, 0, 0)
+
+    if not hasattr(self, 'bitmapRep') or not self.bitmapRep:
+      raise Exception('Failed to create surface: ' + str(p))
+
+  def size(self):
+    return map(int, self.bitmapRep.size())  # cocoa returns floats. cocoa ftw
+
+  def data(self):
+    """Returns data in ARGB order (on intel, at least)."""
+    r = self.bitmapRep
+    if r.bitmapFormat() != (NSAlphaNonpremultipliedBitmapFormat |
+          NSAlphaFirstBitmapFormat) or \
+        r.bitsPerPixel() != 32 or \
+        r.isPlanar() or \
+        r.samplesPerPixel() != 4:
+      raise Exception("Unsupported image format")
+    return self.bitmapRep.bitmapData()
+
+  def save(self, filename):
+    """Saves image as png file."""
+    self.bitmapRep.representationUsingType_properties_(NSPNGFileType, None) \
+        .writeToFile_atomically_(filename, True)
+
+  def draw(self):
+    self.bitmapRep.draw()
+
+  def context(self):
+    # Note: Cocoa only supports contexts with premultiplied alpha
+    return NSGraphicsContext.graphicsContextWithBitmapImageRep_(self.bitmapRep)
+
+  def copy(self):
+    return Surface(self.bitmapRep.copy())
+
+
+class Image(object):
+  """Represents an image that can consist of several Surfaces."""
+
+  def __init__(self, param):
+    if isinstance(param, str):
+      self.image = NSImage.alloc().initWithContentsOfFile_(param)
+    elif isinstance(param, Surface):
+      self.image = NSImage.alloc().initWithSize_( param.size() )
+      self.image.addRepresentation_(param.bitmapRep)
+
+    if not self.image:
+      raise Exception('Failed to load image: ' + str(param))
+
+  def surfaceOfSize(self, w, h):
+    """Returns an ARGB, non-premultiplied surface of size w*h or throws."""
+    r = None
+    for rep in self.image.representations():
+      # Cocoa reports fraction widths for pngs (wtf?!), so use round()
+      if map(lambda x: int(round(x)), rep.size()) == [w, h]:
+        r = rep
+        break
+
+    # XXX: Resample in this case? That'd make the program easier to use, but
+    #      can silently create blurry backgrounds. Since this happens with
+    #      the app icon anyways, this might not be a huge deal?
+    if not r:
+      raise Exception('Unsupported size %dx%d', w, h)
+    return Surface(r)
+
+  def blend(self):
+    self.compositeInRect( ((0, 0), self.image.size()) )
+
+  def compositeInRect(self, r, mode=NSCompositeSourceOver):
+    self.image.drawInRect_fromRect_operation_fraction_(r, NSZeroRect,
+        mode, 1.0)
+
+  def sizes(self):
+    s = set()
+    for rep in self.image.representations():
+      s.add(tuple(map(lambda x: int(round(x)), rep.size())))
+    return s
+
+
+class Context(object):
+  # Tiger has only Python2.3, so we can't use __enter__ / __exit__ for this :-(
+
+  def __init__(self, surface):
+    NSGraphicsContext.saveGraphicsState()
+    c = surface.context()
+    c.setShouldAntialias_(True);
+    c.setImageInterpolation_(NSImageInterpolationHigh);
+    NSGraphicsContext.setCurrentContext_(c)
+
+  def done(self):
+    NSGraphicsContext.restoreGraphicsState()
+
+
+class SplittableBackground(object):
+
+  def __init__(self, unsplitted, shouldSplit=True):
+    self.unsplitted = unsplitted
+    self.shouldSplit = shouldSplit
+    self.ground = {}
+    self.shadow = {}
+
+  def rawGroundAtSize(self, s):
+    return self.unsplitted.surfaceOfSize(s, s)
+
+  def groundAtSize(self, s):
+    if not self.shouldSplit:
+      return self.rawGroundAtSize(s)
+    self._performSplit(s)
+    return self.ground[s]
+
+  def shadowAtSize(self, s):
+    if not self.shouldSplit:
+      return None
+    self._performSplit(s)
+    return self.shadow[s]
+
+  def _performSplit(self, s):
+    if s in self.ground:
+      assert s in self.shadow
+      return
+    assert s not in self.shadow
+    ground, shadow = splitGenericDocumentIcon(self.unsplitted, s)
+    self.ground[s] = ground
+    self.shadow[s] = shadow
+
+
+class BackgroundRenderer(object):
+
+  def __init__(self, bg, icon=None, r={}):
+    self.bgRenderer = bg
+    self.icon = icon
+    self.cache = {}
+    self.rect = r
+
+  def drawIcon(self, s):
+    if not self.icon:
+      return
+
+    assert s in [16, 32, 128, 256, 512]
+    a = list(self.rect[s])
+
+    # convert from `flow` coords to cocoa
+    a[2] = -a[2]  # mirror y
+
+    w, h = s*a[1], s*a[3]
+    self.icon.compositeInRect( (((s-w)/2 + a[0], (s-h)/2 + a[2]), (w, h)) )
+
+  def drawAtSize(self, s):
+    if not self.icon:
+      # No need to split the background if no icons is interleaved -- take
+      # the faster code path in that case.
+      self.bgRenderer.rawGroundAtSize(s).draw()
+      return
+
+    self.bgRenderer.groundAtSize(s).draw()
+    self.drawIcon(s)
+    if self.bgRenderer.shouldSplit:
+      # shadow needs to be composited, so it needs to be in an image
+      Image(self.bgRenderer.shadowAtSize(s)).blend()
+
+  def backgroundAtSize(self, s):
+    if not s in self.cache:
+      result = Surface(s, s)
+      context = Context(result)
+      self.drawAtSize(s)
+      context.done()
+      self.cache[s] = result
+    return self.cache[s]
+
+
+def splitGenericDocumentIcon(img, s):
+  """Takes the generic document icon and splits it into a background and a
+  shadow layer. For the 32x32 and 16x16 variants, the white pixels of the page
+  curl are hardcoded into the otherwise transparent shadow layer."""
+
+  w, h = s, s
+  r = img.surfaceOfSize(w, h)
+  bps = 4*w
+  data = r.data()
+
+  ground = Surface(w, h, premultiplyAlpha=False)
+  shadow = Surface(w, h, premultiplyAlpha=False)
+
+  grounddata = ground.data()
+  shadowdata = shadow.data()
+
+  for y in xrange(h):
+    for x in xrange(w):
+      idx = y*bps + 4*x
+      ia, ir, ig, ib = data[idx:idx + 4]
+      if ia != chr(255):
+        # buffer objects don't support slice assignment :-(
+        grounddata[idx] = ia
+        grounddata[idx + 1] = ir
+        grounddata[idx + 2] = ig
+        grounddata[idx + 3] = ib
+        shadowdata[idx] = chr(0)
+        shadowdata[idx + 1] = chr(0)
+        shadowdata[idx + 2] = chr(0)
+        shadowdata[idx + 3] = chr(0)
+        continue
+
+      assert ir == ig == ib
+      grounddata[idx] = chr(255)
+      grounddata[idx + 1] = chr(255)
+      grounddata[idx + 2] = chr(255)
+      grounddata[idx + 3] = chr(255)
+      shadowdata[idx] = chr(255 - ord(ir))
+      shadowdata[idx + 1] = chr(0)
+      shadowdata[idx + 2] = chr(0)
+      shadowdata[idx + 3] = chr(0)
+
+  # Special-case 16x16 and 32x32 cases: Make some pixels on the fold white.
+  # Ideally, I could make the fold whiteish in all variants, but I can't.
+  whitePix = { 16: [(10, 2), (10, 3), (11, 3), (10, 4), (11, 4), (12, 4)],
+               32: [(21, 4), (21, 5), (22, 5), (21, 6), (22, 6), (23, 6)]}
+  if (w, h) in [(16, 16), (32, 32)]:
+    for x, y in whitePix[w]:
+      idx = y*bps + 4*x
+      shadowdata[idx] = chr(255)
+      shadowdata[idx + 1] = chr(255)
+      shadowdata[idx + 2] = chr(255)
+      shadowdata[idx + 3] = chr(255)
+
+  return ground, shadow
+
+
+class TextRenderer(object):
+
+  def __init__(self):
+    self.cache = {}
+
+  def attribsAtSize(self, s):
+    if s not in self.cache:
+      self.cache[s] = self._attribsAtSize(s)
+    return self.cache[s]
+
+  def centeredStyle(self):
+    style = NSMutableParagraphStyle.new()
+    style.setParagraphStyle_(NSParagraphStyle.defaultParagraphStyle())
+    style.setAlignment_(NSCenterTextAlignment)
+    return style
+
+  def _attribsAtSize(self, s):
+    # This looks not exactly like the font on Preview.app's document icons,
+    # but I believe that's because Preview's icons are drawn by Photoshop,
+    # and Adobe's font rendering is different from Apple's.
+    fontname = 'LucidaGrande-Bold'
+
+    # Prepare text format
+    fontsizes = { 512: 72.0,  256: 36.0,  128: 18.0,  32: 7.0,  16: 3.0 }
+    # http://developer.apple.com/documentation/Cocoa/Conceptual/AttributedStrings/Articles/standardAttributes.html#//apple_ref/doc/uid/TP40004903
+    attribs = {
+      NSParagraphStyleAttributeName: self.centeredStyle(),
+      NSForegroundColorAttributeName: NSColor.colorWithDeviceWhite_alpha_(
+          0.34, 1),
+      NSFontAttributeName: NSFont.fontWithName_size_(fontname, fontsizes[s])
+    }
+
+    # tighten font a bit for some sizes
+    if s in [256, 512]:
+      attribs[NSKernAttributeName] = -1.0
+    elif s == 32:
+      attribs[NSKernAttributeName] = -0.25
+
+    if not attribs[NSFontAttributeName]:
+      raise Exception('Failed to load font %s' % fontname)
+    return attribs
+
+  def drawTextAtSize(self, text, s):
+    """Draws text `s` into the current context of size `s`."""
+
+    textRects = {
+        512: ((0, 7), (512, 119)),
+        128: ((0, 6), (128, 26.5)),
+        256: ((0, 7), (256, 57)),
+         16: ((1, 1), (15, 5)),
+         #32: ((1, 1), (31, 9))
+        }
+
+    attribs = self.attribsAtSize(s)
+    text = NSString.stringWithString_(text)
+    if s in [16, 128, 256, 512]:
+      text.drawInRect_withAttributes_(textRects[s], attribs)
+    elif s == 32:
+      # Try to align text on pixel boundary:
+      attribs = attribs.copy()
+      attribs[NSParagraphStyleAttributeName] = \
+          NSParagraphStyle.defaultParagraphStyle()
+      ts = text.sizeWithAttributes_(attribs)
+      text.drawAtPoint_withAttributes_( (math.floor((32.0-ts[0])/2) + 0.5, 1.5),
+          attribs)
+
+
+class OfficeTextRenderer(TextRenderer):
+  """Uses Office's LucidaSans font for 32x32.
+
+  This font looks much better for certain strings (e.g. "PDF") but much worse
+  for most others (e.g. "VIM", "JAVA") -- and office fonts are usually not
+  installed. Hence, this class is better not used.
+  """
+
+  def _attribsAtSize(self, s):
+    self.useOfficeFont = False
+    attribs = TextRenderer._attribsAtSize(self, s)
+    if s == 32:
+      font = NSFont.fontWithName_size_('LucidaSans-Demi', 7.0)
+      if font:
+        attribs[NSFontAttributeName] = font
+        attribs[NSKernAttributeName] = 0
+        self.useOfficeFont = True
+    return attribs
+
+  def drawTextAtSize(self, text, s):
+    attribs = self.attribsAtSize(s)
+    if not self.useOfficeFont or s != 32:
+      TextRenderer.drawTextAtSize(self, text, s)
+      return
+    text = NSString.stringWithString_(text)
+    text.drawInRect_withAttributes_( ((0, 1), (31, 11)), attribs)
+
+
+def createIcon(s, bg, textRenderer, text):
+
+  # Fill in background
+  output = bg.backgroundAtSize(s).copy()
+
+  # Draw text on top of shadow
+  context = Context(output)
+  if s in text and text[s]:
+    textRenderer.drawTextAtSize(text[s], s)
+  context.done()
+
+  return output
+
+
+def textDictFromTextList(l):
+  assert 1 <= len(l) <= 3
+  if len(l) == 1:
+    return dict.fromkeys([16, 32, 128, 256, 512], l[0])
+  elif len(l) == 2:
+    return dict(zip([16, 32], 2*[l[1]]) + zip((128, 256, 512), 3*[l[0]]))
+  elif len(l) == 3:
+    return dict([(16, l[2]), (32, l[1])] + zip((128, 256, 512), 3*[l[0]]))
+
+
+def saveIcns(icons, icnsName, makeIcns='./makeicns'):
+  """Creates an icns file with several variants.
+
+  Params:
+    icons: A dict that contains icon size as key and Surface as value.
+           Valid keys are 512, 256, 128, 32, 16
+    icnsname: Name of the output file
+  """
+  # If IconFamily was less buggy, we could wrap it into a python module and
+  # call it directly, which is about a lot faster. However, IconFamily does not
+  # work with NSAlphaNonpremultipliedBitmapFormat correctly, so this has to
+  # wait.
+  #import IconFamily
+  #typeDict = {
+      #16: IconFamily.kSmall32BitData,
+      #32: IconFamily.kLarge32BitData,
+      #128: IconFamily.kThumbnail32BitData,
+      #256: IconFamily.kIconServices256PixelDataARGB,
+      #512: IconFamily.IconServices512PixelDataARGB,
+  #}
+  #maskDict = {
+      #16: IconFamily.kSmall8BitMask,
+      #32: IconFamily.kLarge8BitMask,
+      #128: IconFamily.kThumbnail8BitMask,
+  #}
+  #output = IconFamily.IconFamily.iconFamily()
+  #for s, icon in icons.items():
+    #output.setIconFamilyElement_fromBitmapImageRep_(typeDict[s], icon.bitmapRep)
+    #if s in maskDict:
+      #output.setIconFamilyElement_fromBitmapImageRep_(
+          #maskDict[s], icon.bitmapRep)
+  #output.writeToFile_(icnsName)
+  TMPFILE = 'docerator_tmp_%d.png'
+  try:
+    args = []
+    for s, icon in icons.items():
+      assert s in [512, 256, 128, 32, 16]
+      assert icon.size() == [s, s]
+      icon.save(TMPFILE % s)
+      args.append('-%d %s' % (s, TMPFILE % s))
+    return \
+        os.system('%s %s -out %s' % (makeIcns, ' '.join(args), icnsName)) == 0
+  finally:
+    for s in icons:
+      if os.access(TMPFILE % s, os.F_OK):
+        os.remove(TMPFILE % s)
+
+
+def getOutname(options):
+  def saneBasename(p):
+    """ '/my/path/to/file.txt' -> 'file' """
+    return os.path.splitext(os.path.basename(p))[0]
+  textPart = 'Generic'
+  if options.text:
+    textPart = options.text.split(',')[0]
+  if options.appicon:
+    base = saneBasename(options.appicon)
+  else:
+    base = saneBasename(getBgName(options))
+  return '%s-%s.icns' % (base, textPart)
+
+
+def cachedImage(filename):
+  absPath = os.path.abspath(filename)
+  if not absPath in imageCache:
+    imageCache[absPath] = Image(absPath)
+  return imageCache[absPath]
+
+
+def cachedBackground(img, split):
+  key = (img, split)
+  if not key in bgCache:
+    bgCache[key] = SplittableBackground(img, shouldSplit=split)
+  return bgCache[key]
+
+
+# taken from running flow on preview
+defaultRects = {
+    16: (-0.30890000000000001, 0.4919, -1.2968, 0.4743),
+    32: (-0.27810000000000001,
+      0.58930000000000005,
+      -2.2292999999999998,
+      0.57140000000000002),
+    128: (1.1774, 0.56820000000000004, -0.8246, 0.56799999999999995),
+    256: (0.5917, 0.56489999999999996, -1.8994, 0.56499999999999995),
+    512: (0.68700000000000006,
+      0.56530000000000002,
+      -4.2813999999999997,
+      0.56540000000000001)
+    }
+
+
+def getBgName(options):
+  if not hasattr(options, 'background') \
+      or options.background in ['default-split', 'default-unsplit']:
+    return DEFAULT_BACKGROUND
+  else:
+    return options.background
+
+
+class IconGenerator(object):
+  def __init__(self, options):
+    if hasattr(options, 'textrenderer') and options.textrenderer:
+      self.textRenderer = options.textrenderer()
+    else:
+      self.textRenderer = TextRenderer()
+    
+    # Prepare input images
+    splitBackground = options.background == 'default-split'
+    self.bgIcon = cachedImage(getBgName(options))
+
+    self.testIcon = None
+    if options.appicon:
+      self.testIcon = cachedImage(options.appicon)
+
+    rects = defaultRects.copy()
+    rects[16] = [ 0.0000, 0.5000, -1.0000, 0.5000]  # manually, better
+    if hasattr(options, 'rects'):
+      rects.update(options.rects)
+
+    bg = cachedBackground(self.bgIcon, splitBackground)
+
+    if hasattr(options, 'backgroundrenderer') and options.backgroundrenderer:
+      self.bgRenderer = options.backgroundrenderer(bg, self.testIcon, rects)
+    else:
+      self.bgRenderer = BackgroundRenderer(bg, self.testIcon, rects)
+
+    self.testtext = textDictFromTextList(options.text.split(','))
+
+  def createIconAtSize(self, s):
+    return createIcon(s, self.bgRenderer, self.textRenderer, self.testtext)
+
+
+def iconGenerator(**kwargs):
+  return IconGenerator(optsFromDict(**kwargs))
+
+
+def makedocicon_opts(options):
+  renderer = IconGenerator(options)
+
+  if hasattr(options, 'sizes') and options.sizes:
+    if isinstance(options.sizes, list):
+      sizes = options.sizes
+    else:
+      sizes = map(int, options.sizes.split(','))
+  else:
+    sizes = renderer.bgIcon.sizes()
+    if renderer.testIcon:
+      sizes = sizes.intersection(renderer.testIcon.sizes())
+    sizes = sorted(map(operator.itemgetter(0), sizes))
+
+  icons = dict([(s, renderer.createIconAtSize(s)) for s in sizes])
+
+  if options.debug:
+    for s, icon in icons.iteritems():
+      icon.save(options.debug % s)
+
+  if hasattr(options, 'outname') and options.outname:
+    outname = options.outname
+  else:
+    outname = getOutname(options)
+  if saveIcns(icons, outname, options.makeicns):
+    print 'Wrote', outname
+  else:
+    print 'Failed to write %s. Make sure makeicns is in your path.' % outname
+
+
+def optsFromDict(**kwargs):
+  options, _ = getopts().parse_args([])  # get default options
+  for k in kwargs:
+    setattr(options, k, kwargs[k])
+  return options
+
+
+def makedocicon(**kwargs):
+  makedocicon_opts(optsFromDict(**kwargs))
+
+
+def makedocicons_opts(options):
+  if not hasattr(options, 'text') or not options.text:
+    options.text = ['']
+  texts = options.text
+  for text in texts:
+    options.text = text
+    makedocicon_opts(options)
+
+
+def makedocicons(**kwargs):
+  makedocicons_opts(optsFromDict(**kwargs))
+
+
+def getopts():
+  parser = OptionParser(usage='%prog [options]', version='%prog 1.01')
+  parser.add_option('--background', '--bg', default='default-split',
+      help='Used as background (special values: "default-split" (default), ' \
+          '"default-unsplit").')
+  parser.add_option('--appicon', help='App icon, defaults to no icon.')
+
+  parser.add_option('--text', help='Text on icon. Defaults to empty. '
+      'More than one text is supported, multiple docicons are generated in '
+      'that case.', action='append')
+  parser.add_option('--sizes', help='Sizes of icons. ' \
+      'Defaults to all sizes available in input appicon. Example: "512,128,16"')
+  # XXX(Nico): This has to go
+  parser.add_option('--debug', help='If set, write out pngs for all variants.' \
+      ' This needs to look like "debug%d.png".')
+  # XXX(Nico): This has to go once IconFamily is less buggy and can be used
+  # directly
+  parser.add_option('--makeicns', help='Path to makeicns binary',
+      default='./makeicns')
+  return parser
+
+
+def main():
+  options, args = getopts().parse_args()
+  makedocicons_opts(options)
+
+
+if __name__ == '__main__':
+  main()

src/MacVim/icons/docerator_test.py

@@ -0,0 +1,65 @@
+import docerator
+import unittest
+
+
+class TextDictFromTextListTest(unittest.TestCase):
+
+  def testBasic(self):
+
+    self.assertEquals({16: 'a', 32: 'a', 128: 'a', 256: 'a', 512: 'a'},
+        docerator.textDictFromTextList(['a']))
+    self.assertEquals({16: 'b', 32: 'b', 128: 'a', 256: 'a', 512: 'a'},
+        docerator.textDictFromTextList(['a', 'b']))
+    self.assertEquals({16: 'c', 32: 'b', 128: 'a', 256: 'a', 512: 'a'},
+        docerator.textDictFromTextList(['a', 'b', 'c']))
+
+
+class OutnameTest(unittest.TestCase):
+
+  class FakeOptions(object):
+    def __init__(self, **kwargs):
+      for k in kwargs:
+        self.__setattr__(k, kwargs[k])
+
+  def testBasic(self):
+    options = OutnameTest.FakeOptions(
+        appicon = '/Applications/iTunes.app/Contents/Resources/iTunes.icns',
+        text='MP3')
+    self.assertEquals('iTunes-MP3.icns', docerator.getOutname(options))
+
+  def testTextList(self):
+    options = OutnameTest.FakeOptions(
+        appicon = '/Applications/iTunes.app/Contents/Resources/iTunes.icns',
+        text='PYTHON,PY')
+    self.assertEquals('iTunes-PYTHON.icns',
+        docerator.getOutname(options))
+
+  def testEmptyText(self):
+    options = OutnameTest.FakeOptions(
+        appicon = '/Applications/iTunes.app/Contents/Resources/iTunes.icns',
+        text='')
+    self.assertEquals('iTunes-Generic.icns', docerator.getOutname(options))
+    options = OutnameTest.FakeOptions(
+        appicon = '/Applications/iTunes.app/Contents/Resources/iTunes.icns',
+        text=None)
+    self.assertEquals('iTunes-Generic.icns',
+        docerator.getOutname(options))
+
+  def testEmptyIcon(self):
+    options = OutnameTest.FakeOptions(appicon=None, text='MP3')
+    self.assertEquals('GenericDocumentIcon-MP3.icns',
+        docerator.getOutname(options))
+    options = OutnameTest.FakeOptions(appicon=None, text='')
+    self.assertEquals('GenericDocumentIcon-Generic.icns',
+        docerator.getOutname(options))
+    options = OutnameTest.FakeOptions(appicon=None, text='',
+        background='/Applications/Bla/bgicon.icns')
+    self.assertEquals('bgicon-Generic.icns',
+        docerator.getOutname(options))
+
+
+# XXX(Nico): Look at the doctest module.
+
+
+if __name__ == '__main__':
+  unittest.main()

src/MacVim/icons/loadfont.c

@@ -0,0 +1,56 @@
+// A small python module that registers a font with ATS, given the name of
+// the font.
+
+#include <Python/Python.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <Carbon/Carbon.h>
+
+static PyObject* loadfont(PyObject* self, PyObject* args) {
+  PyObject*   result = Py_False;
+  const char* path = NULL;
+  int         ok = PyArg_ParseTuple(args, "s", &path);
+
+  if (ok) {
+    CFStringRef componentPath = CFStringCreateWithCString(kCFAllocatorDefault,
+        path, kCFStringEncodingUTF8);
+    CFURLRef componentURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
+        componentPath, kCFURLPOSIXPathStyle, false);
+    FSRef fsref;
+
+    if (CFURLGetFSRef(componentURL, &fsref)) {
+      OSStatus err = noErr;
+      ATSFontContainerRef fontContainerRef;  // we don't deactivate the font
+#if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
+      err = ATSFontActivateFromFileReference(&fsref,
+          kATSFontContextLocal, kATSFontFormatUnspecified, NULL,
+          kATSOptionFlagsDefault, &fontContainerRef);
+#else
+      FSSpec fsSpec;
+      FSRef  fsRef;
+      if ((err = FSGetCatalogInfo(
+              &fsRef, kFSCatInfoNone, NULL, NULL, &fsSpec, NULL)) == noErr) {
+        err = ATSFontActivateFromFileSpecification(&fsSpec,
+            kATSFontContextLocal, kATSFontFormatUnspecified, NULL,
+            kATSOptionFlagsDefault, &fontContainerRef);
+      }
+
+#endif
+
+      if (err == noErr) {
+        result = Py_True;
+      }
+    }
+    CFRelease(componentURL);
+    CFRelease(componentPath);       
+  }
+  return result;
+}
+
+static PyMethodDef LoadfontMethods[] = {
+  { "loadfont", loadfont, METH_VARARGS, "Locally activates font from file." },
+  { NULL, NULL, 0, NULL }
+};
+
+PyMODINIT_FUNC initloadfont(void) {
+  Py_InitModule("loadfont", LoadfontMethods);
+}

src/MacVim/icons/make_icons.py

@@ -1,31 +1,51 @@
-# Creates a document icon from an app icon and an optional text.
-
-# The font is not quite right, use this script to create a document icon
-# for 'PDF' and compare the D with the D in Preview's pdf.icns
+# Creates all of MacVim document icons.
 
 # http://www.macresearch.org/cocoa-scientists-part-xx-python-scriptersmeet-cocoa
 try:
-  from Foundation import *
+  # Make us independent of sysprefs->appearance->antialias fonts smaller than...
+  # Needs to happen before docerator is imported.
+  from AppKit import NSUserDefaults
+  prefs = NSUserDefaults.standardUserDefaults()
+  prefs.setInteger_forKey_(4, 'AppleAntiAliasingThreshold')
+
+  import docerator
+
+  # Load Envy Code R from a file and register it under its postscript name
+  # Thanks to DamienG for this font (redistributed with permission):
+  # http://damieng.com/blog/2008/05/26/envy-code-r-preview-7-coding-font-released
+  import loadfont
+  loadfont.loadfont('Envy Code R Bold.ttf')
+
+  from Foundation import NSString
   from AppKit import *
+
   dont_create = False
 except:
   dont_create = True  # most likely because we're on tiger
-  NSCompositeSourceOver = 2
 
-import math
 import os
 import sys
 
+
 # icon types
 LARGE = 0  # 512, 128, 32, 16; about 96kB
 SMALL = 1  # 128, 32, 16; about 36kB
 LINK = 2  # Create link to generic icon; 4kB (== smallest block size on HFS+)
 
-# path to makeicns binary
+iconsizes = {
+    SMALL: [128, 32, 16],
+    LARGE: [512, 128, 32, 16],
+}
+
+
+# Resources
 MAKEICNS = 'makeicns/makeicns'
+APPICON = 'vim-noshadow-512.png'
+DEFAULT_BACKGROUND = '/System/Library/CoreServices/CoreTypes.bundle/' + \
+    'Contents/Resources/GenericDocumentIcon.icns'
+
 
 # List of icons to create
-# XXX: 32x32 variants only support 3-4 letters of text
 GENERIC_ICON_NAME = 'MacVim-generic'
 vimIcons = {
     GENERIC_ICON_NAME: [u'', LARGE],
@@ -36,19 +56,19 @@ vimIcons = {
     'MacVim-c': [u'C', SMALL],
     'MacVim-m': [u'M', SMALL],
     'MacVim-mm': [u'MM', SMALL],
-    'MacVim-cpp': [u'C\uff0b\uff0b', SMALL],  # fullwidth plusses
+    'MacVim-cpp': [u'C\uff0b\uff0b,C++,C++', SMALL],  # fullwidth plusses
     'MacVim-java': [u'JAVA', SMALL],
     'MacVim-f': [u'FTRAN', SMALL],
     'MacVim-html': [u'HTML', SMALL],
     'MacVim-xml': [u'XML', SMALL],
     'MacVim-js': [u'JS', SMALL],
-    'MacVim-perl': [u'PERL', SMALL],
-    'MacVim-py': [u'PYTHON', SMALL],
+    'MacVim-perl': [u'PERL,PL', SMALL],
+    'MacVim-py': [u'PYTHON,PY', SMALL],
     'MacVim-php': [u'PHP', SMALL],
-    'MacVim-rb': [u'RUBY', SMALL],
+    'MacVim-rb': [u'RUBY,RB', SMALL],
     'MacVim-bash': [u'SH', SMALL],
     'MacVim-patch': [u'DIFF', SMALL],
-    'MacVim-applescript': [u'\uf8ffSCPT', SMALL],  # apple sign
+    'MacVim-applescript': [u'\uf8ffSCPT,\uf8ffS', SMALL],  # apple sign
     'MacVim-as': [u'FLASH', LINK],
     'MacVim-asp': [u'ASP', LINK],
     'MacVim-bib': [u'BIB', LINK],
@@ -61,8 +81,8 @@ vimIcons = {
     'MacVim-css': [u'CSS', SMALL],
     'MacVim-dtd': [u'DTD', LINK],
     'MacVim-dylan': [u'DYLAN', LINK],
-    'MacVim-erl': [u'ERLANG', SMALL],
-    'MacVim-fscript': [u'FSCPT', SMALL],
+    'MacVim-erl': [u'ERLANG,ERL', SMALL],
+    'MacVim-fscript': [u'FSCPT,FSCR,FS', SMALL],
     'MacVim-hs': [u'HS', SMALL],
     'MacVim-inc': [u'INC', LINK],
     'MacVim-ics': [u'ICS', SMALL],
@@ -71,385 +91,21 @@ vimIcons = {
     'MacVim-bsh': [u'BSH', LINK],
     'MacVim-properties': [u'PROP', LINK],
     'MacVim-jsp': [u'JSP', SMALL],
-    'MacVim-lisp': [u'LISP', SMALL],
+    'MacVim-lisp': [u'LISP,LISP,LSP', SMALL],
     'MacVim-log': [u'LOG', SMALL],
     'MacVim-wiki': [u'WIKI', SMALL],
     'MacVim-ps': [u'PS', LINK],
     #'MacVim-plist': [u'PLIST', SMALL],
-    'MacVim-sch': [u'SCHEME', SMALL],
+    'MacVim-sch': [u'SCHEME,SCM', SMALL],
     'MacVim-sql': [u'SQL', SMALL],
     'MacVim-tcl': [u'TCL', SMALL],
     'MacVim-xsl': [u'XSL', LINK],
-    'MacVim-vcf': [u'VCARD', SMALL],
-    'MacVim-vb': [u'VBASIC', LINK],
-    'MacVim-yaml': [u'YAML', SMALL],
+    'MacVim-vcf': [u'VCARD,VCF', SMALL],
+    'MacVim-vb': [u'VBASIC,VB', LINK],
+    'MacVim-yaml': [u'YAML,YAML,YML', SMALL],
     'MacVim-gtd': [u'GTD', LINK],
 }
 
-shorttext = {
-    u'MacVim-py': u'PY',
-    u'MacVim-rb': u'RB',
-    u'MacVim-perl': u'PL',
-    u'MacVim-applescript': u'\uf8ffS',
-    u'MacVim-erl': u'ERL',
-    u'MacVim-fscript': u'FSCR',
-    u'MacVim-sch': u'SCM',
-    u'MacVim-vcf': u'VCF',
-    u'MacVim-vb': u'VB',
-}
-
-
-# Resources
-BACKGROUND = '/System/Library/CoreServices/CoreTypes.bundle/' + \
-    'Contents/Resources/GenericDocumentIcon.icns'  # might require leopard?
-APPICON = 'vim-noshadow-512.png'
-#APPICON = 'vim-noshadow-no-v-512.png'
-
-class Surface(object):
-  """Represents a simple bitmapped image."""
-
-  def __init__(self, *p, **kw):
-    if not 'premultiplyAlpha' in kw:
-      kw['premultiplyAlpha'] = True
-    if len(p) == 1 and isinstance(p[0], NSBitmapImageRep):
-      self.bitmapRep = p[0]
-    elif len(p) == 2 and isinstance(p[0], int) and isinstance(p[1], int):
-      format = NSAlphaFirstBitmapFormat
-      if not kw['premultiplyAlpha']:
-        format += NSAlphaNonpremultipliedBitmapFormat
-      self.bitmapRep = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bitmapFormat_bytesPerRow_bitsPerPixel_(
-          None, p[0], p[1], 8, 4, True, False, NSDeviceRGBColorSpace,
-          format, 0, 0)
-
-    if not hasattr(self, 'bitmapRep') or not self.bitmapRep:
-      raise Exception('Failed to create surface: ' + str(p))
-
-  def size(self):
-    return map(int, self.bitmapRep.size())  # cocoa returns floats. cocoa ftw
-
-  def data(self):
-    """Returns data in ARGB order (on intel, at least)."""
-    r = self.bitmapRep
-    if r.bitmapFormat() != (NSAlphaNonpremultipliedBitmapFormat |
-          NSAlphaFirstBitmapFormat) or \
-        r.bitsPerPixel() != 32 or \
-        r.isPlanar() or \
-        r.samplesPerPixel() != 4:
-      raise Exception("Unsupported image format")
-    return self.bitmapRep.bitmapData()
-
-  def save(self, filename):
-    """Saves image as png file."""
-    self.bitmapRep.representationUsingType_properties_(NSPNGFileType, None) \
-        .writeToFile_atomically_(filename, True)
-
-  def draw(self):
-    self.bitmapRep.draw()
-
-  def context(self):
-    # Note: Cocoa only supports contexts with premultiplied alpha
-    return NSGraphicsContext.graphicsContextWithBitmapImageRep_(self.bitmapRep)
-
-  def copy(self):
-    return Surface(self.bitmapRep.copy())
-
-
-class Image(object):
-  """Represents an image that can consist of several Surfaces."""
-
-  def __init__(self, param):
-    if isinstance(param, str):
-      self.image = NSImage.alloc().initWithContentsOfFile_(param)
-    elif isinstance(param, Surface):
-      self.image = NSImage.alloc().initWithSize_( param.size() )
-      self.image.addRepresentation_(param.bitmapRep)
-
-    if not self.image:
-      raise Exception('Failed to load image: ' + str(filename))
-
-  def surfaceOfSize(self, w, h):
-    """Returns an ARGB, non-premultiplied surface of size w*h or throws."""
-    r = None
-    for rep in self.image.representations():
-      if map(int, rep.size()) == [w, h]:
-        r = rep
-        break
-    if not r:
-      raise Exception('Unsupported size %dx%d', w, h)
-    return Surface(r)
-
-  def blend(self):
-    self.compositeInRect( ((0, 0), self.image.size()) )
-
-  def compositeInRect(self, r, mode=NSCompositeSourceOver):
-    self.image.drawInRect_fromRect_operation_fraction_(r, NSZeroRect,
-        mode, 1.0)
-
-
-class Context(object):
-  # Tiger has only Python2.3, so we can't use __enter__ / __exit__ for this :-(
-
-  def __init__(self, surface):
-    NSGraphicsContext.saveGraphicsState()
-    c = surface.context()
-    c.setShouldAntialias_(True);
-    c.setImageInterpolation_(NSImageInterpolationHigh);
-    NSGraphicsContext.setCurrentContext_(c)
-
-  def done(self):
-    NSGraphicsContext.restoreGraphicsState()
-
-
-class SplittableBackground(object):
-
-  def __init__(self, unsplitted, shouldSplit=True):
-    self.unsplitted = unsplitted
-    self.shouldSplit = shouldSplit
-    self.ground = {}
-    self.shadow = {}
-
-  def rawGroundAtSize(self, s):
-    return self.unsplitted.surfaceOfSize(s, s)
-
-  def groundAtSize(self, s):
-    if not self.shouldSplit:
-      return self.rawGroundAtSize(s)
-    self._performSplit(s)
-    return self.ground[s]
-
-  def shadowAtSize(self, s):
-    if not self.shouldSplit:
-      return None
-    self._performSplit(s)
-    return self.shadow[s]
-
-  def _performSplit(self, s):
-    if s in self.ground:
-      assert s in self.shadow
-      return
-    assert s not in self.shadow
-    ground, shadow = splitGenericDocumentIcon(self.unsplitted, s)
-    self.ground[s] = ground
-    self.shadow[s] = shadow
-
-
-class BackgroundRenderer(object):
-
-  def __init__(self, bg, icon=None):
-    self.bgRenderer = bg
-    self.icon = icon
-    self.cache = {}
-
-  def drawIcon(self, s):
-    if not self.icon:
-      return
-    # found by flow program, better than anything i came up with manually before
-    # (except for the 16x16 variant :-( )
-    transforms = {
-        512: [ 0.7049, 0.5653, -4.2432, 0.5656],
-        256: [ 0.5690, 0.5658, -1.9331, 0.5656],
-        128: [ 1.1461, 0.5684, -0.8482, 0.5681],
-
-         32: [-0.2682, 0.5895, -2.2130, 0.5701],  # intensity
-         #32: [-0.2731, 0.5898, -2.2262, 0.5729],  # rgb (no rmse difference)
-
-         #16: [-0.3033, 0.4909, -1.3235, 0.4790],  # program, intensity
-         #16: [-0.3087, 0.4920, -1.2990, 0.4750],  # program, rgb mode
-         16: [ 0.0000, 0.5000, -1.0000, 0.5000],  # manually, better
-        }
-
-    assert s in [16, 32, 128, 256, 512]
-    a = transforms[s]
-
-    # convert from `flow` coords to cocoa
-    a[2] = -a[2]  # mirror y
-
-    w, h = s*a[1], s*a[3]
-    self.icon.compositeInRect( (((s-w)/2 + a[0], (s-h)/2 + a[2]), (w, h)) )
-
-  def drawAtSize(self, s):
-    self.bgRenderer.groundAtSize(s).draw()
-    self.drawIcon(s)
-    if self.bgRenderer.shouldSplit:
-      # shadow needs to be composited, so it needs to be in an image
-      Image(self.bgRenderer.shadowAtSize(s)).blend()
-
-  def backgroundAtSize(self, s):
-    if not s in self.cache:
-      result = Surface(s, s)
-      context = Context(result)
-      self.drawAtSize(s)
-      context.done()
-      self.cache[s] = result
-    return self.cache[s]
-
-
-def splitGenericDocumentIcon(img, s):
-  """Takes the generic document icon and splits it into a background and a
-  shadow layer. For the 32x32 and 16x16 variants, the white pixels of the page
-  curl are hardcoded into the otherwise transparent shadow layer."""
-
-  w, h = s, s
-  r = img.surfaceOfSize(w, h)
-  bps = 4*w
-  data = r.data()
-
-  ground = Surface(w, h, premultiplyAlpha=False)
-  shadow = Surface(w, h, premultiplyAlpha=False)
-
-  grounddata = ground.data()
-  shadowdata = shadow.data()
-
-  for y in xrange(h):
-    for x in xrange(w):
-      idx = y*bps + 4*x
-      ia, ir, ig, ib = data[idx:idx + 4]
-      if ia != chr(255):
-        # buffer objects don't support slice assignment :-(
-        grounddata[idx] = ia
-        grounddata[idx + 1] = ir
-        grounddata[idx + 2] = ig
-        grounddata[idx + 3] = ib
-        shadowdata[idx] = chr(0)
-        shadowdata[idx + 1] = chr(0)
-        shadowdata[idx + 2] = chr(0)
-        shadowdata[idx + 3] = chr(0)
-        continue
-
-      assert ir == ig == ib
-      grounddata[idx] = chr(255)
-      grounddata[idx + 1] = chr(255)
-      grounddata[idx + 2] = chr(255)
-      grounddata[idx + 3] = chr(255)
-      shadowdata[idx] = chr(255 - ord(ir))
-      shadowdata[idx + 1] = chr(0)
-      shadowdata[idx + 2] = chr(0)
-      shadowdata[idx + 3] = chr(0)
-
-  # Special-case 16x16 and 32x32 cases: Make some pixels on the fold white.
-  # Ideally, I could make the fold whiteish in all variants, but I can't.
-  whitePix = { 16: [(10, 2), (10, 3), (11, 3), (10, 4), (11, 4), (12, 4)],
-               32: [(21, 4), (21, 5), (22, 5), (21, 6), (22, 6), (23, 6)]}
-  if (w, h) in [(16, 16), (32, 32)]:
-    for x, y in whitePix[w]:
-      idx = y*bps + 4*x
-      shadowdata[idx] = chr(255)
-      shadowdata[idx + 1] = chr(255)
-      shadowdata[idx + 2] = chr(255)
-      shadowdata[idx + 3] = chr(255)
-
-  return ground, shadow
-
-
-class TextRenderer(object):
-
-  def __init__(self):
-    self.cache = {}
-
-  def attribsAtSize(self, s):
-    if s not in self.cache:
-      self.cache[s] = self._attribsAtSize(s)
-    return self.cache[s]
-
-  def centeredStyle(self):
-    style = NSMutableParagraphStyle.new()
-    style.setParagraphStyle_(NSParagraphStyle.defaultParagraphStyle())
-    style.setAlignment_(NSCenterTextAlignment)
-    return style
-
-  def _attribsAtSize(self, s):
-    # This looks not exactly like the font on Preview.app's document icons,
-    # but I believe that's because Preview's icons are drawn by Photoshop,
-    # and Adobe's font rendering is different from Apple's.
-    fontname = 'LucidaGrande-Bold'
-
-    # Prepare text format
-    fontsizes = { 512: 72.0,  256: 36.0,  128: 18.0,  32: 7.0,  16: 3.0 }
-    # http://developer.apple.com/documentation/Cocoa/Conceptual/AttributedStrings/Articles/standardAttributes.html#//apple_ref/doc/uid/TP40004903
-    attribs = {
-      NSParagraphStyleAttributeName: self.centeredStyle(),
-      NSForegroundColorAttributeName: NSColor.colorWithDeviceWhite_alpha_(
-          0.34, 1),
-      NSFontAttributeName: NSFont.fontWithName_size_(fontname, fontsizes[s])
-    }
-
-    # tighten font a bit for some sizes
-    if s in [256, 512]:
-      attribs[NSKernAttributeName] = -1.0
-    elif s == 32:
-      attribs[NSKernAttributeName] = -0.25
-
-    if not attribs[NSFontAttributeName]:
-      raise Exception('Failed to load font %s' % fontname)
-    return attribs
-
-  def drawTextAtSize(self, text, s):
-    """Draws text `s` into the current context of size `s`."""
-
-    textRects = {
-        512: ((0, 7), (512, 119)),
-        128: ((0, 6), (128, 26.5)),
-        256: ((0, 7), (256, 57)),
-         16: ((1, 1), (15, 5)),
-         #32: ((1, 1), (31, 9))
-        }
-
-    attribs = self.attribsAtSize(s)
-    text = NSString.stringWithString_(text)
-    if s in [16, 128, 256, 512]:
-      text.drawInRect_withAttributes_(textRects[s], attribs)
-    elif s == 32:
-      # Try to align text on pixel boundary:
-      attribs = attribs.copy()
-      attribs[NSParagraphStyleAttributeName] = \
-          NSParagraphStyle.defaultParagraphStyle()
-      ts = text.sizeWithAttributes_(attribs)
-      text.drawAtPoint_withAttributes_( (math.floor((32.0-ts[0])/2) + 0.5, 1.5),
-          attribs)
-
-
-class OfficeTextRenderer(TextRenderer):
-  """Uses Office's LucidaSans font for 32x32.
-
-  This font looks much better for certain strings (e.g. "PDF") but much worse
-  for most others (e.g. "VIM", "JAVA") -- and office fonts are usually not
-  installed. Hence, this class is better not used.
-  """
-
-  def _attribsAtSize(self, s):
-    self.useOfficeFont = False
-    attribs = TextRenderer._attribsAtSize(self, s)
-    if s == 32:
-      font = NSFont.fontWithName_size_('LucidaSans-Demi', 7.0)
-      if font:
-        attribs[NSFontAttributeName] = font
-        attribs[NSKernAttributeName] = 0
-        self.useOfficeFont = True
-    return attribs
-
-  def drawTextAtSize(self, text, s):
-    attribs = self.attribsAtSize(s)
-    if not self.useOfficeFont or s != 32:
-      TextRenderer.drawTextAtSize(self, text, s)
-      return
-    text = NSString.stringWithString_(text)
-    text.drawInRect_withAttributes_( ((0, 1), (31, 11)), attribs)
-
-
-def createIcon(s, bg, textRenderer, text, shorttext=None):
-
-  # Fill in background
-  output = bg.backgroundAtSize(s).copy()
-
-  # Draw text on top of shadow
-  context = Context(output)
-  if s in [16, 32] and shorttext:
-    text = shorttext
-  textRenderer.drawTextAtSize(text, s)
-  context.done()
-
-  return output
-
 
 def createLinks(icons, target):
   assert len(icons) > 0
@@ -460,80 +116,75 @@ def createLinks(icons, target):
     os.symlink(target, icnsName)
 
 
-def saveIcns(icons, icnsName, makeIcns='./makeicns'):
-  """Creates an icns file with several variants.
+if not dont_create:
+  # define a few classes to render custom 16x16 icons
 
-  Params:
-    icons: A dict that contains icon size as key and Surface as value.
-           Valid keys are 512, 256, 128, 32, 16
-    icnsname: Name of the output file
-  """
-  # XXX: Figure out how to call ObjC directly from Python, then this doesn't
-  # need to call a different process and do lots of i/o.
-  args = []
-  for s, icon in icons.items():
-    assert s in [512, 256, 128, 32, 16]
-    assert icon.size() == [s, s]
-    icon.save(TMPFILE % s)
-    args.append('-%d %s' % (s, TMPFILE % s))
-  os.system('%s %s -out %s' % (makeIcns, ' '.join(args), icnsName))
+  class NoTextRenderer(docerator.TextRenderer):
+    def drawTextAtSize(self, text, s):
+      if s == 16: return  # No text at 16x16
+      docerator.TextRenderer.drawTextAtSize(self, text, s)
+
+  class NoIconRenderer(docerator.BackgroundRenderer):
+    def drawIcon(self, s):
+      if s == 16: return  # no "MacVim" icon on the sheet at 16x16
+      docerator.BackgroundRenderer.drawIcon(self, s)
+
+  class SmallTextRenderer(docerator.TextRenderer):
+    def _attribsAtSize(self, s):
+      attribs = docerator.TextRenderer._attribsAtSize(self, s)
+      if s == 16:
+        font = NSFont.fontWithName_size_('EnvyCodeR-Bold', 7.0)
+        assert font
+        attribs[NSFontAttributeName] = font
+        attribs[NSForegroundColorAttributeName] = \
+            NSColor.colorWithDeviceRed_green_blue_alpha_(
+                0/255.0, 82/255.0, 0/255.0, 1)
+      return attribs
+
+    def drawTextAtSize(self, text, s):
+      if s != 16:
+        docerator.TextRenderer.drawTextAtSize(self, text, s)
+        return
+      text = NSString.stringWithString_(text.lower()[0:3])  # at most 3 chars
+      attribs = self.attribsAtSize(s)
+      if len(text) <= 2:
+        attribs[NSKernAttributeName] = 0  # we have some space
+      else:
+        attribs[NSKernAttributeName] = -1  # we need all the room we can get
+      text.drawInRect_withAttributes_( ((1, 2), (15, 11)), attribs)
 
 
-TMPFILE = 'make_icons_tmp_%d.png'
-sizes = [512, 128, 32, 16]
 def main():
+  if dont_create:
+    print "PyObjC not found, only using a stock icon for document icons."
+    # Can't use the constants from docerator in this case
+    import shutil
+    shutil.copyfile(DEFAULT_BACKGROUND, '%s.icns' % GENERIC_ICON_NAME)
+    createLinks([name for name in vimIcons if name != GENERIC_ICON_NAME],
+        '%s.icns' % GENERIC_ICON_NAME)
+    return
+
   srcdir = os.getcwd()
   if len(sys.argv) > 1:
     os.chdir(sys.argv[1])
   appIcon = os.path.join(srcdir, APPICON)
   makeIcns = os.path.join(srcdir, MAKEICNS)
 
-  if dont_create:
-    print "PyObjC not found, only using a stock icon for document icons."
-    import shutil
-    shutil.copyfile(BACKGROUND, '%s.icns' % GENERIC_ICON_NAME)
-    createLinks([name for name in vimIcons if name != GENERIC_ICON_NAME],
-        '%s.icns' % GENERIC_ICON_NAME)
-    return
-  # Make us not crash
-  # http://www.cocoabuilder.com/archive/message/cocoa/2008/8/6/214964
-  NSApplicationLoad()
-
-  textRenderer = TextRenderer()
-  #textRenderer = OfficeTextRenderer()
-
-  # Prepare input images
-  bgIcon = Image(BACKGROUND)
-
-  #bg = SplittableBackground(bgIcon, shouldSplit=False)
-  bg = SplittableBackground(bgIcon, shouldSplit=True)
-
-  icon = Image(appIcon)
-  bgRenderer = BackgroundRenderer(bg, icon)
-
-  if not os.access(makeIcns, os.X_OK):
-    print 'Cannot find makeicns at %s', makeIcns
-    return
-
   # create LARGE and SMALL icons first...
   for name, t in vimIcons.iteritems():
     text, size = t
     if size == LINK: continue
     print name
-    icnsName = '%s.icns' % name
-
-    if size == SMALL:
-      currSizes = [128, 32, 16]
-    elif size == LARGE:
-      currSizes = [512, 128, 32, 16]
-
-    st = shorttext.get(name)
-    icons = [(s, createIcon(s, bgRenderer, textRenderer, text, shorttext=st))
-        for s in currSizes]
-    icons = dict(icons)
-    saveIcns(icons, '%s.icns' % name, makeIcns)
-
-  del text, size, name, t
+    if name == GENERIC_ICON_NAME:
+      # The generic icon has no text; make the appicon a bit larger
+      docerator.makedocicon(outname='%s.icns' % name, appicon=appIcon,
+          text=text, sizes=iconsizes[size], makeicns=makeIcns,
+          textrenderer=NoTextRenderer, rects={16:(0.0, 0.5533, 0.0, 0.5533)})
+    else:
+      # For the other icons, leave out appicon and render text in Envy Code R
+      docerator.makedocicon(outname='%s.icns' % name, appicon=appIcon,
+          text=text, sizes=iconsizes[size], makeicns=makeIcns,
+          textrenderer=SmallTextRenderer, backgroundrenderer=NoIconRenderer)
 
   # ...create links later (to make sure the link targets exist)
   createLinks([name for (name, t) in vimIcons.items() if t[1] == LINK],
@@ -541,9 +192,4 @@ def main():
 
 
 if __name__ == '__main__':
-  try:
     main()
-  finally:
-    for s in sizes:
-      if os.access(TMPFILE % s, os.F_OK):
-        os.remove(TMPFILE % s)

src/MacVim/icons/makeicns/makeicns.m

@@ -54,9 +54,10 @@ void usage() {
 NSBitmapImageRep* getBitmapImageRepOfSize(NSImage* img, int size) {
 
   // Don't resample if it's not necessary
-  // XXX: Seems as if this creates problems in some situations, disable this
-  // for now.
 #if 0
+  // IconFamily does not work correctly with
+  // NSAlphaNonpremultipliedBitmapFormat images, so this has to stay disabled
+  // until IconFamily is fixed (if ever).
   NSEnumerator* e = [[img representations] objectEnumerator];
   NSImageRep* ir;
   while ((ir = [e nextObject])) {

src/MacVim/icons/setup.py

@@ -0,0 +1,5 @@
+from distutils.core import setup, Extension
+
+setup(name="loadfont", version="1.0",
+	ext_modules = [Extension("loadfont", ["loadfont.c"])])
+

src/MacVim/macvim_latest.xml

@@ -40,6 +40,71 @@
     Sparkle supports updates in zip, tar, tbz, tgz, or dmg format.
     -->
 
+    <item>
+      <title>Snapshot 43 released</title>
+      <description><![CDATA[
+<h1>MacVim snapshot 43 released</h1>
+
+<p><b>The automatic updating feature is broken in snapshots 39 and 40.  If the automatic updating never finishes extracting then you are affected by this bug and will have to upgrade manually.  To do so, simply go to the <a href="http://code.google.com/p/macvim/wiki/Snapshot">Snapshot page</a> to download the latest version.</b></p>
+
+<p> Changes since snapshot 42:
+  <ul>
+    <li> Do inclusive search when opening files (Jonathon Mah) </li>
+    <li> Respect layout prefs when double-clicking an already open file </li>
+    <li> Fix two minor memory leaks </li>
+    <li> Ctrl-] works on German keyboard layout </li>
+    <li> The .viminfo file is written on Cmd-q </li>
+    <li> New 16x16 icons (Nico Weber) </li>
+    <li> Untitled window again opens on reopen event if requested in prefs </li>
+    <li> Fork earlier; fixes bug with 'autochdir', faster startup, "f" no longer supported in 'guioptions' </li>
+    <li> Some other minor bug fixes </li>
+    <li> Use latest runtime files and Vim patches </li>
+  </ul>
+</p>
+      ]]></description>
+      <pubDate>Fri, 20 Feb 2009 13:49 CET</pubDate>
+      <enclosure type="application/octet-stream"
+        url="http://newmacvim.muskokamug.org/mirror/files/MacVim-snapshot-43.tbz"
+        length="8136440"
+        sparkle:version="43"
+        sparkle:shortVersionString="7.2"
+        />
+    </item>
+
+
+    <item>
+      <title>Snapshot 42 released</title>
+      <description><![CDATA[
+<h1>MacVim snapshot 42 released</h1>
+
+<p><b>The automatic updating feature is broken in snapshots 39 and 40.  If the automatic updating never finishes extracting then you are affected by this bug and will have to upgrade manually.  To do so, simply go to the <a href="http://code.google.com/p/macvim/wiki/Snapshot">Snapshot page</a> to download the latest version.</b></p>
+
+<p> Changes since snapshot 40:
+  <ul>
+    <li> The menu bar behaves better when using full-screen and switching Spaces (Nico Weber) </li>
+    <li> Don't switch Spaces when using "mvim" on one Space and a MacVim window is open on another Space </li>
+    <li> Add user default to toggle the "add tab" button on the tabline (to disable, enter "defaults org.vim.MacVim MMShowAddTabButton 0" in Terminal) </li>
+    <li> Avoid the "Press ENTER..." prompt when dragging and dropping </li>
+    <li> Faster startup (and shutdown, but you're not likely to notice that unless you are me ;-) </li>
+    <li> Automatic updating works again </li>
+    <li> Possible to interrupt external commands (e.g. you can Ctrl-C during a lenghty :grep now) </li>
+    <li> The output from external commands is displayed "interactively" (i.e. you don't have to wait for the command to finish before any output is drawn; try ":!ls -l /usr/lib" and compare with snap 40 to see what I mean) </li>
+    <li> Cmd-. sends SIGINT (so that if a Vim process is stuck you should always be able to interrupt it with Cmd-. even if Ctrl-C doesn't work) </li>
+    <li> Fix crashing bug: e.g. with snap 40 if you go to the src/ folder of Vim and type ":grep a *.c" MacVim would crash </li>
+    <li> Toggle loading of default font with user default MMLoadDefaultFont </li>
+  </ul>
+</p>
+      ]]></description>
+      <pubDate>Sat, 12 Jan 2009 16:12 CET</pubDate>
+      <enclosure type="application/octet-stream"
+        url="http://newmacvim.muskokamug.org/mirror/files/MacVim-snapshot-42.tbz"
+        length="8131516"
+        sparkle:version="42"
+        sparkle:shortVersionString="7.2"
+        />
+    </item>
+
+
     <item>
       <title>Snapshot 40 released</title>
       <description><![CDATA[

src/Make_mvc.mak

@@ -354,6 +354,9 @@ MSVCVER = 9.0
 !if "$(_NMAKE_VER)" == "9.00.21022.08"
 MSVCVER = 9.0
 !endif
+!if "$(_NMAKE_VER)" == "9.00.30729.01"
+MSVCVER = 9.0
+!endif
 !endif
 
 # Abort bulding VIM if version of VC is unrecognised.

src/buffer.c

@@ -437,10 +437,6 @@ close_buffer(win, buf, action)
 	return;
 #endif
 
-#ifdef FEAT_NETBEANS_INTG
-    if (usingNetbeans)
-	netbeans_file_closed(buf);
-#endif
 #ifdef FEAT_ODB_EDITOR
     odb_buffer_close(buf);
 #endif
@@ -643,6 +639,10 @@ free_buffer_stuff(buf, free_options)
 #ifdef FEAT_SIGNS
     buf_delete_signs(buf);		/* delete any signs */
 #endif
+#ifdef FEAT_NETBEANS_INTG
+    if (usingNetbeans)
+        netbeans_file_killed(buf);
+#endif
 #ifdef FEAT_LOCALMAP
     map_clear_int(buf, MAP_ALL_MODES, TRUE, FALSE);  /* clear local mappings */
     map_clear_int(buf, MAP_ALL_MODES, TRUE, TRUE);   /* clear local abbrevs */
@@ -819,9 +819,6 @@ do_bufdel(command, arg, addr_count, start_bnr, end_bnr, forceit)
     int		bnr;		/* buffer number */
     char_u	*p;
 
-#ifdef FEAT_NETBEANS_INTG
-    netbeansCloseFile = 1;
-#endif
     if (addr_count == 0)
     {
 	(void)do_buffer(command, DOBUF_CURRENT, FORWARD, 0, forceit);
@@ -916,9 +913,6 @@ do_bufdel(command, arg, addr_count, start_bnr, end_bnr, forceit)
 	}
     }
 
-#ifdef FEAT_NETBEANS_INTG
-    netbeansCloseFile = 0;
-#endif
 
     return errormsg;
 }

src/diff.c

@@ -8,7 +8,7 @@
  */
 
 /*
- * diff.c: code for diff'ing two or three buffers.
+ * diff.c: code for diff'ing two, three or four buffers.
  */
 
 #include "vim.h"
@@ -116,7 +116,7 @@ diff_buf_adjust(win)
  * Add a buffer to make diffs for.
  * Call this when a new buffer is being edited in the current window where
  * 'diff' is set.
- * Marks the current buffer as being part of the diff and requireing updating.
+ * Marks the current buffer as being part of the diff and requiring updating.
  * This must be done before any autocmd, because a command may use info
  * about the screen contents.
  */
@@ -929,7 +929,7 @@ ex_diffpatch(eap)
 	goto theend;
 
 #ifdef UNIX
-    /* Temporaraly chdir to /tmp, to avoid patching files in the current
+    /* Temporarily chdir to /tmp, to avoid patching files in the current
      * directory when the patch file contains more than one patch.  When we
      * have our own temp dir use that instead, it will be cleaned up when we
      * exit (any .rej files created).  Don't change directory if we can't
@@ -2129,6 +2129,8 @@ ex_diffgetput(eap)
 	    EMSG2(_("E102: Can't find buffer \"%s\""), eap->arg);
 	    return;
 	}
+	if (buf == curbuf)
+	    return;		/* nothing to do */
 	idx_other = diff_buf_idx(buf);
 	if (idx_other == DB_COUNT)
 	{

src/edit.c

@@ -147,6 +147,7 @@ static void ins_compl_clear __ARGS((void));
 static int  ins_compl_bs __ARGS((void));
 static void ins_compl_new_leader __ARGS((void));
 static void ins_compl_addleader __ARGS((int c));
+static int ins_compl_len __ARGS((void));
 static void ins_compl_restart __ARGS((void));
 static void ins_compl_set_original_text __ARGS((char_u *str));
 static void ins_compl_addfrommatch __ARGS((void));
@@ -197,7 +198,8 @@ static void replace_pop_ins __ARGS((void));
 static void mb_replace_pop_ins __ARGS((int cc));
 #endif
 static void replace_flush __ARGS((void));
-static void replace_do_bs __ARGS((void));
+static void replace_do_bs __ARGS((int limit_col));
+static int del_char_after_col __ARGS((int limit_col));
 #ifdef FEAT_CINDENT
 static int cindent_on __ARGS((void));
 #endif
@@ -1933,6 +1935,8 @@ truncate_spaces(line)
 /*
  * Backspace the cursor until the given column.  Handles REPLACE and VREPLACE
  * modes correctly.  May also be used when not in insert mode at all.
+ * Will attempt not to go before "col" even when there is a composing
+ * character.
  */
     void
 backspace_until_column(col)
@@ -1942,13 +1946,50 @@ backspace_until_column(col)
     {
 	curwin->w_cursor.col--;
 	if (State & REPLACE_FLAG)
-	    replace_do_bs();
-	else
-	    (void)del_char(FALSE);
+	    replace_do_bs(col);
+	else if (!del_char_after_col(col))
+	    break;
     }
 }
 #endif
 
+/*
+ * Like del_char(), but make sure not to go before column "limit_col".
+ * Only matters when there are composing characters.
+ * Return TRUE when something was deleted.
+ */
+/*ARGSUSED*/
+   static int
+del_char_after_col(limit_col)
+    int limit_col;
+{
+#ifdef FEAT_MBYTE
+    if (enc_utf8 && limit_col >= 0)
+    {
+	int ecol = curwin->w_cursor.col + 1;
+
+	/* Make sure the cursor is at the start of a character, but
+	 * skip forward again when going too far back because of a
+	 * composing character. */
+	mb_adjust_cursor();
+	while (curwin->w_cursor.col < (colnr_T)limit_col)
+	{
+	    int l = utf_ptr2len(ml_get_cursor());
+
+	    if (l == 0)  /* end of line */
+		break;
+	    curwin->w_cursor.col += l;
+	}
+	if (*ml_get_cursor() == NUL || curwin->w_cursor.col == ecol)
+	    return FALSE;
+	del_bytes((long)(ecol - curwin->w_cursor.col), FALSE, TRUE);
+    }
+    else
+#endif
+	(void)del_char(FALSE);
+    return TRUE;
+}
+
 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
 /*
  * CTRL-X pressed in Insert mode.
@@ -2418,7 +2459,7 @@ ins_compl_longest_match(match)
 	{
 	    had_match = (curwin->w_cursor.col > compl_col);
 	    ins_compl_delete();
-	    ins_bytes(compl_leader + curwin->w_cursor.col - compl_col);
+	    ins_bytes(compl_leader + ins_compl_len());
 	    ins_redraw(FALSE);
 
 	    /* When the match isn't there (to avoid matching itself) remove it
@@ -2470,7 +2511,7 @@ ins_compl_longest_match(match)
 	    *p = NUL;
 	    had_match = (curwin->w_cursor.col > compl_col);
 	    ins_compl_delete();
-	    ins_bytes(compl_leader + curwin->w_cursor.col - compl_col);
+	    ins_bytes(compl_leader + ins_compl_len());
 	    ins_redraw(FALSE);
 
 	    /* When the match isn't there (to avoid matching itself) remove it
@@ -3209,7 +3250,7 @@ ins_compl_new_leader()
 {
     ins_compl_del_pum();
     ins_compl_delete();
-    ins_bytes(compl_leader + curwin->w_cursor.col - compl_col);
+    ins_bytes(compl_leader + ins_compl_len());
     compl_used_match = FALSE;
 
     if (compl_started)
@@ -3263,6 +3304,20 @@ ins_compl_new_leader()
 	compl_enter_selects = FALSE;
 }
 
+/*
+ * Return the length of the completion, from the completion start column to
+ * the cursor column.  Making sure it never goes below zero.
+ */
+    static int
+ins_compl_len()
+{
+    int off = curwin->w_cursor.col - compl_col;
+
+    if (off < 0)
+	return 0;
+    return off;
+}
+
 /*
  * Append one character to the match leader.  May reduce the number of
  * matches.
@@ -3621,10 +3676,9 @@ ins_compl_prep(c)
 	    {
 		ins_compl_delete();
 		if (compl_leader != NULL)
-		    ins_bytes(compl_leader + curwin->w_cursor.col - compl_col);
+		    ins_bytes(compl_leader + ins_compl_len());
 		else if (compl_first_match != NULL)
-		    ins_bytes(compl_orig_text
-					  + curwin->w_cursor.col - compl_col);
+		    ins_bytes(compl_orig_text + ins_compl_len());
 		retval = TRUE;
 	    }
 
@@ -4187,7 +4241,7 @@ ins_compl_get_exp(ini)
 	}
 
 	/* check if compl_curr_match has changed, (e.g. other type of
-	 * expansion added somenthing) */
+	 * expansion added something) */
 	if (type != 0 && compl_curr_match != old_match)
 	    found_new_match = OK;
 
@@ -4256,7 +4310,7 @@ ins_compl_delete()
     static void
 ins_compl_insert()
 {
-    ins_bytes(compl_shown_match->cp_str + curwin->w_cursor.col - compl_col);
+    ins_bytes(compl_shown_match->cp_str + ins_compl_len());
     if (compl_shown_match->cp_flags & ORIGINAL_TEXT)
 	compl_used_match = FALSE;
     else
@@ -4425,7 +4479,7 @@ ins_compl_next(allow_get_expansion, count, insert_match)
 	if (!compl_get_longest || compl_used_match)
 	    ins_compl_insert();
 	else
-	    ins_bytes(compl_leader + curwin->w_cursor.col - compl_col);
+	    ins_bytes(compl_leader + ins_compl_len());
     }
     else
 	compl_used_match = FALSE;
@@ -4688,7 +4742,7 @@ ins_complete(c)
 		}
 		compl_length = curwin->w_cursor.col - (int)compl_col;
 		/* IObuff is used to add a "word from the next line" would we
-		 * have enough space?  just being paranoic */
+		 * have enough space?  just being paranoid */
 #define	MIN_SPACE 75
 		if (compl_length > (IOSIZE - MIN_SPACE))
 		{
@@ -7123,9 +7177,12 @@ replace_flush()
  * cc == 0: character was inserted, delete it
  * cc > 0: character was replaced, put cc (first byte of original char) back
  * and check for more characters to be put back
+ * When "limit_col" is >= 0, don't delete before this column.  Matters when
+ * using composing characters, use del_char_after_col() instead of del_char().
  */
     static void
-replace_do_bs()
+replace_do_bs(limit_col)
+    int		limit_col;
 {
     int		cc;
 #ifdef FEAT_VREPLACE
@@ -7153,7 +7210,7 @@ replace_do_bs()
 #ifdef FEAT_MBYTE
 	if (has_mbyte)
 	{
-	    del_char(FALSE);
+	    (void)del_char_after_col(limit_col);
 # ifdef FEAT_VREPLACE
 	    if (State & VREPLACE_FLAG)
 		orig_len = (int)STRLEN(ml_get_cursor());
@@ -7203,7 +7260,7 @@ replace_do_bs()
 	changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
     }
     else if (cc == 0)
-	(void)del_char(FALSE);
+	(void)del_char_after_col(limit_col);
 }
 
 #ifdef FEAT_CINDENT
@@ -8150,7 +8207,7 @@ ins_ctrl_o()
 /*
  * If the cursor is on an indent, ^T/^D insert/delete one
  * shiftwidth.	Otherwise ^T/^D behave like a "<<" or ">>".
- * Always round the indent to 'shiftwith', this is compatible
+ * Always round the indent to 'shiftwidth', this is compatible
  * with vi.  But vi only supports ^T and ^D after an
  * autoindent, we support it everywhere.
  */
@@ -8239,7 +8296,7 @@ ins_bs_one(vcolp)
 	 * Replace mode */
 	if (curwin->w_cursor.lnum != Insstart.lnum
 		|| curwin->w_cursor.col >= Insstart.col)
-	    replace_do_bs();
+	    replace_do_bs(-1);
     }
     else
 	(void)del_char(FALSE);
@@ -8556,7 +8613,7 @@ ins_bs(c, mode, inserted_space_p)
 		break;
 	    }
 	    if (State & REPLACE_FLAG)
-		replace_do_bs();
+		replace_do_bs(-1);
 	    else
 	    {
 #ifdef FEAT_MBYTE

src/eval.c

@@ -3928,7 +3928,7 @@ eval0(arg, rettv, nextcmd, evaluate)
 
 /*
  * Handle top level expression:
- *	expr1 ? expr0 : expr0
+ *	expr2 ? expr1 : expr1
  *
  * "arg" must point to the first non-white of the expression.
  * "arg" is advanced to the next non-white after the recognized expression.
@@ -7918,9 +7918,9 @@ get_func_tv(name, len, rettv, arg, firstline, lastline, doesrange,
     else if (!aborting())
     {
 	if (argcount == MAX_FUNC_ARGS)
-	    emsg_funcname("E740: Too many arguments for function %s", name);
+	    emsg_funcname(N_("E740: Too many arguments for function %s"), name);
 	else
-	    emsg_funcname("E116: Invalid arguments for function %s", name);
+	    emsg_funcname(N_("E116: Invalid arguments for function %s"), name);
     }
 
     while (--argcount >= 0)
@@ -8153,6 +8153,7 @@ call_func(name, len, rettv, argcount, argvars, firstline, lastline,
 
 /*
  * Give an error message with a function name.  Handle <SNR> things.
+ * "ermsg" is to be passed without translation, use N_() instead of _().
  */
     static void
 emsg_funcname(ermsg, name)
@@ -19887,7 +19888,7 @@ ex_function(eap)
 		}
 	    }
 	    else
-		emsg_funcname("E123: Undefined function: %s", name);
+		emsg_funcname(N_("E123: Undefined function: %s"), name);
 	}
 	goto ret_free;
     }
@@ -19931,7 +19932,7 @@ ex_function(eap)
 						      : eval_isnamec(arg[j])))
 		++j;
 	    if (arg[j] != NUL)
-		emsg_funcname(_(e_invarg2), arg);
+		emsg_funcname((char *)e_invarg2, arg);
 	}
     }
 
@@ -20203,7 +20204,7 @@ ex_function(eap)
 	v = find_var(name, &ht);
 	if (v != NULL && v->di_tv.v_type == VAR_FUNC)
 	{
-	    emsg_funcname("E707: Function name conflicts with variable: %s",
+	    emsg_funcname(N_("E707: Function name conflicts with variable: %s"),
 									name);
 	    goto erret;
 	}
@@ -20218,7 +20219,7 @@ ex_function(eap)
 	    }
 	    if (fp->uf_calls > 0)
 	    {
-		emsg_funcname("E127: Cannot redefine function %s: It is in use",
+		emsg_funcname(N_("E127: Cannot redefine function %s: It is in use"),
 									name);
 		goto erret;
 	    }
@@ -21497,7 +21498,7 @@ call_user_func(fp, argcount, argvars, rettv, firstline, lastline, selfdict)
 
 /*
  * Return TRUE if items in "fc" do not have "copyID".  That means they are not
- * referenced from anywyere.
+ * referenced from anywhere.
  */
     static int
 can_free_funccal(fc, copyID)

src/ex_cmds.c

@@ -49,6 +49,7 @@ do_ascii(eap)
     exarg_T	*eap;
 {
     int		c;
+    int		cval;
     char	buf1[20];
     char	buf2[20];
     char_u	buf3[7];
@@ -75,6 +76,10 @@ do_ascii(eap)
     {
 	if (c == NL)	    /* NUL is stored as NL */
 	    c = NUL;
+	if (c == CAR && get_fileformat(curbuf) == EOL_MAC)
+	    cval = NL;	    /* NL is stored as CR */
+	else
+	    cval = c;
 	if (vim_isprintc_strict(c) && (c < ' '
 #ifndef EBCDIC
 		    || c > '~'
@@ -94,7 +99,7 @@ do_ascii(eap)
 	    buf2[0] = NUL;
 	vim_snprintf((char *)IObuff, IOSIZE,
 		_("<%s>%s%s  %d,  Hex %02x,  Octal %03o"),
-					   transchar(c), buf1, buf2, c, c, c);
+				  transchar(c), buf1, buf2, cval, cval, cval);
 #ifdef FEAT_MBYTE
 	if (enc_utf8)
 	    c = cc[ci++];
@@ -2412,8 +2417,8 @@ print_line(lnum, use_number, list)
 	cursor_on();		/* msg_start() switches it off */
 	out_flush();
 	silent_mode = save_silent;
-	info_message = FALSE;
     }
+    info_message = FALSE;
 }
 
 /*
@@ -2702,7 +2707,12 @@ do_write(eap)
 	if (eap->cmdidx == CMD_saveas)
 	{
 	    if (retval == OK)
+	    {
 		curbuf->b_p_ro = FALSE;
+#ifdef FEAT_WINDOWS
+		redraw_tabline = TRUE;
+#endif
+	    }
 	    /* Change directories when the 'acd' option is set. */
 	    DO_AUTOCHDIR
 	}

src/ex_cmds2.c

@@ -2915,6 +2915,7 @@ do_source(fname, check_other, is_vimrc)
     linenr_T		    save_sourcing_lnum;
     char_u		    *p;
     char_u		    *fname_exp;
+    char_u		    *firstline = NULL;
     int			    retval = FAIL;
 #ifdef FEAT_EVAL
     scid_T		    save_current_SID;
@@ -3065,23 +3066,6 @@ do_source(fname, check_other, is_vimrc)
 
     cookie.level = ex_nesting_level;
 #endif
-#ifdef FEAT_MBYTE
-    cookie.conv.vc_type = CONV_NONE;		/* no conversion */
-
-    /* Try reading the first few bytes to check for a UTF-8 BOM. */
-    {
-	char_u	    buf[3];
-
-	if (fread((char *)buf, sizeof(char_u), (size_t)3, cookie.fp)
-								  == (size_t)3
-		&& buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf)
-	    /* Found BOM, setup conversion and skip over it. */
-	    convert_setup(&cookie.conv, (char_u *)"utf-8", p_enc);
-	else
-	    /* No BOM found, rewind. */
-	    fseek(cookie.fp, 0L, SEEK_SET);
-    }
-#endif
 
     /*
      * Keep the sourcing name/lnum, for recursive calls.
@@ -3091,6 +3075,27 @@ do_source(fname, check_other, is_vimrc)
     save_sourcing_lnum = sourcing_lnum;
     sourcing_lnum = 0;
 
+#ifdef FEAT_MBYTE
+    cookie.conv.vc_type = CONV_NONE;		/* no conversion */
+
+    /* Read the first line so we can check for a UTF-8 BOM. */
+    firstline = getsourceline(0, (void *)&cookie, 0);
+    if (firstline != NULL && STRLEN(firstline) >= 3 && firstline[0] == 0xef
+			      && firstline[1] == 0xbb && firstline[2] == 0xbf)
+    {
+	/* Found BOM; setup conversion, skip over BOM and recode the line. */
+	convert_setup(&cookie.conv, (char_u *)"utf-8", p_enc);
+	p = string_convert(&cookie.conv, firstline + 3, NULL);
+	if (p == NULL)
+	    p = vim_strsave(firstline + 3);
+	if (p != NULL)
+	{
+	    vim_free(firstline);
+	    firstline = p;
+	}
+    }
+#endif
+
 #ifdef STARTUPTIME
     time_push(&tv_rel, &tv_start);
 #endif
@@ -3184,9 +3189,8 @@ do_source(fname, check_other, is_vimrc)
     /*
      * Call do_cmdline, which will call getsourceline() to get the lines.
      */
-    do_cmdline(NULL, getsourceline, (void *)&cookie,
+    do_cmdline(firstline, getsourceline, (void *)&cookie,
 				     DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_REPEAT);
-
     retval = OK;
 
 #ifdef FEAT_PROFILE
@@ -3244,6 +3248,7 @@ almosttheend:
 #endif
     fclose(cookie.fp);
     vim_free(cookie.nextline);
+    vim_free(firstline);
 #ifdef FEAT_MBYTE
     convert_setup(&cookie.conv, NULL, NULL);
 #endif

src/ex_docmd.c

@@ -5500,6 +5500,9 @@ invalid_count:
     return OK;
 }
 
+/*
+ * ":command ..."
+ */
     static void
 ex_command(eap)
     exarg_T   *eap;
@@ -5932,6 +5935,7 @@ do_ucmd(eap)
 
     char_u	*start;
     char_u	*end;
+    char_u	*ksp;
     size_t	len, totlen;
 
     size_t	split_len = 0;
@@ -5948,16 +5952,51 @@ do_ucmd(eap)
 
     /*
      * Replace <> in the command by the arguments.
+     * First round: "buf" is NULL, compute length, allocate "buf".
+     * Second round: copy result into "buf".
      */
     buf = NULL;
     for (;;)
     {
-	p = cmd->uc_rep;
-	q = buf;
+	p = cmd->uc_rep;    /* source */
+	q = buf;	    /* destinateion */
 	totlen = 0;
-	while ((start = vim_strchr(p, '<')) != NULL
-	       && (end = vim_strchr(start + 1, '>')) != NULL)
+
+	for (;;)
 	{
+	    start = vim_strchr(p, '<');
+	    if (start != NULL)
+		end = vim_strchr(start + 1, '>');
+	    if (buf != NULL)
+	    {
+		ksp = vim_strchr(p, K_SPECIAL);
+		if (ksp != NULL && (start == NULL || ksp < start || end == NULL)
+			&& ((ksp[1] == KS_SPECIAL && ksp[2] == KE_FILLER)
+# ifdef FEAT_GUI
+			    || (ksp[1] == KS_EXTRA && ksp[2] == (int)KE_CSI)
+# endif
+			    ))
+		{
+		    /* K_SPECIAL han been put in the buffer as K_SPECIAL
+		     * KS_SPECIAL KE_FILLER, like for mappings, but
+		     * do_cmdline() doesn't handle that, so convert it back.
+		     * Also change K_SPECIAL KS_EXTRA KE_CSI into CSI. */
+		    len = ksp - p;
+		    if (len > 0)
+		    {
+			mch_memmove(q, p, len);
+			q += len;
+		    }
+		    *q++ = ksp[1] == KS_SPECIAL ? K_SPECIAL : CSI;
+		    p = ksp + 3;
+		    continue;
+		}
+	    }
+
+	    /* break if there no <item> is found */
+	    if (start == NULL || end == NULL)
+		break;
+
 	    /* Include the '>' */
 	    ++end;
 

src/fileio.c

@@ -6111,12 +6111,24 @@ vim_rename(from, to)
 #ifdef HAVE_ACL
     vim_acl_T	acl;		/* ACL from original file */
 #endif
+#if defined(UNIX) || defined(CASE_INSENSITIVE_FILENAME)
+    int		use_tmp_file = FALSE;
+#endif
 
     /*
-     * When the names are identical, there is nothing to do.
+     * When the names are identical, there is nothing to do.  When they refer
+     * to the same file (ignoring case and slash/backslash differences) but
+     * the file name differs we need to go through a temp file.
      */
     if (fnamecmp(from, to) == 0)
-	return 0;
+    {
+#ifdef CASE_INSENSITIVE_FILENAME
+	if (STRCMP(gettail(from), gettail(to)) != 0)
+	    use_tmp_file = TRUE;
+	else
+#endif
+	    return 0;
+    }
 
     /*
      * Fail if the "from" file doesn't exist.  Avoids that "to" is deleted.
@@ -6124,6 +6136,55 @@ vim_rename(from, to)
     if (mch_stat((char *)from, &st) < 0)
 	return -1;
 
+#ifdef UNIX
+    {
+	struct stat	st_to;
+
+	/* It's possible for the source and destination to be the same file.
+	 * This happens when "from" and "to" differ in case and are on a FAT32
+	 * filesystem.  In that case go through a temp file name. */
+	if (mch_stat((char *)to, &st_to) >= 0
+		&& st.st_dev == st_to.st_dev
+		&& st.st_ino == st_to.st_ino)
+	    use_tmp_file = TRUE;
+    }
+#endif
+
+#if defined(UNIX) || defined(CASE_INSENSITIVE_FILENAME)
+    if (use_tmp_file)
+    {
+	char	tempname[MAXPATHL + 1];
+
+	/*
+	 * Find a name that doesn't exist and is in the same directory.
+	 * Rename "from" to "tempname" and then rename "tempname" to "to".
+	 */
+	if (STRLEN(from) >= MAXPATHL - 5)
+	    return -1;
+	STRCPY(tempname, from);
+	for (n = 123; n < 99999; ++n)
+	{
+	    sprintf((char *)gettail((char_u *)tempname), "%d", n);
+	    if (mch_stat(tempname, &st) < 0)
+	    {
+		if (mch_rename((char *)from, tempname) == 0)
+		{
+		    if (mch_rename(tempname, (char *)to) == 0)
+			return 0;
+		    /* Strange, the second step failed.  Try moving the
+		     * file back and return failure. */
+		    mch_rename(tempname, (char *)from);
+		    return -1;
+		}
+		/* If it fails for one temp name it will most likely fail
+		 * for any temp name, give up. */
+		return -1;
+	    }
+	}
+	return -1;
+    }
+#endif
+
     /*
      * Delete the "to" file, this is required on some systems to make the
      * mch_rename() work, on other systems it makes sure that we don't have

src/fold.c

@@ -740,7 +740,7 @@ deleteFold(start, end, recursive, had_visual)
     garray_T	*found_ga;
     fold_T	*found_fp = NULL;
     linenr_T	found_off = 0;
-    int		use_level = FALSE;
+    int		use_level;
     int		maybe_small = FALSE;
     int		level = 0;
     linenr_T	lnum = start;
@@ -757,6 +757,7 @@ deleteFold(start, end, recursive, had_visual)
 	gap = &curwin->w_folds;
 	found_ga = NULL;
 	lnum_off = 0;
+	use_level = FALSE;
 	for (;;)
 	{
 	    if (!foldFind(gap, lnum - lnum_off, &fp))
@@ -783,20 +784,21 @@ deleteFold(start, end, recursive, had_visual)
 	else
 	{
 	    lnum = found_fp->fd_top + found_fp->fd_len + found_off;
-	    did_one = TRUE;
 
 	    if (foldmethodIsManual(curwin))
 		deleteFoldEntry(found_ga,
 		    (int)(found_fp - (fold_T *)found_ga->ga_data), recursive);
 	    else
 	    {
-		if (found_fp->fd_top + found_off < first_lnum)
-		    first_lnum = found_fp->fd_top;
-		if (lnum > last_lnum)
+		if (first_lnum > found_fp->fd_top + found_off)
+		    first_lnum = found_fp->fd_top + found_off;
+		if (last_lnum < lnum)
 		    last_lnum = lnum;
-		parseMarker(curwin);
+		if (!did_one)
+		    parseMarker(curwin);
 		deleteFoldMarkers(found_fp, recursive, found_off);
 	    }
+	    did_one = TRUE;
 
 	    /* redraw window */
 	    changed_window_setting();
@@ -811,6 +813,10 @@ deleteFold(start, end, recursive, had_visual)
 	    redraw_curbuf_later(INVERTED);
 #endif
     }
+    else
+	/* Deleting markers may make cursor column invalid. */
+	check_cursor_col();
+
     if (last_lnum > 0)
 	changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L);
 }

src/globals.h

@@ -1342,7 +1342,6 @@ EXTERN garray_T error_ga
 
 #ifdef FEAT_NETBEANS_INTG
 EXTERN char *netbeansArg INIT(= NULL);	/* the -nb[:host:port:passwd] arg */
-EXTERN int netbeansCloseFile INIT(= 0);	/* send killed if != 0 */
 EXTERN int netbeansFireChanges INIT(= 1); /* send buffer changes if != 0 */
 EXTERN int netbeansForcedQuit INIT(= 0);/* don't write modified files */
 EXTERN int netbeansReadFile INIT(= 1);	/* OK to read from disk if != 0 */

src/gui.c

@@ -58,7 +58,11 @@ static int can_update_cursor = TRUE; /* can display the cursor */
 gui_start()
 {
     char_u	*old_term;
-#if defined(UNIX) && !defined(__BEOS__)
+#if defined(UNIX) && !defined(__BEOS__) && !defined(MACOS_X)
+    /* By the time we get here Mac OS X will already have forked (it does so
+     * right after scanning the command line) so don't do anything here.  This
+     * means that "f" in 'guioptions' cannot be supported.
+     */
 # define MAY_FORK
     int		dofork = TRUE;
 #endif
@@ -117,82 +121,10 @@ gui_start()
      */
     if (gui.in_use && dofork)
     {
-	pid_t	pid = -1;
-
-# if defined MACOS_X
-        int i;
-
-        /* on os x, you have to exec after a fork, otherwise calls to
-         * frameworks will assert (and without corefoundation, you can't start
-         * the gui. what fun.). See CAVEATS at
-http://developer.apple.com/documentation/Darwin/Reference/ManPages/man2/fork.2.html
-         *
-         * Since we have to go through this anyways, we might as well use vfork.
-         * But: then we can't detach from our starting shell, so stick with
-         * fork.
-         *
-         * Kinda sucks to restart vim when doing :gui, so don't fork in that
-         * case (make sure gui.dofork is only set when interpreting argv, not
-         * when doing :gui. Currently, gui.dofork is set to false in ex_gui().
-         *
-         * Also doesn't work well if vim starts cscope (or some other
-         * subprocess I guess), because it's not transferred to the newly
-         * exec'd process, leaving an orphaned process (not a zombie process)
-         * behind. The Right Thing is to kill all our child processes before
-         * calling exec.
-         */
-
-        /* stolen from http://paste.lisp.org/display/50906 */
-        extern int *_NSGetArgc(void);
-        extern char ***_NSGetArgv(void);
-
-        int argc = *_NSGetArgc();
-        char ** argv = *_NSGetArgv();
-        char * newargv[argc+2];
-
-        newargv[0] = argv[0];
-
-        /*
-         * make sure "-f" is in front of potential "--remote" flags, else
-         * they would consume it.
-         */
-        newargv[1] = "-f";
-
-        for (i = 1; i < argc; i++) {
-            newargv[i + 1] = argv[i];
-        }
-        newargv[argc+1] = NULL;
-
-        /* shut down all the stuff we just started, just to start
-         * it again from the exec :-\ */
-        prepare_getout();
-
-        pid = fork();
-        switch(pid) {
-            case -1:
-#  ifndef NDEBUG
-                fprintf(stderr, "vim: Mac OS X workaround fork() failed!");
-#  endif
-                _exit(255);
-            case 0:
-                /* Child. */
-
-                /* make sure we survive our shell */
-                setsid();
-
-                 /* Restarts the vim process, will not return. */
-                execvp(argv[0], newargv);
-
-                /* if we come here, exec has failed. bail. */
-                _exit(255);
-            default:
-                /* Parent */
-                _exit(0);
-        }
-# else
 	int	pipefd[2];	/* pipe between parent and child */
 	int	pipe_error;
 	char	dummy;
+	pid_t	pid = -1;
 
 	/* Setup a pipe between the child and the parent, so that the parent
 	 * knows when the child has done the setsid() call and is allowed to
@@ -227,30 +159,27 @@ http://developer.apple.com/documentation/Darwin/Reference/ManPages/man2/fork.2.h
 	    _exit(0);
 	}
 
-#  if defined(HAVE_SETSID) || defined(HAVE_SETPGID)
+# if defined(HAVE_SETSID) || defined(HAVE_SETPGID)
 	/*
 	 * Change our process group.  On some systems/shells a CTRL-C in the
 	 * shell where Vim was started would otherwise kill gvim!
 	 */
 	if (pid == 0)	    /* child */
-#   if defined(HAVE_SETSID)
+#  if defined(HAVE_SETSID)
 	    (void)setsid();
-#   else
+#  else
 	    (void)setpgid(0, 0);
-#   endif
 #  endif
+# endif
 	if (!pipe_error)
 	{
 	    close(pipefd[0]);
 	    close(pipefd[1]);
 	}
 
-
-#  if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
+# if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
 	/* Tell the session manager our new PID */
 	gui_mch_forked();
-#  endif
-
 # endif
     }
 #else
@@ -4820,6 +4749,8 @@ ex_gui(eap)
      * Check for "-f" argument: foreground, don't fork.
      * Also don't fork when started with "gvim -f".
      * Do fork when using "gui -b".
+     * Note that Mac OS X will never fork on :gui since it can only fork on
+     * startup right after scanning the command line.
      */
     if (arg[0] == '-'
 	    && (arg[1] == 'f' || arg[1] == 'b')
@@ -4832,13 +4763,6 @@ ex_gui(eap)
     {
 	/* Clear the command.  Needed for when forking+exiting, to avoid part
 	 * of the argument ending up after the shell prompt. */
-
-#ifdef MACOS_X
-        /* os x doesn't really support fork(), so we can't fork of a gui
-         * in an already running vim. see gui_start() for more details.
-         */
-	gui.dofork = FALSE;
-#endif
 	msg_clr_eos_force();
 	gui_start();
     }

src/gui_w32.c

@@ -1582,6 +1582,17 @@ gui_mch_init(void)
     s_findrep_struct.lpstrReplaceWith[0] = NUL;
     s_findrep_struct.wFindWhatLen = MSWIN_FR_BUFSIZE;
     s_findrep_struct.wReplaceWithLen = MSWIN_FR_BUFSIZE;
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+    s_findrep_struct_w.lStructSize = sizeof(s_findrep_struct_w);
+    s_findrep_struct_w.lpstrFindWhat =
+			      (LPWSTR)alloc(MSWIN_FR_BUFSIZE * sizeof(WCHAR));
+    s_findrep_struct_w.lpstrFindWhat[0] = NUL;
+    s_findrep_struct_w.lpstrReplaceWith =
+			      (LPWSTR)alloc(MSWIN_FR_BUFSIZE * sizeof(WCHAR));
+    s_findrep_struct_w.lpstrReplaceWith[0] = NUL;
+    s_findrep_struct_w.wFindWhatLen = MSWIN_FR_BUFSIZE;
+    s_findrep_struct_w.wReplaceWithLen = MSWIN_FR_BUFSIZE;
+# endif
 #endif
 
 theend:
@@ -2938,8 +2949,27 @@ dialog_callback(
 
 	/* If the edit box exists, copy the string. */
 	if (s_textfield != NULL)
-	    GetDlgItemText(hwnd, DLG_NONBUTTON_CONTROL + 2,
+	{
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+	    /* If the OS is Windows NT, and 'encoding' differs from active
+	     * codepage: use wide function and convert text. */
+	    if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
+		    && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
+            {
+	       WCHAR  *wp = (WCHAR *)alloc(IOSIZE * sizeof(WCHAR));
+	       char_u *p;
+
+	       GetDlgItemTextW(hwnd, DLG_NONBUTTON_CONTROL + 2, wp, IOSIZE);
+	       p = utf16_to_enc(wp, NULL);
+	       vim_strncpy(s_textfield, p, IOSIZE);
+	       vim_free(p);
+	       vim_free(wp);
+	    }
+	    else
+# endif
+		GetDlgItemText(hwnd, DLG_NONBUTTON_CONTROL + 2,
 							 s_textfield, IOSIZE);
+	}
 
 	/*
 	 * Need to check for IDOK because if the user just hits Return to

src/gui_w48.c

@@ -153,6 +153,9 @@ static int		destroying = FALSE;	/* call DestroyWindow() ourselves */
 #ifdef MSWIN_FIND_REPLACE
 static UINT		s_findrep_msg = 0;	/* set in gui_w[16/32].c */
 static FINDREPLACE	s_findrep_struct;
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+static FINDREPLACEW	s_findrep_struct_w;
+# endif
 static HWND		s_findrep_hwnd = NULL;
 static int		s_findrep_is_find;	/* TRUE for find dialog, FALSE
 						   for find/replace dialog */
@@ -884,6 +887,45 @@ _OnMenu(
 #endif
 
 #ifdef MSWIN_FIND_REPLACE
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+/*
+ * copy useful data from structure LPFINDREPLACE to structure LPFINDREPLACEW
+ */
+    static void
+findrep_atow(LPFINDREPLACEW lpfrw, LPFINDREPLACE lpfr)
+{
+    WCHAR *wp;
+
+    lpfrw->hwndOwner = lpfr->hwndOwner;
+    lpfrw->Flags = lpfr->Flags;
+
+    wp = enc_to_utf16(lpfr->lpstrFindWhat, NULL);
+    wcsncpy(lpfrw->lpstrFindWhat, wp, lpfrw->wFindWhatLen - 1);
+    vim_free(wp);
+
+    /* the field "lpstrReplaceWith" doesn't need to be copied */
+}
+
+/*
+ * copy useful data from structure LPFINDREPLACEW to structure LPFINDREPLACE
+ */
+    static void
+findrep_wtoa(LPFINDREPLACE lpfr, LPFINDREPLACEW lpfrw)
+{
+    char_u *p;
+
+    lpfr->Flags = lpfrw->Flags;
+
+    p = utf16_to_enc(lpfrw->lpstrFindWhat, NULL);
+    vim_strncpy(lpfr->lpstrFindWhat, p, lpfr->wFindWhatLen - 1);
+    vim_free(p);
+
+    p = utf16_to_enc(lpfrw->lpstrReplaceWith, NULL);
+    vim_strncpy(lpfr->lpstrReplaceWith, p, lpfr->wReplaceWithLen - 1);
+    vim_free(p);
+}
+# endif
+
 /*
  * Handle a Find/Replace window message.
  */
@@ -893,6 +935,16 @@ _OnFindRepl(void)
     int	    flags = 0;
     int	    down;
 
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+    /* If the OS is Windows NT, and 'encoding' differs from active codepage:
+     * convert text from wide string. */
+    if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
+			&& enc_codepage >= 0 && (int)GetACP() != enc_codepage)
+    {
+        findrep_wtoa(&s_findrep_struct, &s_findrep_struct_w);
+    }
+# endif
+
     if (s_findrep_struct.Flags & FR_DIALOGTERM)
 	/* Give main window the focus back. */
 	(void)SetFocus(s_hwnd);
@@ -1663,8 +1715,17 @@ process_message(void)
     if (msg.message == WM_OLE)
     {
 	char_u *str = (char_u *)msg.lParam;
-	add_to_input_buf(str, (int)STRLEN(str));
-	vim_free(str);
+	if (str == NULL || *str == NUL)
+	{
+	    /* Message can't be ours, forward it.  Fixes problem with Ultramon
+	     * 3.0.4 */
+	    DispatchMessage(&msg);
+	}
+	else
+	{
+	    add_to_input_buf(str, (int)STRLEN(str));
+	    vim_free(str);  /* was allocated in CVim::SendKeys() */
+	}
 	return;
     }
 #endif
@@ -2553,7 +2614,19 @@ gui_mch_find_dialog(exarg_T *eap)
 	if (!IsWindow(s_findrep_hwnd))
 	{
 	    initialise_findrep(eap->arg);
-	    s_findrep_hwnd = FindText((LPFINDREPLACE) &s_findrep_struct);
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+	    /* If the OS is Windows NT, and 'encoding' differs from active
+	     * codepage: convert text and use wide function. */
+	    if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
+		    && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
+	    {
+	        findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
+		s_findrep_hwnd = FindTextW(
+					(LPFINDREPLACEW) &s_findrep_struct_w);
+	    }
+	    else
+# endif
+		s_findrep_hwnd = FindText((LPFINDREPLACE) &s_findrep_struct);
 	}
 
 	set_window_title(s_findrep_hwnd,
@@ -2578,7 +2651,18 @@ gui_mch_replace_dialog(exarg_T *eap)
 	if (!IsWindow(s_findrep_hwnd))
 	{
 	    initialise_findrep(eap->arg);
-	    s_findrep_hwnd = ReplaceText((LPFINDREPLACE) &s_findrep_struct);
+# if defined(FEAT_MBYTE) && defined(WIN3264)
+	    if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT
+		    && enc_codepage >= 0 && (int)GetACP() != enc_codepage)
+	    {
+		findrep_atow(&s_findrep_struct_w, &s_findrep_struct);
+		s_findrep_hwnd = ReplaceTextW(
+					(LPFINDREPLACEW) &s_findrep_struct_w);
+	    }
+	    else
+# endif
+		s_findrep_hwnd = ReplaceText(
+					   (LPFINDREPLACE) &s_findrep_struct);
 	}
 
 	set_window_title(s_findrep_hwnd,

src/if_cscope.c

@@ -1177,8 +1177,16 @@ cs_help(eap)
     (void)MSG_PUTS(_("cscope commands:\n"));
     while (cmdp->name != NULL)
     {
-	(void)smsg((char_u *)_("%-5s: %-30s (Usage: %s)"),
-				      cmdp->name, _(cmdp->help), cmdp->usage);
+	char *help = _(cmdp->help);
+	int  space_cnt = 30 - vim_strsize((char_u *)help);
+
+	/* Use %*s rather than %30s to ensure proper alignment in utf-8 */
+	if (space_cnt < 0)
+	    space_cnt = 0;
+	(void)smsg((char_u *)_("%-5s: %s%*s (Usage: %s)"),
+				      cmdp->name,
+				      help, space_cnt, " ",
+				      cmdp->usage);
 	if (strcmp(cmdp->name, "find") == 0)
 	    MSG_PUTS(_("\n"
 		       "       c: Find functions calling this function\n"

src/if_ole.cpp

@@ -353,9 +353,13 @@ CVim::SendKeys(BSTR keys)
     }
 
     /* Pass the string to the main input loop. The memory will be freed when
-     * the message is processed.
+     * the message is processed.  Except for an empty message, we don't need
+     * to post it then.
      */
-    PostMessage(NULL, WM_OLE, 0, (LPARAM)str);
+    if (*str == NUL)
+	vim_free(str);
+    else
+	PostMessage(NULL, WM_OLE, 0, (LPARAM)str);
 
     return S_OK;
 }

src/if_python.c

@@ -1151,14 +1151,23 @@ VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
 
     /* Check if we run into a recursive loop.  The item must be in lookupDict
      * then and we can use it again. */
-    sprintf(ptrBuf, PRINTF_DECIMAL_LONG_U, (long_u)our_tv);
-    result = PyDict_GetItemString(lookupDict, ptrBuf);
-    if (result != NULL)
-	Py_INCREF(result);
-    else if (our_tv->v_type == VAR_STRING)
+    if ((our_tv->v_type == VAR_LIST && our_tv->vval.v_list != NULL)
+	    || (our_tv->v_type == VAR_DICT && our_tv->vval.v_dict != NULL))
+    {
+	sprintf(ptrBuf, PRINTF_DECIMAL_LONG_U,
+	        our_tv->v_type == VAR_LIST ? (long_u)our_tv->vval.v_list
+		                           : (long_u)our_tv->vval.v_dict);
+	result = PyDict_GetItemString(lookupDict, ptrBuf);
+	if (result != NULL)
+	{
+	    Py_INCREF(result);
+	    return result;
+	}
+    }
+
+    if (our_tv->v_type == VAR_STRING)
     {
 	result = Py_BuildValue("s", our_tv->vval.v_string);
-	PyDict_SetItemString(lookupDict, ptrBuf, result);
     }
     else if (our_tv->v_type == VAR_NUMBER)
     {
@@ -1167,7 +1176,6 @@ VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
 	/* For backwards compatibility numbers are stored as strings. */
 	sprintf(buf, "%ld", (long)our_tv->vval.v_number);
 	result = Py_BuildValue("s", buf);
-	PyDict_SetItemString(lookupDict, ptrBuf, result);
     }
 # ifdef FEAT_FLOAT
     else if (our_tv->v_type == VAR_FLOAT)
@@ -1176,7 +1184,6 @@ VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
 
 	sprintf(buf, "%f", our_tv->vval.v_float);
 	result = Py_BuildValue("s", buf);
-	PyDict_SetItemString(lookupDict, ptrBuf, result);
     }
 # endif
     else if (our_tv->v_type == VAR_LIST)
@@ -1185,10 +1192,11 @@ VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
 	listitem_T	*curr;
 
 	result = PyList_New(0);
-	PyDict_SetItemString(lookupDict, ptrBuf, result);
 
 	if (list != NULL)
 	{
+	    PyDict_SetItemString(lookupDict, ptrBuf, result);
+
 	    for (curr = list->lv_first; curr != NULL; curr = curr->li_next)
 	    {
 		newObj = VimToPython(&curr->li_tv, depth + 1, lookupDict);
@@ -1200,7 +1208,6 @@ VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
     else if (our_tv->v_type == VAR_DICT)
     {
 	result = PyDict_New();
-	PyDict_SetItemString(lookupDict, ptrBuf, result);
 
 	if (our_tv->vval.v_dict != NULL)
 	{
@@ -1209,6 +1216,8 @@ VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
 	    hashitem_T	*hi;
 	    dictitem_T	*di;
 
+	    PyDict_SetItemString(lookupDict, ptrBuf, result);
+
 	    for (hi = ht->ht_array; todo > 0; ++hi)
 	    {
 		if (!HASHITEM_EMPTY(hi))

src/main.c

@@ -360,6 +360,11 @@ main
     command_line_scan(&params);
     TIME_MSG("parsing arguments");
 
+#ifdef MACOS_X
+    if (gui.starting && gui.dofork)
+	macosx_fork();	/* Never returns */
+#endif
+
     /*
      * On some systems, when we compile with the GUI, we always use it.  On Mac
      * there is no terminal version, and on Windows we can't fork one off with
@@ -1282,9 +1287,10 @@ getout_preserve_modified(exitval)
 #endif
 
 
-/* Prepare proper exit*/
+/* Exit properly */
     void
-prepare_getout()
+getout(exitval)
+    int		exitval;
 {
 #ifdef FEAT_AUTOCMD
     buf_T	*buf;
@@ -1294,6 +1300,12 @@ prepare_getout()
 
     exiting = TRUE;
 
+    /* When running in Ex mode an error causes us to exit with a non-zero exit
+     * code.  POSIX requires this, although it's not 100% clear from the
+     * standard. */
+    if (exmode_active)
+	exitval += ex_exitval;
+
     /* Position the cursor on the last screen line, below all the text */
 #ifdef FEAT_GUI
     if (!gui.in_use)
@@ -1410,20 +1422,7 @@ prepare_getout()
     if (garbage_collect_at_exit)
 	garbage_collect();
 #endif
-}
 
-/* Exit properly */
-    void
-getout(exitval)
-    int		exitval;
-{
-    /* When running in Ex mode an error causes us to exit with a non-zero exit
-     * code.  POSIX requires this, although it's not 100% clear from the
-     * standard. */
-    if (exmode_active)
-	exitval += ex_exitval;
-
-    prepare_getout();
     mch_exit(exitval);
 }
 

src/message.c

@@ -3309,7 +3309,10 @@ do_dialog(type, title, message, buttons, dfltbutton, textfield)
     {
 	c = gui_mch_dialog(type, title, message, buttons, dfltbutton,
 								   textfield);
-	msg_end_prompt();
+	/* avoid a hit-enter prompt without clearing the cmdline */
+	need_wait_return = FALSE;
+	emsg_on_display = FALSE;
+	cmdline_row = msg_row;
 
 	/* Flush output to avoid that further messages and redrawing is done
 	 * in the wrong order. */
@@ -4556,7 +4559,13 @@ vim_snprintf(str, str_m, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
 			remove_trailing_zeroes = TRUE;
 		    }
 
-		    if (fmt_spec == 'f' && abs_f > 1.0e307)
+		    if (fmt_spec == 'f' &&
+#ifdef VAX
+			    abs_f > 1.0e38
+#else
+			    abs_f > 1.0e307
+#endif
+			    )
 		    {
 			/* Avoid a buffer overflow */
 			strcpy(tmp, "inf");

src/misc2.c

@@ -4696,7 +4696,8 @@ vim_findfile(search_ctx_arg)
 				stackp->ffs_filearray_cur = i + 1;
 				ff_push(search_ctx, stackp);
 
-				simplify_filename(file_path);
+				if (!path_with_url(file_path))
+				    simplify_filename(file_path);
 				if (mch_dirname(ff_expand_buffer, MAXPATHL)
 									== OK)
 				{

src/netbeans.c

@@ -2921,44 +2921,26 @@ netbeans_file_opened(buf_T *bufp)
 }
 
 /*
- * Tell netbeans a file was closed.
+ * Tell netbeans that a file was deleted or wiped out.
  */
     void
-netbeans_file_closed(buf_T *bufp)
+netbeans_file_killed(buf_T *bufp)
 {
     int		bufno = nb_getbufno(bufp);
     nbbuf_T	*nbbuf = nb_get_buf(bufno);
     char	buffer[2*MAXPATHL];
 
-    if (!haveConnection || bufno < 0)
+    if (!haveConnection || bufno == -1)
 	return;
 
-    if (!netbeansCloseFile)
-    {
-	nbdebug(("Ignoring file_closed for %s. File was closed from IDE\n",
-		    bufp->b_ffname));
-	return;
-    }
-
-    nbdebug(("netbeans_file_closed:\n"));
-    nbdebug(("    Closing bufno: %d", bufno));
-    if (curbuf != NULL && curbuf != bufp)
-    {
-	nbdebug(("    Curbuf bufno:  %d\n", nb_getbufno(curbuf)));
-    }
-    else if (curbuf == bufp)
-    {
-	nbdebug(("    curbuf == bufp\n"));
-    }
-
-    if (bufno <= 0)
-	return;
+    nbdebug(("netbeans_file_killed:\n"));
+    nbdebug(("    Killing bufno: %d", bufno));
 
     sprintf(buffer, "%d:killed=%d\n", bufno, r_cmdno);
 
     nbdebug(("EVT: %s", buffer));
 
-    nb_send(buffer, "netbeans_file_closed");
+    nb_send(buffer, "netbeans_file_killed");
 
     if (nbbuf != NULL)
 	nbbuf->bufp = NULL;

src/normal.c

@@ -6811,6 +6811,8 @@ nv_replace(cap)
     /* Visual mode "r" */
     if (VIsual_active)
     {
+	if (got_int)
+	    reset_VIsual();
 	nv_operator(cap);
 	return;
     }
@@ -7867,7 +7869,7 @@ nv_g_cmd(cap)
 	else
 	    i = curwin->w_leftcol;
 	/* Go to the middle of the screen line.  When 'number' is on and lines
-	 * are wrapping the middle can be more to the left.*/
+	 * are wrapping the middle can be more to the left. */
 	if (cap->nchar == 'm')
 	    i += (W_WIDTH(curwin) - curwin_col_off()
 		    + ((curwin->w_p_wrap && i > 0)

src/option.c

@@ -4178,11 +4178,23 @@ do_set(arg, opt_flags)
 					   && options[opt_idx].var == VAR_WIN)
 		goto skip;
 
-	    /* Disallow changing some options from modelines */
-	    if ((opt_flags & OPT_MODELINE) && (flags & P_SECURE))
+	    /* Disallow changing some options from modelines. */
+	    if (opt_flags & OPT_MODELINE)
 	    {
-		errmsg = (char_u *)_("E520: Not allowed in a modeline");
-		goto skip;
+		if (flags & P_SECURE)
+		{
+		    errmsg = (char_u *)_("E520: Not allowed in a modeline");
+		    goto skip;
+		}
+#ifdef FEAT_DIFF
+		/* In diff mode some options are overruled.  This avoids that
+		 * 'foldmethod' becomes "marker" instead of "diff" and that
+		 * "wrap" gets set. */
+		if (curwin->w_p_diff
+			&& (options[opt_idx].indir == PV_FDM
+			    || options[opt_idx].indir == PV_WRAP))
+		    goto skip;
+#endif
 	    }
 
 #ifdef HAVE_SANDBOX
@@ -5332,6 +5344,21 @@ insecure_flag(opt_idx, opt_flags)
 }
 #endif
 
+#ifdef FEAT_TITLE
+static void redraw_titles __ARGS((void));
+
+/*
+ * Redraw the window title and/or tab page text later.
+ */
+static void redraw_titles()
+{
+    need_maketitle = TRUE;
+# ifdef FEAT_WINDOWS
+    redraw_tabline = TRUE;
+# endif
+}
+#endif
+
 /*
  * Set a string option to a new value (without checking the effect).
  * The string is copied into allocated memory.
@@ -5471,6 +5498,10 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
     int		did_chartab = FALSE;
     char_u	**gvarp;
     long_u	free_oldval = (options[opt_idx].flags & P_ALLOCED);
+#ifdef FEAT_GUI
+    /* set when changing an option that only requires a redraw in the GUI */
+    int		redraw_gui_only = FALSE;
+#endif
 
     /* Get the global option to compare with, otherwise we would have to check
      * two values for all local options. */
@@ -5732,7 +5763,7 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 	    {
 # ifdef FEAT_TITLE
 		/* May show a "+" in the title now. */
-		need_maketitle = TRUE;
+		redraw_titles();
 # endif
 		/* Add 'fileencoding' to the swap file. */
 		ml_setflags(curbuf);
@@ -5751,7 +5782,7 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 	    {
 		errmsg = mb_init();
 # ifdef FEAT_TITLE
-		need_maketitle = TRUE;
+		redraw_titles();
 # endif
 	    }
 	}
@@ -5864,7 +5895,7 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 	    else
 		curbuf->b_p_tx = FALSE;
 #ifdef FEAT_TITLE
-	    need_maketitle = TRUE;
+	    redraw_titles();
 #endif
 	    /* update flag in swap file */
 	    ml_setflags(curbuf);
@@ -6124,6 +6155,7 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 		    errmsg = (char_u *)N_("E596: Invalid font(s)");
 	    }
 	}
+	redraw_gui_only = TRUE;
     }
 # ifdef FEAT_XFONTSET
     else if (varp == &p_guifontset)
@@ -6132,6 +6164,7 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 	    errmsg = (char_u *)N_("E597: can't select fontset");
 	else if (gui.in_use && gui_init_font(p_guifontset, TRUE) != OK)
 	    errmsg = (char_u *)N_("E598: Invalid fontset");
+	redraw_gui_only = TRUE;
     }
 # endif
 # ifdef FEAT_MBYTE
@@ -6141,6 +6174,7 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 	    errmsg = (char_u *)N_("E533: can't select wide font");
 	else if (gui_get_wide_font() == FAIL)
 	    errmsg = (char_u *)N_("E534: Invalid wide font");
+	redraw_gui_only = TRUE;
     }
 # endif
 #endif
@@ -6202,13 +6236,24 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 #ifdef FEAT_GUI
     /* 'guioptions' */
     else if (varp == &p_go)
+    {
 	gui_init_which_components(oldval);
+	redraw_gui_only = TRUE;
+    }
 #endif
 
 #if defined(FEAT_GUI_TABLINE)
     /* 'guitablabel' */
     else if (varp == &p_gtl)
+    {
 	redraw_tabline = TRUE;
+	redraw_gui_only = TRUE;
+    }
+    /* 'guitabtooltip' */
+    else if (varp == &p_gtt)
+    {
+	redraw_gui_only = TRUE;
+    }
 #endif
 
 #if defined(FEAT_MOUSE_TTY) && (defined(UNIX) || defined(VMS))
@@ -6797,7 +6842,11 @@ did_set_string_option(opt_idx, varp, new_value_alloced, oldval, errbuf,
 
     if (curwin->w_curswant != MAXCOL)
 	curwin->w_set_curswant = TRUE;  /* in case 'showbreak' changed */
-    check_redraw(options[opt_idx].flags);
+#ifdef FEAT_GUI
+    /* check redraw when it's not a GUI option or the GUI is active. */
+    if (!redraw_gui_only || gui.in_use)
+#endif
+	check_redraw(options[opt_idx].flags);
 
     return errmsg;
 }
@@ -7185,22 +7234,28 @@ set_bool_option(opt_idx, varp, value, opt_flags)
 	    curbuf->b_did_warn = FALSE;
 
 #ifdef FEAT_TITLE
-	need_maketitle = TRUE;
+	redraw_titles();
 #endif
     }
 
 #ifdef FEAT_TITLE
     /* when 'modifiable' is changed, redraw the window title */
     else if ((int *)varp == &curbuf->b_p_ma)
-	need_maketitle = TRUE;
+    {
+	redraw_titles();
+    }
     /* when 'endofline' is changed, redraw the window title */
     else if ((int *)varp == &curbuf->b_p_eol)
-	need_maketitle = TRUE;
-#ifdef FEAT_MBYTE
-    /* when 'bomb' is changed, redraw the window title */
+    {
+	redraw_titles();
+    }
+# ifdef FEAT_MBYTE
+    /* when 'bomb' is changed, redraw the window title and tab page text */
     else if ((int *)varp == &curbuf->b_p_bomb)
-	need_maketitle = TRUE;
-#endif
+    {
+	redraw_titles();
+    }
+# endif
 #endif
 
     /* when 'bin' is set also set some other options */
@@ -7208,7 +7263,7 @@ set_bool_option(opt_idx, varp, value, opt_flags)
     {
 	set_options_bin(old_value, curbuf->b_p_bin, opt_flags);
 #ifdef FEAT_TITLE
-	need_maketitle = TRUE;
+	redraw_titles();
 #endif
     }
 
@@ -7393,7 +7448,7 @@ set_bool_option(opt_idx, varp, value, opt_flags)
 	if (!value)
 	    save_file_ff(curbuf);	/* Buffer is unchanged */
 #ifdef FEAT_TITLE
-	need_maketitle = TRUE;
+	redraw_titles();
 #endif
 #ifdef FEAT_AUTOCMD
 	modified_was_set = value;
@@ -7828,7 +7883,7 @@ set_num_option(opt_idx, varp, value, errbuf, errbuflen, opt_flags)
 	newFoldLevel();
     }
 
-    /* 'foldminlevel' */
+    /* 'foldminlines' */
     else if (pp == &curwin->w_p_fml)
     {
 	foldUpdateAll(curwin);

src/os_macosx.c

@@ -609,3 +609,67 @@ mch_textdomain(const char *domain)
     return (char*)domain;
 }
 #endif
+
+
+
+void macosx_fork()
+{
+    pid_t pid;
+    int   i;
+
+    /*
+     * On OS X, you have to exec after a fork, otherwise calls to frameworks
+     * will assert (and without Core Foundation, you can't start the gui. What
+     * fun.). See CAVEATS at:
+     *
+     *   http://developer.apple.com/documentation/Darwin/Reference/ManPages/
+     *							    man2/fork.2.html
+     *
+     * Since we have to go through this anyways, we might as well use vfork.
+     * But: then we can't detach from our starting shell, so stick with fork.
+     */
+
+    /* Stolen from http://paste.lisp.org/display/50906 */
+    extern int *_NSGetArgc(void);
+    extern char ***_NSGetArgv(void);
+
+    int argc = *_NSGetArgc();
+    char ** argv = *_NSGetArgv();
+    char * newargv[argc+2];
+
+    newargv[0] = argv[0];
+
+    /*
+     * Make sure "-f" is in front of potential "--remote" flags, else
+     * they would consume it.
+     */
+    newargv[1] = "-f";
+
+    for (i = 1; i < argc; i++) {
+	newargv[i + 1] = argv[i];
+    }
+    newargv[argc+1] = NULL;
+
+    pid = fork();
+    switch(pid) {
+	case -1:
+#  ifndef NDEBUG
+	    fprintf(stderr, "vim: Mac OS X workaround fork() failed!");
+#  endif
+	    _exit(255);
+	case 0:
+	    /* Child. */
+
+	    /* Make sure we survive our shell */
+	    setsid();
+
+	    /* Restarts the vim process, will not return. */
+	    execvp(argv[0], newargv);
+
+	    /* If we come here, exec has failed. bail. */
+	    _exit(255);
+	default:
+	    /* Parent */
+	    _exit(0);
+    }
+}

src/os_mswin.c

@@ -1223,6 +1223,25 @@ utf16_to_enc(short_u *str, int *lenp)
 }
 #endif /* FEAT_MBYTE */
 
+/*
+ * Wait for another process to Close the Clipboard.
+ * Returns TRUE for success.
+ */
+    int
+vim_open_clipboard()
+{
+    int delay = 10;
+
+    while (!OpenClipboard(NULL))
+    {
+        if (delay > 500)
+            return FALSE;  /* waited too long, give up */
+        Sleep(delay);
+        delay *= 2;	/* wait for 10, 20, 40, 80, etc. msec */
+    }
+    return TRUE;
+}
+
 /*
  * Get the current selection and put it in the clipboard register.
  *
@@ -1254,7 +1273,7 @@ clip_mch_request_selection(VimClipboard *cbd)
      * Don't pass GetActiveWindow() as an argument to OpenClipboard() because
      * then we can't paste back into the same window for some reason - webb.
      */
-    if (!OpenClipboard(NULL))
+    if (!vim_open_clipboard())
 	return;
 
     /* Check for vim's own clipboard format first.  This only gets the type of
@@ -1562,7 +1581,7 @@ clip_mch_set_selection(VimClipboard *cbd)
      * because then we can't paste back into the same window for some
      * reason - webb.
      */
-    if (OpenClipboard(NULL))
+    if (vim_open_clipboard())
     {
 	if (EmptyClipboard())
 	{

src/os_unix.c

@@ -3952,7 +3952,17 @@ mch_call_shell(cmd, options)
 		 * children can be kill()ed.  Don't do this when using pipes,
 		 * because stdin is not a tty, we would lose /dev/tty. */
 		if (p_stmp)
+		{
 		    (void)setsid();
+#  if defined(SIGHUP)
+		    /* When doing "!xterm&" and 'shell' is bash: the shell
+		     * will exit and send SIGHUP to all processes in its
+		     * group, killing the just started process.  Ignore SIGHUP
+		     * to avoid that. (suggested by Simon Schubert)
+		     */
+		    signal(SIGHUP, SIG_IGN);
+#  endif
+		}
 # endif
 # ifdef FEAT_GUI
 		if (pty_slave_fd >= 0)

src/proto.h

@@ -263,6 +263,9 @@ extern char *vim_SelFile __ARGS((Widget toplevel, char *prompt, char *init_path,
 #ifdef MACOS_CONVERT
 # include "os_mac_conv.pro"
 #endif
+#ifdef MACOS_X
+# include "os_macosx.pro"
+#endif
 
 #ifdef __BORLANDC__
 # define _PROTO_H

src/proto/main.pro

@@ -1,6 +1,5 @@
 /* main.c */
 void main_loop __ARGS((int cmdwin, int noexmode));
-void prepare_getout __ARGS(());
 void getout_preserve_modified __ARGS((int exitval));
 void getout __ARGS((int exitval));
 int process_env __ARGS((char_u *env, int is_viminit));

src/proto/netbeans.pro

@@ -11,7 +11,7 @@ void netbeans_send_disconnect __ARGS((void));
 void netbeans_frame_moved __ARGS((int new_x, int new_y));
 void netbeans_file_activated __ARGS((buf_T *bufp));
 void netbeans_file_opened __ARGS((buf_T *bufp));
-void netbeans_file_closed __ARGS((buf_T *bufp));
+void netbeans_file_killed __ARGS((buf_T *bufp));
 void netbeans_inserted __ARGS((buf_T *bufp, linenr_T linenr, colnr_T col, char_u *txt, int newlen));
 void netbeans_removed __ARGS((buf_T *bufp, linenr_T linenr, colnr_T col, long len));
 void netbeans_unmodified __ARGS((buf_T *bufp));

src/proto/os_macosx.pro

@@ -0,0 +1,3 @@
+/* os_macosx.pro */
+void macosx_fork __ARGS((void));
+/* vim: set ft=c : */

src/spell.c

@@ -2376,7 +2376,7 @@ spell_move_to(wp, dir, allwords, curline, attrp)
 
 	    /* If we are back at the starting line and there is no match then
 	     * give up. */
-	    if (lnum == wp->w_cursor.lnum && !found_one)
+	    if (lnum == wp->w_cursor.lnum && (!found_one || wrapped))
 		break;
 
 	    /* Skip the characters at the start of the next line that were
@@ -4956,13 +4956,16 @@ typedef struct compitem_S
  * Structure that is used to store the items in the word tree.  This avoids
  * the need to keep track of each allocated thing, everything is freed all at
  * once after ":mkspell" is done.
+ * Note: "sb_next" must be just before "sb_data" to make sure the alignment of
+ * "sb_data" is correct for systems where pointers must be aligned on
+ * pointer-size boundaries and sizeof(pointer) > sizeof(int) (e.g., Sparc).
  */
 #define  SBLOCKSIZE 16000	/* size of sb_data */
 typedef struct sblock_S sblock_T;
 struct sblock_S
 {
-    sblock_T	*sb_next;	/* next block in list */
     int		sb_used;	/* nr of bytes already in use */
+    sblock_T	*sb_next;	/* next block in list */
     char_u	sb_data[1];	/* data, actually longer */
 };
 
@@ -15011,7 +15014,7 @@ soundalike_score(goodstart, badstart)
 
 	case 0:
 	    /*
-	     * Lenghts are equal, thus changes must result in same length: An
+	     * Lengths are equal, thus changes must result in same length: An
 	     * insert is only possible in combination with a delete.
 	     * 1: check if for identical strings
 	     */

src/tag.c

@@ -515,7 +515,7 @@ do_tag(tag, type, count, forceit, verbose)
 	     * If a count is supplied to the ":tag <name>" command, then
 	     * jump to count'th matching tag.
 	     */
-	    if (type == DT_TAG && count > 0)
+	    if (type == DT_TAG && *tag != NUL && count > 0)
 		cur_match = count - 1;
 
 	    if (type == DT_SELECT || type == DT_JUMP

src/term.c

@@ -4920,7 +4920,15 @@ check_termcode(max_offset, buf, buflen)
 	key_name[0] = KEY2TERMCAP0(key);
 	key_name[1] = KEY2TERMCAP1(key);
 	if (key_name[0] == KS_KEY)
-	    string[new_slen++] = key_name[1];	/* from ":set <M-b>=xx" */
+	{
+	    /* from ":set <M-b>=xx" */
+#ifdef FEAT_MBYTE
+	    if (has_mbyte)
+		new_slen += (*mb_char2bytes)(key_name[1], string + new_slen);
+	    else
+#endif
+		string[new_slen++] = key_name[1];
+	}
 	else
 	{
 	    string[new_slen++] = K_SPECIAL;

src/version.c

@@ -691,6 +691,72 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    108,
+/**/
+    107,
+/**/
+    106,
+/**/
+    105,
+/**/
+    104,
+/**/
+    103,
+/**/
+    102,
+/**/
+    101,
+/**/
+    100,
+/**/
+    99,
+/**/
+    98,
+/**/
+    97,
+/**/
+    96,
+/**/
+    95,
+/**/
+    94,
+/**/
+    93,
+/**/
+    92,
+/**/
+    91,
+/**/
+    90,
+/**/
+    89,
+/**/
+    88,
+/**/
+    87,
+/**/
+    86,
+/**/
+    85,
+/**/
+    84,
+/**/
+    83,
+/**/
+    82,
+/**/
+    81,
+/**/
+    80,
+/**/
+    79,
+/**/
+    78,
+/**/
+    77,
+/**/
+    76,
 /**/
     75,
 /**/