vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

python3complete.vim (24396B)


      1 "python3complete.vim - Omni Completion for python
      2 " Maintainer: <vacancy>
      3 " Previous Maintainer: Aaron Griffin <aaronmgriffin@gmail.com>
      4 " Version: 0.10
      5 " Last Updated: 2026 Jun 21
      6 "
      7 " Roland Puntaier: this file contains adaptations for python3 and is parallel to pythoncomplete.vim
      8 "
      9 " Changes
     10 " TODO:
     11 " 'info' item output can use some formatting work
     12 " Add an "unsafe eval" mode, to allow for return type evaluation
     13 " Complete basic syntax along with import statements
     14 "   i.e. "import url<c-x,c-o>"
     15 " Continue parsing on invalid line??
     16 "
     17 " v 0.10 by Vim project
     18 "   * disables importing local modules, unless the global Vim variable
     19 "     g:pythoncomplete_allow_import is set to non-zero
     20 "   * strip default values and annotations from function parameter lists
     21 "     before exec(), and whitelist class base lists to dotted names: the
     22 "     previous code passed buffer-supplied expressions to exec() which
     23 "     Python evaluates at definition time, allowing arbitrary code
     24 "     execution via crafted def/class headers
     25 "   * use repr() on doc strings to prevent code execution
     26 "
     27 " v 0.9
     28 "   * Fixed docstring parsing for classes and functions
     29 "   * Fixed parsing of *args and **kwargs type arguments
     30 "   * Better function param parsing to handle things like tuples and
     31 "     lambda defaults args
     32 "
     33 " v 0.8
     34 "   * Fixed an issue where the FIRST assignment was always used instead of
     35 "   using a subsequent assignment for a variable
     36 "   * Fixed a scoping issue when working inside a parameterless function
     37 "
     38 "
     39 " v 0.7
     40 "   * Fixed function list sorting (_ and __ at the bottom)
     41 "   * Removed newline removal from docs.  It appears vim handles these better in
     42 "   recent patches
     43 "
     44 " v 0.6:
     45 "   * Fixed argument completion
     46 "   * Removed the 'kind' completions, as they are better indicated
     47 "   with real syntax
     48 "   * Added tuple assignment parsing (whoops, that was forgotten)
     49 "   * Fixed import handling when flattening scope
     50 "
     51 " v 0.5:
     52 " Yeah, I skipped a version number - 0.4 was never public.
     53 "  It was a bugfix version on top of 0.3.  This is a complete
     54 "  rewrite.
     55 "
     56 
     57 if !has('python3')
     58     echo "Error: Required vim compiled with +python3"
     59     finish
     60 endif
     61 
     62 function! python3complete#Complete(findstart, base)
     63     "findstart = 1 when we need to get the text length
     64     if a:findstart == 1
     65         let line = getline('.')
     66         let idx = col('.')
     67         while idx > 0
     68             let idx -= 1
     69             let c = line[idx]
     70             if c =~ '\w'
     71                 continue
     72             elseif ! c =~ '\.'
     73                 let idx = -1
     74                 break
     75             else
     76                 break
     77             endif
     78         endwhile
     79 
     80         return idx
     81     "findstart = 0 when we need to return the list of completions
     82     else
     83         "vim no longer moves the cursor upon completion... fix that
     84         let line = getline('.')
     85         let idx = col('.')
     86         let cword = ''
     87         while idx > 0
     88             let idx -= 1
     89             let c = line[idx]
     90             if c =~ '\w' || c =~ '\.'
     91                 let cword = c . cword
     92                 continue
     93             elseif strlen(cword) > 0 || idx == 0
     94                 break
     95             endif
     96         endwhile
     97 	execute "py3 vimpy3complete('" . escape(cword, "'") . "', '" . escape(a:base, "'") . "')"
     98         return g:python3complete_completions
     99     endif
    100 endfunction
    101 
    102 function! s:DefPython()
    103 py3 << PYTHONEOF
    104 import warnings
    105 warnings.simplefilter(action='ignore', category=FutureWarning)
    106 
    107 import sys, tokenize, io, types
    108 from token import NAME, DEDENT, NEWLINE, STRING
    109 import re
    110 
    111 # Used by Class.get_code(): a base class expression is only included in the
    112 # code passed to exec() if it is a pure dotted name (e.g. "Base", "mod.Base",
    113 # "pkg.sub.Cls").  Anything containing calls, subscripts, "=", ":" or other
    114 # operators is dropped, since exec()-ing it would evaluate buffer-supplied
    115 # expressions.  See the security note in the file header.
    116 _DOTTED_NAME_RE = re.compile(r'^[A-Za-z_]\w*(\s*\.\s*[A-Za-z_]\w*)*$')
    117 
    118 def _strip_param(p):
    119     # Return the bare parameter name from a parameter spec harvested by
    120     # _parenparse(), discarding any default value or annotation.  Default
    121     # values and annotations would otherwise be evaluated by exec() at
    122     # function-definition time.  Star prefixes ("*args", "**kw") and bare
    123     # "*" / "/" are preserved as written.
    124     p = p.split('=', 1)[0]
    125     p = p.split(':', 1)[0]
    126     return p.strip()
    127 
    128 debugstmts=[]
    129 def dbg(s): debugstmts.append(s)
    130 def showdbg():
    131     for d in debugstmts: print("DBG: %s " % d)
    132 
    133 def vimpy3complete(context,match):
    134     global debugstmts
    135     debugstmts = []
    136     try:
    137         import vim
    138         cmpl = Completer()
    139         cmpl.evalsource('\n'.join(vim.current.buffer),vim.eval("line('.')"))
    140         all = cmpl.get_completions(context,match)
    141         all.sort(key=lambda x:x['abbr'].replace('_','z'))
    142         dictstr = '['
    143         # have to do this for double quoting
    144         for cmpl in all:
    145             dictstr += '{'
    146             for x in cmpl: dictstr += '"%s":"%s",' % (x,cmpl[x])
    147             dictstr += '"icase":0},'
    148         if dictstr[-1] == ',': dictstr = dictstr[:-1]
    149         dictstr += ']'
    150         #dbg("dict: %s" % dictstr)
    151         vim.command("silent let g:python3complete_completions = %s" % dictstr)
    152         #dbg("Completion dict:\n%s" % all)
    153     except vim.error:
    154         dbg("VIM Error: %s" % vim.error)
    155 
    156 class Completer(object):
    157     def __init__(self):
    158        self.compldict = {}
    159        self.parser = PyParser()
    160 
    161     def evalsource(self,text,line=0):
    162         # vim is imported locally in vimpy3complete(); re-import here so the
    163         # vim.eval() below works (otherwise NameError, silently caught).
    164         import vim
    165         sc = self.parser.parse(text,line)
    166         try: allow_imports = int(
    167           vim.eval("get(g:, 'pythoncomplete_allow_import', 0)"))
    168         except Exception:
    169           allow_imports = 0
    170         src = sc.get_code()
    171         dbg("source: %s" % src)
    172         try: exec(src,self.compldict)
    173         except: dbg("parser: %s, %s" % (sys.exc_info()[0],sys.exc_info()[1]))
    174         for l in sc.locals:
    175             # Executing import/from statements harvested from the buffer runs
    176             # arbitrary package code; only do so when the user opted in.
    177             if not allow_imports and (l.startswith('import')
    178                                             or l.startswith('from ')):
    179                 continue
    180             try: exec(l,self.compldict)
    181             except: dbg("locals: %s, %s [%s]" % (sys.exc_info()[0],sys.exc_info()[1],l))
    182 
    183     def _cleanstr(self,doc):
    184         return doc.replace('"',' ').replace("'",' ')
    185 
    186     def get_arguments(self,func_obj):
    187         def _ctor(class_ob):
    188             try: return class_ob.__init__
    189             except AttributeError:
    190                 for base in class_ob.__bases__:
    191                     rc = _ctor(base)
    192                     if rc is not None: return rc
    193             return None
    194 
    195         arg_offset = 1
    196         if type(func_obj) == type: func_obj = _ctor(func_obj)
    197         elif type(func_obj) == types.MethodType: arg_offset = 1
    198         else: arg_offset = 0
    199 
    200         arg_text=''
    201         if type(func_obj) in [types.FunctionType, types.LambdaType,types.MethodType]:
    202             try:
    203                 cd = func_obj.__code__
    204                 real_args = cd.co_varnames[arg_offset:cd.co_argcount]
    205                 defaults = func_obj.__defaults__ or []
    206                 defaults = ["=%s" % name for name in defaults]
    207                 defaults = [""] * (len(real_args)-len(defaults)) + defaults
    208                 items = [a+d for a,d in zip(real_args,defaults)]
    209                 if func_obj.__code__.co_flags & 0x4:
    210                     items.append("...")
    211                 if func_obj.__code__.co_flags & 0x8:
    212                     items.append("***")
    213                 arg_text = (','.join(items)) + ')'
    214             except:
    215                 dbg("arg completion: %s: %s" % (sys.exc_info()[0],sys.exc_info()[1]))
    216                 pass
    217         if len(arg_text) == 0:
    218             # The doc string sometimes contains the function signature
    219             #  this works for a lot of C modules that are part of the
    220             #  standard library
    221             doc = func_obj.__doc__
    222             if doc:
    223                 doc = doc.lstrip()
    224                 pos = doc.find('\n')
    225                 if pos > 0:
    226                     sigline = doc[:pos]
    227                     lidx = sigline.find('(')
    228                     ridx = sigline.find(')')
    229                     if lidx > 0 and ridx > 0:
    230                         arg_text = sigline[lidx+1:ridx] + ')'
    231         if len(arg_text) == 0: arg_text = ')'
    232         return arg_text
    233 
    234     def get_completions(self,context,match):
    235         #dbg("get_completions('%s','%s')" % (context,match))
    236         stmt = ''
    237         if context: stmt += str(context)
    238         if match: stmt += str(match)
    239         try:
    240             result = None
    241             all = {}
    242             ridx = stmt.rfind('.')
    243             if len(stmt) > 0 and stmt[-1] == '(':
    244                 result = eval(_sanitize(stmt[:-1]), self.compldict)
    245                 doc = result.__doc__
    246                 if doc is None: doc = ''
    247                 args = self.get_arguments(result)
    248                 return [{'word':self._cleanstr(args),'info':self._cleanstr(doc)}]
    249             elif ridx == -1:
    250                 match = stmt
    251                 all = self.compldict
    252             else:
    253                 match = stmt[ridx+1:]
    254                 stmt = _sanitize(stmt[:ridx])
    255                 result = eval(stmt, self.compldict)
    256                 all = dir(result)
    257 
    258             dbg("completing: stmt:%s" % stmt)
    259             completions = []
    260 
    261             try: maindoc = result.__doc__
    262             except: maindoc = ' '
    263             if maindoc is None: maindoc = ' '
    264             for m in all:
    265                 if m == "_PyCmplNoType": continue #this is internal
    266                 try:
    267                     dbg('possible completion: %s' % m)
    268                     if m.find(match) == 0:
    269                         if result is None: inst = all[m]
    270                         else: inst = getattr(result,m)
    271                         try: doc = inst.__doc__
    272                         except: doc = maindoc
    273                         typestr = str(inst)
    274                         if doc is None or doc == '': doc = maindoc
    275 
    276                         wrd = m[len(match):]
    277                         c = {'word':wrd, 'abbr':m,  'info':self._cleanstr(doc)}
    278                         if "function" in typestr:
    279                             c['word'] += '('
    280                             c['abbr'] += '(' + self._cleanstr(self.get_arguments(inst))
    281                         elif "method" in typestr:
    282                             c['word'] += '('
    283                             c['abbr'] += '(' + self._cleanstr(self.get_arguments(inst))
    284                         elif "module" in typestr:
    285                             c['word'] += '.'
    286                         elif "type" in typestr:
    287                             c['word'] += '('
    288                             c['abbr'] += '('
    289                         completions.append(c)
    290                 except:
    291                     i = sys.exc_info()
    292                     dbg("inner completion: %s,%s [stmt='%s']" % (i[0],i[1],stmt))
    293             return completions
    294         except:
    295             i = sys.exc_info()
    296             dbg("completion: %s,%s [stmt='%s']" % (i[0],i[1],stmt))
    297             return []
    298 
    299 class Scope(object):
    300     def __init__(self,name,indent,docstr=''):
    301         self.subscopes = []
    302         self.docstr = docstr
    303         self.locals = []
    304         self.parent = None
    305         self.name = name
    306         self.indent = indent
    307 
    308     def add(self,sub):
    309         #print('push scope: [%s@%s]' % (sub.name,sub.indent))
    310         sub.parent = self
    311         self.subscopes.append(sub)
    312         return sub
    313 
    314     def doc(self,str):
    315         """ Clean up a docstring """
    316         d = str.replace('\n',' ')
    317         d = d.replace('\t',' ')
    318         while d.find('  ') > -1: d = d.replace('  ',' ')
    319         while d[0] in '"\'\t ': d = d[1:]
    320         while d[-1] in '"\'\t ': d = d[:-1]
    321         dbg("Scope(%s)::docstr = %s" % (self,d))
    322         self.docstr = d
    323 
    324     def local(self,loc):
    325         self._checkexisting(loc)
    326         self.locals.append(loc)
    327 
    328     def copy_decl(self,indent=0):
    329         """ Copy a scope's declaration only, at the specified indent level - not local variables """
    330         return Scope(self.name,indent,self.docstr)
    331 
    332     def _checkexisting(self,test):
    333         "Convienance function... keep out duplicates"
    334         if test.find('=') > -1:
    335             var = test.split('=')[0].strip()
    336             for l in self.locals:
    337                 if l.find('=') > -1 and var == l.split('=')[0].strip():
    338                     self.locals.remove(l)
    339 
    340     def get_code(self):
    341         str = ""
    342         if len(self.docstr) > 0: str += repr(self.docstr)+'\n'
    343         str += 'class _PyCmplNoType:\n    def __getattr__(self,name):\n        return None\n'
    344         for sub in self.subscopes:
    345             str += sub.get_code()
    346         for l in self.locals:
    347             if not l.startswith('import') and not l.startswith('from '): str += l+'\n'
    348 
    349         return str
    350 
    351     def pop(self,indent):
    352         #print('pop scope: [%s] to [%s]' % (self.indent,indent))
    353         outer = self
    354         while outer.parent != None and outer.indent >= indent:
    355             outer = outer.parent
    356         return outer
    357 
    358     def currentindent(self):
    359         #print('parse current indent: %s' % self.indent)
    360         return '    '*self.indent
    361 
    362     def childindent(self):
    363         #print('parse child indent: [%s]' % (self.indent+1))
    364         return '    '*(self.indent+1)
    365 
    366 class Class(Scope):
    367     def __init__(self, name, supers, indent, docstr=''):
    368         Scope.__init__(self,name,indent, docstr)
    369         self.supers = supers
    370     def copy_decl(self,indent=0):
    371         c = Class(self.name,self.supers,indent, self.docstr)
    372         for s in self.subscopes:
    373             c.add(s.copy_decl(indent+1))
    374         return c
    375     def get_code(self):
    376         str = '%sclass %s' % (self.currentindent(),self.name)
    377         # Only include base class expressions that are pure dotted names.
    378         # Anything else (calls, subscripts, conditionals, ...) is dropped
    379         # because exec() would evaluate it at class-definition time.  See
    380         # the security note in the file header.
    381         safe_supers = [s.strip() for s in self.supers
    382                        if _DOTTED_NAME_RE.match(s.strip())]
    383         if len(safe_supers) > 0: str += '(%s)' % ','.join(safe_supers)
    384         str += ':\n'
    385         if len(self.docstr) > 0: str += self.childindent()+repr(self.docstr)+'\n'
    386         if len(self.subscopes) > 0:
    387             for s in self.subscopes: str += s.get_code()
    388         else:
    389             str += '%spass\n' % self.childindent()
    390         return str
    391 
    392 
    393 class Function(Scope):
    394     def __init__(self, name, params, indent, docstr=''):
    395         Scope.__init__(self,name,indent, docstr)
    396         self.params = params
    397     def copy_decl(self,indent=0):
    398         return Function(self.name,self.params,indent, self.docstr)
    399     def get_code(self):
    400         # Strip default values and annotations from each parameter before
    401         # joining: exec() evaluates these at definition time and a hostile
    402         # buffer could otherwise execute arbitrary code via crafted def
    403         # headers.  See file header for details.
    404         safe_params = [_strip_param(p) for p in self.params]
    405         safe_params = [p for p in safe_params if p]
    406         str = "%sdef %s(%s):\n" % \
    407             (self.currentindent(),self.name,','.join(safe_params))
    408         if len(self.docstr) > 0: str += self.childindent()+repr(self.docstr)+'\n'
    409         str += "%spass\n" % self.childindent()
    410         return str
    411 
    412 class PyParser:
    413     def __init__(self):
    414         self.top = Scope('global',0)
    415         self.scope = self.top
    416         self.parserline = 0
    417 
    418     def _parsedotname(self,pre=None):
    419         #returns (dottedname, nexttoken)
    420         name = []
    421         if pre is None:
    422             tokentype, token, indent = self.donext()
    423             if tokentype != NAME and token != '*':
    424                 return ('', token)
    425         else: token = pre
    426         name.append(token)
    427         while True:
    428             tokentype, token, indent = self.donext()
    429             if token != '.': break
    430             tokentype, token, indent = self.donext()
    431             if tokentype != NAME: break
    432             name.append(token)
    433         return (".".join(name), token)
    434 
    435     def _parseimportlist(self):
    436         imports = []
    437         while True:
    438             name, token = self._parsedotname()
    439             if not name: break
    440             name2 = ''
    441             if token == 'as': name2, token = self._parsedotname()
    442             imports.append((name, name2))
    443             while token != "," and "\n" not in token:
    444                 tokentype, token, indent = self.donext()
    445             if token != ",": break
    446         return imports
    447 
    448     def _parenparse(self):
    449         name = ''
    450         names = []
    451         level = 1
    452         while True:
    453             tokentype, token, indent = self.donext()
    454             if token in (')', ',') and level == 1:
    455                 if '=' not in name: name = name.replace(' ', '')
    456                 names.append(name.strip())
    457                 name = ''
    458             if token == '(':
    459                 level += 1
    460                 name += "("
    461             elif token == ')':
    462                 level -= 1
    463                 if level == 0: break
    464                 else: name += ")"
    465             elif token == ',' and level == 1:
    466                 pass
    467             else:
    468                 name += "%s " % str(token)
    469         return names
    470 
    471     def _parsefunction(self,indent):
    472         self.scope=self.scope.pop(indent)
    473         tokentype, fname, ind = self.donext()
    474         if tokentype != NAME: return None
    475 
    476         tokentype, open, ind = self.donext()
    477         if open != '(': return None
    478         params=self._parenparse()
    479 
    480         tokentype, colon, ind = self.donext()
    481         if colon != ':': return None
    482 
    483         return Function(fname,params,indent)
    484 
    485     def _parseclass(self,indent):
    486         self.scope=self.scope.pop(indent)
    487         tokentype, cname, ind = self.donext()
    488         if tokentype != NAME: return None
    489 
    490         super = []
    491         tokentype, thenext, ind = self.donext()
    492         if thenext == '(':
    493             super=self._parenparse()
    494         elif thenext != ':': return None
    495 
    496         return Class(cname,super,indent)
    497 
    498     def _parseassignment(self):
    499         assign=''
    500         tokentype, token, indent = self.donext()
    501         if tokentype == tokenize.STRING or token == 'str':
    502             return '""'
    503         elif token == '(' or token == 'tuple':
    504             return '()'
    505         elif token == '[' or token == 'list':
    506             return '[]'
    507         elif token == '{' or token == 'dict':
    508             return '{}'
    509         elif tokentype == tokenize.NUMBER:
    510             return '0'
    511         elif token == 'open' or token == 'file':
    512             return 'file'
    513         elif token == 'None':
    514             return '_PyCmplNoType()'
    515         elif token == 'type':
    516             return 'type(_PyCmplNoType)' #only for method resolution
    517         else:
    518             assign += token
    519             level = 0
    520             while True:
    521                 tokentype, token, indent = self.donext()
    522                 if token in ('(','{','['):
    523                     level += 1
    524                 elif token in (']','}',')'):
    525                     level -= 1
    526                     if level == 0: break
    527                 elif level == 0:
    528                     if token in (';','\n'): break
    529                     assign += token
    530         return "%s" % assign
    531 
    532     def donext(self):
    533         type, token, (lineno, indent), end, self.parserline = next(self.gen)
    534         if lineno == self.curline:
    535             #print('line found [%s] scope=%s' % (line.replace('\n',''),self.scope.name))
    536             self.currentscope = self.scope
    537         return (type, token, indent)
    538 
    539     def _adjustvisibility(self):
    540         newscope = Scope('result',0)
    541         scp = self.currentscope
    542         while scp != None:
    543             if type(scp) == Function:
    544                 slice = 0
    545                 #Handle 'self' params
    546                 if scp.parent != None and type(scp.parent) == Class:
    547                     slice = 1
    548                     newscope.local('%s = %s' % (scp.params[0],scp.parent.name))
    549                 for p in scp.params[slice:]:
    550                     i = p.find('=')
    551                     if len(p) == 0: continue
    552                     pvar = ''
    553                     ptype = ''
    554                     if i == -1:
    555                         pvar = p
    556                         ptype = '_PyCmplNoType()'
    557                     else:
    558                         pvar = p[:i]
    559                         ptype = _sanitize(p[i+1:])
    560                     if pvar.startswith('**'):
    561                         pvar = pvar[2:]
    562                         ptype = '{}'
    563                     elif pvar.startswith('*'):
    564                         pvar = pvar[1:]
    565                         ptype = '[]'
    566 
    567                     newscope.local('%s = %s' % (pvar,ptype))
    568 
    569             for s in scp.subscopes:
    570                 ns = s.copy_decl(0)
    571                 newscope.add(ns)
    572             for l in scp.locals: newscope.local(l)
    573             scp = scp.parent
    574 
    575         self.currentscope = newscope
    576         return self.currentscope
    577 
    578     #p.parse(vim.current.buffer[:],vim.eval("line('.')"))
    579     def parse(self,text,curline=0):
    580         self.curline = int(curline)
    581         buf = io.StringIO(''.join(text) + '\n')
    582         self.gen = tokenize.generate_tokens(buf.readline)
    583         self.currentscope = self.scope
    584 
    585         try:
    586             freshscope=True
    587             while True:
    588                 tokentype, token, indent = self.donext()
    589                 #dbg( 'main: token=[%s] indent=[%s]' % (token,indent))
    590 
    591                 if tokentype == DEDENT or token == "pass":
    592                     self.scope = self.scope.pop(indent)
    593                 elif token == 'def':
    594                     func = self._parsefunction(indent)
    595                     if func is None:
    596                         print("function: syntax error...")
    597                         continue
    598                     dbg("new scope: function")
    599                     freshscope = True
    600                     self.scope = self.scope.add(func)
    601                 elif token == 'class':
    602                     cls = self._parseclass(indent)
    603                     if cls is None:
    604                         print("class: syntax error...")
    605                         continue
    606                     freshscope = True
    607                     dbg("new scope: class")
    608                     self.scope = self.scope.add(cls)
    609 
    610                 elif token == 'import':
    611                     imports = self._parseimportlist()
    612                     for mod, alias in imports:
    613                         loc = "import %s" % mod
    614                         if len(alias) > 0: loc += " as %s" % alias
    615                         self.scope.local(loc)
    616                     freshscope = False
    617                 elif token == 'from':
    618                     mod, token = self._parsedotname()
    619                     if not mod or token != "import":
    620                         print("from: syntax error...")
    621                         continue
    622                     names = self._parseimportlist()
    623                     for name, alias in names:
    624                         loc = "from %s import %s" % (mod,name)
    625                         if len(alias) > 0: loc += " as %s" % alias
    626                         self.scope.local(loc)
    627                     freshscope = False
    628                 elif tokentype == STRING:
    629                     if freshscope: self.scope.doc(token)
    630                 elif tokentype == NAME:
    631                     name,token = self._parsedotname(token)
    632                     if token == '=':
    633                         stmt = self._parseassignment()
    634                         dbg("parseassignment: %s = %s" % (name, stmt))
    635                         if stmt != None:
    636                             self.scope.local("%s = %s" % (name,stmt))
    637                     freshscope = False
    638         except StopIteration: #thrown on EOF
    639             pass
    640         except:
    641             dbg("parse error: %s, %s @ %s" %
    642                 (sys.exc_info()[0], sys.exc_info()[1], self.parserline))
    643         return self._adjustvisibility()
    644 
    645 def _sanitize(str):
    646     val = ''
    647     level = 0
    648     for c in str:
    649         if c in ('(','{','['):
    650             level += 1
    651         elif c in (']','}',')'):
    652             level -= 1
    653         elif level == 0:
    654             val += c
    655     return val
    656 
    657 sys.path.extend(['.','..'])
    658 PYTHONEOF
    659 endfunction
    660 
    661 call s:DefPython()