diff --git a/runtime/autoload/pycomplete.vim b/runtime/autoload/pycomplete.vim
index 8cd5a5f..56a6b4e 100644
--- a/runtime/autoload/pycomplete.vim
+++ b/runtime/autoload/pycomplete.vim
@@ -1,10 +1,20 @@
 "pycomplete.vim - Omni Completion for python
 " Maintainer: Aaron Griffin
-" Version: 0.2
-" Last Updated: 5 January 2006
+" Version: 0.3
+" Last Updated: 23 January 2006
+"
+"   v0.3 Changes:
+"       added top level def parsing
+"       for safety, call returns are not evaluated
+"       handful of parsing changes
+"       trailing ( and . characters
+"       argument completion on open parens
+"       stop parsing at current line - ++performance, local var resolution
 "
 "   TODO
-"   * local variables *inside* class members
+"       RExec subclass
+"       Code cleanup + make class
+"       use internal dict, not globals()
 
 if !has('python')
     echo "Error: Required vim compiled with +python"
@@ -20,10 +30,10 @@
             let idx -= 1
             let c = line[idx-1]
             if c =~ '\w'
-				continue
-			elseif ! c =~ '\.'
+                continue
+            elseif ! c =~ '\.'
                 idx = -1
-				break
+                break
             else
                 break
             endif
@@ -39,79 +49,222 @@
 
 function! s:DefPython()
 python << PYTHONEOF
-import vim
-import sys
+import vim, sys, types
 import __builtin__
+import tokenize, keyword, cStringIO
 
 LOCALDEFS = \
 	['LOCALDEFS', 'clean_up','eval_source_code', \
 	 'get_completions', '__builtin__', '__builtins__', \
-	 'dbg', '__name__', 'vim', 'sys']
-#comment/uncomment one line at a time to enable/disable debugging
-def dbg(msg):
-    pass
-#    print(msg)
+	 'dbg', '__name__', 'vim', 'sys', 'parse_to_end', \
+     'parse_statement', 'tokenize', 'keyword', 'cStringIO', \
+     'debug_level', 'safe_eval', '_ctor', 'get_arguments', \
+     'strip_calls', 'types', 'parse_block']
 
-#it seems that by this point, vim has already stripped the base
-#  matched in the findstart=1 section, so we will create the
-#  statement from scratch
-def get_completions(base):
-    stmt = vim.eval('expand("<cWORD>")')+base
-    dbg("parsed statement => %s" % stmt)
-    eval_source_code()
+def dbg(level,msg):
+    debug_level = 1
     try:
-        dbg("eval: %s" % stmt)
-        if len(stmt.split('.')) == 1:
-            all = globals().keys() + dir(__builtin__)
-            match = stmt
-        else:
-            rindex= stmt.rfind('.')
-            all = dir(eval(stmt[:rindex]))
-            match = stmt[rindex+1:]
+        debug_level = vim.eval("g:pycomplete_debug_level")
+    except:
+        pass
+    if level <= debug_level: print(msg)
 
+def strip_calls(stmt):
+    parsed=''
+    level = 0
+    for c in stmt:
+        if c in ['[','(']:
+            level += 1
+        elif c in [')',']']:
+            level -= 1
+        elif level == 0:
+            parsed += c
+    ##dbg(10,"stripped: %s" % parsed)
+    return parsed
+
+def get_completions(base):
+    stmt = vim.eval('expand("<cWORD>")')
+    #dbg(1,"statement: %s - %s" % (stmt, base))
+    stmt = stmt+base
+    eval_source_code()
+
+    try:
+        ridx = stmt.rfind('.')
+        if stmt[-1] == '(':
+            match = ""
+            stmt = strip_calls(stmt[:len(stmt)-1])
+            all = get_arguments(eval(stmt))
+        elif ridx == -1:
+            match = stmt
+            all = globals() + __builtin__.__dict__
+        else:
+            match = stmt[ridx+1:]
+            stmt = strip_calls(stmt[:ridx])
+            all = eval(stmt).__dict__
+
+        #dbg(15,"completions for: %s, match=%s" % (stmt,match))
         completions = []
