diff -caPr ..\vimorg/Makefile ./Makefile
*** ..\vimorg/Makefile	2010-04-19 14:38:58.102556800 +0200
--- ./Makefile	2010-04-19 17:39:53.344988200 +0200
***************
*** 81,87 ****
  #   runtime/doc/*.txt and nsis/gvim.nsi. Other things in README_os2.txt.  For a
  #   minor/major version: src/GvimExt/GvimExt.reg, src/vim.def, src/vim16.def.
  # - Correct included_patches[] in src/version.c.
! # - Compile Vim with GTK, Perl, Python, TCL, Ruby, MZscheme (if you can make it
  #   work), Cscope and "huge" features.  Exclude workshop and SNiFF.
  # - With these features: "make proto" (requires cproto and Motif installed;
  #   ignore warnings for missing include files, fix problems for syntax errors).
--- 81,87 ----
  #   runtime/doc/*.txt and nsis/gvim.nsi. Other things in README_os2.txt.  For a
  #   minor/major version: src/GvimExt/GvimExt.reg, src/vim.def, src/vim16.def.
  # - Correct included_patches[] in src/version.c.
! # - Compile Vim with GTK, Perl, Python, Python3, TCL, Ruby, MZscheme (if you can make it
  #   work), Cscope and "huge" features.  Exclude workshop and SNiFF.
  # - With these features: "make proto" (requires cproto and Motif installed;
  #   ignore warnings for missing include files, fix problems for syntax errors).
diff -caPr ..\vimorg/runtime/autoload/python3complete.vim ./runtime/autoload/python3complete.vim
*** ..\vimorg/runtime/autoload/python3complete.vim	1970-01-01 01:00:00.000000000 +0100
--- ./runtime/autoload/python3complete.vim	2010-04-19 17:39:53.344988200 +0200
***************
*** 0 ****
--- 1,606 ----
+ "python3complete.vim - Omni Completion for python
+ " Maintainer: Aaron Griffin <aaronmgriffin@gmail.com>
+ " Version: 0.9
+ " Last Updated: 18 Jun 2009
+ "
+ " Roland Puntaier: this file contains adaptations for python3 and is parallel to pythoncomplete.vim
+ "
+ " Changes
+ " TODO:
+ " 'info' item output can use some formatting work
+ " Add an "unsafe eval" mode, to allow for return type evaluation
+ " Complete basic syntax along with import statements
+ "   i.e. "import url<c-x,c-o>"
+ " Continue parsing on invalid line??
+ "
+ " v 0.9
+ "   * Fixed docstring parsing for classes and functions
+ "   * Fixed parsing of *args and **kwargs type arguments
+ "   * Better function param parsing to handle things like tuples and
+ "     lambda defaults args
+ "
+ " v 0.8
+ "   * Fixed an issue where the FIRST assignment was always used instead of
+ "   using a subsequent assignment for a variable
+ "   * Fixed a scoping issue when working inside a parameterless function
+ "
+ "
+ " v 0.7
+ "   * Fixed function list sorting (_ and __ at the bottom)
+ "   * Removed newline removal from docs.  It appears vim handles these better in
+ "   recent patches
+ "
+ " v 0.6:
+ "   * Fixed argument completion
+ "   * Removed the 'kind' completions, as they are better indicated
+ "   with real syntax
+ "   * Added tuple assignment parsing (whoops, that was forgotten)
+ "   * Fixed import handling when flattening scope
+ "
+ " v 0.5:
+ " Yeah, I skipped a version number - 0.4 was never public.
+ "  It was a bugfix version on top of 0.3.  This is a complete
+ "  rewrite.
+ "
+ 
+ if !has('python3')
+     echo "Error: Required vim compiled with +python3"
+     finish
+ endif
+ 
+ function! python3complete#Complete(findstart, base)
+     "findstart = 1 when we need to get the text length
+     if a:findstart == 1
+         let line = getline('.')
+         let idx = col('.')
+         while idx > 0
+             let idx -= 1
+             let c = line[idx]
+             if c =~ '\w'
+                 continue
+             elseif ! c =~ '\.'
+                 let idx = -1
+                 break
+             else
+                 break
+             endif
+         endwhile
+ 
+         return idx
+     "findstart = 0 when we need to return the list of completions
+     else
+         "vim no longer moves the cursor upon completion... fix that
+         let line = getline('.')
+         let idx = col('.')
+         let cword = ''
+         while idx > 0
+             let idx -= 1
+             let c = line[idx]
+             if c =~ '\w' || c =~ '\.'
+                 let cword = c . cword
+                 continue
+             elseif strlen(cword) > 0 || idx == 0
+                 break
+             endif
+         endwhile
+         execute "py3 vimpy3complete('" . cword . "', '" . a:base . "')"
+         return g:python3complete_completions
+     endif
+ endfunction
+ 
+ function! s:DefPython()
+ py3 << PYTHONEOF
+ import sys, tokenize, io, types
+ from token import NAME, DEDENT, NEWLINE, STRING
+ 
+ debugstmts=[]
+ def dbg(s): debugstmts.append(s)
+ def showdbg():
+     for d in debugstmts: print("DBG: %s " % d)
+ 
+ def vimpy3complete(context,match):
+     global debugstmts
+     debugstmts = []
+     try:
+         import vim
+         cmpl = Completer()
+         cmpl.evalsource('\n'.join(vim.current.buffer),vim.eval("line('.')"))
+         all = cmpl.get_completions(context,match)
+         all.sort(key=lambda x:x['abbr'].replace('_','z'))
+         dictstr = '['
+         # have to do this for double quoting
+         for cmpl in all:
+             dictstr += '{'
+             for x in cmpl: dictstr += '"%s":"%s",' % (x,cmpl[x])
+             dictstr += '"icase":0},'
+         if dictstr[-1] == ',': dictstr = dictstr[:-1]
+         dictstr += ']'
+         #dbg("dict: %s" % dictstr)
+         vim.command("silent let g:python3complete_completions = %s" % dictstr)
+         #dbg("Completion dict:\n%s" % all)
+     except vim.error:
+         dbg("VIM Error: %s" % vim.error)
+ 
+ class Completer(object):
+     def __init__(self):
+        self.compldict = {}
+        self.parser = PyParser()
+ 
+     def evalsource(self,text,line=0):
+         sc = self.parser.parse(text,line)
+         src = sc.get_code()
+         dbg("source: %s" % src)
+         try: exec(src,self.compldict)
+         except: dbg("parser: %s, %s" % (sys.exc_info()[0],sys.exc_info()[1]))
+         for l in sc.locals:
+             try: exec(l,self.compldict)
+             except: dbg("locals: %s, %s [%s]" % (sys.exc_info()[0],sys.exc_info()[1],l))
+ 
+     def _cleanstr(self,doc):
+         return doc.replace('"',' ').replace("'",' ')
+ 
+     def get_arguments(self,func_obj):
+         def _ctor(class_ob):
+             try: return class_ob.__init__
+             except AttributeError:
+                 for base in class_ob.__bases__:
+                     rc = _ctor(base)
+                     if rc is not None: return rc
+             return None
+ 
+         arg_offset = 1
+         if type(func_obj) == type: func_obj = _ctor(func_obj)
+         elif type(func_obj) == types.MethodType: arg_offset = 1
+         else: arg_offset = 0
+ 
+         arg_text=''
+         if type(func_obj) in [types.FunctionType, types.LambdaType,types.MethodType]:
+             try:
+                 cd = func_obj.__code__
+                 real_args = cd.co_varnames[arg_offset:cd.co_argcount]
+                 defaults = func_obj.__defaults__ or []
+                 defaults = ["=%s" % name for name in defaults]
+                 defaults = [""] * (len(real_args)-len(defaults)) + defaults
+                 items = [a+d for a,d in zip(real_args,defaults)]
+                 if func_obj.__code__.co_flags & 0x4:
+                     items.append("...")
+                 if func_obj.__code__.co_flags & 0x8:
+                     items.append("***")
+                 arg_text = (','.join(items)) + ')'
+             except:
+                 dbg("arg completion: %s: %s" % (sys.exc_info()[0],sys.exc_info()[1]))
+                 pass
+         if len(arg_text) == 0:
+             # The doc string sometimes contains the function signature
+             #  this works for alot of C modules that are part of the
+             #  standard library
+             doc = func_obj.__doc__
+             if doc:
+                 doc = doc.lstrip()
+                 pos = doc.find('\n')
+                 if pos > 0:
+                     sigline = doc[:pos]
+                     lidx = sigline.find('(')
+                     ridx = sigline.find(')')
+                     if lidx > 0 and ridx > 0:
+                         arg_text = sigline[lidx+1:ridx] + ')'
+         if len(arg_text) == 0: arg_text = ')'
+         return arg_text
+ 
+     def get_completions(self,context,match):
+         #dbg("get_completions('%s','%s')" % (context,match))
+         stmt = ''
+         if context: stmt += str(context)
+         if match: stmt += str(match)
+         try:
+             result = None
+             all = {}
+             ridx = stmt.rfind('.')
+             if len(stmt) > 0 and stmt[-1] == '(':
+                 result = eval(_sanitize(stmt[:-1]), self.compldict)
+                 doc = result.__doc__
+                 if doc is None: doc = ''
+                 args = self.get_arguments(result)
+                 return [{'word':self._cleanstr(args),'info':self._cleanstr(doc)}]
+             elif ridx == -1:
+                 match = stmt
+                 all = self.compldict
+             else:
+                 match = stmt[ridx+1:]
+                 stmt = _sanitize(stmt[:ridx])
+                 result = eval(stmt, self.compldict)
+                 all = dir(result)
+ 
+             dbg("completing: stmt:%s" % stmt)
+             completions = []
+ 
+             try: maindoc = result.__doc__
+             except: maindoc = ' '
+             if maindoc is None: maindoc = ' '
+             for m in all:
+                 if m == "_PyCmplNoType": continue #this is internal
+                 try:
+                     dbg('possible completion: %s' % m)
+                     if m.find(match) == 0:
+                         if result is None: inst = all[m]
+                         else: inst = getattr(result,m)
+                         try: doc = inst.__doc__
+                         except: doc = maindoc
+                         typestr = str(inst)
+                         if doc is None or doc == '': doc = maindoc
+ 
+                         wrd = m[len(match):]
+                         c = {'word':wrd, 'abbr':m,  'info':self._cleanstr(doc)}
+                         if "function" in typestr:
+                             c['word'] += '('
+                             c['abbr'] += '(' + self._cleanstr(self.get_arguments(inst))
+                         elif "method" in typestr:
+                             c['word'] += '('
+                             c['abbr'] += '(' + self._cleanstr(self.get_arguments(inst))
+                         elif "module" in typestr:
+                             c['word'] += '.'
+                         elif "type" in typestr:
+                             c['word'] += '('
+                             c['abbr'] += '('
+                         completions.append(c)
+                 except:
+                     i = sys.exc_info()
+                     dbg("inner completion: %s,%s [stmt='%s']" % (i[0],i[1],stmt))
+             return completions
+         except:
+             i = sys.exc_info()
+             dbg("completion: %s,%s [stmt='%s']" % (i[0],i[1],stmt))
+             return []
+ 
+ class Scope(object):
+     def __init__(self,name,indent,docstr=''):
+         self.subscopes = []
+         self.docstr = docstr
+         self.locals = []
+         self.parent = None
+         self.name = name
+         self.indent = indent
+ 
+     def add(self,sub):
+         #print('push scope: [%s@%s]' % (sub.name,sub.indent))
+         sub.parent = self
+         self.subscopes.append(sub)
+         return sub
+ 
+     def doc(self,str):
+         """ Clean up a docstring """
+         d = str.replace('\n',' ')
+         d = d.replace('\t',' ')
+         while d.find('  ') > -1: d = d.replace('  ',' ')
+         while d[0] in '"\'\t ': d = d[1:]
+         while d[-1] in '"\'\t ': d = d[:-1]
+         dbg("Scope(%s)::docstr = %s" % (self,d))
+         self.docstr = d
+ 
+     def local(self,loc):
+         self._checkexisting(loc)
+         self.locals.append(loc)
+ 
+     def copy_decl(self,indent=0):
+         """ Copy a scope's declaration only, at the specified indent level - not local variables """
+         return Scope(self.name,indent,self.docstr)
+ 
+     def _checkexisting(self,test):
+         "Convienance function... keep out duplicates"
+         if test.find('=') > -1:
+             var = test.split('=')[0].strip()
+             for l in self.locals:
+                 if l.find('=') > -1 and var == l.split('=')[0].strip():
+                     self.locals.remove(l)
+ 
+     def get_code(self):
+         str = ""
+         if len(self.docstr) > 0: str += '"""'+self.docstr+'"""\n'
+         for l in self.locals:
+             if l.startswith('import'): str += l+'\n'
+         str += 'class _PyCmplNoType:\n    def __getattr__(self,name):\n        return None\n'
+         for sub in self.subscopes:
+             str += sub.get_code()
+         for l in self.locals:
+             if not l.startswith('import'): str += l+'\n'
+ 
+         return str
+ 
+     def pop(self,indent):
+         #print('pop scope: [%s] to [%s]' % (self.indent,indent))
+         outer = self
+         while outer.parent != None and outer.indent >= indent:
+             outer = outer.parent
+         return outer
+ 
+     def currentindent(self):
+         #print('parse current indent: %s' % self.indent)
+         return '    '*self.indent
+ 
+     def childindent(self):
+         #print('parse child indent: [%s]' % (self.indent+1))
+         return '    '*(self.indent+1)
+ 
+ class Class(Scope):
+     def __init__(self, name, supers, indent, docstr=''):
+         Scope.__init__(self,name,indent, docstr)
+         self.supers = supers
+     def copy_decl(self,indent=0):
+         c = Class(self.name,self.supers,indent, self.docstr)
+         for s in self.subscopes:
+             c.add(s.copy_decl(indent+1))
+         return c
+     def get_code(self):
+         str = '%sclass %s' % (self.currentindent(),self.name)
+         if len(self.supers) > 0: str += '(%s)' % ','.join(self.supers)
+         str += ':\n'
+         if len(self.docstr) > 0: str += self.childindent()+'"""'+self.docstr+'"""\n'
+         if len(self.subscopes) > 0:
+             for s in self.subscopes: str += s.get_code()
+         else:
+             str += '%spass\n' % self.childindent()
+         return str
+ 
+ 
+ class Function(Scope):
+     def __init__(self, name, params, indent, docstr=''):
+         Scope.__init__(self,name,indent, docstr)
+         self.params = params
+     def copy_decl(self,indent=0):
+         return Function(self.name,self.params,indent, self.docstr)
+     def get_code(self):
+         str = "%sdef %s(%s):\n" % \
+             (self.currentindent(),self.name,','.join(self.params))
+         if len(self.docstr) > 0: str += self.childindent()+'"""'+self.docstr+'"""\n'
+         str += "%spass\n" % self.childindent()
+         return str
+ 
+ class PyParser:
+     def __init__(self):
+         self.top = Scope('global',0)
+         self.scope = self.top
+ 
+     def _parsedotname(self,pre=None):
+         #returns (dottedname, nexttoken)
+         name = []
+         if pre is None:
+             tokentype, token, indent = self.donext()
+             if tokentype != NAME and token != '*':
+                 return ('', token)
+         else: token = pre
+         name.append(token)
+         while True:
+             tokentype, token, indent = self.donext()
+             if token != '.': break
+             tokentype, token, indent = self.donext()
+             if tokentype != NAME: break
+             name.append(token)
+         return (".".join(name), token)
+ 
+     def _parseimportlist(self):
+         imports = []
+         while True:
+             name, token = self._parsedotname()
+             if not name: break
+             name2 = ''
+             if token == 'as': name2, token = self._parsedotname()
+             imports.append((name, name2))
+             while token != "," and "\n" not in token:
+                 tokentype, token, indent = self.donext()
+             if token != ",": break
+         return imports
+ 
+     def _parenparse(self):
+         name = ''
+         names = []
+         level = 1
+         while True:
+             tokentype, token, indent = self.donext()
+             if token in (')', ',') and level == 1:
+                 if '=' not in name: name = name.replace(' ', '')
+                 names.append(name.strip())
+                 name = ''
+             if token == '(':
+                 level += 1
+                 name += "("
+             elif token == ')':
+                 level -= 1
+                 if level == 0: break
+                 else: name += ")"
+             elif token == ',' and level == 1:
+                 pass
+             else:
+                 name += "%s " % str(token)
+         return names
+ 
+     def _parsefunction(self,indent):
+         self.scope=self.scope.pop(indent)
+         tokentype, fname, ind = self.donext()
+         if tokentype != NAME: return None
+ 
+         tokentype, open, ind = self.donext()
+         if open != '(': return None
+         params=self._parenparse()
+ 
+         tokentype, colon, ind = self.donext()
+         if colon != ':': return None
+ 
+         return Function(fname,params,indent)
+ 
+     def _parseclass(self,indent):
+         self.scope=self.scope.pop(indent)
+         tokentype, cname, ind = self.donext()
+         if tokentype != NAME: return None
+ 
+         super = []
+         tokentype, thenext, ind = self.donext()
+         if thenext == '(':
+             super=self._parenparse()
+         elif thenext != ':': return None
+ 
+         return Class(cname,super,indent)
+ 
+     def _parseassignment(self):
+         assign=''
+         tokentype, token, indent = self.donext()
+         if tokentype == tokenize.STRING or token == 'str':  
+             return '""'
+         elif token == '(' or token == 'tuple':
+             return '()'
+         elif token == '[' or token == 'list':
+             return '[]'
+         elif token == '{' or token == 'dict':
+             return '{}'
+         elif tokentype == tokenize.NUMBER:
+             return '0'
+         elif token == 'open' or token == 'file':
+             return 'file'
+         elif token == 'None':
+             return '_PyCmplNoType()'
+         elif token == 'type':
+             return 'type(_PyCmplNoType)' #only for method resolution
+         else:
+             assign += token
+             level = 0
+             while True:
+                 tokentype, token, indent = self.donext()
+                 if token in ('(','{','['):
+                     level += 1
+                 elif token in (']','}',')'):
+                     level -= 1
+                     if level == 0: break
+                 elif level == 0:
+                     if token in (';','\n'): break
+                     assign += token
+         return "%s" % assign
+ 
+     def donext(self):
+         type, token, (lineno, indent), end, self.parserline = next(self.gen)
+         if lineno == self.curline:
+             #print('line found [%s] scope=%s' % (line.replace('\n',''),self.scope.name))
+             self.currentscope = self.scope
+         return (type, token, indent)
+ 
+     def _adjustvisibility(self):
+         newscope = Scope('result',0)
+         scp = self.currentscope
+         while scp != None:
+             if type(scp) == Function:
+                 slice = 0
+                 #Handle 'self' params
+                 if scp.parent != None and type(scp.parent) == Class:
+                     slice = 1
+                     newscope.local('%s = %s' % (scp.params[0],scp.parent.name))
+                 for p in scp.params[slice:]:
+                     i = p.find('=')
+                     if len(p) == 0: continue
+                     pvar = ''
+                     ptype = ''
+                     if i == -1:
+                         pvar = p
+                         ptype = '_PyCmplNoType()'
+                     else:
+                         pvar = p[:i]
+                         ptype = _sanitize(p[i+1:])
+                     if pvar.startswith('**'):
+                         pvar = pvar[2:]
+                         ptype = '{}'
+                     elif pvar.startswith('*'):
+                         pvar = pvar[1:]
+                         ptype = '[]'
+ 
+                     newscope.local('%s = %s' % (pvar,ptype))
+ 
+             for s in scp.subscopes:
+                 ns = s.copy_decl(0)
+                 newscope.add(ns)
+             for l in scp.locals: newscope.local(l)
+             scp = scp.parent
+ 
+         self.currentscope = newscope
+         return self.currentscope
+ 
+     #p.parse(vim.current.buffer[:],vim.eval("line('.')"))
+     def parse(self,text,curline=0):
+         self.curline = int(curline)
+         buf = io.StringIO(''.join(text) + '\n')
+         self.gen = tokenize.generate_tokens(buf.readline)
+         self.currentscope = self.scope
+ 
+         try:
+             freshscope=True
+             while True:
+                 tokentype, token, indent = self.donext()
+                 #dbg( 'main: token=[%s] indent=[%s]' % (token,indent))
+ 
+                 if tokentype == DEDENT or token == "pass":
+                     self.scope = self.scope.pop(indent)
+                 elif token == 'def':
+                     func = self._parsefunction(indent)
+                     if func is None:
+                         print("function: syntax error...")
+                         continue
+                     dbg("new scope: function")
+                     freshscope = True
+                     self.scope = self.scope.add(func)
+                 elif token == 'class':
+                     cls = self._parseclass(indent)
+                     if cls is None:
+                         print("class: syntax error...")
+                         continue
+                     freshscope = True
+                     dbg("new scope: class")
+                     self.scope = self.scope.add(cls)
+                     
+                 elif token == 'import':
+                     imports = self._parseimportlist()
+                     for mod, alias in imports:
+                         loc = "import %s" % mod
+                         if len(alias) > 0: loc += " as %s" % alias
+                         self.scope.local(loc)
+                     freshscope = False
+                 elif token == 'from':
+                     mod, token = self._parsedotname()
+                     if not mod or token != "import":
+                         print("from: syntax error...")
+                         continue
+                     names = self._parseimportlist()
+                     for name, alias in names:
+                         loc = "from %s import %s" % (mod,name)
+                         if len(alias) > 0: loc += " as %s" % alias
+                         self.scope.local(loc)
+                     freshscope = False
+                 elif tokentype == STRING:
+                     if freshscope: self.scope.doc(token)
+                 elif tokentype == NAME:
+                     name,token = self._parsedotname(token) 
+                     if token == '=':
+                         stmt = self._parseassignment()
+                         dbg("parseassignment: %s = %s" % (name, stmt))
+                         if stmt != None:
+                             self.scope.local("%s = %s" % (name,stmt))
+                     freshscope = False
+         except StopIteration: #thrown on EOF
+             pass
+         except:
+             dbg("parse error: %s, %s @ %s" %
+                 (sys.exc_info()[0], sys.exc_info()[1], self.parserline))
+         return self._adjustvisibility()
+ 
+ def _sanitize(str):
+     val = ''
+     level = 0
+     for c in str:
+         if c in ('(','{','['):
+             level += 1
+         elif c in (']','}',')'):
+             level -= 1
+         elif level == 0:
+             val += c
+     return val
+ 
+ sys.path.extend(['.','..'])
+ PYTHONEOF
+ endfunction
+ 
+ call s:DefPython()
diff -caPr ..\vimorg/runtime/syntax/vim.vim ./runtime/syntax/vim.vim
*** ..\vimorg/runtime/syntax/vim.vim	2010-04-19 14:14:01.599597600 +0200
--- ./runtime/syntax/vim.vim	2010-04-19 17:39:53.344988200 +0200
***************
*** 576,590 ****
   unlet! b:current_syntax
   syn include @vimPythonScript <sfile>:p:h/python.vim
   if exists("g:vimsyn_folding") && g:vimsyn_folding =~ 'P'
!   syn region vimPythonRegion fold matchgroup=vimScriptDelim start=+py\%[thon]\s*<<\s*\z(.*\)$+ end=+^\z1$+ contains=@vimPythonScript
!   syn region vimPythonRegion fold matchgroup=vimScriptDelim start=+py\%[thon]\s*<<\s*$+ end=+\.$+ contains=@vimPythonScript
   else
!   syn region vimPythonRegion matchgroup=vimScriptDelim start=+py\%[thon]\s*<<\s*\z(.*\)$+ end=+^\z1$+ contains=@vimPythonScript
!   syn region vimPythonRegion matchgroup=vimScriptDelim start=+py\%[thon]\s*<<\s*$+ end=+\.$+ contains=@vimPythonScript
   endif
  else
!  syn region vimEmbedError start=+py\%[thon]\s*<<\s*\z(.*\)$+ end=+^\z1$+
!  syn region vimEmbedError start=+py\%[thon]\s*<<\s*$+ end=+\.$+
  endif
  
  " [-- tcl --] {{{3
--- 576,590 ----
   unlet! b:current_syntax
   syn include @vimPythonScript <sfile>:p:h/python.vim
   if exists("g:vimsyn_folding") && g:vimsyn_folding =~ 'P'
!   syn region vimPythonRegion fold matchgroup=vimScriptDelim start=+py[3]\%[thon]\s*<<\s*\z(.*\)$+ end=+^\z1$+ contains=@vimPythonScript
!   syn region vimPythonRegion fold matchgroup=vimScriptDelim start=+py[3]\%[thon]\s*<<\s*$+ end=+\.$+ contains=@vimPythonScript
   else
!   syn region vimPythonRegion matchgroup=vimScriptDelim start=+[3]py\%[thon]\s*<<\s*\z(.*\)$+ end=+^\z1$+ contains=@vimPythonScript
!   syn region vimPythonRegion matchgroup=vimScriptDelim start=+[3]py\%[thon]\s*<<\s*$+ end=+\.$+ contains=@vimPythonScript
   endif
  else
!  syn region vimEmbedError start=+[3]py\%[thon]\s*<<\s*\z(.*\)$+ end=+^\z1$+
!  syn region vimEmbedError start=+[3]py\%[thon]\s*<<\s*$+ end=+\.$+
  endif
  
  " [-- tcl --] {{{3
