Python3 postional arguments. Clean up code more along the lines of uncompyle3.

uncompyle6/parser.py

@@ -8,18 +8,10 @@ Common spark parser routines Python.
 
 from __future__ import print_function
 
-from uncompyle6 import PYTHON3
-
 import sys
 
 from uncompyle6.parsers.spark import GenericASTBuilder
 
-if PYTHON3:
-    intern = sys.intern
-    from collections import UserList
-else:
-    from UserList import UserList
-
 class ParserError(Exception):
     def __init__(self, token, offset):
         self.token = token
@@ -29,27 +21,7 @@ class ParserError(Exception):
         return "Syntax error at or near `%r' token at offset %s\n" % \
                (self.token, self.offset)
 
-class AST(UserList):
-    def __init__(self, type, kids=[]):
-        self.type = intern(type)
-        UserList.__init__(self, kids)
-
-    def __getslice__(self, low, high):    return self.data[low:high]
-
-    def __eq__(self, o):
-        if isinstance(o, AST):
-            return self.type == o.type \
-                   and UserList.__eq__(self, o)
-        else:
-            return self.type == o
-
-    def __hash__(self):            return hash(self.type)
-
-    def __repr__(self, indent=''):
-        rv = str(self.type)
-        for k in self:
-            rv = rv + '\n' + str(k).replace('\n', '\n   ')
-        return rv
+nop_func = lambda self, args: None
 
 class PythonParser(GenericASTBuilder):
 
@@ -97,71 +69,9 @@ class PythonParser(GenericASTBuilder):
         return GenericASTBuilder.resolve(self, list)
 
 def parse(p, tokens, customize):
-    '''
-    Special handling for opcodes that take a variable number
-    of arguments -- we add a new rule for each:
-
-        expr ::= {expr}^n BUILD_LIST_n
-        expr ::= {expr}^n BUILD_TUPLE_n
-        unpack_list ::= UNPACK_LIST {expr}^n
-        unpack ::= UNPACK_TUPLE {expr}^n
-        unpack ::= UNPACK_SEQEUENE {expr}^n
-        mkfunc ::= {expr}^n LOAD_CONST MAKE_FUNCTION_n
-        mkfunc ::= {expr}^n load_closure LOAD_CONST MAKE_FUNCTION_n
-        expr ::= expr {expr}^n CALL_FUNCTION_n
-        expr ::= expr {expr}^n CALL_FUNCTION_VAR_n POP_TOP
-        expr ::= expr {expr}^n CALL_FUNCTION_VAR_KW_n POP_TOP
-        expr ::= expr {expr}^n CALL_FUNCTION_KW_n POP_TOP
-    '''
-    nop = lambda self, args: None
-
-    for k, v in list(customize.items()):
-        # avoid adding the same rule twice to this parser
-        if k in p.customized:
-            continue
-        p.customized[k] = None
-
-        # nop = lambda self, args: None
-
-        op = k[:k.rfind('_')]
-        if op in ('BUILD_LIST', 'BUILD_TUPLE', 'BUILD_SET'):
-            rule = 'build_list ::= ' + 'expr '*v + k
-        elif op in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE'):
-            rule = 'unpack ::= ' + k + ' designator'*v
-        elif op == 'UNPACK_LIST':
-            rule = 'unpack_list ::= ' + k + ' designator'*v
-        elif op in ('DUP_TOPX', 'RAISE_VARARGS'):
-            # no need to add a rule
-            continue
-            # rule = 'dup_topx ::= ' + 'expr '*v + k
-        elif op == 'MAKE_FUNCTION':
-            p.addRule('mklambda ::= %s LOAD_LAMBDA %s' %
-                  ('expr '*v, k), nop)
-            rule = 'mkfunc ::= %s LOAD_CONST %s' % ('expr '*v, k)
-        elif op == 'MAKE_CLOSURE':
-            p.addRule('mklambda ::= %s load_closure LOAD_LAMBDA %s' %
-                  ('expr '*v, k), nop)
-            p.addRule('genexpr ::= %s load_closure LOAD_GENEXPR %s expr GET_ITER CALL_FUNCTION_1' %
-                  ('expr '*v, k), nop)
-            p.addRule('setcomp ::= %s load_closure LOAD_SETCOMP %s expr GET_ITER CALL_FUNCTION_1' %
-                  ('expr '*v, k), nop)
-            p.addRule('dictcomp ::= %s load_closure LOAD_DICTCOMP %s expr GET_ITER CALL_FUNCTION_1' %
-                  ('expr '*v, k), nop)
-            rule = 'mkfunc ::= %s load_closure LOAD_CONST %s' % ('expr '*v, k)
-#            rule = 'mkfunc ::= %s closure_list LOAD_CONST %s' % ('expr '*v, k)
-        elif op in ('CALL_FUNCTION', 'CALL_FUNCTION_VAR',
-                'CALL_FUNCTION_VAR_KW', 'CALL_FUNCTION_KW'):
-            na = (v & 0xff)           # positional parameters
-            nk = (v >> 8) & 0xff      # keyword parameters
-            # number of apply equiv arguments:
-            nak = ( len(op)-len('CALL_FUNCTION') ) // 3
-            rule = 'call_function ::= expr ' + 'expr '*na + 'kwarg '*nk \
-                   + 'expr ' * nak + k
-        else:
-            raise Exception('unknown customize token %s' % k)
-        p.addRule(rule, nop)
+    p.add_custom_rules(tokens, customize)
     ast = p.parse(tokens)
-#   p.cleanup()
+    #  p.cleanup()
     return ast