-        dbg("match == %s" % match)
-        for m in all:
-            #TODO: remove private (_foo) functions?
-            if m.find('__') != 0 and \
-               m.find(match) == 0 and \
-			   m not in LOCALDEFS:
-                dbg("matched... %s, %s" % (m, m.find(match)))
-                completions.append(m)
-        dbg("all completions: %s" % completions)
+        if type(all) == types.DictType:
+            for m in all:
+                if m.find('_') != 0 and m.find(match) == 0 and \
+			       m not in LOCALDEFS:
+                    #dbg(25,"matched... %s, %s" % (m, m.find(match)))
+                    typestr = str(all[m])
+                    if "function" in typestr: m += '('
+                    elif "method" in typestr: m += '('
+                    elif "module" in typestr: m += '.'
+                    elif "class" in typestr: m += '('
+                    completions.append(m)
+            completions.sort()
+        else:
+            completions.append(all)
+        #dbg(10,"all completions: %s" % completions)
         vim.command("let g:pycomplete_completions = %s" % completions)
     except:
-        dbg("exception: %s" % sys.exc_info()[1])
         vim.command("let g:pycomplete_completions = []")
+        #dbg(1,"exception: %s" % sys.exc_info()[1])
     clean_up()
 
-#yes, this is a quasi-functional python lexer
+def get_arguments(func_obj):
+    def _ctor(obj):
+        try:
+            return class_ob.__init__.im_func
+        except AttributeError:
+            for base in class_ob.__bases__:
+                rc = _find_constructor(base)
+                if rc is not None: return rc
+        return None
+
+    arg_offset = 1
+    if type(func_obj) == types.ClassType: func_obj = _ctor(func_obj)
+    elif type(func_obj) == types.MethodType: func_obj = func_obj.im_func
+    else: arg_offset = 0
+    
+    #dbg(20,"%s, offset=%s" % (str(func_obj), arg_offset))
+
+    arg_text = ''
+    if type(func_obj) in [types.FunctionType, types.LambdaType]:
+        try:
+            cd = func_obj.func_code
+            real_args = cd.co_varnames[arg_offset:cd.co_argcount]
+            defaults = func_obj.func_defaults or []
+            defaults = list(map(lambda name: "=%s" % name, defaults))
+            defaults = [""] * (len(real_args)-len(defaults)) + defaults
+            items = map(lambda a,d: a+d, real_args, defaults)
+            if func_obj.func_code.co_flags & 0x4:
+                items.append("...")
+            if func_obj.func_code.co_flags & 0x8:
+                items.append("***")
+            arg_text = ", ".join(items) + ')'
+
+        except:
+            #dbg(1,"exception: %s" % 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 = getattr(func_obj, '__doc__', '')
+        if doc:
+            doc = doc.lstrip()
+            pos = doc.find('\n')
+            if pos > 0:
+                sigline = doc[:pos]
+                lidx = sigline.find('(')
+                ridx = sigline.find(')')
+                retidx = sigline.find('->')
+                ret = sigline[retidx+2:].strip()
+                if lidx > 0 and ridx > 0:
+                    arg_text = sigline[lidx+1:ridx] + ')'
+                    if len(ret) > 0: arg_text += ' #returns %s' % ret
+    #dbg(15,"argument completion: %s" % arg_text)
+    return arg_text
+
+def parse_to_end(gen):
+    stmt=''
+    level = 0
+    for type, str, begin, end, line in gen:
+        if line == vim.eval('getline(\'.\')'): break
+        elif str == '\\': continue
+        elif str == ';':
+            break
+        elif type == tokenize.NEWLINE and level == 0:
+            break
+        elif str in ['[','(']:
+            level += 1
+        elif str in [')',']']:
+            level -= 1
+        elif level == 0:
+            stmt += str
+        #dbg(10,"current statement: %s" % stmt)
+    return stmt
+
+def parse_block(gen):
+    lines = []
+    level = 0
+    for type, str, begin, end, line in gen:
+        if line.replace('\n','') == vim.eval('getline(\'.\')'): break
+        elif type == tokenize.INDENT:
+            level += 1
+        elif type == tokenize.DEDENT:
+            level -= 1
+            if level == 0: break;
+        else:
+            stmt = parse_statement(gen,str)
+            if len(stmt) > 0: lines.append(stmt)
+    return lines
+
+def parse_statement(gen,curstr=''):
+    var = curstr
+    type, str, begin, end, line = gen.next()
+    if str == '=':
+        type, str, begin, end, line = gen.next()
+        if type == tokenize.NEWLINE:
+            return ''
+        elif type == tokenize.STRING or str == 'str':  
+            return '%s = str' % var
+        elif str == '[' or str == 'list':
+            return '%s= list' % var
+        elif str == '{' or str == 'dict':
+            return '%s = dict' % var
+        elif type == tokenize.NUMBER:
+            return '%s = 0' % var
+        elif str == 'Set': 
+            return '%s = Set' % var
+        elif str == 'open' or str == 'file':
+            return '%s = file' % var
+        else:
+            inst = str + parse_to_end(gen)
+            if len(inst) > 0:
+                #dbg(5,"found [%s = %s]" % (var, inst))
+                return '%s = %s' % (var, inst)
+    return ''
+
 def eval_source_code():