diff -caPr ..\vimorg/src/auto/configure ./src/auto/configure
*** ..\vimorg/src/auto/configure	2010-04-19 14:14:30.196911500 +0200
--- ./src/auto/configure	2010-04-19 17:39:53.360608200 +0200
***************
*** 693,698 ****
--- 693,704 ----
  PYTHON_LIBS
  PYTHON_CONFDIR
  vi_cv_path_python
+ PYTHON3_OBJ
+ PYTHON3_SRC
+ PYTHON3_CFLAGS
+ PYTHON3_LIBS
+ PYTHON3_CONFDIR
+ vi_cv_path_python3
  PERL_LIBS
  PERL_CFLAGS
  PERL_PRO
***************
*** 792,797 ****
--- 798,805 ----
  enable_perlinterp
  enable_pythoninterp
  with_python_config_dir
+ enable_python3interp
+ with_python3_config_dir
  enable_tclinterp
  with_tclsh
  enable_rubyinterp
***************
*** 1466,1471 ****
--- 1474,1480 ----
    --enable-mzschemeinterp   Include MzScheme interpreter.
    --enable-perlinterp     Include Perl interpreter.
    --enable-pythoninterp   Include Python interpreter.
+   --enable-python3interp  Include Python3 interpreter.
    --enable-tclinterp      Include Tcl interpreter.
    --enable-rubyinterp     Include Ruby interpreter.
    --enable-cscope         Include cscope interface.
***************
*** 1506,1511 ****
--- 1515,1521 ----
    --with-compiledby=NAME  name to show in :version message
    --with-plthome=PLTHOME   Use PLTHOME.
    --with-python-config-dir=PATH  Python's config directory
+   --with-python3-config-dir=PATH  Python3's config directory
    --with-tclsh=PATH       which tclsh to use (default: tclsh8.0)
    --with-ruby-command=RUBY  name of the Ruby command (default: ruby)
    --with-x                use the X Window System
***************
*** 5067,5074 ****
  
  
  
! 
! 
  
  
  { $as_echo "$as_me:$LINENO: checking --enable-pythoninterp argument" >&5
--- 5077,5398 ----
  
  
  
! { $as_echo "$as_me:$LINENO: checking --enable-python3interp argument" >&5
! $as_echo_n "checking --enable-python3interp argument... " >&6; }
! # Check whether --enable-python3interp was given.
! if test "${enable_python3interp+set}" = set; then
!   enableval=$enable_python3interp;
! else
!   enable_python3interp="no"
! fi
!  
! { $as_echo "$as_me:$LINENO: result: $enable_python3interp" >&5
! $as_echo "$enable_python3interp" >&6; }
! if test "$enable_python3interp" = "yes"; then
!     # Extract the first word of "python3", so it can be a program name with args.
! set dummy python3; ac_word=$2
! { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
! $as_echo_n "checking for $ac_word... " >&6; }
! if test "${ac_cv_path_vi_cv_path_python3+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!   case $vi_cv_path_python3 in
!   [\\/]* | ?:[\\/]*)
!   ac_cv_path_vi_cv_path_python3="$vi_cv_path_python3" # Let the user override the test with a path.
!   ;;
!   *)
!   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
! for as_dir in $PATH
! do
!   IFS=$as_save_IFS
!   test -z "$as_dir" && as_dir=.
!   for ac_exec_ext in '' $ac_executable_extensions; do
!   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
!     ac_cv_path_vi_cv_path_python3="$as_dir/$ac_word$ac_exec_ext"
!     $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
!     break 2
!   fi
! done
! done
! IFS=$as_save_IFS
!  
!   ;;
! esac
! fi
! vi_cv_path_python3=$ac_cv_path_vi_cv_path_python3
! if test -n "$vi_cv_path_python3"; then
!   { $as_echo "$as_me:$LINENO: result: $vi_cv_path_python3" >&5
! $as_echo "$vi_cv_path_python3" >&6; }
! else
!   { $as_echo "$as_me:$LINENO: result: no" >&5
! $as_echo "no" >&6; }
! fi
!  
!  
!   if test "X$vi_cv_path_python3" != "X"; then
!  
!         { $as_echo "$as_me:$LINENO: checking Python3 version" >&5
! $as_echo_n "checking Python3 version... " >&6; }
! if test "${vi_cv_var_python3_version+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!   vi_cv_var_python3_version=`
! 	    ${vi_cv_path_python3} -c 'import sys; print(sys.version[1:3])'`
! fi
! { $as_echo "$as_me:$LINENO: result: $vi_cv_var_python3_version" >&5
! $as_echo "$vi_cv_var_python3_version" >&6; }
!  
!  
!             { $as_echo "$as_me:$LINENO: checking Python3's install prefix" >&5
! $as_echo_n "checking Python3's install prefix... " >&6; }
! if test "${vi_cv_path_python3_pfx+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!    vi_cv_path_python3_pfx=`
! 	    ${vi_cv_path_python3} -c \
! 		"import sys; print(sys.prefix)"`
! fi
! { $as_echo "$as_me:$LINENO: result: $vi_cv_path_python3_pfx" >&5
! $as_echo "$vi_cv_path_python3_pfx" >&6; }
!  
!             { $as_echo "$as_me:$LINENO: checking Python3's execution prefix" >&5
! $as_echo_n "checking Python3's execution prefix... " >&6; }
! if test "${vi_cv_path_python3_epfx+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!    vi_cv_path_python3_epfx=`
! 	    ${vi_cv_path_python3} -c \
! 		"import sys; print(sys.exec_prefix)"`
! fi
! { $as_echo "$as_me:$LINENO: result: $vi_cv_path_python3_epfx" >&5
! $as_echo "$vi_cv_path_python3_epfx" >&6; }
!  
!  
!       if test "${vi_cv_path_python3path+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!    vi_cv_path_python3path=`
! 	    unset PYTHONPATH;
! 	    ${vi_cv_path_python3} -c \
! 		"import sys, string; print(':'.join(sys.path))"`
! fi
!  
!  
!  
!  
! # Check whether --with-python3-config-dir was given.
! if test "${with_python3_config_dir+set}" = set; then
!   withval=$with_python3_config_dir;  vi_cv_path_python3_conf="${withval}"
! fi
!  
!  
!       { $as_echo "$as_me:$LINENO: checking Python3's configuration directory" >&5
! $as_echo_n "checking Python3's configuration directory... " >&6; }
! if test "${vi_cv_path_python3_conf+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!  
! 	vi_cv_path_python3_conf=
! 	for path in "${vi_cv_path_python3_pfx}" "${vi_cv_path_python3_epfx}"; do
! 	  for subdir in lib share; do
! 	    d="${path}/${subdir}/python3${vi_cv_var_python3_version}/config"
! 	    if test -d "$d" && test -f "$d/config.c"; then
! 	      vi_cv_path_python3_conf="$d"
! 	    fi
! 	  done
! 	done
!  
! fi
! { $as_echo "$as_me:$LINENO: result: $vi_cv_path_python3_conf" >&5
! $as_echo "$vi_cv_path_python3_conf" >&6; }
!  
!       PYTHON3_CONFDIR="${vi_cv_path_python3_conf}"
!  
!       if test "X$PYTHON3_CONFDIR" = "X"; then
! 	{ $as_echo "$as_me:$LINENO: result: can't find it!" >&5
! $as_echo "can't find it!" >&6; }
!       else
!  
! 			if test "${vi_cv_path_python3_plibs+set}" = set; then
!   $as_echo_n "(cached) " >&6
! else
!  
! 	    pwd=`pwd`
! 	    tmp_mkf="$pwd/config-PyMake$$"
! 	    cat -- "${PYTHON3_CONFDIR}/Makefile" - <<'eof' >"${tmp_mkf}"
! __:
! 	@echo "python3_MODLIBS='$(MODLIBS)'"
! 	@echo "python3_LIBS='$(LIBS)'"
! 	@echo "python3_SYSLIBS='$(SYSLIBS)'"
! 	@echo "python3_LINKFORSHARED='$(LINKFORSHARED)'"
! eof
! 	    	    eval "`cd ${PYTHON3_CONFDIR} && make -f "${tmp_mkf}" __ | sed '/ directory /d'`"
! 	    rm -f -- "${tmp_mkf}"
!           vi_cv_path_python3_plibs="-L${PYTHON3_CONFDIR} -lpython3${vi_cv_var_python3_version}"
!           vi_cv_path_python3_plibs="${vi_cv_path_python3_plibs} ${python3_MODLIBS} ${python3_LIBS} ${python3_SYSLIBS} ${python3_LINKFORSHARED}"
!           vi_cv_path_python3_plibs=`echo $vi_cv_path_python3_plibs | sed s/-ltermcap//`
!  
! fi
!  
!  
! 	PYTHON3_LIBS="${vi_cv_path_python3_plibs}"
! 	if test "${vi_cv_path_python3_pfx}" = "${vi_cv_path_python3_epfx}"; then
! 	  PYTHON3_CFLAGS="-I${vi_cv_path_python3_pfx}/include/python3${vi_cv_var_python3_version}"
! 	else
! 	  PYTHON3_CFLAGS="-I${vi_cv_path_python3_pfx}/include/python3${vi_cv_var_python3_version} -I${vi_cv_path_python3_epfx}/include/python3${vi_cv_var_python3_version}"
! 	fi
! 	PYTHON3_SRC="if_python3.c"
! 		if test "x$MACOSX" = "xyes"; then
! 	  PYTHON3_OBJ="objects/if_python3.o"
! 	else
! 	  PYTHON3_OBJ="objects/if_python3.o objects/py3_config.o"
! 	fi
!  
! 								{ $as_echo "$as_me:$LINENO: checking if -pthread should be used" >&5
! $as_echo_n "checking if -pthread should be used... " >&6; }
! 	threadsafe_flag=
! 	thread_lib=
! 	        if test "`(uname) 2>/dev/null`" != Darwin; then
! 	  test "$GCC" = yes && threadsafe_flag="-pthread"
! 	  if test "`(uname) 2>/dev/null`" = FreeBSD; then
! 	    threadsafe_flag="-D_THREAD_SAFE"
! 	    thread_lib="-pthread"
! 	  fi
! 	fi
! 	libs_save_old=$LIBS
! 	if test -n "$threadsafe_flag"; then
! 	  cflags_save=$CFLAGS
! 	  CFLAGS="$CFLAGS $threadsafe_flag"
! 	  LIBS="$LIBS $thread_lib"
! 	  cat >conftest.$ac_ext <<_ACEOF
! /* confdefs.h.  */
! _ACEOF
! cat confdefs.h >>conftest.$ac_ext
! cat >>conftest.$ac_ext <<_ACEOF
! /* end confdefs.h.  */
!  
! int
! main ()
! {
!  
!   ;
!   return 0;
! }
! _ACEOF
! rm -f conftest.$ac_objext conftest$ac_exeext
! if { (ac_try="$ac_link"
! case "(($ac_try" in
!   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
!   *) ac_try_echo=$ac_try;;
! esac
! eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
! $as_echo "$ac_try_echo") >&5
!   (eval "$ac_link") 2>conftest.er1
!   ac_status=$?
!   grep -v '^ *+' conftest.er1 >conftest.err
!   rm -f conftest.er1
!   cat conftest.err >&5
!   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
!   (exit $ac_status); } && {
! 	 test -z "$ac_c_werror_flag" ||
! 	 test ! -s conftest.err
!        } && test -s conftest$ac_exeext && {
! 	 test "$cross_compiling" = yes ||
! 	 $as_test_x conftest$ac_exeext
!        }; then
!   { $as_echo "$as_me:$LINENO: result: yes" >&5
! $as_echo "yes" >&6; }; PYTHON3_CFLAGS="$PYTHON3_CFLAGS $threadsafe_flag"
! else
!   $as_echo "$as_me: failed program was:" >&5
! sed 's/^/| /' conftest.$ac_ext >&5
!  
! 	{ $as_echo "$as_me:$LINENO: result: no" >&5
! $as_echo "no" >&6; }; LIBS=$libs_save_old
!  
! fi
!  
! rm -rf conftest.dSYM
! rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
!       conftest$ac_exeext conftest.$ac_ext
! 	  CFLAGS=$cflags_save
! 	else
! 	  { $as_echo "$as_me:$LINENO: result: no" >&5
! $as_echo "no" >&6; }
! 	fi
!  
! 			{ $as_echo "$as_me:$LINENO: checking if compile and link flags for Python3 are sane" >&5
! $as_echo_n "checking if compile and link flags for Python3 are sane... " >&6; }
! 	cflags_save=$CFLAGS
! 	libs_save=$LIBS
! 	CFLAGS="$CFLAGS $PYTHON3_CFLAGS"
! 	LIBS="$LIBS $PYTHON3_LIBS"
! 	cat >conftest.$ac_ext <<_ACEOF
! /* confdefs.h.  */
! _ACEOF
! cat confdefs.h >>conftest.$ac_ext
! cat >>conftest.$ac_ext <<_ACEOF
! /* end confdefs.h.  */
!  
! int
! main ()
! {
!  
!   ;
!   return 0;
! }
! _ACEOF
! rm -f conftest.$ac_objext conftest$ac_exeext
! if { (ac_try="$ac_link"
! case "(($ac_try" in
!   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
!   *) ac_try_echo=$ac_try;;
! esac
! eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
! $as_echo "$ac_try_echo") >&5
!   (eval "$ac_link") 2>conftest.er1
!   ac_status=$?
!   grep -v '^ *+' conftest.er1 >conftest.err
!   rm -f conftest.er1
!   cat conftest.err >&5
!   $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
!   (exit $ac_status); } && {
! 	 test -z "$ac_c_werror_flag" ||
! 	 test ! -s conftest.err
!        } && test -s conftest$ac_exeext && {
! 	 test "$cross_compiling" = yes ||
! 	 $as_test_x conftest$ac_exeext
!        }; then
!   { $as_echo "$as_me:$LINENO: result: yes" >&5
! $as_echo "yes" >&6; }; python3_ok=yes
! else
!   $as_echo "$as_me: failed program was:" >&5
! sed 's/^/| /' conftest.$ac_ext >&5
!  
! 	{ $as_echo "$as_me:$LINENO: result: no: PYTHON3 DISABLED" >&5
! $as_echo "no: PYTHON3 DISABLED" >&6; }; python3_ok=no
! fi
!  
! rm -rf conftest.dSYM
! rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
!       conftest$ac_exeext conftest.$ac_ext
! 	CFLAGS=$cflags_save
! 	LIBS=$libs_save
! 	if test $python3_ok = yes; then
! 	  cat >>confdefs.h <<\_ACEOF
! #define FEAT_PYTHON3 1
! _ACEOF
!  
! 	else
! 	  LIBS=$libs_save_old
! 	  PYTHON3_SRC=
! 	  PYTHON3_OBJ=
! 	  PYTHON3_LIBS=
! 	  PYTHON3_CFLAGS=
! 	fi
!  
!       fi
!   fi
! fi
  
  
  { $as_echo "$as_me:$LINENO: checking --enable-pythoninterp argument" >&5
***************
*** 5415,5422 ****
--- 5739,5762 ----
  
  
  
+ if test $python_ok = yes && test $python3_ok = yes; then
+   cat >>confdefs.h <<\_ACEOF
+ #define DYNAMIC_PYTHON 1
+ _ACEOF
  
+   cat >>confdefs.h <<\_ACEOF
+ #define DYNAMIC_PYTHON3 1
+ _ACEOF
  
+   PYTHON_SRC="if_python.c"
+   PYTHON_OBJ="objects/if_python.o"
+   PYTHON_CFLAGS="$PYTHON_CFLAGS -DDYNAMIC_PYTHON_DLL=\\\"libpython${vi_cv_var_python_version}.so\\\""
+   PYTHON_LIBS=
+   PYTHON3_SRC="if_python3.c"
+   PYTHON3_OBJ="objects/if_python3.o"
+   PYTHON3_CFLAGS="$PYTHON3_CFLAGS -DDYNAMIC_PYTHON3_DLL=\\\"libpython3${vi_cv_var_python3_version}.so\\\""
+   PYTHON3_LIBS=
+ fi
  
  
  { $as_echo "$as_me:$LINENO: checking --enable-tclinterp argument" >&5
diff -caPr ..\vimorg/src/buffer.c ./src/buffer.c
*** ..\vimorg/src/buffer.c	2010-04-19 14:14:44.627573900 +0200
--- ./src/buffer.c	2010-04-19 17:39:53.376228200 +0200
***************
*** 603,608 ****
--- 603,611 ----
  #ifdef FEAT_PYTHON
      python_buffer_free(buf);
  #endif
+ #ifdef FEAT_PYTHON3
+     python3_buffer_free(buf);
+ #endif
  #ifdef FEAT_RUBY
      ruby_buffer_free(buf);
  #endif
diff -caPr ..\vimorg/src/config.h.in ./src/config.h.in
*** ..\vimorg/src/config.h.in	2010-04-19 14:14:45.174189900 +0200
--- ./src/config.h.in	2010-04-19 17:39:53.376228200 +0200
***************
*** 302,307 ****
--- 302,316 ----
  /* Define if you want to include the Python interpreter. */
  #undef FEAT_PYTHON
  
+ /* Define if you want to include the Python3 interpreter. */
+ #undef FEAT_PYTHON3
+ 
+ /* Define for linking via dlopen() or LoadLibrary() */
+ #undef DYNAMIC_PYTHON
+ 
+ /* Define for linking via dlopen() or LoadLibrary() */
+ #undef DYNAMIC_PYTHON3
+ 
  /* Define if you want to include the Ruby interpreter. */
  #undef FEAT_RUBY
  
diff -caPr ..\vimorg/src/config.mk.in ./src/config.mk.in
*** ..\vimorg/src/config.mk.in	2010-04-19 14:14:44.471397900 +0200
--- ./src/config.mk.in	2010-04-19 17:39:53.376228200 +0200
***************
*** 60,65 ****
--- 60,71 ----
  PYTHON_CONFDIR	= @PYTHON_CONFDIR@
  PYTHON_GETPATH_CFLAGS = @PYTHON_GETPATH_CFLAGS@
  
+ PYTHON3_SRC	= @PYTHON3_SRC@
+ PYTHON3_OBJ	= @PYTHON3_OBJ@
+ PYTHON3_CFLAGS	= @PYTHON3_CFLAGS@
+ PYTHON3_LIBS	= @PYTHON3_LIBS@
+ PYTHON3_CONFDIR	= @PYTHON3_CONFDIR@
+ 
  TCL		= @vi_cv_path_tcl@
  TCL_SRC		= @TCL_SRC@
  TCL_OBJ		= @TCL_OBJ@
diff -caPr ..\vimorg/src/configure.in ./src/configure.in
*** ..\vimorg/src/configure.in	2010-04-19 14:14:44.346457100 +0200
--- ./src/configure.in	2010-04-19 17:39:53.391848200 +0200
***************
*** 826,831 ****
--- 826,832 ----
      fi
    fi
  fi
+ 
  AC_SUBST(PYTHON_CONFDIR)
  AC_SUBST(PYTHON_LIBS)
  AC_SUBST(PYTHON_GETPATH_CFLAGS)
***************
*** 833,838 ****
--- 834,1015 ----
  AC_SUBST(PYTHON_SRC)
  AC_SUBST(PYTHON_OBJ)
  
+ 
+ AC_MSG_CHECKING(--enable-python3interp argument)
+ AC_ARG_ENABLE(python3interp,
+ 	[  --enable-python3interp   Include Python3 interpreter.], ,
+ 	[enable_python3interp="no"])
+ AC_MSG_RESULT($enable_python3interp)
+ if test "$enable_python3interp" = "yes"; then
+   dnl -- find the python3 executable
+   AC_PATH_PROG(vi_cv_path_python3, python3)
+   if test "X$vi_cv_path_python3" != "X"; then
+ 
+     dnl -- get its version number
+     AC_CACHE_CHECK(Python version,vi_cv_var_python3_version,
+     [[vi_cv_var_python3_version=`
+           ${vi_cv_path_python3} -c 'import sys; print(sys.version[1:3])'`
+     ]])
+ 
+     dnl -- find where python3 thinks it was installed
+     AC_CACHE_CHECK(Python's install prefix,vi_cv_path_python3_pfx,
+     [ vi_cv_path_python3_pfx=`
+      ${vi_cv_path_python3} -c \
+      "import sys; print(sys.prefix)"` ])
+ 
+     dnl -- and where it thinks it runs
+     AC_CACHE_CHECK(Python's execution prefix,vi_cv_path_python3_epfx,
+     [ vi_cv_path_python3_epfx=`
+      ${vi_cv_path_python3} -c \
+      "import sys; print(sys.exec_prefix)"` ])
+ 
+     dnl -- python3's internal library path
+ 
+     AC_CACHE_VAL(vi_cv_path_python3path,
+     [ vi_cv_path_python3path=`
+      unset PYTHONPATH;
+      ${vi_cv_path_python3} -c \
+      "import sys, string; print(':'.join(sys.path))"` ])
+ 
+     dnl -- where the Python implementation library archives are
+ 
+     AC_ARG_WITH(python3-config-dir,
+      [  --with-python3-config-dir=PATH  Python's config directory],
+      [ vi_cv_path_python3_conf="${withval}" ] )
+ 
+     AC_CACHE_CHECK(Python's configuration directory,vi_cv_path_python3_conf,
+     [
+      vi_cv_path_python3_conf=
+      for path in "${vi_cv_path_python3_pfx}" "${vi_cv_path_python3_epfx}"; do
+        for subdir in lib share; do
+          d="${path}/${subdir}/python3${vi_cv_var_python3_version}/config"
+          if test -d "$d" && test -f "$d/config.c"; then
+            vi_cv_path_python3_conf="$d"
+          fi
+        done
+      done
+     ])
+ 
+     PYTHON3_CONFDIR="${vi_cv_path_python3_conf}"
+ 
+     if test "X$PYTHON3_CONFDIR" = "X"; then
+       AC_MSG_RESULT([can't find it!])
+     else
+ 
+       dnl -- we need to examine Python's config/Makefile too
+       dnl    see what the interpreter is built from
+       AC_CACHE_VAL(vi_cv_path_python3_plibs,
+       [
+           pwd=`pwd`
+           tmp_mkf="$pwd/config-PyMake$$"
+           cat -- "${PYTHON3_CONFDIR}/Makefile" - <<'eof' >"${tmp_mkf}"
+ __:
+ 	@echo "python3_MODLIBS='$(MODLIBS)'"
+ 	@echo "python3_LIBS='$(LIBS)'"
+ 	@echo "python3_SYSLIBS='$(SYSLIBS)'"
+ 	@echo "python3_LINKFORSHARED='$(LINKFORSHARED)'"
+ eof
+           dnl -- delete the lines from make about Entering/Leaving directory
+           eval "`cd ${PYTHON3_CONFDIR} && make -f "${tmp_mkf}" __ | sed '/ directory /d'`"
+           rm -f -- "${tmp_mkf}"
+           vi_cv_path_python3_plibs="-L${PYTHON3_CONFDIR} -lpython3${vi_cv_var_python3_version}"
+           vi_cv_path_python3_plibs="${vi_cv_path_python3_plibs} ${python3_MODLIBS} ${python3_LIBS} ${python3_SYSLIBS} ${python3_LINKFORSHARED}"
+           dnl remove -ltermcap, it can conflict with an earlier -lncurses
+           vi_cv_path_python3_plibs=`echo $vi_cv_path_python3_plibs | sed s/-ltermcap//`
+       ])
+ 
+       PYTHON3_LIBS="${vi_cv_path_python3_plibs}"
+       if test "${vi_cv_path_python3_pfx}" = "${vi_cv_path_python3_epfx}"; then
+         PYTHON3_CFLAGS="-I${vi_cv_path_python3_pfx}/include/python3${vi_cv_var_python3_version}"
+       else
+         PYTHON3_CFLAGS="-I${vi_cv_path_python3_pfx}/include/python3${vi_cv_var_python3_version} -I${vi_cv_path_python3_epfx}/include/python3${vi_cv_var_python3_version}"
+       fi
+       PYTHON3_SRC="if_python3.c"
+       dnl For Mac OSX 10.2 config.o is included in the Python library.
+       if test "x$MACOSX" = "xyes"; then
+         PYTHON3_OBJ="objects/if_python3.o"
+       else
+         PYTHON3_OBJ="objects/if_python3.o objects/py3_config.o"
+       fi
+ 
+       dnl On FreeBSD linking with "-pthread" is required to use threads.
+       dnl _THREAD_SAFE must be used for compiling then.
+       dnl The "-pthread" is added to $LIBS, so that the following check for
+       dnl sigaltstack() will look in libc_r (it's there in libc!).
+       dnl Otherwise, when using GCC, try adding -pthread to $CFLAGS.  GCC
+       dnl will then define target-specific defines, e.g., -D_REENTRANT.
+       dnl Don't do this for Mac OSX, -pthread will generate a warning.
+       AC_MSG_CHECKING([if -pthread should be used])
+       threadsafe_flag=
+       thread_lib=
+       dnl if test "x$MACOSX" != "xyes"; then
+       if test "`(uname) 2>/dev/null`" != Darwin; then
+         test "$GCC" = yes && threadsafe_flag="-pthread"
+         if test "`(uname) 2>/dev/null`" = FreeBSD; then
+           threadsafe_flag="-D_THREAD_SAFE"
+           thread_lib="-pthread"
+         fi
+       fi
+       libs_save_old=$LIBS
+       if test -n "$threadsafe_flag"; then
+         cflags_save=$CFLAGS
+         CFLAGS="$CFLAGS $threadsafe_flag"
+         LIBS="$LIBS $thread_lib"
+         AC_TRY_LINK(,[ ],
+            AC_MSG_RESULT(yes); PYTHON3_CFLAGS="$PYTHON3_CFLAGS $threadsafe_flag",
+            AC_MSG_RESULT(no); LIBS=$libs_save_old
+            )
+         CFLAGS=$cflags_save
+       else
+         AC_MSG_RESULT(no)
+       fi
+ 
+       dnl check that compiling a simple program still works with the flags
+       dnl added for Python.
+       AC_MSG_CHECKING([if compile and link flags for Python are sane])
+       cflags_save=$CFLAGS
+       libs_save=$LIBS
+       CFLAGS="$CFLAGS $PYTHON3_CFLAGS"
+       LIBS="$LIBS $PYTHON3_LIBS"
+       AC_TRY_LINK(,[ ],
+              AC_MSG_RESULT(yes); python3_ok=yes,
+              AC_MSG_RESULT(no: PYTHON3 DISABLED); python3_ok=no)
+       CFLAGS=$cflags_save
+       LIBS=$libs_save
+       if test $python3_ok = yes; then
+         AC_DEFINE(FEAT_PYTHON3)
+       else
+         LIBS=$libs_save_old
+         PYTHON3_SRC=
+         PYTHON3_OBJ=
+         PYTHON3_LIBS=
+         PYTHON3_CFLAGS=
+       fi
+     fi
+   fi
+ fi
+ 
+ AC_SUBST(PYTHON3_CONFDIR)
+ AC_SUBST(PYTHON3_LIBS)
+ AC_SUBST(PYTHON3_CFLAGS)
+ AC_SUBST(PYTHON3_SRC)
+ AC_SUBST(PYTHON3_OBJ)
+ 
+ dnl if python2.x and python3.x are enabled one can only link in code
+ dnl with dlopen(), dlsym(), dlclose() 
+ if test $python_ok = yes && test $python3_ok = yes; then
+   AC_DEFINE(DYNAMIC_PYTHON)
+   AC_DEFINE(DYNAMIC_PYTHON3)
+   PYTHON_SRC="if_python.c"
+   PYTHON_OBJ="objects/if_python.o"
+   PYTHON_CFLAGS="$PYTHON_CFLAGS -DDYNAMIC_PYTHON_DLL=\\\"libpython${vi_cv_var_python_version}.so\\\""
+   PYTHON_LIBS=
+   PYTHON3_SRC="if_python3.c"
+   PYTHON3_OBJ="objects/if_python3.o"
+   PYTHON3_CFLAGS="$PYTHON3_CFLAGS -DDYNAMIC_PYTHON3_DLL=\\\"libpython3${vi_cv_var_python3_version}.so\\\""
+   PYTHON3_LIBS=
+ fi
+ 
  AC_MSG_CHECKING(--enable-tclinterp argument)
  AC_ARG_ENABLE(tclinterp,
  	[  --enable-tclinterp      Include Tcl interpreter.], ,
diff -caPr ..\vimorg/src/eval.c ./src/eval.c
*** ..\vimorg/src/eval.c	2010-04-19 14:14:44.690044300 +0200
--- ./src/eval.c	2010-04-19 18:24:52.512228200 +0200
***************
*** 5872,5879 ****
      return item1 == NULL && item2 == NULL;
  }
  
! #if defined(FEAT_RUBY) || defined(FEAT_PYTHON) || defined(FEAT_MZSCHEME) \
! 	|| defined(PROTO)
  /*
   * Return the dictitem that an entry in a hashtable points to.
   */
--- 5872,5878 ----
      return item1 == NULL && item2 == NULL;
  }
  
! #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(FEAT_MZSCHEME) || defined(PROTO) || defined(PROTO)
  /*
   * Return the dictitem that an entry in a hashtable points to.
   */
***************
*** 11706,11711 ****
--- 11705,11715 ----
  	"python",
  #endif
  #endif
+ #ifdef FEAT_PYTHON3
+ #ifndef DYNAMIC_PYTHON3
+ 	"python3",
+ #endif
+ #endif
  #ifdef FEAT_POSTSCRIPT
  	"postscript",
  #endif
***************
*** 11895,11904 ****
--- 11899,11916 ----
  	else if (STRICMP(name, "ruby") == 0)
  	    n = ruby_enabled(FALSE);
  #endif
+ #ifdef FEAT_PYTHON
  #ifdef DYNAMIC_PYTHON
  	else if (STRICMP(name, "python") == 0)
  	    n = python_enabled(FALSE);
  #endif
+ #endif
+ #ifdef FEAT_PYTHON3
+ #ifdef DYNAMIC_PYTHON3
+ 	else if (STRICMP(name, "python3") == 0)
+ 	    n = python3_enabled(FALSE);
+ #endif
+ #endif
  #ifdef DYNAMIC_PERL
  	else if (STRICMP(name, "perl") == 0)
  	    n = perl_enabled(FALSE);
diff -caPr ..\vimorg/src/ex_cmds.h ./src/ex_cmds.h
*** ..\vimorg/src/ex_cmds.h	2010-04-19 14:14:44.283986700 +0200
--- ./src/ex_cmds.h	2010-04-19 17:39:53.423088200 +0200
***************
*** 729,734 ****
--- 729,738 ----
  			RANGE|EXTRA|NEEDARG|CMDWIN),
  EX(CMD_pyfile,		"pyfile",	ex_pyfile,
  			RANGE|FILE1|NEEDARG|CMDWIN),
+ EX(CMD_python3,		"py3",	ex_python3,
+ 			RANGE|EXTRA|NEEDARG|CMDWIN),
+ EX(CMD_py3file,		"py3file",	ex_py3file,
+ 			RANGE|FILE1|NEEDARG|CMDWIN),
  EX(CMD_quit,		"quit",		ex_quit,
  			BANG|TRLBAR|CMDWIN),
  EX(CMD_quitall,		"quitall",	ex_quit_all,
diff -caPr ..\vimorg/src/ex_docmd.c ./src/ex_docmd.c
*** ..\vimorg/src/ex_docmd.c	2010-04-19 14:14:44.268369100 +0200
--- ./src/ex_docmd.c	2010-04-19 17:39:53.438708200 +0200
***************
*** 129,135 ****
  static int	check_more __ARGS((int, int));
  static linenr_T get_address __ARGS((char_u **, int skip, int to_other_file));
  static void	get_flags __ARGS((exarg_T *eap));
! #if !defined(FEAT_PERL) || !defined(FEAT_PYTHON) || !defined(FEAT_TCL) \
  	|| !defined(FEAT_RUBY) || !defined(FEAT_MZSCHEME)
  # define HAVE_EX_SCRIPT_NI
  static void	ex_script_ni __ARGS((exarg_T *eap));
--- 129,135 ----
  static int	check_more __ARGS((int, int));
  static linenr_T get_address __ARGS((char_u **, int skip, int to_other_file));
  static void	get_flags __ARGS((exarg_T *eap));
! #if !defined(FEAT_PERL) || !defined(FEAT_PYTHON) || !defined(FEAT_PYTHON3) || !defined(FEAT_TCL) \
  	|| !defined(FEAT_RUBY) || !defined(FEAT_MZSCHEME)
  # define HAVE_EX_SCRIPT_NI
  static void	ex_script_ni __ARGS((exarg_T *eap));
***************
*** 255,260 ****
--- 255,264 ----
  # define ex_python		ex_script_ni
  # define ex_pyfile		ex_ni
  #endif
+ #ifndef FEAT_PYTHON3
+ # define ex_python3		ex_script_ni
+ # define ex_py3file		ex_ni
+ #endif
  #ifndef FEAT_TCL
  # define ex_tcl			ex_script_ni
  # define ex_tcldo		ex_ni
***************
*** 2537,2542 ****
--- 2541,2547 ----
  	    case CMD_perl:
  	    case CMD_psearch:
  	    case CMD_python:
+ 	    case CMD_python3:
  	    case CMD_return:
  	    case CMD_rightbelow:
  	    case CMD_ruby:
***************
*** 2799,2804 ****
--- 2804,2814 ----
      {
  	while (ASCII_ISALPHA(*p))
  	    ++p;
+         //for python 3.x support (:py3)
+         if (STRNCMP(eap->cmd,"py",(size_t)2)==0)
+             while (ASCII_ISALNUM(*p))
+                 ++p;
+                 
  	/* check for non-alpha command */
  	if (p == eap->cmd && vim_strchr((char_u *)"@*!=><&~#", *p) != NULL)
  	    ++p;
diff -caPr ..\vimorg/src/globals.h ./src/globals.h
*** ..\vimorg/src/globals.h	2010-04-19 14:14:45.814511500 +0200
--- ./src/globals.h	2010-04-19 17:39:53.438708200 +0200
***************
*** 1414,1420 ****
  #ifdef FEAT_LIBCALL
  EXTERN char_u e_libcall[]	INIT(= N_("E364: Library call failed for \"%s()\""));
  #endif
! #if defined(DYNAMIC_PERL) || defined(DYNAMIC_PYTHON) || defined(DYNAMIC_RUBY) \
  	|| defined(DYNAMIC_TCL) || defined(DYNAMIC_ICONV) \
  	|| defined(DYNAMIC_GETTEXT) || defined(DYNAMIC_MZSCHEME)
  EXTERN char_u e_loadlib[]	INIT(= N_("E370: Could not load library %s"));
--- 1414,1420 ----
  #ifdef FEAT_LIBCALL
  EXTERN char_u e_libcall[]	INIT(= N_("E364: Library call failed for \"%s()\""));
  #endif
! #if defined(DYNAMIC_PERL) || defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3) || defined(DYNAMIC_RUBY) \
  	|| defined(DYNAMIC_TCL) || defined(DYNAMIC_ICONV) \
  	|| defined(DYNAMIC_GETTEXT) || defined(DYNAMIC_MZSCHEME)
  EXTERN char_u e_loadlib[]	INIT(= N_("E370: Could not load library %s"));
diff -caPr ..\vimorg/src/if_python.c ./src/if_python.c
*** ..\vimorg/src/if_python.c	2010-04-19 14:14:44.736897100 +0200
--- ./src/if_python.c	2010-04-19 17:39:53.454328200 +0200
***************
*** 96,101 ****
--- 96,114 ----
  #  define HINSTANCE long_u		/* for generating prototypes */
  # endif
  
+ #ifndef _WIN32
+ #include <dlfcn.h>
+ #define FARPROC void*
+ #define HINSTANCE void*
+ #define load_dll(n) dlopen((n),RTLD_LAZY)
+ #define close_dll dlclose
+ #define symbol_from_dll dlsym
+ #else
+ #define load_dll LoadLibrary
+ #define close_dll FreeLibrary
+ #define symbol_from_dll GetProcAddress
+ #endif
+ 
  /* This makes if_python.c compile without warnings against Python 2.5
   * on Win32 and Win64. */
  #undef PyRun_SimpleString
***************
*** 315,321 ****
  {
      if (hinstPython)
      {
! 	FreeLibrary(hinstPython);
  	hinstPython = 0;
      }
  }
--- 328,334 ----
  {
      if (hinstPython)
      {
! 	close_dll(hinstPython);
  	hinstPython = 0;
      }
  }
***************
*** 332,338 ****
  
      if (hinstPython)
  	return OK;
!     hinstPython = LoadLibrary(libname);
      if (!hinstPython)
      {
  	if (verbose)
--- 345,351 ----
  
      if (hinstPython)
  	return OK;
!     hinstPython = load_dll(libname);
      if (!hinstPython)
      {
  	if (verbose)
***************
*** 342,351 ****
  
      for (i = 0; python_funcname_table[i].ptr; ++i)
      {
! 	if ((*python_funcname_table[i].ptr = GetProcAddress(hinstPython,
  			python_funcname_table[i].name)) == NULL)
  	{
! 	    FreeLibrary(hinstPython);
  	    hinstPython = 0;
  	    if (verbose)
  		EMSG2(_(e_loadfunc), python_funcname_table[i].name);
--- 355,364 ----
  
      for (i = 0; python_funcname_table[i].ptr; ++i)
      {
! 	if ((*python_funcname_table[i].ptr = symbol_from_dll(hinstPython,
  			python_funcname_table[i].name)) == NULL)
  	{
! 	    close_dll(hinstPython);
  	    hinstPython = 0;
  	    if (verbose)
  		EMSG2(_(e_loadfunc), python_funcname_table[i].name);
diff -caPr ..\vimorg/src/if_python3.c ./src/if_python3.c
*** ..\vimorg/src/if_python3.c	1970-01-01 01:00:00.000000000 +0100
--- ./src/if_python3.c	2010-04-19 17:39:53.438708200 +0200
***************
*** 0 ****
--- 1,2863 ----
+ /* vi:set ts=8 sts=4 sw=4:
+  *
+  * VIM - Vi IMproved    by Bram Moolenaar
+  *
+  * Do ":help uganda"  in Vim to read copying and usage conditions.
+  * Do ":help credits" in Vim to see a list of people who contributed.
+  * See README.txt for an overview of the Vim source code.
+  */
+ /*
+  * Python extensions by Paul Moore.
+  * Changes for Unix by David Leonard.
+  *
+  * This consists of four parts:
+  * 1. Python interpreter main program
+  * 2. Python output stream: writes output via [e]msg().
+  * 3. Implementation of the Vim module for Python
+  * 4. Utility functions for handling the interface between Vim and Python.
+  */
+ 
+ /*
+  * Roland Puntaier 2009/sept/16:
+  * Adaptations to support both python3.x and python2.x
+  */
+ 
+ //uncomment this if used with the debug version of python
+ //#define Py_DEBUG
+ 
+ #include "vim.h"
+ 
+ #include <limits.h>
+ 
+ /* Python.h defines _POSIX_THREADS itself (if needed) */
+ #ifdef _POSIX_THREADS
+ # undef _POSIX_THREADS
+ #endif
+ 
+ #if defined(_WIN32) && defined (HAVE_FCNTL_H)
+ # undef HAVE_FCNTL_H
+ #endif
+ 
+ #ifdef _DEBUG
+ # undef _DEBUG
+ #endif
+ 
+ #ifdef HAVE_STDARG_H
+ # undef HAVE_STDARG_H   /* Python's config.h defines it as well. */
+ #endif
+ 
+ #define PY_SSIZE_T_CLEAN
+ 
+ #ifdef F_BLANK
+ # undef F_BLANK
+ #endif
+ 
+ #include <Python.h>
+ #if defined(MACOS) && !defined(MACOS_X_UNIX)
+ # include "macglue.h"
+ # include <CodeFragments.h>
+ #endif
+ #undef main /* Defined in python.h - aargh */
+ #undef HAVE_FCNTL_H /* Clash with os_win32.h */
+ 
+ 
+ #if defined(DYNAMIC_PYTHON3) 
+ 
+ #ifndef _WIN32
+ #include <dlfcn.h>
+ #define FARPROC void*
+ #define HINSTANCE void*
+ #define load_dll(n) dlopen((n),RTLD_LAZY)
+ #define close_dll dlclose
+ #define symbol_from_dll dlsym
+ #else
+ #define load_dll LoadLibrary
+ #define close_dll FreeLibrary
+ #define symbol_from_dll GetProcAddress
+ #endif
+ /*
+  * Wrapper defines
+  */
+ #undef PyArg_Parse
+ # define PyArg_Parse py3_PyArg_Parse
+ #undef PyArg_ParseTuple
+ # define PyArg_ParseTuple py3_PyArg_ParseTuple
+ # define PyDict_SetItemString py3_PyDict_SetItemString
+ # define PyErr_BadArgument py3_PyErr_BadArgument
+ # define PyErr_Clear py3_PyErr_Clear
+ # define PyErr_NoMemory py3_PyErr_NoMemory
+ # define PyErr_Occurred py3_PyErr_Occurred
+ # define PyErr_SetNone py3_PyErr_SetNone
+ # define PyErr_SetString py3_PyErr_SetString
+ # define PyEval_InitThreads py3_PyEval_InitThreads
+ # define PyEval_RestoreThread py3_PyEval_RestoreThread
+ # define PyEval_SaveThread py3_PyEval_SaveThread
+ # define PyGILState_Ensure py3_PyGILState_Ensure
+ # define PyGILState_Release py3_PyGILState_Release
+ # define PyLong_AsLong py3_PyLong_AsLong
+ # define PyLong_FromLong py3_PyLong_FromLong
+ # define PyList_GetItem py3_PyList_GetItem
+ # define PyList_Append py3_PyList_Append
+ # define PyList_New py3_PyList_New
+ # define PyList_SetItem py3_PyList_SetItem
+ # define PyList_Size py3_PyList_Size
+ # define PySlice_GetIndicesEx py3_PySlice_GetIndicesEx
+ # define PyImport_ImportModule py3_PyImport_ImportModule
+ # define PyObject_Init py3__PyObject_Init
+ # define PyDict_New py3_PyDict_New
+ # define PyDict_GetItemString py3_PyDict_GetItemString
+ # define PyModule_GetDict py3_PyModule_GetDict
+ #undef PyRun_SimpleString
+ # define PyRun_SimpleString py3_PyRun_SimpleString
+ # define PySys_SetObject py3_PySys_SetObject
+ # define PySys_SetArgv py3_PySys_SetArgv
+ # define PyType_Type (*py3_PyType_Type)
+ # define PyType_Ready py3_PyType_Ready
+ #undef Py_BuildValue
+ # define Py_BuildValue py3_Py_BuildValue
+ # define Py_Initialize py3_Py_Initialize
+ # define Py_Finalize py3_Py_Finalize
+ # define Py_IsInitialized py3_Py_IsInitialized
+ # define _Py_NoneStruct (*py3__Py_NoneStruct)
+ # define PyModule_AddObject py3_PyModule_AddObject
+ # define PyImport_AppendInittab py3_PyImport_AppendInittab
+ # define _PyUnicode_AsString py3__PyUnicode_AsString
+ # define PyObject_GenericGetAttr py3_PyObject_GenericGetAttr
+ # define PySlice_Type (*py3_PySlice_Type)
+ #ifdef Py_DEBUG
+     # define _Py_NegativeRefcount py3__Py_NegativeRefcount
+     # define _Py_RefTotal (*py3__Py_RefTotal)
+     # define _Py_Dealloc py3__Py_Dealloc
+     # define _PyObject_DebugMalloc py3__PyObject_DebugMalloc
+     # define _PyObject_DebugFree py3__PyObject_DebugFree
+ #else
+     # define PyObject_Malloc py3_PyObject_Malloc
+     # define PyObject_Free py3_PyObject_Free
+ #endif
+ # define PyType_GenericAlloc py3_PyType_GenericAlloc
+ # define PyType_GenericNew py3_PyType_GenericNew
+ # define PyModule_Create2 py3_PyModule_Create2
+ # define PyUnicodeUCS2_FromString py3_PyUnicodeUCS2_FromString
+ # define PyUnicodeUCS2_FromStringAndSize py3_PyUnicodeUCS2_FromStringAndSize
+ 
+ #ifdef Py_DEBUG
+ #undef PyObject_NEW
+ #define PyObject_NEW(type, typeobj) \
+ ( (type *) PyObject_Init( \
+         (PyObject *) _PyObject_DebugMalloc( _PyObject_SIZE(typeobj) ), (typeobj)) )
+ #endif        
+ /*
+  * Pointers for dynamic link
+  */
+ static int (*py3_PySys_SetArgv)(int, wchar_t **);
+ static void (*py3_Py_Initialize)(void);
+ static PyObject* (*py3_PyList_New)(Py_ssize_t size);
+ static PyGILState_STATE (*py3_PyGILState_Ensure)(void);
+ static void (*py3_PyGILState_Release)(PyGILState_STATE);
+ static int (*py3_PySys_SetObject)(char *, PyObject *);
+ static PyObject* (*py3_PyList_Append)(PyObject *, PyObject *);
+ static Py_ssize_t (*py3_PyList_Size)(PyObject *);
+ static int (*py3_PySlice_GetIndicesEx)(PySliceObject *r, Py_ssize_t length,
+                      Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength);
+ static PyObject* (*py3_PyErr_NoMemory)(void);
+ static void (*py3_Py_Finalize)(void);
+ static void (*py3_PyErr_SetString)(PyObject *, const char *);
+ static int (*py3_PyRun_SimpleString)(char *);
+ static PyObject* (*py3_PyList_GetItem)(PyObject *, Py_ssize_t);
+ static PyObject* (*py3_PyImport_ImportModule)(const char *);
+ static int (*py3_PyErr_BadArgument)(void);
+ static PyTypeObject* py3_PyType_Type;
+ static PyObject* (*py3_PyErr_Occurred)(void);
+ static PyObject* (*py3_PyModule_GetDict)(PyObject *);
+ static int (*py3_PyList_SetItem)(PyObject *, Py_ssize_t, PyObject *);
+ static PyObject* (*py3_PyDict_GetItemString)(PyObject *, const char *);
+ static PyObject* (*py3_PyLong_FromLong)(long);
+ static PyObject* (*py3_PyDict_New)(void);
+ static PyObject* (*py3_Py_BuildValue)(char *, ...);
+ static int (*py3_PyType_Ready)(PyTypeObject *type);
+ static int (*py3_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item);
+ static PyObject* (*py3_PyUnicodeUCS2_FromString)(const char *u);
+ static PyObject* (*py3_PyUnicodeUCS2_FromStringAndSize)(const char *u, Py_ssize_t size);
+ static long (*py3_PyLong_AsLong)(PyObject *);
+ static void (*py3_PyErr_SetNone)(PyObject *);
+ static void (*py3_PyEval_InitThreads)(void);
+ static void(*py3_PyEval_RestoreThread)(PyThreadState *);
+ static PyThreadState*(*py3_PyEval_SaveThread)(void);
+ static int (*py3_PyArg_Parse)(PyObject *, char *, ...);
+ static int (*py3_PyArg_ParseTuple)(PyObject *, char *, ...);
+ static int (*py3_Py_IsInitialized)(void);
+ static void (*py3_PyErr_Clear)(void);
+ static PyObject*(*py3__PyObject_Init)(PyObject *, PyTypeObject *);
+ static PyObject* py3__Py_NoneStruct;
+ static int (*py3_PyModule_AddObject)(PyObject *m, const char *name, PyObject *o);
+ static int (*py3_PyImport_AppendInittab)(const char *name, PyObject* (*initfunc)(void));
+ static char* (*py3__PyUnicode_AsString)(PyObject *unicode);
+ static PyObject* (*py3_PyObject_GenericGetAttr)(PyObject *obj, PyObject *name);
+ static PyObject* (*py3_PyModule_Create2)(struct PyModuleDef* module, int module_api_version);
+ static PyObject* (*py3_PyType_GenericAlloc)(PyTypeObject *type, Py_ssize_t nitems);
+ static PyObject* (*py3_PyType_GenericNew)(PyTypeObject *type, PyObject *args, PyObject *kwds);
+ static PyTypeObject* py3_PySlice_Type;
+ #ifdef Py_DEBUG
+     static void (*py3__Py_NegativeRefcount)(const char *fname, int lineno, PyObject *op);
+     static Py_ssize_t* py3__Py_RefTotal;
+     static void (*py3__Py_Dealloc)(PyObject *obj);
+     static void (*py3__PyObject_DebugFree)(void*);
+     static void* (*py3__PyObject_DebugMalloc)(size_t);
+ #else
+     static void (*py3_PyObject_Free)(void*);
+     static void* (*py3_PyObject_Malloc)(size_t);
+ #endif
+ 
+ 
+ static HINSTANCE hinstPy3 = 0; /* Instance of python.dll */
+ 
+ /* Imported exception objects */
+ static PyObject *p3imp_PyExc_AttributeError;
+ static PyObject *p3imp_PyExc_IndexError;
+ static PyObject *p3imp_PyExc_KeyboardInterrupt;
+ static PyObject *p3imp_PyExc_TypeError;
+ static PyObject *p3imp_PyExc_ValueError;
+ 
+ # define PyExc_AttributeError p3imp_PyExc_AttributeError
+ # define PyExc_IndexError p3imp_PyExc_IndexError
+ # define PyExc_KeyboardInterrupt p3imp_PyExc_KeyboardInterrupt
+ # define PyExc_TypeError p3imp_PyExc_TypeError
+ # define PyExc_ValueError p3imp_PyExc_ValueError
+ 
+ /*
+  * Table of name to function pointer of python.
+  */
+ # define PYTHON_PROC FARPROC
+ static struct
+ {
+     char *name;
+     PYTHON_PROC *ptr;
+ } py3_funcname_table[] =
+ {
+     {"PySys_SetArgv", (PYTHON_PROC*)&py3_PySys_SetArgv},
+     {"Py_Initialize", (PYTHON_PROC*)&py3_Py_Initialize},
+     {"PyArg_ParseTuple", (PYTHON_PROC*)&py3_PyArg_ParseTuple},
+     {"PyList_New", (PYTHON_PROC*)&py3_PyList_New},
+     {"PyGILState_Ensure", (PYTHON_PROC*)&py3_PyGILState_Ensure},
+     {"PyGILState_Release", (PYTHON_PROC*)&py3_PyGILState_Release},
+     {"PySys_SetObject", (PYTHON_PROC*)&py3_PySys_SetObject},
+     {"PyList_Append", (PYTHON_PROC*)&py3_PyList_Append},
+     {"PyList_Size", (PYTHON_PROC*)&py3_PyList_Size},
+     {"PySlice_GetIndicesEx", (PYTHON_PROC*)&py3_PySlice_GetIndicesEx},
+     {"PyErr_NoMemory", (PYTHON_PROC*)&py3_PyErr_NoMemory},
+     {"Py_Finalize", (PYTHON_PROC*)&py3_Py_Finalize},
+     {"PyErr_SetString", (PYTHON_PROC*)&py3_PyErr_SetString},
+     {"PyRun_SimpleString", (PYTHON_PROC*)&py3_PyRun_SimpleString},
+     {"PyList_GetItem", (PYTHON_PROC*)&py3_PyList_GetItem},
+     {"PyImport_ImportModule", (PYTHON_PROC*)&py3_PyImport_ImportModule},
+     {"PyErr_BadArgument", (PYTHON_PROC*)&py3_PyErr_BadArgument},
+     {"PyType_Type", (PYTHON_PROC*)&py3_PyType_Type},
+     {"PyErr_Occurred", (PYTHON_PROC*)&py3_PyErr_Occurred},
+     {"PyModule_GetDict", (PYTHON_PROC*)&py3_PyModule_GetDict},
+     {"PyList_SetItem", (PYTHON_PROC*)&py3_PyList_SetItem},
+     {"PyDict_GetItemString", (PYTHON_PROC*)&py3_PyDict_GetItemString},
+     {"PyLong_FromLong", (PYTHON_PROC*)&py3_PyLong_FromLong},
+     {"PyDict_New", (PYTHON_PROC*)&py3_PyDict_New},
+     {"Py_BuildValue", (PYTHON_PROC*)&py3_Py_BuildValue},
+     {"PyType_Ready", (PYTHON_PROC*)&py3_PyType_Ready},
+     {"PyDict_SetItemString", (PYTHON_PROC*)&py3_PyDict_SetItemString},
+     {"PyLong_AsLong", (PYTHON_PROC*)&py3_PyLong_AsLong},
+     {"PyErr_SetNone", (PYTHON_PROC*)&py3_PyErr_SetNone},
+     {"PyEval_InitThreads", (PYTHON_PROC*)&py3_PyEval_InitThreads},
+     {"PyEval_RestoreThread", (PYTHON_PROC*)&py3_PyEval_RestoreThread},
+     {"PyEval_SaveThread", (PYTHON_PROC*)&py3_PyEval_SaveThread},
+     {"PyArg_Parse", (PYTHON_PROC*)&py3_PyArg_Parse},
+     {"PyArg_ParseTuple", (PYTHON_PROC*)&py3_PyArg_ParseTuple},
+     {"Py_IsInitialized", (PYTHON_PROC*)&py3_Py_IsInitialized},
+     {"_Py_NoneStruct", (PYTHON_PROC*)&py3__Py_NoneStruct},
+     {"PyErr_Clear", (PYTHON_PROC*)&py3_PyErr_Clear},
+     {"PyObject_Init", (PYTHON_PROC*)&py3__PyObject_Init},
+     {"PyModule_AddObject", (PYTHON_PROC*)&py3_PyModule_AddObject},
+     {"PyImport_AppendInittab", (PYTHON_PROC*)&py3_PyImport_AppendInittab},
+     {"_PyUnicode_AsString", (PYTHON_PROC*)&py3__PyUnicode_AsString},
+     {"PyObject_GenericGetAttr", (PYTHON_PROC*)&py3_PyObject_GenericGetAttr},
+     {"PyModule_Create2", (PYTHON_PROC*)&py3_PyModule_Create2},
+     {"PyType_GenericAlloc", (PYTHON_PROC*)&py3_PyType_GenericAlloc},
+     {"PyType_GenericNew", (PYTHON_PROC*)&py3_PyType_GenericNew},
+     {"PyUnicodeUCS2_FromString", (PYTHON_PROC*)&py3_PyUnicodeUCS2_FromString},
+     {"PyUnicodeUCS2_FromStringAndSize", (PYTHON_PROC*)&py3_PyUnicodeUCS2_FromStringAndSize},
+     {"PySlice_Type", (PYTHON_PROC*)&py3_PySlice_Type},
+ #ifdef Py_DEBUG
+     {"_Py_NegativeRefcount", (PYTHON_PROC*)&py3__Py_NegativeRefcount},
+     {"_Py_RefTotal", (PYTHON_PROC*)&py3__Py_RefTotal},
+     {"_Py_Dealloc", (PYTHON_PROC*)&py3__Py_Dealloc},
+     {"_PyObject_DebugFree", (PYTHON_PROC*)&py3__PyObject_DebugFree},
+     {"_PyObject_DebugMalloc", (PYTHON_PROC*)&py3__PyObject_DebugMalloc},
+ #else
+     {"PyObject_Malloc", (PYTHON_PROC*)&py3_PyObject_Malloc},
+     {"PyObject_Free", (PYTHON_PROC*)&py3_PyObject_Free},
+ #endif
+     {"", NULL},
+ };
+ 
+ /*
+  * Free python.dll
+  */
+ static void end_dynamic_python3(void)
+ {
+     if (hinstPy3)
+     {
+         close_dll(hinstPy3);
+         hinstPy3 = 0;
+     }
+ }
+ 
+ /*
+  * Load library and get all pointers.
+  * Parameter 'libname' provides name of DLL.
+  * Return OK or FAIL.
+  */
+ static int py3_runtime_link_init(char *libname, int verbose)
+ {
+     int i;
+ 
+     if (hinstPy3)
+         return OK;
+     hinstPy3 = load_dll(libname);
+ 
+     if (!hinstPy3)
+     {
+         if (verbose)
+             EMSG2(_(e_loadlib), libname);
+         return FAIL;
+     }
+ 
+     for (i = 0; py3_funcname_table[i].ptr; ++i)
+     {
+         if ((*py3_funcname_table[i].ptr = symbol_from_dll(hinstPy3,
+                         py3_funcname_table[i].name)) == NULL)
+         {
+             close_dll(hinstPy3);
+             hinstPy3 = 0;
+             if (verbose)
+                 EMSG2(_(e_loadfunc), py3_funcname_table[i].name);
+             return FAIL;
+         }
+     }
+     return OK;
+ }
+ 
+ /*
+  * If python is enabled (there is installed python on Windows system) return
+  * TRUE, else FALSE.
+  */
+ int python3_enabled(int verbose)
+ {
+     return py3_runtime_link_init(DYNAMIC_PYTHON3_DLL, verbose) == OK;
+ }
+ 
+ /* Load the standard Python exceptions - don't import the symbols from the
+  * DLL, as this can cause errors (importing data symbols is not reliable).
+  */
+ static void get_py3_exceptions __ARGS((void));
+ 
+ static void get_py3_exceptions()
+ {
+     PyObject *exmod = PyImport_ImportModule("builtins");
+     PyObject *exdict = PyModule_GetDict(exmod);
+     p3imp_PyExc_AttributeError = PyDict_GetItemString(exdict, "AttributeError");
+     p3imp_PyExc_IndexError = PyDict_GetItemString(exdict, "IndexError");
+     p3imp_PyExc_KeyboardInterrupt = PyDict_GetItemString(exdict, "KeyboardInterrupt");
+     p3imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError");
+     p3imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError");
+     Py_XINCREF(p3imp_PyExc_AttributeError);
+     Py_XINCREF(p3imp_PyExc_IndexError);
+     Py_XINCREF(p3imp_PyExc_KeyboardInterrupt);
+     Py_XINCREF(p3imp_PyExc_TypeError);
+     Py_XINCREF(p3imp_PyExc_ValueError);
+     Py_XDECREF(exmod);
+ }
+ #endif /* DYNAMIC_PYTHON3 */
+ 
+ static void call_PyObject_Free(void *p)
+ {
+ #ifdef Py_DEBUG
+     _PyObject_DebugFree(p);
+ #else
+     PyObject_Free(p);
+ #endif
+ }
+ static PyObject* call_PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
+ {
+     return PyType_GenericNew(type,args,kwds);
+ }
+ static PyObject* call_PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
+ {
+     return PyType_GenericAlloc(type,nitems);
+ }
+ 
+ /******************************************************
+  * Internal function prototypes.
+  */
+ 
+ static void DoPy3Command(exarg_T *, const char *);
+ static Py_ssize_t RangeStart;
+ static Py_ssize_t RangeEnd;
+ 
+ static void PythonIO_Flush(void);
+ static int PythonIO_Init(void);
+ static void PythonIO_Fini(void);
+ PyMODINIT_FUNC Py3Init_vim(void);
+ 
+ /* Utility functions for the vim/python interface
+  * ----------------------------------------------
+  */
+ static PyObject *GetBufferLine(buf_T *, Py_ssize_t);
+ 
+ static int SetBufferLine(buf_T *, Py_ssize_t, PyObject *, Py_ssize_t*);
+ static int InsertBufferLines(buf_T *, Py_ssize_t, PyObject *, Py_ssize_t*);
+ static PyObject *GetBufferLineList(buf_T *buf, Py_ssize_t lo, Py_ssize_t hi);
+ 
+ static PyObject *LineToString(const char *);
+ static char *StringToLine(PyObject *);
+ 
+ static int VimErrorCheck(void);
+ 
+ #define PyErr_SetVim(str) PyErr_SetString(VimError, str)
+ 
+ /******************************************************
+  * 1. Python interpreter main program.
+  */
+ 
+ static int py3initialised = 0;
+ 
+ 
+ static PyGILState_STATE pygilstate = PyGILState_UNLOCKED;
+ 
+ /*
+  * obtain a lock on the Vim data structures
+  */
+ static void Python_Lock_Vim(void)
+ {
+ }
+ 
+ /*
+  * release a lock on the Vim data structures
+  */
+ static void Python_Release_Vim(void)
+ {
+ }
+ 
+ void python3_end()
+ {
+     static int recurse = 0;
+ 
+     /* If a crash occurs while doing this, don't try again. */
+     if (recurse != 0)
+         return;
+ 
+     ++recurse;
+ 
+ #ifdef DYNAMIC_PYTHON3
+     if (hinstPy3)
+ #endif
+     if (Py_IsInitialized())
+     {
+ 	//acquire lock before finalizing
+ 	pygilstate = PyGILState_Ensure();
+ 
+         PythonIO_Fini();
+         Py_Finalize();
+     }
+ 
+ #ifdef DYNAMIC_PYTHON3
+     end_dynamic_python3();
+ #endif
+ 
+     --recurse;
+ }
+ 
+ static int Python3_Init(void)
+ {
+     if (!py3initialised)
+     {
+ #ifdef DYNAMIC_PYTHON3
+         if (!python3_enabled(TRUE))
+         {
+             EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded."));
+             goto fail;
+         }
+ #endif
+ 
+         /* initialise threads */
+         PyEval_InitThreads();
+ 
+ #if !defined(MACOS) || defined(MACOS_X_UNIX)
+         Py_Initialize();
+ #else
+         PyMac_Initialize();
+ #endif
+ 
+ #ifdef DYNAMIC_PYTHON3
+         get_py3_exceptions();
+ #endif
+ 
+         if (PythonIO_Init())
+             goto fail;
+ 
+         PyImport_AppendInittab("vim",Py3Init_vim);
+ 
+         /* Remove the element from sys.path that was added because of our
+          * argv[0] value in Py3Init_vim().  Previously we used an empty
+          * string, but dependinding on the OS we then get an empty entry or
+          * the current directory in sys.path. */
+         PyRun_SimpleString("import sys; sys.path = list(filter(lambda x: x != '/must>not&exist', sys.path))");
+ 
+         //lock is created and acquired in PyEval_InitThreads() and thread state is created in Py_Initialize()
+ 	//there _PyGILState_NoteThreadState() also sets gilcounter to 1 (python must have threads enabled!)
+         //so the following does both: unlock GIL and save thread state in TLS without deleting thread state
+ 	PyGILState_Release(pygilstate);
+ 
+         py3initialised = 1;
+     }
+ 
+     return 0;
+ 
+ fail:
+     /* We call PythonIO_Flush() here to print any Python errors.
+      * This is OK, as it is possible to call this function even
+      * if PythonIO_Init() has not completed successfully (it will
+      * not do anything in this case).
+      */
+     PythonIO_Flush();
+     return -1;
+ }
+ 
+ /*
+  * External interface
+  */
+ static void DoPy3Command(exarg_T *eap, const char *cmd)
+ {
+ #if defined(MACOS) && !defined(MACOS_X_UNIX)
+     GrafPtr             oldPort;
+ #endif
+ #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
+     char                *saved_locale;
+ #endif
+ 
+ #if defined(MACOS) && !defined(MACOS_X_UNIX)
+     GetPort(&oldPort);
+     /* Check if the Python library is available */
+     if ((Ptr)PyMac_Initialize == (Ptr)kUnresolvedCFragSymbolAddress)
+         goto theend;
+ #endif
+     if (Python3_Init())
+         goto theend;
+ 
+     RangeStart = eap->line1;
+     RangeEnd = eap->line2;
+     Python_Release_Vim();           /* leave vim */
+ 
+ #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
+     /* Python only works properly when the LC_NUMERIC locale is "C". */
+     saved_locale = setlocale(LC_NUMERIC, NULL);
+     if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
+         saved_locale = NULL;
+     else
+     {
+         /* Need to make a copy, value may change when setting new locale. */
+         saved_locale = (char *)vim_strsave((char_u *)saved_locale);
+         (void)setlocale(LC_NUMERIC, "C");
+     }
+ #endif
+ 
+     pygilstate = PyGILState_Ensure();
+ 
+     PyRun_SimpleString((char *)(cmd));
+ 
+     PyGILState_Release(pygilstate);
+ 
+ #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
+     if (saved_locale != NULL)
+     {
+         (void)setlocale(LC_NUMERIC, saved_locale);
+         vim_free(saved_locale);
+     }
+ #endif
+ 
+     Python_Lock_Vim();              /* enter vim */
+     PythonIO_Flush();
+ #if defined(MACOS) && !defined(MACOS_X_UNIX)
+     SetPort(oldPort);
+ #endif
+ 
+ theend:
+     return;         /* keeps lint happy */
+ }
+ 
+ /*
+  * ":python"
+  */
+ void ex_python3(exarg_T *eap)
+ {
+     char_u *script;
+ 
+     script = script_get(eap, eap->arg);
+     if (!eap->skip)
+     {
+         if (script == NULL)
+             DoPy3Command(eap, (char *)eap->arg);
+         else
+             DoPy3Command(eap, (char *)script);
+     }
+     vim_free(script);
+ }
+ 
+ #define BUFFER_SIZE 2048
+ 
+ /*
+  * ":pyfile"
+  */
+     void
+ ex_py3file(exarg_T *eap)
+ {
+     static char buffer[BUFFER_SIZE];
+     const char *file;
+     char *p;
+     int i;
+ 
+     /* Have to do it like this. PyRun_SimpleFile requires you to pass a
+      * stdio file pointer, but Vim and the Python DLL are compiled with
+      * different options under Windows, meaning that stdio pointers aren't
+      * compatible between the two. Yuk.
+      * 
+      * construct: exec(compile(open('a_filename').read(), 'a_filename', 'exec'))
+      *
+      * We need to escape any backslashes or single quotes in the file name, so that
+      * Python won't mangle the file name.
+      */
+     
+     strcpy(buffer, "exec(compile(open('");
+     p = buffer + 19; /* size of "exec(compile(open('" */
+ 
+     for (i=0; i<2; ++i)
+     {
+         file = (char *)eap->arg;
+         while (*file && p < buffer + (BUFFER_SIZE - 3))
+         {
+             if (*file == '\\' || *file == '\'')
+                 *p++ = '\\';
+             *p++ = *file++;
+         }
+         /* If we didn't finish the file name, we hit a buffer overflow */
+         if (*file != '\0')
+             return;
+         if (i==0)
+         {
+             strcpy(p,"').read(),'");
+             p += 11;
+         }
+         else
+         {
+             strcpy(p,"','exec'))");
+             p += 10;
+         }
+     }   
+ 
+ 
+     /* Execute the file */
+     DoPy3Command(eap, buffer);
+ }
+ 
+ /******************************************************
+  * 2. Python output stream: writes output via [e]msg().
+  */
+ 
+ /* Implementation functions
+  */
+ 
+ static PyObject *OutputGetattro(PyObject *, PyObject *);
+ static int OutputSetattro(PyObject *, PyObject *, PyObject *);
+ 
+ static PyObject *OutputWrite(PyObject *, PyObject *);
+ static PyObject *OutputWritelines(PyObject *, PyObject *);
+ 
+ typedef void (*writefn)(char_u *);
+ static void writer(writefn fn, char_u *str, Py_ssize_t n);
+ 
+ /* Output object definition
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+     long softspace;
+     long error;
+ } OutputObject;
+ 
+ static struct PyMethodDef OutputMethods[] = {
+     /* name,        function,           calling,    documentation */
+     {"write",       OutputWrite,        1,          "" },
+     {"writelines",  OutputWritelines,   1,          "" },
+     { NULL,         NULL,               0,          NULL }
+ };
+ 
+ static PyTypeObject OutputType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.message",             /* tp_name */
+     sizeof(OutputObject), /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     0,                         /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     0,                         /* tp_repr */
+     0,                         /* tp_as_number */
+     0,                         /* tp_as_sequence */
+     0,                         /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     OutputGetattro,            /* tp_getattro */
+     OutputSetattro,            /* tp_setattro */
+     0,                         /* tp_as_buffer */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim message object",      /* tp_doc */
+     0,                         /*tp_traverse*/
+     0,                         /*tp_clear*/
+     0,                         /*tp_richcompare*/
+     0,                         /*tp_weaklistoffset*/
+     0,                         /*tp_iter*/
+     0,                         /*tp_iternext*/
+     OutputMethods,             /*tp_methods*/
+     0,                         /*tp_members*/
+     0,                         /*tp_getset*/
+     0,                         /*tp_base*/
+     0,                         /*tp_dict*/
+     0,                         /*tp_descr_get*/
+     0,                         /*tp_descr_set*/
+     0,                         /*tp_dictoffset*/
+     0,                         /*tp_init*/
+     call_PyType_GenericAlloc,       /*tp_alloc*/
+     call_PyType_GenericNew,         /*tp_new*/
+     call_PyObject_Free,        /*tp_free*/
+     0,                         /*tp_is_gc*/
+ };
+ 
+ /*************/
+ 
+ static PyObject * OutputGetattro(PyObject *self, PyObject *nameobj)
+ {
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+     if (strcmp(name, "softspace") == 0)
+         return PyLong_FromLong(((OutputObject *)(self))->softspace);
+ 
+     return PyObject_GenericGetAttr(self, nameobj);
+ }
+ 
+ static int OutputSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
+ {
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+     if (val == NULL) {
+         PyErr_SetString(PyExc_AttributeError, _("can't delete OutputObject attributes"));
+         return -1;
+     }
+ 
+     if (strcmp(name, "softspace") == 0)
+     {
+         if (!PyLong_Check(val)) {
+             PyErr_SetString(PyExc_TypeError, _("softspace must be an integer"));
+             return -1;
+         }
+ 
+         ((OutputObject *)(self))->softspace = PyLong_AsLong(val);
+         return 0;
+     }
+ 
+     PyErr_SetString(PyExc_AttributeError, _("invalid attribute"));
+     return -1;
+ }
+ 
+ /*************/
+ 
+ static PyObject * OutputWrite(PyObject *self, PyObject *args)
+ {
+     int len;
+     char *str;
+     int error = ((OutputObject *)(self))->error;
+ 
+     if (!PyArg_ParseTuple(args, "s#", &str, &len))
+         return NULL;
+ 
+     Py_BEGIN_ALLOW_THREADS
+     Python_Lock_Vim();
+     writer((writefn)(error ? emsg : msg), (char_u *)str, len);
+     Python_Release_Vim();
+     Py_END_ALLOW_THREADS
+ 
+     Py_INCREF(Py_None);
+     return Py_None;
+ }
+ 
+ static PyObject * OutputWritelines(PyObject *self, PyObject *args)
+ {
+     Py_ssize_t n;
+     Py_ssize_t i;
+     PyObject *list;
+     int error = ((OutputObject *)(self))->error;
+ 
+     if (!PyArg_ParseTuple(args, "O", &list))
+         return NULL;
+     Py_INCREF(list);
+ 
+     if (!PyList_Check(list)) {
+         PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
+         Py_DECREF(list);
+         return NULL;
+     }
+ 
+     n = PyList_Size(list);
+ 
+     for (i = 0; i < n; ++i)
+     {
+         PyObject *line = PyList_GetItem(list, i);
+         char *str;
+         Py_ssize_t len;
+ 
+         if (!PyArg_Parse(line, "s#", &str, &len)) {
+             PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
+             Py_DECREF(list);
+             return NULL;
+         }
+ 
+         Py_BEGIN_ALLOW_THREADS
+         Python_Lock_Vim();
+         writer((writefn)(error ? emsg : msg), (char_u *)str, len);
+         Python_Release_Vim();
+         Py_END_ALLOW_THREADS
+     }
+ 
+     Py_DECREF(list);
+     Py_INCREF(Py_None);
+     return Py_None;
+ }
+ 
+ /* Output buffer management
+  */
+ 
+ static char_u *buffer = NULL;
+ static Py_ssize_t buffer_len = 0;
+ static Py_ssize_t buffer_size = 0;
+ 
+ static writefn old_fn = NULL;
+ 
+ static void buffer_ensure(Py_ssize_t n)
+ {
+     Py_ssize_t new_size;
+     char_u *new_buffer;
+ 
+     if (n < buffer_size)
+         return;
+ 
+     new_size = buffer_size;
+     while (new_size < n)
+         new_size += 80;
+ 
+     if (new_size != buffer_size)
+     {
+         new_buffer = alloc((unsigned)new_size);
+         if (new_buffer == NULL)
+             return;
+ 
+         if (buffer)
+         {
+             memcpy(new_buffer, buffer, buffer_len);
+             vim_free(buffer);
+         }
+ 
+         buffer = new_buffer;
+         buffer_size = new_size;
+     }
+ }
+ 
+ static void PythonIO_Flush(void)
+ {
+     if (old_fn && buffer_len)
+     {
+         buffer[buffer_len] = 0;
+         old_fn(buffer);
+     }
+ 
+     buffer_len = 0;
+ }
+ 
+ static void writer(writefn fn, char_u *str, Py_ssize_t n)
+ {
+     char_u *ptr;
+ 
+     if (fn != old_fn && old_fn != NULL)
+         PythonIO_Flush();
+ 
+     old_fn = fn;
+ 
+     while (n > 0 && (ptr = memchr(str, '\n', n)) != NULL)
+     {
+         Py_ssize_t len = ptr - str;
+ 
+         buffer_ensure(buffer_len + len + 1);
+ 
+         memcpy(buffer + buffer_len, str, len);
+         buffer_len += len;
+         buffer[buffer_len] = 0;
+         fn(buffer);
+         str = ptr + 1;
+         n -= len + 1;
+         buffer_len = 0;
+     }
+ 
+     /* Put the remaining text into the buffer for later printing */
+     buffer_ensure(buffer_len + n + 1);
+     memcpy(buffer + buffer_len, str, n);
+     buffer_len += n;
+ }
+ 
+ /***************/
+ 
+ static OutputObject Output =
+ {
+     PyObject_HEAD_INIT(&OutputType)
+     0,
+     0
+ };
+ 
+ static OutputObject Error =
+ {
+     PyObject_HEAD_INIT(&OutputType)
+     0,
+     1
+ };
+ 
+ static int PythonIO_Init(void)
+ {
+     PyType_Ready(&OutputType);
+ 
+     PySys_SetObject("stdout", (PyObject *)(void *)&Output);
+     PySys_SetObject("stderr", (PyObject *)(void *)&Error);
+ 
+     if (PyErr_Occurred())
+     {
+         EMSG(_("E264: Python: Error initialising I/O objects"));
+         return -1;
+     }
+ 
+     return 0;
+ }
+ static void PythonIO_Fini(void)
+ {
+     PySys_SetObject("stdout", NULL);
+     PySys_SetObject("stderr", NULL);
+ }
+ 
+ /******************************************************
+  * 3. Implementation of the Vim module for Python
+  */
+ 
+ /* Vim module - Implementation functions
+  * -------------------------------------
+  */
+ 
+ static PyObject *VimError;
+ 
+ static PyObject *VimCommand(PyObject *, PyObject *);
+ static PyObject *VimEval(PyObject *, PyObject *);
+ 
+ /* Window type - Implementation functions
+  * --------------------------------------
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+     win_T       *win;
+ }
+ WindowObject;
+ 
+ #define INVALID_WINDOW_VALUE ((win_T *)(-1))
+ 
+ #define WindowType_Check(obj) ((obj)->ob_base.ob_type == &WindowType)
+ 
+ static PyObject *WindowNew(win_T *);
+ 
+ static void WindowDestructor(PyObject *);
+ static PyObject *WindowGetattro(PyObject *, PyObject *);
+ static int WindowSetattro(PyObject *, PyObject *, PyObject *);
+ static PyObject *WindowRepr(PyObject *);
+ 
+ /* Buffer type - Implementation functions
+  * --------------------------------------
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+     buf_T *buf;
+ }
+ BufferObject;
+ 
+ #define INVALID_BUFFER_VALUE ((buf_T *)(-1))
+ 
+ #define BufferType_Check(obj) ((obj)->ob_base.ob_type == &BufferType)
+ 
+ static PyObject *BufferNew (buf_T *);
+ 
+ static void BufferDestructor(PyObject *);
+ 
+ static PyObject *BufferGetattro(PyObject *, PyObject*);
+ static PyObject *BufferRepr(PyObject *);
+ 
+ static Py_ssize_t BufferLength(PyObject *);
+ static PyObject *BufferItem(PyObject *, Py_ssize_t);
+ static Py_ssize_t BufferAsItem(PyObject *, Py_ssize_t, PyObject *);
+ static PyObject* BufferSubscript(PyObject *self, PyObject* idx);
+ 
+ static PyObject *BufferAppend(PyObject *, PyObject *);
+ static PyObject *BufferMark(PyObject *, PyObject *);
+ static PyObject *BufferRange(PyObject *, PyObject *);
+ 
+ /* Line range type - Implementation functions
+  * --------------------------------------
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+     BufferObject *buf;
+     Py_ssize_t start;
+     Py_ssize_t end;
+ }
+ RangeObject;
+ 
+ #define RangeType_Check(obj) ((obj)->ob_base.ob_type == &RangeType)
+ 
+ static PyObject *RangeNew(buf_T *, Py_ssize_t, Py_ssize_t);
+ 
+ static void RangeDestructor(PyObject *);
+ static PyObject *RangeGetattro(PyObject *, PyObject *);
+ static PyObject *RangeRepr(PyObject *);
+ static PyObject* RangeSubscript(PyObject *self, PyObject* idx);
+ 
+ static Py_ssize_t RangeLength(PyObject *);
+ static PyObject *RangeItem(PyObject *, Py_ssize_t);
+ static Py_ssize_t RangeAsItem(PyObject *, Py_ssize_t, PyObject *);
+ 
+ static PyObject *RangeAppend(PyObject *, PyObject *);
+ 
+ /* Window list type - Implementation functions
+  * -------------------------------------------
+  */
+ 
+ static Py_ssize_t WinListLength(PyObject *);
+ static PyObject *WinListItem(PyObject *, Py_ssize_t);
+ 
+ /* Buffer list type - Implementation functions
+  * -------------------------------------------
+  */
+ 
+ static Py_ssize_t BufListLength(PyObject *);
+ static PyObject *BufListItem(PyObject *, Py_ssize_t);
+ 
+ /* Current objects type - Implementation functions
+  * -----------------------------------------------
+  */
+ 
+ static PyObject *CurrentGetattro(PyObject *, PyObject *);
+ static int CurrentSetattro(PyObject *, PyObject *, PyObject *);
+ 
+ /* Vim module - Definitions
+  */
+ 
+ static struct PyMethodDef VimMethods[] = {
+     /* name,         function,          calling,    documentation */
+     {"command",      VimCommand,        1,          "Execute a Vim ex-mode command" },
+     {"eval",         VimEval,           1,          "Evaluate an expression using Vim evaluator" },
+     { NULL,          NULL,              0,          NULL }
+ };
+ 
+ /* Vim module - Implementation
+  */
+ /*ARGSUSED*/
+ static PyObject * VimCommand(PyObject *self, PyObject *args)
+ {
+     char *cmd;
+     PyObject *result;
+ 
+     if (!PyArg_ParseTuple(args, "s", &cmd))
+         return NULL;
+ 
+     PyErr_Clear();
+ 
+     Py_BEGIN_ALLOW_THREADS
+     Python_Lock_Vim();
+ 
+     do_cmdline_cmd((char_u *)cmd);
+     update_screen(VALID);
+ 
+     Python_Release_Vim();
+     Py_END_ALLOW_THREADS
+ 
+     if (VimErrorCheck())
+         result = NULL;
+     else
+         result = Py_None;
+ 
+     Py_XINCREF(result);
+     return result;
+ }
+ 
+ #ifdef FEAT_EVAL
+ /*
+  * Function to translate a typval_T into a PyObject; this will recursively
+  * translate lists/dictionaries into their Python equivalents.
+  *
+  * The depth parameter is to avoid infinite recursion, set it to 1 when
+  * you call VimToPython.
+  */
+ static PyObject * VimToPython(typval_T *our_tv, int depth, PyObject *lookupDict)
+ {
+     PyObject    *result;
+     PyObject    *newObj;
+     char        ptrBuf[NUMBUFLEN];
+ 
+     /* Avoid infinite recursion */
+     if (depth > 100)
+     {
+         Py_INCREF(Py_None);
+         result = Py_None;
+         return result;
+     }
+ 
+     /* Check if we run into a recursive loop.  The item must be in lookupDict
+      * then and we can use it again. */
+     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);
+     }
+     else if (our_tv->v_type == VAR_NUMBER)
+     {
+         char buf[NUMBUFLEN];
+ 
+         /* For backwards compatibility numbers are stored as strings. */
+         sprintf(buf, "%ld", (long)our_tv->vval.v_number);
+         result = Py_BuildValue("s", buf);
+     }
+ # ifdef FEAT_FLOAT
+     else if (our_tv->v_type == VAR_FLOAT)
+     {
+         char buf[NUMBUFLEN];
+ 
+         sprintf(buf, "%f", our_tv->vval.v_float);
+         result = Py_BuildValue("s", buf);
+     }
+ # endif
+     else if (our_tv->v_type == VAR_LIST)
+     {
+         list_T          *list = our_tv->vval.v_list;
+         listitem_T      *curr;
+ 
+         result = PyList_New(0);
+ 
+         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);
+                 PyList_Append(result, newObj);
+                 Py_DECREF(newObj);
+             }
+         }
+     }
+     else if (our_tv->v_type == VAR_DICT)
+     {
+         result = PyDict_New();
+ 
+         if (our_tv->vval.v_dict != NULL)
+         {
+             hashtab_T   *ht = &our_tv->vval.v_dict->dv_hashtab;
+             long_u      t = ht->ht_used;
+             hashitem_T  *hi;
+             dictitem_T  *di;
+ 
+             PyDict_SetItemString(lookupDict, ptrBuf, result);
+ 
+             for (hi = ht->ht_array; t > 0; ++hi)
+             {
+                 if (!HASHITEM_EMPTY(hi))
+                 {
+                     --t;
+ 
+                     di = dict_lookup(hi);
+                     newObj = VimToPython(&di->di_tv, depth + 1, lookupDict);
+                     PyDict_SetItemString(result, (char *)hi->hi_key, newObj);
+                     Py_DECREF(newObj);
+                 }
+             }
+         }
+     }
+     else
+     {
+         Py_INCREF(Py_None);
+         result = Py_None;
+     }
+ 
+     return result;
+ }
+ #endif
+ 
+ /*ARGSUSED*/
+ static PyObject * VimEval(PyObject *self, PyObject *args)
+ {
+ #ifdef FEAT_EVAL
+     char        *expr;
+     typval_T    *our_tv;
+     PyObject    *result;
+     PyObject    *lookup_dict;
+ 
+     if (!PyArg_ParseTuple(args, "s", &expr))
+         return NULL;
+ 
+     Py_BEGIN_ALLOW_THREADS
+     Python_Lock_Vim();
+     our_tv = eval_expr((char_u *)expr, NULL);
+ 
+     Python_Release_Vim();
+     Py_END_ALLOW_THREADS
+ 
+     if (our_tv == NULL)
+     {
+         PyErr_SetVim(_("invalid expression"));
+         return NULL;
+     }
+ 
+     /* Convert the Vim type into a Python type.  Create a dictionary that's
+      * used to check for recursive loops. */
+     lookup_dict = PyDict_New();
+     result = VimToPython(our_tv, 1, lookup_dict);
+     Py_DECREF(lookup_dict);
+ 
+ 
+     Py_BEGIN_ALLOW_THREADS
+     Python_Lock_Vim();
+     free_tv(our_tv);
+     Python_Release_Vim();
+     Py_END_ALLOW_THREADS
+ 
+     return result;
+ #else
+     PyErr_SetVim(_("expressions disabled at compile time"));
+     return NULL;
+ #endif
+ }
+ 
+ /* Common routines for buffers and line ranges
+  * -------------------------------------------
+  */
+ static int CheckBuffer(BufferObject *this)
+ {
+     if (this->buf == INVALID_BUFFER_VALUE)
+     {
+         PyErr_SetVim(_("attempt to refer to deleted buffer"));
+         return -1;
+     }
+ 
+     return 0;
+ }
+ 
+ static PyObject * RBItem(BufferObject *self, Py_ssize_t n, Py_ssize_t start, Py_ssize_t end)
+ {
+     if (CheckBuffer(self))
+         return NULL;
+ 
+     if (n < 0 || n > end - start)
+     {
+         PyErr_SetString(PyExc_IndexError, _("line number out of range"));
+         return NULL;
+     }
+ 
+     return GetBufferLine(self->buf, n+start);
+ }
+ 
+ static Py_ssize_t RBAsItem(BufferObject *self, Py_ssize_t n, PyObject *val, Py_ssize_t start, Py_ssize_t end, Py_ssize_t *new_end)
+ {
+     Py_ssize_t len_change;
+ 
+     if (CheckBuffer(self))
+         return -1;
+ 
+     if (n < 0 || n > end - start)
+     {
+         PyErr_SetString(PyExc_IndexError, _("line number out of range"));
+         return -1;
+     }
+ 
+     if (SetBufferLine(self->buf, n+start, val, &len_change) == FAIL)
+         return -1;
+ 
+     if (new_end)
+         *new_end = end + len_change;
+ 
+     return 0;
+ }
+ 
+ static PyObject * RBSlice(BufferObject *self, Py_ssize_t lo, Py_ssize_t hi, Py_ssize_t start, Py_ssize_t end)
+ {
+     Py_ssize_t size;
+ 
+     if (CheckBuffer(self))
+         return NULL;
+ 
+     size = end - start + 1;
+ 
+     if (lo < 0)
+         lo = 0;
+     else if (lo > size)
+         lo = size;
+     if (hi < 0)
+         hi = 0;
+     if (hi < lo)
+         hi = lo;
+     else if (hi > size)
+         hi = size;
+ 
+     return GetBufferLineList(self->buf, lo+start, hi+start);
+ }
+ 
+ static PyObject * RBAppend(BufferObject *self, PyObject *args, Py_ssize_t start, Py_ssize_t end, Py_ssize_t *new_end)
+ {
+     PyObject *lines;
+     Py_ssize_t len_change;
+     Py_ssize_t max;
+     Py_ssize_t n;
+ 
+     if (CheckBuffer(self))
+         return NULL;
+ 
+     max = n = end - start + 1;
+ 
+     if (!PyArg_ParseTuple(args, "O|n" , &lines, &n))
+         return NULL;
+ 
+     if (n < 0 || n > max)
+     {
+         PyErr_SetString(PyExc_ValueError, _("line number out of range"));
+         return NULL;
+     }
+ 
+     if (InsertBufferLines(self->buf, n + start - 1, lines, &len_change) == FAIL)
+         return NULL;
+ 
+     if (new_end)
+         *new_end = end + len_change;
+ 
+     Py_INCREF(Py_None);
+     return Py_None;
+ }
+ 
+ 
+ static struct PyMethodDef BufferMethods[] = {
+     /* name,        function,           calling,    documentation */
+     {"append",      BufferAppend,       1,          "Append data to Vim buffer" },
+     {"mark",        BufferMark,         1,          "Return (row,col) representing position of named mark" },
+     {"range",       BufferRange,        1,          "Return a range object which represents the part of the given buffer between line numbers s and e" },
+     { NULL,         NULL,               0,          NULL }
+ };
+ 
+ static PySequenceMethods BufferAsSeq = {
+     (lenfunc)           BufferLength,       /* sq_length,    len(x)   */
+     (binaryfunc)        0,                  /* sq_concat,    x+y      */
+     (ssizeargfunc)      0,                  /* sq_repeat,    x*n      */
+     (ssizeargfunc)      BufferItem,         /* sq_item,      x[i]     */
+     0,                                      /* was_sq_slice,     x[i:j]   */
+     (ssizeobjargproc)   BufferAsItem,       /* sq_as_item,  x[i]=v   */
+     0,                                      /* was_sq_as_slice, x[i:j]=v */
+ };
+ 
+ PyMappingMethods BufferAsMapping = {
+     /* mp_length        */ (lenfunc)BufferLength,
+     /* mp_subscript     */ (binaryfunc)BufferSubscript,
+     /* mp_ass_subscript */ (objobjargproc)0,
+ };
+ 
+ 
+ /* Buffer object - Definitions
+  */
+ 
+ static PyTypeObject BufferType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.buffer",             /* tp_name */
+     sizeof(BufferObject), /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     BufferDestructor,                         /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     BufferRepr,                /* tp_repr */
+     0,                         /* tp_as_number */
+     &BufferAsSeq,              /* tp_as_sequence */
+     &BufferAsMapping,          /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     BufferGetattro,            /* tp_getattro */
+     0,            /* tp_setattro */
+     0,                         /* tp_as_buffer */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim buffer object",      /* tp_doc */
+     0,                         /*tp_traverse*/
+     0,                         /*tp_clear*/
+     0,                         /*tp_richcompare*/
+     0,                         /*tp_weaklistoffset*/
+     0,                         /*tp_iter*/
+     0,                         /*tp_iternext*/
+     BufferMethods,             /*tp_methods*/
+     0,                         /*tp_members*/
+     0,                         /*tp_getset*/
+     0,                         /*tp_base*/
+     0,                         /*tp_dict*/
+     0,                         /*tp_descr_get*/
+     0,                         /*tp_descr_set*/
+     0,                         /*tp_dictoffset*/
+     0,                         /*tp_init*/
+     call_PyType_GenericAlloc,       /*tp_alloc*/
+     call_PyType_GenericNew,         /*tp_new*/
+     call_PyObject_Free,             /*tp_free*/
+     0,                         /*tp_is_gc*/
+ };
+ 
+ static PyObject * BufferNew(buf_T *buf)
+ {
+     /* We need to handle deletion of buffers underneath us.
+      * If we add a "b_python3_ref" field to the buf_T structure,
+      * then we can get at it in buf_freeall() in vim. We then
+      * need to create only ONE Python object per buffer - if
+      * we try to create a second, just INCREF the existing one
+      * and return it. The (single) Python object referring to
+      * the buffer is stored in "b_python3_ref".
+      * Question: what to do on a buf_freeall(). We'll probably
+      * have to either delete the Python object (DECREF it to
+      * zero - a bad idea, as it leaves dangling refs!) or
+      * set the buf_T * value to an invalid value (-1?), which
+      * means we need checks in all access functions... Bah.
+      */
+ 
+     BufferObject *self;
+ 
+     if (buf->b_python3_ref != NULL)
+     {
+         self = buf->b_python3_ref;
+         Py_INCREF(self);
+     }
+     else
+     {
+         self = PyObject_NEW(BufferObject, &BufferType);
+         buf->b_python3_ref = self;
+         if (self == NULL)
+             return NULL;
+         self->buf = buf;
+     }
+ 
+     return (PyObject *)(self);
+ }
+ 
+ static void BufferDestructor(PyObject *self)
+ {
+     BufferObject *this = (BufferObject *)(self);
+ 
+     if (this->buf && this->buf != INVALID_BUFFER_VALUE)
+         this->buf->b_python3_ref = NULL;
+ }
+ 
+ static PyObject * BufferGetattro(PyObject *self, PyObject*nameobj)
+ {
+     BufferObject *this = (BufferObject *)(self);
+ 
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+     if (CheckBuffer(this))
+         return NULL;
+ 
+     if (strcmp(name, "name") == 0)
+         return Py_BuildValue("s", this->buf->b_ffname);
+     else if (strcmp(name, "number") == 0)
+         return Py_BuildValue("n", this->buf->b_fnum);
+     else if (strcmp(name,"__members__") == 0)
+         return Py_BuildValue("[ss]", "name", "number");
+     else
+         return PyObject_GenericGetAttr(self, nameobj);
+ }
+ 
+ static PyObject * BufferRepr(PyObject *self)
+ {
+     static char repr[100];
+     BufferObject *this = (BufferObject *)(self);
+ 
+     if (this->buf == INVALID_BUFFER_VALUE)
+     {
+         vim_snprintf(repr, 100, _("<buffer object (deleted) at %p>"), (self));
+         return PyUnicode_FromString(repr);
+     }
+     else
+     {
+         char *name = (char *)this->buf->b_fname;
+         Py_ssize_t len;
+ 
+         if (name == NULL)
+             name = "";
+         len = strlen(name);
+ 
+         if (len > 35)
+             name = name + (35 - len);
+ 
+         vim_snprintf(repr, 100, "<buffer %s%s>", len > 35 ? "..." : "", name);
+ 
+         return PyUnicode_FromString(repr);
+     }
+ }
+ 
+ /******************/
+ 
+ static Py_ssize_t BufferLength(PyObject *self)
+ {
+     if (CheckBuffer((BufferObject *)(self)))
+         return -1; 
+ 
+     return (Py_ssize_t)(((BufferObject *)(self))->buf->b_ml.ml_line_count);
+ }
+ 
+ static PyObject * BufferItem(PyObject *self, Py_ssize_t n)
+ {
+     return RBItem((BufferObject *)(self), n, 1,
+                   (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);
+ }
+ 
+ static Py_ssize_t BufferAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
+ {
+     return RBAsItem((BufferObject *)(self), n, val, 1,
+                      (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
+                      NULL);
+ }
+ 
+ static PyObject * BufferSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)
+ {
+     return RBSlice((BufferObject *)(self), lo, hi, 1,
+                    (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);
+ }
+ 
+ 
+ static PyObject* BufferSubscript(PyObject *self, PyObject* idx)
+ {
+     if (PyLong_Check(idx)) {
+         long _idx = PyLong_AsLong(idx);
+         return BufferItem(self,_idx);
+     } else if (PySlice_Check(idx)) {
+         Py_ssize_t start, stop, step, slicelen;
+         
+         if (PySlice_GetIndicesEx((PySliceObject *)idx,
+                                  (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count+1, 
+                                  &start, &stop,
+                                  &step, &slicelen) < 0) {
+                 return NULL;
+         }
+         return BufferSlice(self,start,stop+1);
+     } else {
+         PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
+         return NULL;
+     }
+ }
+ 
+ static PyObject * BufferAppend(PyObject *self, PyObject *args)
+ {
+     return RBAppend((BufferObject *)(self), args, 1,
+                     (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
+                     NULL);
+ }
+ 
+ static PyObject * BufferMark(PyObject *self, PyObject *args)
+ {
+     pos_T       *posp;
+     char        *pmark;//test
+     char        mark;
+     buf_T       *curbuf_save;
+ 
+     if (CheckBuffer((BufferObject *)(self)))
+         return NULL;
+ 
+     if (!PyArg_ParseTuple(args, "s", &pmark))//test: "c"->"s"
+         return NULL;
+     mark = *pmark;//test
+ 
+     curbuf_save = curbuf;
+     curbuf = ((BufferObject *)(self))->buf;
+     posp = getmark(mark, FALSE);
+     curbuf = curbuf_save;
+ 
+     if (posp == NULL)
+     {
+         PyErr_SetVim(_("invalid mark name"));
+         return NULL;
+     }
+ 
+     /* Ckeck for keyboard interrupt */
+     if (VimErrorCheck())
+         return NULL;
+ 
+     if (posp->lnum <= 0)
+     {
+         /* Or raise an error? */
+         Py_INCREF(Py_None);
+         return Py_None;
+     }
+ 
+     return Py_BuildValue("(ll)", (long)(posp->lnum), (long)(posp->col));
+ }
+ 
+ static PyObject * BufferRange(PyObject *self, PyObject *args)
+ {
+     Py_ssize_t start;
+     Py_ssize_t end;
+ 
+     if (CheckBuffer((BufferObject *)(self)))
+         return NULL;
+ 
+     if (!PyArg_ParseTuple(args, "nn", &start, &end))
+         return NULL;
+ 
+     return RangeNew(((BufferObject *)(self))->buf, start, end);
+ }
+ 
+ /* Line range object - Definitions
+  */
+ 
+ static struct PyMethodDef RangeMethods[] = {
+     /* name,        function,           calling,    documentation */
+     {"append",      RangeAppend,        1,          "Append data to the Vim range" },
+     { NULL,         NULL,               0,          NULL }
+ };
+ 
+ static PySequenceMethods RangeAsSeq = {
+     (lenfunc)           RangeLength,     /* sq_length,    len(x)   */
+     (binaryfunc)        0,               /* RangeConcat, */          /* sq_concat,    x+y      */
+     (ssizeargfunc)      0,               /* RangeRepeat, */        /* sq_repeat,    x*n      */
+     (ssizeargfunc)      RangeItem,       /* sq_item,      x[i]     */
+     0,                                   /* was_sq_slice,     x[i:j]   */
+     (ssizeobjargproc)   RangeAsItem,     /* sq_as_item,  x[i]=v   */
+     0,                                   /* was_sq_as_slice, x[i:j]=v */
+ };
+ 
+ PyMappingMethods RangeAsMapping = {
+     /* mp_length        */ (lenfunc)RangeLength,
+     /* mp_subscript     */ (binaryfunc)RangeSubscript,
+     /* mp_ass_subscript */ (objobjargproc)0,
+ };
+ 
+ static PyTypeObject RangeType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.range",               /* tp_name */
+     sizeof(RangeObject),       /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     RangeDestructor,           /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     RangeRepr,                 /* tp_repr */
+     0,                         /* tp_as_number */
+     &RangeAsSeq,               /* tp_as_sequence */
+     &RangeAsMapping,           /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     RangeGetattro,             /* tp_getattro */
+     0,                         /* tp_setattro */
+     0,                         /* tp_as_Range */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim Range object",        /* tp_doc */
+     0,                         /*tp_traverse*/
+     0,                         /*tp_clear*/
+     0,                         /*tp_richcompare*/
+     0,                         /*tp_weaklistoffset*/
+     0,                         /*tp_iter*/
+     0,                         /*tp_iternext*/
+     RangeMethods,              /*tp_methods*/
+     0,                         /*tp_members*/
+     0,                         /*tp_getset*/
+     0,                         /*tp_base*/
+     0,                         /*tp_dict*/
+     0,                         /*tp_descr_get*/
+     0,                         /*tp_descr_set*/
+     0,                         /*tp_dictoffset*/
+     0,                         /*tp_init*/
+     call_PyType_GenericAlloc,  /*tp_alloc*/
+     call_PyType_GenericNew,    /*tp_new*/
+     call_PyObject_Free,        /*tp_free*/
+     0,                         /*tp_is_gc*/
+ };
+ 
+ /* Line range object - Implementation
+  */
+ 
+ static PyObject * RangeNew(buf_T *buf, Py_ssize_t start, Py_ssize_t end)
+ {
+     BufferObject *bufr;
+     RangeObject *self;
+     self = PyObject_NEW(RangeObject, &RangeType);
+     if (self == NULL)
+         return NULL;
+ 
+     bufr = (BufferObject *)BufferNew(buf);
+     if (bufr == NULL)
+     {
+         Py_DECREF(self);
+         return NULL;
+     }
+     Py_INCREF(bufr);
+ 
+     self->buf = bufr;
+     self->start = start;
+     self->end = end;
+ 
+     return (PyObject *)(self);
+ }
+ 
+ static void RangeDestructor(PyObject *self)
+ {
+     Py_DECREF(((RangeObject *)(self))->buf);
+ }
+ 
+ static PyObject * RangeGetattro(PyObject *self, PyObject *nameobj)
+ {
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+     if (strcmp(name, "start") == 0)
+         return Py_BuildValue("n", ((RangeObject *)(self))->start - 1);
+     else if (strcmp(name, "end") == 0)
+         return Py_BuildValue("n", ((RangeObject *)(self))->end - 1);
+     else
+         return PyObject_GenericGetAttr(self, nameobj);
+ }
+ 
+ static PyObject * RangeRepr(PyObject *self)
+ {
+     static char repr[100];
+     RangeObject *this = (RangeObject *)(self);
+ 
+     if (this->buf->buf == INVALID_BUFFER_VALUE)
+     {
+         vim_snprintf(repr, 100, "<range object (for deleted buffer) at %p>",
+                                                                       (self));
+         return PyUnicode_FromString(repr);
+     }
+     else
+     {
+         char *name = (char *)this->buf->buf->b_fname;
+         int len;
+ 
+         if (name == NULL)
+             name = "";
+         len = (int)strlen(name);
+ 
+         if (len > 45)
+             name = name + (45 - len);
+ 
+         vim_snprintf(repr, 100, "<range %s%s (%d:%d)>",
+                 len > 45 ? "..." : "", name,
+                 this->start, this->end);
+ 
+         return PyUnicode_FromString(repr);
+     }
+ }
+ 
+ /****************/
+ 
+ static Py_ssize_t RangeLength(PyObject *self)
+ {
+     /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
+     if (CheckBuffer(((RangeObject *)(self))->buf))
+         return -1; /* ??? */
+ 
+     return (((RangeObject *)(self))->end - ((RangeObject *)(self))->start + 1);
+ }
+ 
+ static PyObject * RangeItem(PyObject *self, Py_ssize_t n)
+ {
+     return RBItem(((RangeObject *)(self))->buf, n,
+                   ((RangeObject *)(self))->start,
+                   ((RangeObject *)(self))->end);
+ }
+ 
+ static Py_ssize_t RangeAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
+ {
+     return RBAsItem(((RangeObject *)(self))->buf, n, val,
+                      ((RangeObject *)(self))->start,
+                      ((RangeObject *)(self))->end,
+                      &((RangeObject *)(self))->end);
+ }
+ 
+ static PyObject * RangeSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)
+ {
+     return RBSlice(((RangeObject *)(self))->buf, lo, hi,
+                    ((RangeObject *)(self))->start,
+                    ((RangeObject *)(self))->end);
+ }
+ 
+ static PyObject* RangeSubscript(PyObject *self, PyObject* idx)
+ {
+     if (PyLong_Check(idx)) {
+         long _idx = PyLong_AsLong(idx);
+         return RangeItem(self,_idx);
+     } else if (PySlice_Check(idx)) {
+         Py_ssize_t start, stop, step, slicelen;
+         
+         if (PySlice_GetIndicesEx((PySliceObject *)idx,
+                                  ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1, 
+                                  &start, &stop,
+                                  &step, &slicelen) < 0) {
+                 return NULL;
+         }
+         return RangeSlice(self,start,stop+1);
+     } else {
+         PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
+         return NULL;
+     }
+ }
+ 
+ static PyObject * RangeAppend(PyObject *self, PyObject *args)
+ {
+     return RBAppend(((RangeObject *)(self))->buf, args,
+                     ((RangeObject *)(self))->start,
+                     ((RangeObject *)(self))->end,
+                     &((RangeObject *)(self))->end);
+ }
+ 
+ /* Buffer list object - Definitions
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+ }
+ BufListObject;
+ 
+ static PySequenceMethods BufListAsSeq = {
+     (lenfunc)           BufListLength,      /* sq_length,    len(x)   */
+     (binaryfunc)        0,                  /* sq_concat,    x+y      */
+     (ssizeargfunc)      0,                  /* sq_repeat,    x*n      */
+     (ssizeargfunc)      BufListItem,        /* sq_item,      x[i]     */
+     0,                                      /* was_sq_slice,     x[i:j]   */
+     (ssizeobjargproc)   0,                  /* sq_as_item,  x[i]=v   */
+     0                                       /* was_sq_as_slice, x[i:j]=v */
+ };
+ 
+ static PyTypeObject BufListType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.bufferlist",          /* tp_name */
+     sizeof(BufListObject),     /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     0,                         /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     0,                         /* tp_repr */
+     0,                         /* tp_as_number */
+     &BufListAsSeq,                         /* tp_as_sequence */
+     0,                         /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     0,                         /* tp_getattro */
+     0,                         /* tp_setattro */
+     0,                         /* tp_as_buffer */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim buffer list",         /* tp_doc */
+ };
+ 
+ /* Buffer list object - Implementation
+  */
+ 
+ /*ARGSUSED*/
+ static Py_ssize_t BufListLength(PyObject *self)
+ {
+     buf_T       *b = firstbuf;
+     Py_ssize_t  n = 0;
+ 
+     while (b)
+     {
+         ++n;
+         b = b->b_next;
+     }
+ 
+     return n;
+ }
+ 
+ /*ARGSUSED*/
+ static PyObject * BufListItem(PyObject *self, Py_ssize_t n)
+ {
+     buf_T *b;
+ 
+     for (b = firstbuf; b; b = b->b_next, --n)
+     {
+         if (n == 0)
+             return BufferNew(b);
+     }
+ 
+     PyErr_SetString(PyExc_IndexError, _("no such buffer"));
+     return NULL;
+ }
+ 
+ /* Window object - Definitions
+  */
+ 
+ static struct PyMethodDef WindowMethods[] = {
+     /* name,        function,           calling,    documentation */
+     { NULL,         NULL,               0,          NULL }
+ };
+ 
+ static PyTypeObject WindowType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.window",             /* tp_name */
+     sizeof(WindowObject), /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     WindowDestructor,                         /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     WindowRepr,                         /* tp_repr */
+     0,                         /* tp_as_number */
+     0,                         /* tp_as_sequence */
+     0,                         /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     WindowGetattro,            /* tp_getattro */
+     WindowSetattro,            /* tp_setattro */
+     0,                         /* tp_as_Window */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim Window object",      /* tp_doc */
+     0,                         /*tp_traverse*/
+     0,                         /*tp_clear*/
+     0,                         /*tp_richcompare*/
+     0,                         /*tp_weaklistoffset*/
+     0,                         /*tp_iter*/
+     0,                         /*tp_iternext*/
+     WindowMethods,             /*tp_methods*/
+     0,                         /*tp_members*/
+     0,                         /*tp_getset*/
+     0,                         /*tp_base*/
+     0,                         /*tp_dict*/
+     0,                         /*tp_descr_get*/
+     0,                         /*tp_descr_set*/
+     0,                         /*tp_dictoffset*/
+     0,                         /*tp_init*/
+     call_PyType_GenericAlloc,       /*tp_alloc*/
+     call_PyType_GenericNew,         /*tp_new*/
+     call_PyObject_Free,             /*tp_free*/
+     0,                         /*tp_is_gc*/
+ };
+ 
+ /* Window object - Implementation
+  */
+ 
+ static PyObject * WindowNew(win_T *win)
+ {
+     /* We need to handle deletion of windows underneath us.
+      * If we add a "w_python3_ref" field to the win_T structure,
+      * then we can get at it in win_free() in vim. We then
+      * need to create only ONE Python object per window - if
+      * we try to create a second, just INCREF the existing one
+      * and return it. The (single) Python object referring to
+      * the window is stored in "w_python3_ref".
+      * On a win_free() we set the Python object's win_T* field
+      * to an invalid value. We trap all uses of a window
+      * object, and reject them if the win_T* field is invalid.
+      */
+ 
+     WindowObject *self;
+ 
+     if (win->w_python3_ref)
+     {
+         self = win->w_python3_ref;
+         Py_INCREF(self);
+     }
+     else
+     {
+         self = PyObject_NEW(WindowObject, &WindowType);
+         if (self == NULL)
+             return NULL;
+         self->win = win;
+         win->w_python3_ref = self;
+     }
+ 
+     return (PyObject *)(self);
+ }
+ 
+ static void WindowDestructor(PyObject *self)
+ {
+     WindowObject *this = (WindowObject *)(self);
+ 
+     if (this->win && this->win != INVALID_WINDOW_VALUE)
+         this->win->w_python3_ref = NULL;
+ }
+ 
+ static int CheckWindow(WindowObject *this)
+ {
+     if (this->win == INVALID_WINDOW_VALUE)
+     {
+         PyErr_SetVim(_("attempt to refer to deleted window"));
+         return -1;
+     }
+ 
+     return 0;
+ }
+ 
+ static PyObject * WindowGetattro(PyObject *self, PyObject *nameobj)
+ {
+     WindowObject *this = (WindowObject *)(self);
+ 
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+ 
+     if (CheckWindow(this))
+         return NULL;
+ 
+     if (strcmp(name, "buffer") == 0)
+         return (PyObject *)BufferNew(this->win->w_buffer);
+     else if (strcmp(name, "cursor") == 0)
+     {
+         pos_T *pos = &this->win->w_cursor;
+ 
+         return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
+     }
+     else if (strcmp(name, "height") == 0)
+         return Py_BuildValue("l", (long)(this->win->w_height));
+ #ifdef FEAT_VERTSPLIT
+     else if (strcmp(name, "width") == 0)
+         return Py_BuildValue("l", (long)(W_WIDTH(this->win)));
+ #endif
+     else if (strcmp(name,"__members__") == 0)
+         return Py_BuildValue("[sss]", "buffer", "cursor", "height");
+     else
+         return PyObject_GenericGetAttr(self, nameobj);
+ }
+ 
+ static int WindowSetattro(PyObject *self, PyObject *nameobj, PyObject *val)
+ {
+     WindowObject *this = (WindowObject *)(self);
+ 
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+ 
+     if (CheckWindow(this))
+         return -1;
+ 
+     if (strcmp(name, "buffer") == 0)
+     {
+         PyErr_SetString(PyExc_TypeError, _("readonly attribute"));
+         return -1;
+     }
+     else if (strcmp(name, "cursor") == 0)
+     {
+         long lnum;
+         long col;
+ 
+         if (!PyArg_Parse(val, "(ll)", &lnum, &col))
+             return -1;
+ 
+         if (lnum <= 0 || lnum > this->win->w_buffer->b_ml.ml_line_count)
+         {
+             PyErr_SetVim(_("cursor position outside buffer"));
+             return -1;
+         }
+ 
+         /* Check for keyboard interrupts */
+         if (VimErrorCheck())
+             return -1;
+ 
+         /* NO CHECK ON COLUMN - SEEMS NOT TO MATTER */
+ 
+         this->win->w_cursor.lnum = lnum;
+         this->win->w_cursor.col = col;
+         update_screen(VALID);
+ 
+         return 0;
+     }
+     else if (strcmp(name, "height") == 0)
+     {
+         int     height;
+         win_T   *savewin;
+ 
+         if (!PyArg_Parse(val, "i", &height))
+             return -1;
+ 
+ #ifdef FEAT_GUI
+         need_mouse_correct = TRUE;
+ #endif
+         savewin = curwin;
+         curwin = this->win;
+         win_setheight(height);
+         curwin = savewin;
+ 
+         /* Check for keyboard interrupts */
+         if (VimErrorCheck())
+             return -1;
+ 
+         return 0;
+     }
+ #ifdef FEAT_VERTSPLIT
+     else if (strcmp(name, "width") == 0)
+     {
+         int     width;
+         win_T   *savewin;
+ 
+         if (!PyArg_Parse(val, "i", &width))
+             return -1;
+ 
+ #ifdef FEAT_GUI
+         need_mouse_correct = TRUE;
+ #endif
+         savewin = curwin;
+         curwin = this->win;
+         win_setwidth(width);
+         curwin = savewin;
+ 
+         /* Check for keyboard interrupts */
+         if (VimErrorCheck())
+             return -1;
+ 
+         return 0;
+     }
+ #endif
+     else
+     {
+         PyErr_SetString(PyExc_AttributeError, name);
+         return -1;
+     }
+ }
+ 
+ static PyObject * WindowRepr(PyObject *self)
+ {
+     static char repr[100];
+     WindowObject *this = (WindowObject *)(self);
+ 
+     if (this->win == INVALID_WINDOW_VALUE)
+     {
+         vim_snprintf(repr, 100, _("<window object (deleted) at %p>"), (self));
+         return PyUnicode_FromString(repr);
+     }
+     else
+     {
+         int     i = 0;
+         win_T   *w;
+ 
+         for (w = firstwin; w != NULL && w != this->win; w = W_NEXT(w))
+             ++i;
+ 
+         if (w == NULL)
+             vim_snprintf(repr, 100, _("<window object (unknown) at %p>"),
+                                                                       (self));
+         else
+             vim_snprintf(repr, 100, _("<window %d>"), i);
+ 
+         return PyUnicode_FromString(repr);
+     }
+ }
+ 
+ /* Window list object - Definitions
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+ }
+ WinListObject;
+ 
+ static PySequenceMethods WinListAsSeq = {
+     (lenfunc)        WinListLength,         /* sq_length,    len(x)   */
+     (binaryfunc)     0,                     /* sq_concat,    x+y      */
+     (ssizeargfunc)   0,                     /* sq_repeat,    x*n      */
+     (ssizeargfunc)   WinListItem,           /* sq_item,      x[i]     */
+     0,                                      /* sq_slice,     x[i:j]   */
+     (ssizeobjargproc)0,                     /* sq_as_item,  x[i]=v   */
+     0,                                      /* sq_as_slice, x[i:j]=v */
+ };
+ 
+ static PyTypeObject WinListType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.windowlist",             /* tp_name */
+     sizeof(WinListObject), /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     0,                         /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     0,                         /* tp_repr */
+     0,                         /* tp_as_number */
+     &WinListAsSeq,                         /* tp_as_sequence */
+     0,                         /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     0,            /* tp_getattro */
+     0,            /* tp_setattro */
+     0,                         /* tp_as_buffer */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim window list",      /* tp_doc */
+ };
+ 
+ /* Window list object - Implementation
+  */
+ /*ARGSUSED*/
+ static Py_ssize_t WinListLength(PyObject *self)
+ {
+     win_T       *w = firstwin;
+     Py_ssize_t  n = 0;
+ 
+     while (w != NULL)
+     {
+         ++n;
+         w = W_NEXT(w);
+     }
+ 
+     return n;
+ }
+ 
+ /*ARGSUSED*/
+ static PyObject * WinListItem(PyObject *self, Py_ssize_t n)
+ {
+     win_T *w;
+ 
+     for (w = firstwin; w != NULL; w = W_NEXT(w), --n)
+         if (n == 0)
+             return WindowNew(w);
+ 
+     PyErr_SetString(PyExc_IndexError, _("no such window"));
+     return NULL;
+ }
+ 
+ /* Current items object - Definitions
+  */
+ 
+ typedef struct
+ {
+     PyObject_HEAD
+ }
+ CurrentObject;
+ 
+ static PyTypeObject CurrentType = {
+     PyVarObject_HEAD_INIT(NULL, 0)
+     "vim.currentdata",             /* tp_name */
+     sizeof(CurrentObject), /* tp_basicsize */
+     0,                         /* tp_itemsize */
+     0,                         /* tp_dealloc */
+     0,                         /* tp_print */
+     0,                         /* tp_getattr */
+     0,                         /* tp_setattr */
+     0,                         /* tp_reserved */
+     0,                         /* tp_repr */
+     0,                         /* tp_as_number */
+     0,                         /* tp_as_sequence */
+     0,                         /* tp_as_mapping */
+     0,                         /* tp_hash  */
+     0,                         /* tp_call */
+     0,                         /* tp_str */
+     CurrentGetattro,            /* tp_getattro */
+     CurrentSetattro,            /* tp_setattro */
+     0,                         /* tp_as_buffer */
+     Py_TPFLAGS_DEFAULT,        /* tp_flags */
+     "vim current object",      /* tp_doc */
+ };
+ 
+ /* Current items object - Implementation
+  */
+ /*ARGSUSED*/
+ static PyObject * CurrentGetattro(PyObject *self, PyObject *nameobj)
+ {
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+     if (strcmp(name, "buffer") == 0)
+         return (PyObject *)BufferNew(curbuf);
+     else if (strcmp(name, "window") == 0)
+         return (PyObject *)WindowNew(curwin);
+     else if (strcmp(name, "line") == 0)
+         return GetBufferLine(curbuf, (Py_ssize_t)curwin->w_cursor.lnum);
+     else if (strcmp(name, "range") == 0)
+         return RangeNew(curbuf, RangeStart, RangeEnd);
+     else if (strcmp(name,"__members__") == 0)
+         return Py_BuildValue("[ssss]", "buffer", "window", "line", "range");
+     else
+     {
+         PyErr_SetString(PyExc_AttributeError, name);
+         return NULL;
+     }
+ }
+ 
+ /*ARGSUSED*/
+ static int CurrentSetattro(PyObject *self, PyObject *nameobj, PyObject *value)
+ {
+     char *name = "";
+     if (PyUnicode_Check(nameobj))
+         name = _PyUnicode_AsString(nameobj);
+ 
+     if (strcmp(name, "line") == 0)
+     {
+         if (SetBufferLine(curbuf, (Py_ssize_t)curwin->w_cursor.lnum, value, NULL) == FAIL)
+             return -1;
+ 
+         return 0;
+     }
+     else
+     {
+         PyErr_SetString(PyExc_AttributeError, name);
+         return -1;
+     }
+ }
+ 
+ /* External interface
+  */
+ 
+     void
+ python3_buffer_free(buf_T *buf)
+ {
+     if (buf->b_python3_ref != NULL)
+     {
+         BufferObject *bp = buf->b_python3_ref;
+         bp->buf = INVALID_BUFFER_VALUE;
+         buf->b_python3_ref = NULL;
+     }
+ }
+ 
+ #if defined(FEAT_WINDOWS) || defined(PROTO)
+     void
+ python3_window_free(win_T *win)
+ {
+     if (win->w_python3_ref != NULL)
+     {
+         WindowObject *wp = win->w_python3_ref;
+         wp->win = INVALID_WINDOW_VALUE;
+         win->w_python3_ref = NULL;
+     }
+ }
+ #endif
+ 
+ static BufListObject TheBufferList =
+ {
+     PyObject_HEAD_INIT(&BufListType)
+ };
+ 
+ static WinListObject TheWindowList =
+ {
+     PyObject_HEAD_INIT(&WinListType)
+ };
+ 
+ static CurrentObject TheCurrent =
+ {
+     PyObject_HEAD_INIT(&CurrentType)
+ };
+ 
+ PyDoc_STRVAR(vim_module_doc,"vim python interface\n");
+ 
+ static struct PyModuleDef vimmodule = {
+     PyModuleDef_HEAD_INIT,
+     "vim",
+     vim_module_doc,
+     -1,
+     VimMethods,
+     NULL,
+     NULL,
+     NULL,
+     NULL
+ };
+ 
+ PyMODINIT_FUNC Py3Init_vim(void)
+ {
+     PyObject *mod;
+     /* The special value is removed from sys.path in Python3_Init(). */
+     static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL};
+ 
+     PyType_Ready(&BufferType);
+     PyType_Ready(&RangeType);
+     PyType_Ready(&WindowType);
+     PyType_Ready(&BufListType);
+     PyType_Ready(&WinListType);
+     PyType_Ready(&CurrentType);
+ 
+     /* Set sys.argv[] to avoid a crash in warn(). */
+     PySys_SetArgv(1, argv);
+ 
+     mod = PyModule_Create(&vimmodule);
+ 
+     VimError = Py_BuildValue("s", "vim.error");
+ 
+     PyModule_AddObject(mod, "error", VimError);
+     Py_INCREF((PyObject *)(void *)&TheBufferList);
+     PyModule_AddObject(mod, "buffers", (PyObject *)(void *)&TheBufferList);
+     Py_INCREF((PyObject *)(void *)&TheCurrent);
+     PyModule_AddObject(mod, "current", (PyObject *)(void *)&TheCurrent);
+     Py_INCREF((PyObject *)(void *)&TheWindowList);
+     PyModule_AddObject(mod, "windows", (PyObject *)(void *)&TheWindowList);
+ 
+     if (PyErr_Occurred())
+         return NULL;
+ 
+     return mod;
+ }
+ 
+ /*************************************************************************
+  * 4. Utility functions for handling the interface between Vim and Python.
+  */
+ 
+ 
+ /* Get a list of lines from the specified buffer. The line numbers
+  * are in Vim format (1-based). The range is from lo up to, but not
+  * including, hi. The list is returned as a Python list of string objects.
+  */
+ static PyObject * GetBufferLineList(buf_T *buf, Py_ssize_t lo, Py_ssize_t hi)
+ {
+     Py_ssize_t i;
+     Py_ssize_t n = hi - lo;
+     PyObject *list = PyList_New(n);
+ 
+     if (list == NULL)
+         return NULL;
+ 
+     for (i = 0; i < n; ++i)
+     {
+         PyObject *str = LineToString((char *)ml_get_buf(buf, (linenr_T)(lo+i), FALSE));
+ 
+         /* Error check - was the Python string creation OK? */
+         if (str == NULL)
+         {
+             Py_DECREF(list);
+             return NULL;
+         }
+ 
+         /* Set the list item */
+         if (PyList_SetItem(list, i, str))
+         {
+             Py_DECREF(str);
+             Py_DECREF(list);
+             return NULL;
+         }
+     }
+ 
+     /* The ownership of the Python list is passed to the caller (ie,
+      * the caller should Py_DECREF() the object when it is finished
+      * with it).
+      */
+ 
+     return list;
+ }
+ 
+ /* Get a line from the specified buffer. The line number is
+  * in Vim format (1-based). The line is returned as a Python
+  * string object.
+  */
+ static PyObject * GetBufferLine(buf_T *buf, Py_ssize_t n)
+ {
+     return LineToString((char *)ml_get_buf(buf, (linenr_T)n, FALSE));
+ }
+ 
+ /*
+  * Check if deleting lines made the cursor position invalid.
+  * Changed the lines from "lo" to "hi" and added "extra" lines (negative if
+  * deleted).
+  */
+ static void py_fix_cursor(linenr_T lo, linenr_T hi, linenr_T extra)
+ {
+     if (curwin->w_cursor.lnum >= lo)
+     {
+         /* Adjust the cursor position if it's in/after the changed
+          * lines. */
+         if (curwin->w_cursor.lnum >= hi)
+         {
+             curwin->w_cursor.lnum += extra;
+             check_cursor_col();
+         }
+         else if (extra < 0)
+         {
+             curwin->w_cursor.lnum = lo;
+             check_cursor();
+         }
+         else
+             check_cursor_col();
+         changed_cline_bef_curs();
+     }
+     invalidate_botline();
+ }
+ 
+ /* Replace a line in the specified buffer. The line number is
+  * in Vim format (1-based). The replacement line is given as
+  * a Python string object. The object is checked for validity
+  * and correct format. Errors are returned as a value of FAIL.
+  * The return value is OK on success.
+  * If OK is returned and len_change is not NULL, *len_change
+  * is set to the change in the buffer length.
+  */
+ static int SetBufferLine(buf_T *buf, Py_ssize_t n, PyObject *line, Py_ssize_t *len_change)
+ {
+     /* First of all, we check the thpe of the supplied Python object.
+      * There are three cases:
+      *    1. NULL, or None - this is a deletion.
+      *    2. A string      - this is a replacement.
+      *    3. Anything else - this is an error.
+      */
+     if (line == Py_None || line == NULL)
+     {
+         buf_T *savebuf = curbuf;
+ 
+         PyErr_Clear();
+         curbuf = buf;
+ 
+         if (u_savedel((linenr_T)n, 1L) == FAIL)
+             PyErr_SetVim(_("cannot save undo information"));
+         else if (ml_delete((linenr_T)n, FALSE) == FAIL)
+             PyErr_SetVim(_("cannot delete line"));
+         else
+         {
+             deleted_lines_mark((linenr_T)n, 1L);
+             if (buf == curwin->w_buffer)
+                 py_fix_cursor((linenr_T)n, (linenr_T)n + 1, (linenr_T)-1);
+         }
+ 
+         curbuf = savebuf;
+ 
+         if (PyErr_Occurred() || VimErrorCheck())
+             return FAIL;
+ 
+         if (len_change)
+             *len_change = -1;
+ 
+         return OK;
+     }
+     else if (PyUnicode_Check(line))
+     {
+         char *save = StringToLine(line);
+         buf_T *savebuf = curbuf;
+ 
+         if (save == NULL)
+             return FAIL;
+ 
+         /* We do not need to free "save" if ml_replace() consumes it. */
+         PyErr_Clear();
+         curbuf = buf;
+ 
+         if (u_savesub((linenr_T)n) == FAIL)
+         {
+             PyErr_SetVim(_("cannot save undo information"));
+             vim_free(save);
+         }
+         else if (ml_replace((linenr_T)n, (char_u *)save, FALSE) == FAIL)
+         {
+             PyErr_SetVim(_("cannot replace line"));
+             vim_free(save);
+         }
+         else
+             changed_bytes((linenr_T)n, 0);
+ 
+         curbuf = savebuf;
+ 
+         /* Check that the cursor is not beyond the end of the line now. */
+         if (buf == curwin->w_buffer)
+             check_cursor_col();
+ 
+         if (PyErr_Occurred() || VimErrorCheck())
+             return FAIL;
+ 
+         if (len_change)
+             *len_change = 0;
+ 
+         return OK;
+     }
+     else
+     {
+         PyErr_BadArgument();
+         return FAIL;
+     }
+ }
+ 
+ /* Insert a number of lines into the specified buffer after the specifed line.
+  * The line number is in Vim format (1-based). The lines to be inserted are
+  * given as a Python list of string objects or as a single string. The lines
+  * to be added are checked for validity and correct format. Errors are
+  * returned as a value of FAIL.  The return value is OK on success.
+  * If OK is returned and len_change is not NULL, *len_change
+  * is set to the change in the buffer length.
+  */
+ static int InsertBufferLines(buf_T *buf, Py_ssize_t n, PyObject *lines, Py_ssize_t *len_change)
+ {
+     /* First of all, we check the type of the supplied Python object.
+      * It must be a string or a list, or the call is in error.
+      */
+     if (PyUnicode_Check(lines))
+     {
+         char    *str = StringToLine(lines);
+         buf_T   *savebuf;
+ 
+         if (str == NULL)
+             return FAIL;
+ 
+         savebuf = curbuf;
+ 
+         PyErr_Clear();
+         curbuf = buf;
+ 
+         if (u_save((linenr_T)n, (linenr_T)(n+1)) == FAIL)
+             PyErr_SetVim(_("cannot save undo information"));
+         else if (ml_append((linenr_T)n, (char_u *)str, 0, FALSE) == FAIL)
+             PyErr_SetVim(_("cannot insert line"));
+         else
+             appended_lines_mark((linenr_T)n, 1L);
+ 
+         vim_free(str);
+         curbuf = savebuf;
+         update_screen(VALID);
+ 
+         if (PyErr_Occurred() || VimErrorCheck())
+             return FAIL;
+ 
+         if (len_change)
+             *len_change = 1;
+ 
+         return OK;
+     }
+     else if (PyList_Check(lines))
+     {
+         Py_ssize_t      i;
+         Py_ssize_t      size = PyList_Size(lines);
+         char    **array;
+         buf_T   *savebuf;
+ 
+         array = (char **)alloc((unsigned)(size * sizeof(char *)));
+         if (array == NULL)
+         {
+             PyErr_NoMemory();
+             return FAIL;
+         }
+ 
+         for (i = 0; i < size; ++i)
+         {
+             PyObject *line = PyList_GetItem(lines, i);
+             array[i] = StringToLine(line);
+ 
+             if (array[i] == NULL)
+             {
+                 while (i)
+                     vim_free(array[--i]);
+                 vim_free(array);
+                 return FAIL;
+             }
+         }
+ 
+         savebuf = curbuf;
+ 
+         PyErr_Clear();
+         curbuf = buf;
+ 
+         if (u_save((linenr_T)n, (linenr_T)(n + 1)) == FAIL)
+             PyErr_SetVim(_("cannot save undo information"));
+         else
+         {
+             for (i = 0; i < size; ++i)
+             {
+                 if (ml_append((linenr_T)(n + i),
+                                         (char_u *)array[i], 0, FALSE) == FAIL)
+                 {
+                     PyErr_SetVim(_("cannot insert line"));
+ 
+                     /* Free the rest of the lines */
+                     while (i < size)
+                         vim_free(array[i++]);
+ 
+                     break;
+                 }
+                 vim_free(array[i]);
+             }
+             if (i > 0)
+                 appended_lines_mark((linenr_T)n, (long)i);
+         }
+ 
+         /* Free the array of lines. All of its contents have now
+          * been freed.
+          */
+         vim_free(array);
+ 
+         curbuf = savebuf;
+         update_screen(VALID);
+ 
+         if (PyErr_Occurred() || VimErrorCheck())
+             return FAIL;
+ 
+         if (len_change)
+             *len_change = size;
+ 
+         return OK;
+     }
+     else
+     {
+         PyErr_BadArgument();
+         return FAIL;
+     }
+ }
+ 
+ /* Convert a Vim line into a Python string.
+  * All internal newlines are replaced by null characters.
+  *
+  * On errors, the Python exception data is set, and NULL is returned.
+  */
+ static PyObject * LineToString(const char *str)
+ {
+     PyObject *result;
+     Py_ssize_t len = strlen(str);
+     char *tmp,*p;
+ 
+     tmp = (char *)alloc((unsigned)(len+1));
+     p = tmp;
+     if (p == NULL)
+     {
+         PyErr_NoMemory();
+         return NULL;
+     }
+ 
+     while (*str)
+     {
+         if (*str == '\n')
+             *p = '\0';
+         else
+             *p = *str;
+ 
+         ++p;
+         ++str;
+     }
+     *p = '\0';
+ 
+     result = PyUnicode_FromStringAndSize(tmp, len);
+ 
+     vim_free(tmp);
+     return result;
+ }
+ 
+ /* Convert a Python string into a Vim line.
+  *
+  * The result is in allocated memory. All internal nulls are replaced by
+  * newline characters. It is an error for the string to contain newline
+  * characters.
+  *
+  * On errors, the Python exception data is set, and NULL is returned.
+  */
+ static char * StringToLine(PyObject *obj)
+ {
+     const char *str;
+     char *save;
+     Py_ssize_t len;
+     Py_ssize_t i;
+     char *p;
+ 
+     if (obj == NULL || !PyUnicode_Check(obj))
+     {
+         PyErr_BadArgument();
+         return NULL;
+     }
+ 
+     str = _PyUnicode_AsString(obj);
+     len = PyUnicode_GET_SIZE(obj);
+ 
+     /*
+      * Error checking: String must not contain newlines, as we
+      * are replacing a single line, and we must replace it with
+      * a single line.
+      * A trailing newline is removed, so that append(f.readlines()) works.
+      */
+     p = memchr(str, '\n', len);
+     if (p != NULL)
+     {
+         if (p == str + len - 1)
+             --len;
+         else
+         {
+             PyErr_SetVim(_("string cannot contain newlines"));
+             return NULL;
+         }
+     }
+ 
+     /* Create a copy of the string, with internal nulls replaced by
+      * newline characters, as is the vim convention.
+      */
+     save = (char *)alloc((unsigned)(len+1));
+     if (save == NULL)
+     {
+         PyErr_NoMemory();
+         return NULL;
+     }
+ 
+     for (i = 0; i < len; ++i)
+     {
+         if (str[i] == '\0')
+             save[i] = '\n';
+         else
+             save[i] = str[i];
+     }
+ 
+     save[i] = '\0';
+ 
+     return save;
+ }
+ 
+ /* Check to see whether a Vim error has been reported, or a keyboard
+  * interrupt has been detected.
+  */
+ static int VimErrorCheck(void)
+ {
+     if (got_int)
+     {
+         PyErr_SetNone(PyExc_KeyboardInterrupt);
+         return 1;
+     }
+     else if (did_emsg && !PyErr_Occurred())
+     {
+         PyErr_SetNone(VimError);
+         return 1;
+     }
+ 
+     return 0;
+ }
+ 
diff -caPr ..\vimorg/src/main.c ./src/main.c
*** ..\vimorg/src/main.c	2010-04-19 14:14:44.658809100 +0200
--- ./src/main.c	2010-04-19 17:39:53.454328200 +0200
***************
*** 1352,1357 ****
--- 1352,1360 ----
  #ifdef FEAT_PYTHON
      python_end();
  #endif
+ #ifdef FEAT_PYTHON3
+     python3_end();
+ #endif
  #ifdef FEAT_PERL
      perl_end();
  #endif
diff -caPr ..\vimorg/src/Make_bc5.mak ./src/Make_bc5.mak
*** ..\vimorg/src/Make_bc5.mak	2010-04-19 14:14:44.580721100 +0200
--- ./src/Make_bc5.mak	2010-04-19 17:39:53.469948200 +0200
***************
*** 41,46 ****
--- 41,49 ----
  # PYTHON	define to path to Python dir to get PYTHON support (not defined)
  #   PYTHON_VER	    define to version of Python being used (22)
  #   DYNAMIC_PYTHON  no or yes: use yes to load the Python DLL dynamically (no)
+ # PYTHON3	define to path to Python3 dir to get PYTHON3 support (not defined)
+ #   PYTHON3_VER	    define to version of Python3 being used (31)
+ #   DYNAMIC_PYTHON3  no or yes: use yes to load the Python3 DLL dynamically (no)
  # TCL		define to path to TCL dir to get TCL support (not defined)
  #   TCL_VER	define to version of TCL being used (83)
  #   DYNAMIC_TCL no or yes: use yes to load the TCL DLL dynamically (no)
***************
*** 135,140 ****
--- 138,146 ----
  ### PYTHON: uncomment this line if you want python support in vim
  # PYTHON=c:\python22
  
+ ### PYTHON3: uncomment this line if you want python3 support in vim
+ # PYTHON3=c:\python31
+ 
  ### RUBY: uncomment this line if you want ruby support in vim
  # RUBY=c:\ruby
  
***************
*** 200,205 ****
--- 206,212 ----
  #   don't use FASTCALL when linking with external libs.
  !if ("$(FASTCALL)"=="") && \
  	("$(PYTHON)"=="") && \
+ 	("$(PYTHON3)"=="") && \
  	("$(PERL)"=="") && \
  	("$(TCL)"=="") && \
  	("$(RUBY)"=="") && \
***************
*** 309,316 ****
  !endif
  
  !ifdef PYTHON
  INTERP_DEFINES = $(INTERP_DEFINES) -DFEAT_PYTHON
- INCLUDE = $(PYTHON)\include;$(INCLUDE)
  !ifndef PYTHON_VER
  PYTHON_VER = 22
  !endif
--- 316,329 ----
  !endif
  
  !ifdef PYTHON
+ !ifdef PYTHON3
+ DYNAMIC_PYTHON=yes
+ DYNAMIC_PYTHON3=yes
+ !endif
+ !endif
+ 
+ !ifdef PYTHON
  INTERP_DEFINES = $(INTERP_DEFINES) -DFEAT_PYTHON
  !ifndef PYTHON_VER
  PYTHON_VER = 22
  !endif
***************
*** 320,325 ****
--- 333,350 ----
  !endif
  !endif
  
+ !ifdef PYTHON3
+ INTERP_DEFINES = $(INTERP_DEFINES) -DFEAT_PYTHON3
+ !ifndef PYTHON3_VER
+ PYTHON3_VER = 31
+ !endif
+ !if "$(DYNAMIC_PYTHON3)" == "yes"
+ INTERP_DEFINES = $(INTERP_DEFINES) -DDYNAMIC_PYTHON3 -DDYNAMIC_PYTHON3_DLL=\"python$(PYTHON3_VER).dll\"
+ PYTHON3_LIB_FLAG = /nodefaultlib:
+ !endif
+ !endif
+ 
+ 
  !ifdef RUBY
  !ifndef RUBY_VER
  RUBY_VER = 16
***************
*** 592,597 ****
--- 617,627 ----
      $(OBJDIR)\if_python.obj
  !endif
  
+ !ifdef PYTHON3
+ vimobj = $(vimobj) \
+     $(OBJDIR)\if_python3.obj
+ !endif
+ 
  !ifdef RUBY
  vimobj = $(vimobj) \
      $(OBJDIR)\if_ruby.obj
***************
*** 702,707 ****
--- 732,743 ----
  MSG = $(MSG)(dynamic)
  ! endif
  !endif
+ !ifdef PYTHON3
+ MSG = $(MSG) PYTHON3
+ ! if "$(DYNAMIC_PYTHON3)" == "yes"
+ MSG = $(MSG)(dynamic)
+ ! endif
+ !endif
  !ifdef RUBY
  MSG = $(MSG) RUBY
  ! if "$(DYNAMIC_RUBY)" == "yes"
***************
*** 792,797 ****
--- 828,836 ----
  !ifdef PYTHON
  	-@del python.lib
  !endif
+ !ifdef PYTHON3
+ 	-@del python3.lib
+ !endif
  !ifdef RUBY
  	-@del ruby.lib
  !endif
***************
*** 829,834 ****
--- 868,876 ----
  !ifdef PYTHON
  	$(PYTHON_LIB_FLAG)python.lib+
  !endif
+ !ifdef PYTHON3
+ 	$(PYTHON3_LIB_FLAG)python3.lib+
+ !endif
  !ifdef RUBY
  	$(RUBY_LIB_FLAG)ruby.lib+
  !endif
***************
*** 878,883 ****
--- 920,928 ----
  !ifdef PYTHON
  	$(PYTHON_LIB_FLAG)python.lib+
  !endif
+ !ifdef PYTHON3
+ 	$(PYTHON3_LIB_FLAG)python3.lib+
+ !endif
  !ifdef RUBY
  	$(RUBY_LIB_FLAG)ruby.lib+
  !endif
***************
*** 918,924 ****
  	    $(PERL)\lib\ExtUtils\typemap if_perl.xs > $@
  
  $(OBJDIR)\if_python.obj: if_python.c python.lib
! 	$(CC) $(CCARG) $(CC1) $(CC2)$@ -pc if_python.c
  
  $(OBJDIR)\if_ruby.obj: if_ruby.c ruby.lib
  	$(CC) $(CCARG) $(CC1) $(CC2)$@ -pc if_ruby.c
--- 963,972 ----
  	    $(PERL)\lib\ExtUtils\typemap if_perl.xs > $@
  
  $(OBJDIR)\if_python.obj: if_python.c python.lib
! 	$(CC) -I$(PYTHON)\include $(CCARG) $(CC1) $(CC2)$@ -pc if_python.c
! 
! $(OBJDIR)\if_python3.obj: if_python3.c python3.lib
! 	$(CC) -I$(PYTHON3)\include $(CCARG) $(CC1) $(CC2)$@ -pc if_python3.c
  
  $(OBJDIR)\if_ruby.obj: if_ruby.c ruby.lib
  	$(CC) $(CCARG) $(CC1) $(CC2)$@ -pc if_ruby.c
***************
*** 970,975 ****
--- 1018,1026 ----
  python.lib: $(PYTHON)\libs\python$(PYTHON_VER).lib
  	coff2omf $(PYTHON)\libs\python$(PYTHON_VER).lib $@
  
+ python3.lib: $(PYTHON3)\libs\python$(PYTHON3_VER).lib
+ 	coff2omf $(PYTHON3)\libs\python$(PYTHON3_VER).lib $@
+ 
  ruby.lib: $(RUBY)\lib\$(RUBY_INSTALL_NAME).lib
  	coff2omf $(RUBY)\lib\$(RUBY_INSTALL_NAME).lib $@
  
***************
*** 1018,1020 ****
--- 1069,1072 ----
  | $@
  
  # vi:set sts=4 sw=4:
+ 
diff -caPr ..\vimorg/src/Make_cyg.mak ./src/Make_cyg.mak
*** ..\vimorg/src/Make_cyg.mak	2010-04-19 14:14:44.346457100 +0200
--- ./src/Make_cyg.mak	2010-04-19 17:39:53.469948200 +0200
***************
*** 14,19 ****
--- 14,22 ----
  # PYTHON	define to path to Python dir to get PYTHON support (not defined)
  #   PYTHON_VER	    define to version of Python being used (22)
  #   DYNAMIC_PYTHON  no or yes: use yes to load the Python DLL dynamically (yes)
+ # PYTHON3	define to path to Python3 dir to get PYTHON3 support (not defined)
+ #   PYTHON3_VER	    define to version of Python3 being used (22)
+ #   DYNAMIC_PYTHON3  no or yes: use yes to load the Python3 DLL dynamically (yes)
  # TCL		define to path to TCL dir to get TCL support (not defined)
  #   TCL_VER	define to version of TCL being used (83)
  #   DYNAMIC_TCL no or yes: use yes to load the TCL DLL dynamically (yes)
***************
*** 135,141 ****
  ##############################
  ifdef PYTHON
  DEFINES += -DFEAT_PYTHON
- INCLUDES += -I$(PYTHON)/include
  EXTRA_OBJS += $(OUTDIR)/if_python.o
  
  ifndef DYNAMIC_PYTHON
--- 138,143 ----
***************
*** 154,159 ****
--- 156,184 ----
  endif
  
  ##############################
+ # DYNAMIC_PYTHON3=yes works.
+ # DYNAMIC_PYTHON3=no does not (unresolved externals on link).
+ ##############################
+ ifdef PYTHON3
+ DEFINES += -DFEAT_PYTHON3
+ EXTRA_OBJS += $(OUTDIR)/if_python3.o
+ 
+ ifndef DYNAMIC_PYTHON3
+ DYNAMIC_PYTHON3 = yes
+ endif
+ 
+ ifndef PYTHON3_VER
+ PYTHON3_VER = 31
+ endif
+ 
+ ifeq (yes, $(DYNAMIC_PYTHON3))
+ DEFINES += -DDYNAMIC_PYTHON3 -DDYNAMIC_PYTHON3_DLL=\"python$(PYTHON3_VER).dll\"
+ else
+ EXTRA_LIBS += $(PYTHON3)/libs/python$(PYTHON3_VER).lib
+ endif
+ endif
+ 
+ ##############################
  # DYNAMIC_RUBY=yes works.
  # DYNAMIC_RUBY=no does not (process exits).
  ##############################
***************
*** 533,538 ****
--- 558,569 ----
  $(OUTDIR)/if_ole.o:	if_ole.cpp $(INCL)
  	$(CC) -c $(CFLAGS) if_ole.cpp -o $(OUTDIR)/if_ole.o
  
+ $(OUTDIR)/if_python.o : if_python.c $(INCL)
+ 	$(CC) -c $(CFLAGS) -I$(PYTHON)/include $< -o $@
+ 
+ $(OUTDIR)/if_python3.o : if_python3.c $(INCL)
+ 	$(CC) -c $(CFLAGS) -I$(PYTHON3)/include $< -o $@
+ 
  if_perl.c: if_perl.xs typemap
  	$(PERL)/bin/perl `cygpath -d $(PERL)/lib/ExtUtils/xsubpp` \
  		-prototypes -typemap \
***************
*** 582,584 ****
--- 613,616 ----
  	@echo char_u *compiled_user = (char_u *)"$(USERNAME)"; >> pathdef.c
  	@echo char_u *compiled_sys = (char_u *)"$(USERDOMAIN)"; >> pathdef.c
  endif
+ 
diff -caPr ..\vimorg/src/Make_ming.mak ./src/Make_ming.mak
*** ..\vimorg/src/Make_ming.mak	2010-04-19 14:14:44.393309900 +0200
--- ./src/Make_ming.mak	2010-04-19 17:39:53.485568200 +0200
***************
*** 177,182 ****
--- 177,204 ----
  endif
  endif
  
+ #PYTHON3: See comment for Python 2 above
+ 
+ ifdef PYTHON3
+ ifndef DYNAMIC_PYTHON3
+ DYNAMIC_PYTHON3=yes
+ endif
+ 
+ ifndef PYTHON3_VER
+ PYTHON3_VER=31
+ endif
+ 
+ ifeq (no,$(DYNAMIC_PYTHON3))
+ PYTHON3LIB=-L$(PYTHON3)/libs -lPYTHON$(PYTHON3_VER)
+ endif
+ 
+ ifeq ($(CROSS),no)
+ PYTHON3INC=-I $(PYTHON3)/include
+ else
+ PYTHON3INC=-I $(PYTHON3)/win32inc
+ endif
+ endif
+ 
  #	TCL interface:
  #	  TCL=[Path to TCL directory]
  #	  DYNAMIC_TCL=yes (to load the TCL DLL dynamically)
***************
*** 310,318 ****
  endif
  
  ifdef PYTHON
! CFLAGS += -DFEAT_PYTHON $(PYTHONINC)
  ifeq (yes, $(DYNAMIC_PYTHON))
! CFLAGS += -DDYNAMIC_PYTHON -DDYNAMIC_PYTHON_DLL=\"python$(PYTHON_VER).dll\"
  endif
  endif
  
--- 332,347 ----
  endif
  
  ifdef PYTHON
! CFLAGS += -DFEAT_PYTHON 
  ifeq (yes, $(DYNAMIC_PYTHON))
! CFLAGS += -DDYNAMIC_PYTHON
! endif
! endif
! 
! ifdef PYTHON3 
! CFLAGS += -DFEAT_PYTHON3 
! ifeq (yes, $(DYNAMIC_PYTHON3))
! CFLAGS += -DDYNAMIC_PYTHON3 
  endif
  endif
  
***************
*** 439,444 ****
--- 468,476 ----
  ifdef PYTHON
  OBJ += $(OUTDIR)/if_python.o
  endif
+ ifdef PYTHON3
+ OBJ += $(OUTDIR)/if_python3.o
+ endif
  ifdef RUBY
  OBJ += $(OUTDIR)/if_ruby.o
  endif
***************
*** 547,553 ****
  	$(CC) $(CFLAGS) -o uninstal.exe uninstal.c $(LIB)
  
  $(TARGET): $(OUTDIR) $(OBJ)
! 	$(CC) $(CFLAGS) $(LFLAGS) -o $@ $(OBJ) $(LIB) -lole32 -luuid $(MZSCHEME_LIBDIR) $(MZSCHEME_LIB) $(PYTHONLIB) $(RUBYLIB)
  
  upx: exes
  	upx gvim.exe
--- 579,585 ----
  	$(CC) $(CFLAGS) -o uninstal.exe uninstal.c $(LIB)
  
  $(TARGET): $(OUTDIR) $(OBJ)
! 	$(CC) $(CFLAGS) $(LFLAGS) -o $@ $(OBJ) $(LIB) -lole32 -luuid $(MZSCHEME_LIBDIR) $(MZSCHEME_LIB) $(PYTHONLIB) $(PYTHON3LIB) $(RUBYLIB)
  
  upx: exes
  	upx gvim.exe
***************
*** 579,584 ****
--- 611,622 ----
  	structs.h regexp.h option.h ex_cmds.h proto.h globals.h farsi.h \
  	gui.h
  
+ $(OUTDIR)/if_python.o : if_python.c $(INCL)
+ 	$(CC) -c $(CFLAGS) $(PYTHONINC) -DDYNAMIC_PYTHON_DLL=\"python$(PYTHON_VER).dll\" $< -o $@
+ 
+ $(OUTDIR)/if_python3.o : if_python3.c $(INCL)
+ 	$(CC) -c $(CFLAGS) $(PYTHON3INC) -DDYNAMIC_PYTHON3_DLL=\"PYTHON$(PYTHON3_VER).dll\" $< -o $@
+ 
  $(OUTDIR)/%.o : %.c $(INCL)
  	$(CC) -c $(CFLAGS) $< -o $@
  
***************
*** 630,636 ****
  	@echo 'char_u *default_vim_dir = (char_u *)"$(VIMRCLOC)";' >> pathdef.c
  	@echo 'char_u *default_vimruntime_dir = (char_u *)"$(VIMRUNTIMEDIR)";' >> pathdef.c
  	@echo 'char_u *all_cflags = (char_u *)"$(CC) $(CFLAGS)";' >> pathdef.c
! 	@echo 'char_u *all_lflags = (char_u *)"$(CC) $(CFLAGS) $(LFLAGS) -o $(TARGET) $(LIB) -lole32 -luuid $(MZSCHEME_LIBDIR) $(MZSCHEME_LIB) $(PYTHONLIB) $(RUBYLIB)";' >> pathdef.c
  	@echo 'char_u *compiled_user = (char_u *)"$(USERNAME)";' >> pathdef.c
  	@echo 'char_u *compiled_sys = (char_u *)"$(USERDOMAIN)";' >> pathdef.c
  else
--- 668,674 ----
  	@echo 'char_u *default_vim_dir = (char_u *)"$(VIMRCLOC)";' >> pathdef.c
  	@echo 'char_u *default_vimruntime_dir = (char_u *)"$(VIMRUNTIMEDIR)";' >> pathdef.c
  	@echo 'char_u *all_cflags = (char_u *)"$(CC) $(CFLAGS)";' >> pathdef.c
! 	@echo 'char_u *all_lflags = (char_u *)"$(CC) $(CFLAGS) $(LFLAGS) -o $(TARGET) $(LIB) -lole32 -luuid $(MZSCHEME_LIBDIR) $(MZSCHEME_LIB) $(PYTHONLIB) $(PYTHON3LIB) $(RUBYLIB)";' >> pathdef.c
  	@echo 'char_u *compiled_user = (char_u *)"$(USERNAME)";' >> pathdef.c
  	@echo 'char_u *compiled_sys = (char_u *)"$(USERDOMAIN)";' >> pathdef.c
  else
***************
*** 640,646 ****
  	@echo char_u *default_vim_dir = (char_u *)"$(VIMRCLOC)"; >> pathdef.c
  	@echo char_u *default_vimruntime_dir = (char_u *)"$(VIMRUNTIMEDIR)"; >> pathdef.c
  	@echo char_u *all_cflags = (char_u *)"$(CC) $(CFLAGS)"; >> pathdef.c
! 	@echo char_u *all_lflags = (char_u *)"$(CC) $(CFLAGS) $(LFLAGS) -o $(TARGET) $(LIB) -lole32 -luuid $(MZSCHEME_LIBDIR) $(MZSCHEME_LIB) $(PYTHONLIB) $(RUBYLIB)"; >> pathdef.c
  	@echo char_u *compiled_user = (char_u *)"$(USERNAME)"; >> pathdef.c
  	@echo char_u *compiled_sys = (char_u *)"$(USERDOMAIN)"; >> pathdef.c
  endif
--- 678,685 ----
  	@echo char_u *default_vim_dir = (char_u *)"$(VIMRCLOC)"; >> pathdef.c
  	@echo char_u *default_vimruntime_dir = (char_u *)"$(VIMRUNTIMEDIR)"; >> pathdef.c
  	@echo char_u *all_cflags = (char_u *)"$(CC) $(CFLAGS)"; >> pathdef.c
! 	@echo char_u *all_lflags = (char_u *)"$(CC) $(CFLAGS) $(LFLAGS) -o $(TARGET) $(LIB) -lole32 -luuid $(MZSCHEME_LIBDIR) $(MZSCHEME_LIB) $(PYTHONLIB) $(PYTHON3LIB) $(RUBYLIB)"; >> pathdef.c
  	@echo char_u *compiled_user = (char_u *)"$(USERNAME)"; >> pathdef.c
  	@echo char_u *compiled_sys = (char_u *)"$(USERDOMAIN)"; >> pathdef.c
  endif
+ 
diff -caPr ..\vimorg/src/Make_mvc.mak ./src/Make_mvc.mak
*** ..\vimorg/src/Make_mvc.mak	2010-04-19 14:14:45.455306700 +0200
--- ./src/Make_mvc.mak	2010-04-19 17:39:53.501188200 +0200
***************
*** 47,52 ****
--- 47,57 ----
  #	  DYNAMIC_PYTHON=yes (to load the Python DLL dynamically)
  #	  PYTHON_VER=[Python version, eg 15, 20]  (default is 22)
  #
+ #	Python3 interface:
+ #	  PYTHON3=[Path to Python3 directory]
+ #	  DYNAMIC_PYTHON3=yes (to load the Python3 DLL dynamically)
+ #	  PYTHON3_VER=[Python3 version, eg 30, 31]  (default is 31)
+ #
  #	Ruby interface:
  #	  RUBY=[Path to Ruby directory]
  #	  DYNAMIC_RUBY=yes (to load the Ruby DLL dynamically)
***************
*** 158,163 ****
--- 163,171 ----
  !ifdef PYTHON
  OBJDIR = $(OBJDIR)Y
  !endif
+ !ifdef PYTHON3
+ OBJDIR = $(OBJDIR)H
+ !endif
  !ifdef TCL
  OBJDIR = $(OBJDIR)T
  !endif
***************
*** 600,605 ****
--- 608,620 ----
  !endif
  !endif
  
+ !ifdef PYTHON
+ !ifdef PYTHON3
+ DYNAMIC_PYTHON=yes
+ DYNAMIC_PYTHON3=yes
+ !endif
+ !endif
+ 
  # PYTHON interface
  !ifdef PYTHON
  !ifndef PYTHON_VER
***************
*** 621,626 ****
--- 636,662 ----
  !endif
  !endif
  
+ # PYTHON3 interface
+ !ifdef PYTHON3
+ !ifndef PYTHON3_VER
+ PYTHON3_VER = 31
+ !endif
+ !message Python3 requested (version $(PYTHON3_VER)) - root dir is "$(PYTHON3)"
+ !if "$(DYNAMIC_PYTHON3)" == "yes"
+ !message Python3 DLL will be loaded dynamically
+ !endif
+ CFLAGS = $(CFLAGS) -DFEAT_PYTHON3
+ PYTHON3_OBJ = $(OUTDIR)\if_python3.obj
+ PYTHON3_INC = /I "$(PYTHON3)\Include" /I "$(PYTHON3)\PC"
+ !if "$(DYNAMIC_PYTHON3)" == "yes"
+ CFLAGS = $(CFLAGS) -DDYNAMIC_PYTHON3 \
+ 		-DDYNAMIC_PYTHON3_DLL=\"python$(PYTHON3_VER).dll\"
+ PYTHON3_LIB = /nodefaultlib:python$(PYTHON3_VER).lib
+ !else
+ PYTHON3_LIB = $(PYTHON3)\libs\python$(PYTHON3_VER).lib
+ !endif
+ !endif
+ 
  # MzScheme interface
  !ifdef MZSCHEME
  !message MzScheme requested - root dir is "$(MZSCHEME)"
***************
*** 794,800 ****
  
  LINKARGS1 = $(linkdebug) $(conflags)
  LINKARGS2 = $(CON_LIB) $(GUI_LIB) $(LIBC) $(OLE_LIB)  user32.lib $(SNIFF_LIB) \
! 		$(MZSCHEME_LIB) $(PERL_LIB) $(PYTHON_LIB) $(RUBY_LIB) \
  		$(TCL_LIB) $(NETBEANS_LIB) $(XPM_LIB) $(LINK_PDB)
  
  # Report link time code generation progress if used. 
--- 830,836 ----
  
  LINKARGS1 = $(linkdebug) $(conflags)
  LINKARGS2 = $(CON_LIB) $(GUI_LIB) $(LIBC) $(OLE_LIB)  user32.lib $(SNIFF_LIB) \
! 		$(MZSCHEME_LIB) $(PERL_LIB) $(PYTHON_LIB) $(PYTHON3_LIB) $(RUBY_LIB) \
  		$(TCL_LIB) $(NETBEANS_LIB) $(XPM_LIB) $(LINK_PDB)
  
  # Report link time code generation progress if used. 
***************
*** 810,820 ****
  		GvimExt/gvimext.dll
  
  $(VIM).exe: $(OUTDIR) $(OBJ) $(GUI_OBJ) $(OLE_OBJ) $(OLE_IDL) $(MZSCHEME_OBJ) \
! 		$(PERL_OBJ) $(PYTHON_OBJ) $(RUBY_OBJ) $(TCL_OBJ) $(SNIFF_OBJ) \
  		$(CSCOPE_OBJ) $(NETBEANS_OBJ) $(XPM_OBJ) version.c version.h
  	$(CC) $(CFLAGS) version.c
  	$(link) $(LINKARGS1) -out:$(VIM).exe $(OBJ) $(GUI_OBJ) $(OLE_OBJ) \
! 		$(MZSCHEME_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(RUBY_OBJ) \
  		$(TCL_OBJ) $(SNIFF_OBJ) $(CSCOPE_OBJ) $(NETBEANS_OBJ) \
  		$(XPM_OBJ) $(OUTDIR)\version.obj $(LINKARGS2)
  
--- 846,856 ----
  		GvimExt/gvimext.dll
  
  $(VIM).exe: $(OUTDIR) $(OBJ) $(GUI_OBJ) $(OLE_OBJ) $(OLE_IDL) $(MZSCHEME_OBJ) \
! 		$(PERL_OBJ) $(PYTHON_OBJ) $(PYTHON3_OBJ) $(RUBY_OBJ) $(TCL_OBJ) $(SNIFF_OBJ) \
  		$(CSCOPE_OBJ) $(NETBEANS_OBJ) $(XPM_OBJ) version.c version.h
  	$(CC) $(CFLAGS) version.c
  	$(link) $(LINKARGS1) -out:$(VIM).exe $(OBJ) $(GUI_OBJ) $(OLE_OBJ) \
! 		$(MZSCHEME_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(PYTHON3_OBJ) $(RUBY_OBJ) \
  		$(TCL_OBJ) $(SNIFF_OBJ) $(CSCOPE_OBJ) $(NETBEANS_OBJ) \
  		$(XPM_OBJ) $(OUTDIR)\version.obj $(LINKARGS2)
  
***************
*** 969,974 ****
--- 1005,1013 ----
  $(OUTDIR)/if_python.obj: $(OUTDIR) if_python.c  $(INCL)
  	$(CC) $(CFLAGS) $(PYTHON_INC) if_python.c
  
+ $(OUTDIR)/if_python3.obj: $(OUTDIR) if_python3.c  $(INCL)
+ 	$(CC) $(CFLAGS) $(PYTHON3_INC) if_python3.c
+ 
  $(OUTDIR)/if_ole.obj: $(OUTDIR) if_ole.cpp  $(INCL) if_ole.h
  
  $(OUTDIR)/if_ruby.obj: $(OUTDIR) if_ruby.c  $(INCL)
diff -caPr ..\vimorg/src/Makefile ./src/Makefile
*** ..\vimorg/src/Makefile	2010-04-19 14:14:45.049249100 +0200
--- ./src/Makefile	2010-04-19 17:39:53.485568200 +0200
***************
*** 40,45 ****
--- 40,46 ----
  #	  each makes Vim quite a bit bigger:
  #		--enable-perlinterp	for Perl interpreter
  #		--enable-pythoninterp	for Python interpreter
+ #		--enable-python3interp	for Python3 interpreter
  #		--enable-rubyinterp	for Ruby interpreter
  #		--enable-tclinterp	for Tcl interpreter
  #		--enable-cscope		for Cscope interface
***************
*** 386,392 ****
  # NOTE: This may cause threading to be enabled, which has side effects (such
  # as using different libraries and debugging becomes more difficult).
  # NOTE: Using this together with Perl may cause a crash in initialization.
! #CONF_OPT_PYTHON = --enable-pythoninterp
  
  # TCL
  # Uncomment this when you want to include the Tcl interface.
--- 387,398 ----
  # NOTE: This may cause threading to be enabled, which has side effects (such
  # as using different libraries and debugging becomes more difficult).
  # NOTE: Using this together with Perl may cause a crash in initialization.
! # For Python3 support make a symbolic link in /usr/local/bin: 
! #	ln -s python3 python3.1
! # If both python2.x and python3.x are enabled then the linking will be via
! # dlopen(), dlsym(), dlclose(), i.e. pythonX.Y.so must be available
! # CONF_OPT_PYTHON = --enable-pythoninterp
! # CONF_OPT_PYTHON3 = --enable-python3interp
  
  # TCL
  # Uncomment this when you want to include the Tcl interface.
***************
*** 1304,1310 ****
  .SUFFIXES: .c .o .pro
  
  PRE_DEFS = -Iproto $(DEFS) $(GUI_DEFS) $(GUI_IPATH) $(CPPFLAGS) $(EXTRA_IPATHS)
! POST_DEFS = $(X_CFLAGS) $(MZSCHEME_CFLAGS) $(PERL_CFLAGS) $(PYTHON_CFLAGS) $(TCL_CFLAGS) $(RUBY_CFLAGS) $(EXTRA_DEFS)
  
  ALL_CFLAGS = $(PRE_DEFS) $(CFLAGS) $(PROFILE_CFLAGS) $(POST_DEFS)
  
--- 1310,1316 ----
  .SUFFIXES: .c .o .pro
  
  PRE_DEFS = -Iproto $(DEFS) $(GUI_DEFS) $(GUI_IPATH) $(CPPFLAGS) $(EXTRA_IPATHS)
! POST_DEFS = $(X_CFLAGS) $(MZSCHEME_CFLAGS) $(PERL_CFLAGS) $(TCL_CFLAGS) $(RUBY_CFLAGS) $(EXTRA_DEFS)
  
  ALL_CFLAGS = $(PRE_DEFS) $(CFLAGS) $(PROFILE_CFLAGS) $(POST_DEFS)
  
***************
*** 1324,1330 ****
  PFLAGS = $(PROTO_FLAGS) -DPROTO $(LINT_CFLAGS)
  
  ALL_LIB_DIRS = $(GUI_LIBS_DIR) $(X_LIBS_DIR)
! ALL_LIBS = $(GUI_LIBS1) $(GUI_X_LIBS) $(GUI_LIBS2) $(X_PRE_LIBS) $(X_LIBS) $(X_EXTRA_LIBS) $(LIBS) $(EXTRA_LIBS) $(MZSCHEME_LIBS) $(PERL_LIBS) $(PYTHON_LIBS) $(TCL_LIBS) $(RUBY_LIBS) $(PROFILE_LIBS)
  
  # abbreviations
  DEST_BIN = $(DESTDIR)$(BINDIR)
--- 1330,1350 ----
  PFLAGS = $(PROTO_FLAGS) -DPROTO $(LINT_CFLAGS)
  
  ALL_LIB_DIRS = $(GUI_LIBS_DIR) $(X_LIBS_DIR)
! ALL_LIBS = $(GUI_LIBS1) \
! 	$(GUI_X_LIBS) \
! 	$(GUI_LIBS2) \
! 	$(X_PRE_LIBS) \
! 	$(X_LIBS) \
! 	$(X_EXTRA_LIBS) \
! 	$(LIBS) \
! 	$(EXTRA_LIBS) \
! 	$(MZSCHEME_LIBS) \
! 	$(PERL_LIBS) \
! 	$(PYTHON_LIBS) \
! 	$(PYTHON3_LIBS) \
! 	$(TCL_LIBS) \
! 	$(RUBY_LIBS) \
! 	$(PROFILE_LIBS) 
  
  # abbreviations
  DEST_BIN = $(DESTDIR)$(BINDIR)
***************
*** 1426,1438 ****
  	$(OS_EXTRA_SRC)
  
  SRC =	$(BASIC_SRC) $(GUI_SRC) $(HANGULIN_SRC) $(MZSCHEME_SRC) \
! 	$(PERL_SRC) $(PYTHON_SRC) $(TCL_SRC) $(RUBY_SRC) \
  	$(SNIFF_SRC) $(WORKSHOP_SRC) $(WSDEBUG_SRC)
  
  TAGS_SRC = *.c *.cpp if_perl.xs
  
  EXTRA_SRC = hangulin.c if_mzsch.c auto/if_perl.c if_perlsfio.c \
! 	    if_python.c if_tcl.c if_ruby.c if_sniff.c gui_beval.c \
  	    workshop.c wsdebug.c integration.c netbeans.c
  
  # All sources, also the ones that are not configured
--- 1446,1458 ----
  	$(OS_EXTRA_SRC)
  
  SRC =	$(BASIC_SRC) $(GUI_SRC) $(HANGULIN_SRC) $(MZSCHEME_SRC) \
! 	$(PERL_SRC) $(PYTHON_SRC) $(PYTHON3_SRC) $(TCL_SRC) $(RUBY_SRC) \
  	$(SNIFF_SRC) $(WORKSHOP_SRC) $(WSDEBUG_SRC)
  
  TAGS_SRC = *.c *.cpp if_perl.xs
  
  EXTRA_SRC = hangulin.c if_mzsch.c auto/if_perl.c if_perlsfio.c \
!  	    $(PYTHON_SRC) $(PYTHON3_SRC) if_tcl.c if_ruby.c if_sniff.c gui_beval.c \
  	    workshop.c wsdebug.c integration.c netbeans.c
  
  # All sources, also the ones that are not configured
***************
*** 1441,1447 ****
  # Which files to check with lint.  Select one of these three lines.  ALL_SRC
  # checks more, but may not work well for checking a GUI that wasn't configured.
  # The perl sources also don't work well with lint.
! LINT_SRC = $(BASIC_SRC) $(GUI_SRC) $(HANGULIN_SRC) $(PYTHON_SRC) $(TCL_SRC) \
  	$(SNIFF_SRC) $(WORKSHOP_SRC) $(WSDEBUG_SRC) $(NETBEANS_SRC)
  #LINT_SRC = $(SRC)
  #LINT_SRC = $(ALL_SRC)
--- 1461,1467 ----
  # Which files to check with lint.  Select one of these three lines.  ALL_SRC
  # checks more, but may not work well for checking a GUI that wasn't configured.
  # The perl sources also don't work well with lint.
! LINT_SRC = $(BASIC_SRC) $(GUI_SRC) $(HANGULIN_SRC) $(PYTHON_SRC) $(PYTHON3_SRC) $(TCL_SRC) \
  	$(SNIFF_SRC) $(WORKSHOP_SRC) $(WSDEBUG_SRC) $(NETBEANS_SRC)
  #LINT_SRC = $(SRC)
  #LINT_SRC = $(ALL_SRC)
***************
*** 1499,1504 ****
--- 1519,1525 ----
  	$(MZSCHEME_OBJ) \
  	$(PERL_OBJ) \
  	$(PYTHON_OBJ) \
+ 	$(PYTHON3_OBJ) \
  	$(TCL_OBJ) \
  	$(RUBY_OBJ) \
  	$(OS_EXTRA_OBJ) \
***************
*** 1527,1532 ****
--- 1548,1554 ----
  	if_cscope.pro \
  	if_xcmdsrv.pro \
  	if_python.pro \
+ 	if_python3.pro \
  	if_ruby.pro \
  	main.pro \
  	mark.pro \
***************
*** 1587,1593 ****
  		CC="$(CC)" CPPFLAGS="$(CPPFLAGS)" CFLAGS="$(CFLAGS)" \
  		LDFLAGS="$(LDFLAGS)" $(CONF_SHELL) srcdir="$(srcdir)" \
  		./configure $(CONF_OPT_GUI) $(CONF_OPT_X) $(CONF_OPT_XSMP) \
! 		$(CONF_OPT_DARWIN) $(CONF_OPT_PERL) $(CONF_OPT_PYTHON) \
  		$(CONF_OPT_TCL) $(CONF_OPT_RUBY) $(CONF_OPT_NLS) \
  		$(CONF_OPT_CSCOPE) $(CONF_OPT_MULTIBYTE) $(CONF_OPT_INPUT) \
  		$(CONF_OPT_OUTPUT) $(CONF_OPT_GPM) $(CONF_OPT_WORKSHOP) \
--- 1609,1615 ----
  		CC="$(CC)" CPPFLAGS="$(CPPFLAGS)" CFLAGS="$(CFLAGS)" \
  		LDFLAGS="$(LDFLAGS)" $(CONF_SHELL) srcdir="$(srcdir)" \
  		./configure $(CONF_OPT_GUI) $(CONF_OPT_X) $(CONF_OPT_XSMP) \
! 		$(CONF_OPT_DARWIN) $(CONF_OPT_PERL) $(CONF_OPT_PYTHON) $(CONF_OPT_PYTHON3) \
  		$(CONF_OPT_TCL) $(CONF_OPT_RUBY) $(CONF_OPT_NLS) \
  		$(CONF_OPT_CSCOPE) $(CONF_OPT_MULTIBYTE) $(CONF_OPT_INPUT) \
  		$(CONF_OPT_OUTPUT) $(CONF_OPT_GPM) $(CONF_OPT_WORKSHOP) \
***************
*** 2448,2455 ****
  objects/if_perlsfio.o: if_perlsfio.c
  	$(CCC) -o $@ if_perlsfio.c
  
! objects/if_python.o: if_python.c
! 	$(CCC) -o $@ $(PYTHON_CFLAGS_EXTRA) if_python.c
  
  objects/if_ruby.o: if_ruby.c
  	$(CCC) -o $@ if_ruby.c
--- 2470,2493 ----
  objects/if_perlsfio.o: if_perlsfio.c
  	$(CCC) -o $@ if_perlsfio.c
  
! objects/py_config.o: $(PYTHON_CONFDIR)/config.c
! 	$(CCC) $(PYTHON_CFLAGS) -o $@ $(PYTHON_CONFDIR)/config.c \
! 		-I$(PYTHON_CONFDIR) -DHAVE_CONFIG_H -DNO_MAIN
! 
! objects/py_getpath.o: $(PYTHON_CONFDIR)/getpath.c
! 	$(CCC) $(PYTHON_CFLAGS) -o $@ $(PYTHON_CONFDIR)/getpath.c \
! 		-I$(PYTHON_CONFDIR) -DHAVE_CONFIG_H -DNO_MAIN \
! 		$(PYTHON_GETPATH_CFLAGS)
! 
! objects/py3_config.o: $(PYTHON3_CONFDIR)/config.c
! 	$(CCC) $(PYTHON3_CFLAGS) -o $@ $(PYTHON3_CONFDIR)/config.c \
! 		-I$(PYTHON3_CONFDIR) -DHAVE_CONFIG_H -DNO_MAIN
! 
! objects/if_python.o: if_python.c 
! 	$(CCC) $(PYTHON_CFLAGS) $(PYTHON_CFLAGS_EXTRA) -o $@ if_python.c
! 
! objects/if_python3.o: if_python3.c 
! 	$(CCC) $(PYTHON3_CFLAGS) $(PYTHON3_CFLAGS_EXTRA) -o $@ if_python3.c
  
  objects/if_ruby.o: if_ruby.c
  	$(CCC) -o $@ if_ruby.c
***************
*** 2520,2534 ****
  objects/pathdef.o: auto/pathdef.c
  	$(CCC) -o $@ auto/pathdef.c
  
- objects/py_config.o: $(PYTHON_CONFDIR)/config.c
- 	$(CCC) -o $@ $(PYTHON_CONFDIR)/config.c \
- 		-I$(PYTHON_CONFDIR) -DHAVE_CONFIG_H -DNO_MAIN
- 
- objects/py_getpath.o: $(PYTHON_CONFDIR)/getpath.c
- 	$(CCC) -o $@ $(PYTHON_CONFDIR)/getpath.c \
- 		-I$(PYTHON_CONFDIR) -DHAVE_CONFIG_H -DNO_MAIN \
- 		$(PYTHON_GETPATH_CFLAGS)
- 
  objects/pty.o: pty.c
  	$(CCC) -o $@ pty.c
  
--- 2558,2563 ----
***************
*** 2947,2952 ****
--- 2976,2985 ----
    auto/osdef.h ascii.h keymap.h term.h macros.h option.h structs.h \
    regexp.h gui.h gui_beval.h proto/gui_beval.pro ex_cmds.h proto.h \
    globals.h farsi.h arabic.h
+ objects/if_python3.o: if_python3.c vim.h auto/config.h feature.h os_unix.h \
+   auto/osdef.h ascii.h keymap.h term.h macros.h option.h structs.h \
+   regexp.h gui.h gui_beval.h proto/gui_beval.pro ex_cmds.h proto.h \
+   globals.h farsi.h arabic.h
  objects/if_tcl.o: if_tcl.c vim.h auto/config.h feature.h os_unix.h auto/osdef.h \
    ascii.h keymap.h term.h macros.h option.h structs.h regexp.h gui.h \
    gui_beval.h proto/gui_beval.pro ex_cmds.h proto.h globals.h farsi.h \
diff -caPr ..\vimorg/src/proto/if_python3.pro ./src/proto/if_python3.pro
*** ..\vimorg/src/proto/if_python3.pro	1970-01-01 01:00:00.000000000 +0100
--- ./src/proto/if_python3.pro	2010-04-19 17:39:53.501188200 +0200
***************
*** 0 ****
--- 1,8 ----
+ /* if_python.c */
+ int python3_enabled __ARGS((int verbose));
+ void python3_end __ARGS((void));
+ void ex_python3 __ARGS((exarg_T *eap));
+ void ex_py3file __ARGS((exarg_T *eap));
+ void python3_buffer_free __ARGS((buf_T *buf));
+ void python3_window_free __ARGS((win_T *win));
+ /* vim: set ft=c : */
diff -caPr ..\vimorg/src/proto.h ./src/proto.h
*** ..\vimorg/src/proto.h	2010-04-19 14:14:44.799367500 +0200
--- ./src/proto.h	2010-04-19 17:39:53.501188200 +0200
***************
*** 167,172 ****
--- 167,176 ----
  #  include "if_python.pro"
  # endif
  
+ # ifdef FEAT_PYTHON3
+ #  include "if_python3.pro"
+ # endif
+ 
  # ifdef FEAT_TCL
  #  include "if_tcl.pro"
  # endif
diff -caPr ..\vimorg/src/structs.h ./src/structs.h
*** ..\vimorg/src/structs.h	2010-04-19 14:14:44.518250700 +0200
--- ./src/structs.h	2010-04-19 17:39:53.516808200 +0200
***************
*** 1518,1523 ****
--- 1518,1527 ----
      void	*b_python_ref;	/* The Python reference to this buffer */
  #endif
  
+ #ifdef FEAT_PYTHON3
+     void	*b_python3_ref;	/* The Python3 reference to this buffer */
+ #endif
+ 
  #ifdef FEAT_TCL
      void	*b_tcl_ref;
  #endif
***************
*** 2055,2060 ****
--- 2059,2068 ----
      void	*w_python_ref;		/* The Python value for this window */
  #endif
  
+ #ifdef FEAT_PYTHON3
+     void	*w_python3_ref;		/* The Python value for this window */
+ #endif
+ 
  #ifdef FEAT_TCL
      void	*w_tcl_ref;
  #endif
diff -caPr ..\vimorg/src/version.c ./src/version.c
*** ..\vimorg/src/version.c	2010-04-19 14:14:45.299130700 +0200
--- ./src/version.c	2010-04-19 17:39:53.516808200 +0200
***************
*** 450,455 ****
--- 450,464 ----
  #else
  	"-python",
  #endif
+ #ifdef FEAT_PYTHON3
+ # ifdef DYNAMIC_PYTHON3
+ 	"+python3/dyn",
+ # else
+ 	"+python3",
+ # endif
+ #else
+ 	"-python3",
+ #endif
  #ifdef FEAT_QUICKFIX
  	"+quickfix",
  #else
diff -caPr ..\vimorg/src/vim.h ./src/vim.h
*** ..\vimorg/src/vim.h	2010-04-19 14:14:44.471397900 +0200
--- ./src/vim.h	2010-04-19 17:39:53.516808200 +0200
***************
*** 13,18 ****
--- 13,19 ----
  #if defined(__BORLANDC__) && defined(WIN32) && !defined(DEBUG)
  #if defined(FEAT_PERL) || \
      defined(FEAT_PYTHON) || \
+     defined(FEAT_PYTHON3) || \
      defined(FEAT_RUBY) || \
      defined(FEAT_TCL) || \
      defined(FEAT_MZSCHEME) || \
diff -caPr ..\vimorg/src/window.c ./src/window.c
*** ..\vimorg/src/window.c	2010-04-19 14:14:45.705188300 +0200
--- ./src/window.c	2010-04-19 17:39:53.532428200 +0200
***************
*** 4354,4359 ****
--- 4354,4363 ----
      python_window_free(wp);
  #endif
  
+ #ifdef FEAT_PYTHON3
+     python3_window_free(wp);
+ #endif
+ 
  #ifdef FEAT_TCL
      tcl_window_free(wp);
  #endif