-    import tokenize
-    import keyword
-    import StringIO
-    s = StringIO.StringIO('\n'.join(vim.current.buffer[:]) + '\n')
+    LINE=vim.eval('getline(\'.\')')
+    s = cStringIO.StringIO('\n'.join(vim.current.buffer[:]) + '\n')
     g = tokenize.generate_tokens(s.readline)
 
     stmts = []
     lineNo = 0
     try:
         for type, str, begin, end, line in g:
-            if begin[0] == lineNo:
-                continue
+            if line.replace('\n','') == vim.eval('getline(\'.\')'): break
+            elif begin[0] == lineNo: continue
             #junk
             elif type == tokenize.INDENT or \
                  type == tokenize.DEDENT or \
                  type == tokenize.ERRORTOKEN or \
                  type == tokenize.ENDMARKER or \
-                 type == tokenize.NEWLINE:
+                 type == tokenize.NEWLINE or \
+                 type == tokenize.COMMENT:
                 continue
             #import statement
             elif str == 'import':
-                for type, str, begin, end, line in g:
-                    if str == ';' or type == tokenize.NEWLINE: break
-                    dbg("found [import %s]" % str)
-                    stmts.append("import %s" % str)
+                import_stmt=parse_to_end(g)
+                if len(import_stmt) > 0:
+                    #dbg(5,"found [import %s]" % import_stmt)
+                    stmts.append("import %s" % import_stmt)
             #import from statement
             elif str == 'from':
                 type, str, begin, end, line = g.next()
@@ -119,87 +272,68 @@
 
                 type, str, begin, end, line = g.next()
                 if str != "import": break
-                mem = ''
+                from_stmt=parse_to_end(g)
+                if len(from_stmt) > 0:
+                    #dbg(5,"found [from %s import %s]" % (mod, from_stmt))
+                    stmts.append("from %s import %s" % (mod, from_stmt))
+            #def statement
+            elif str == 'def':
+                funcstr = ''
                 for type, str, begin, end, line in g:
-                    if str == ';' or type == tokenize.NEWLINE: break
-                    mem += (str + ',')
-                if len(mem) > 0:
-                    dbg("found [from %s import %s]" % (mod, mem[:-1]))
-                    stmts.append("from %s import %s" % (mod, mem[:-1]))
+                    if line.replace('\n','') == vim.eval('getline(\'.\')'): break
+                    elif str == ':':
+                        stmts += parse_block(g)
+                        break
+                    funcstr += str
+                if len(funcstr) > 0:
+                    #dbg(5,"found [def %s]" % funcstr)
+                    stmts.append("def %s:\n   pass" % funcstr)
             #class declaration
             elif str == 'class':
                 type, str, begin, end, line = g.next()
                 classname = str
-                dbg("found [class %s]" % classname)
+                #dbg(5,"found [class %s]" % classname)
 
                 level = 0
                 members = []
-                #we don't care about the meat of the members,
-                # only the signatures, so we'll replace the bodies
-                # with 'pass' for evaluation
                 for type, str, begin, end, line in g:
-                    if type == tokenize.INDENT:
+                    if line.replace('\n','') == vim.eval('getline(\'.\')'): break
+                    elif type == tokenize.INDENT:
                         level += 1
                     elif type == tokenize.DEDENT:
                         level -= 1
                         if level == 0: break;
                     elif str == 'def':
-                        #TODO: if name begins with '_', keep private
                         memberstr = ''
                         for type, str, begin, end, line in g:
-                            if str == ':': break
+                            if line.replace('\n','') == vim.eval('getline(\'.\')'): break
+                            elif str == ':':
+                                stmts += parse_block(g)
+                                break
                             memberstr += str
-                        dbg("   member [%s]" % memberstr)
+                        #dbg(5,"   member [%s]" % memberstr)
                         members.append(memberstr)
-                    #TODO parse self.blah = something lines
-                    #elif str == "self" && next && str == "." ...blah...
                 classstr = 'class %s:' % classname
                 for m in members:
                     classstr += ("\n   def %s:\n      pass" % m)
                 stmts.append("%s\n" % classstr)
             elif keyword.iskeyword(str) or str in globals():
-                dbg("keyword = %s" % str)
+                #dbg(5,"keyword = %s" % str)
                 lineNo = begin[0]
             else:
-                if line.find("=") == -1: continue
-                var = str
-                type, str, begin, end, line = g.next()
-                dbg('next = %s' % str)
-                if str != '=': continue
-
-                type, str, begin, end, line = g.next()
-                if type == tokenize.NEWLINE:
-                    continue
-                elif type == tokenize.STRING or str == 'str':  
-                    stmts.append('%s = str' % var)
-                elif str == '[' or str == 'list':
-                    stmts.append('%s= list' % var)
-                elif str == '{' or str == 'dict':
-                    stmts.append('%s = dict' % var)
-                elif type == tokenize.NUMBER:
-                    continue
-                elif str == 'Set': 
-                    stmts.append('%s = Set' % var)
-                elif str == 'open' or str == 'file':
-                    stmts.append('%s = file' % var)
-                else:
-                    inst = str
-                    for type, str, begin, end, line in g:
-                        if type == tokenize.NEWLINE:
-                            break
-                        inst += str
-                    if len(inst) > 0:
-                        dbg("found [%s = %s]" % (var, inst))
-                        stmts.append('%s = %s' % (var, inst))
-                lineNo = begin[0]
+                assign = parse_statement(g,str)
+                if len(assign) > 0: stmts.append(assign)
+                
         for s in stmts:
             try:
-                dbg("evaluating: %s\n" % s)
+                #dbg(15,"evaluating: %s\n" % s)
                 exec(s) in globals()
             except:
+                #dbg(1,"exception: %s" % sys.exc_info()[1])
                 pass
     except:
-        dbg("exception: %s" % sys.exc_info()[1])
+        #dbg(1,"exception: %s" % sys.exc_info()[1])
+        pass
 
 def clean_up():
     for o in globals().keys():
@@ -212,5 +346,6 @@
 PYTHONEOF
 endfunction
 
+let g:pycomplete_debug_level = 0
 call s:DefPython()
 " vim: set et ts=4: