Merged revisions 55328-55341 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/branches/p3yk

........
  r55329 | brett.cannon | 2007-05-14 16:36:56 -0700 (Mon, 14 May 2007) | 3 lines

  Implement the removal of tuple parameter unpacking (PEP 3113).
  Thanks, Tony Lownds for the patch.
........
  r55331 | neal.norwitz | 2007-05-14 16:40:30 -0700 (Mon, 14 May 2007) | 1 line

  Update to use Python 3.0
........
  r55332 | brett.cannon | 2007-05-14 16:47:18 -0700 (Mon, 14 May 2007) | 2 lines

  Mention PEP 3113.  And thanks to Tony Lownds for the PEP 3113 patch.
........
  r55333 | neal.norwitz | 2007-05-14 16:57:06 -0700 (Mon, 14 May 2007) | 1 line

  Fix exception printing (no more exceptions module)
........
  r55334 | neal.norwitz | 2007-05-14 17:11:10 -0700 (Mon, 14 May 2007) | 1 line

  Remove popen* functions from os
........
  r55335 | neal.norwitz | 2007-05-14 18:03:38 -0700 (Mon, 14 May 2007) | 1 line

  Get rid of most of popen.  There are still some uses I need to cleanup.
........
  r55336 | neal.norwitz | 2007-05-14 21:11:34 -0700 (Mon, 14 May 2007) | 1 line

  Remove a few more remnants of the compiler package
........
  r55337 | neal.norwitz | 2007-05-14 22:28:27 -0700 (Mon, 14 May 2007) | 1 line

  Get test_[cx]pickle working on 64-bit platforms (avoid overflow int/long)
........

1 files changed, 46 insertions, 33 deletions

diff --git a/Parser/asdl.py b/Parser/asdl.py
index b1afd0fab1..a3701e6261 100644
--- a/Parser/asdl.py
+++ b/Parser/asdl.py
@@ -115,49 +115,54 @@ class ASDLParser(spark.GenericParser, object):
     def error(self, tok):
         raise ASDLSyntaxError(tok.lineno, tok)
 
-    def p_module_0(self, (module, name, version, _0, _1)):
+    def p_module_0(self, info):
         " module ::= Id Id version { } "
+        module, name, version, _0, _1 = info
         if module.value != "module":
             raise ASDLSyntaxError(module.lineno,
                                   msg="expected 'module', found %s" % module)
         return Module(name, None, version)
 
-    def p_module(self, (module, name, version, _0, definitions, _1)):
+    def p_module(self, info):
         " module ::= Id Id version { definitions } "
+        module, name, version, _0, definitions, _1 = info
         if module.value != "module":
             raise ASDLSyntaxError(module.lineno,
                                   msg="expected 'module', found %s" % module)
         return Module(name, definitions, version)
 
-    def p_version(self, (version, V)):
+    def p_version(self, info):
         "version ::= Id String"
+        version, V = info
         if version.value != "version":
             raise ASDLSyntaxError(version.lineno,
                                   msg="expected 'version', found %" % version)
         return V
 
-    def p_definition_0(self, (definition,)):
+    def p_definition_0(self, definition):
         " definitions ::= definition "
-        return definition
+        return definition[0]
 
-    def p_definition_1(self, (definitions, definition)):
+    def p_definition_1(self, definitions):
         " definitions ::= definition definitions "
-        return definitions + definition
+        return definitions[0] + definitions[1]
 
-    def p_definition(self, (id, _, type)):
+    def p_definition(self, info):
         " definition ::= Id = type "
+        id, _, type = info
         return [Type(id, type)]
 
-    def p_type_0(self, (product,)):
+    def p_type_0(self, product):
         " type ::= product "
-        return product
+        return product[0]
 
-    def p_type_1(self, (sum,)):
+    def p_type_1(self, sum):
         " type ::= sum "
-        return Sum(sum)
+        return Sum(sum[0])
 
-    def p_type_2(self, (sum, id, _0, attributes, _1)):
+    def p_type_2(self, info):
         " type ::= sum Id ( fields ) "
+        sum, id, _0, attributes, _1 = info
         if id.value != "attributes":
             raise ASDLSyntaxError(id.lineno,
                                   msg="expected attributes, found %s" % id)
@@ -165,65 +170,73 @@ class ASDLParser(spark.GenericParser, object):
             attributes.reverse()
         return Sum(sum, attributes)
 
-    def p_product(self, (_0, fields, _1)):
+    def p_product(self, info):
         " product ::= ( fields ) "
+        _0, fields, _1 = info
         # XXX can't I just construct things in the right order?
         fields.reverse()
         return Product(fields)
 
-    def p_sum_0(self, (constructor,)):
+    def p_sum_0(self, constructor):
         " sum ::= constructor """
-        return [constructor]
+        return [constructor[0]]
 
-    def p_sum_1(self, (constructor, _, sum)):
+    def p_sum_1(self, ):
         " sum ::= constructor | sum "
+        constructor, _, sum = info
         return [constructor] + sum
 
-    def p_sum_2(self, (constructor, _, sum)):
+    def p_sum_2(self, info):
         " sum ::= constructor | sum "
+        constructor, _, sum = info
         return [constructor] + sum
 
-    def p_constructor_0(self, (id,)):
+    def p_constructor_0(self, id):
         " constructor ::= Id "
-        return Constructor(id)
+        return Constructor(id[0])
 
-    def p_constructor_1(self, (id, _0, fields, _1)):
+    def p_constructor_1(self, info):
         " constructor ::= Id ( fields ) "
+        id, _0, fields, _1 = info
         # XXX can't I just construct things in the right order?
         fields.reverse()
         return Constructor(id, fields)
 
-    def p_fields_0(self, (field,)):
+    def p_fields_0(self, field):
         " fields ::= field "
-        return [field]
+        return [field[0]]
 
-    def p_fields_1(self, (field, _, fields)):
+    def p_fields_1(self, info):
         " fields ::= field , fields "
+        field, _, fields = info
         return fields + [field]
 
-    def p_field_0(self, (type,)):
+    def p_field_0(self, type_):
         " field ::= Id "
-        return Field(type)
+        return Field(type_[0])
 
-    def p_field_1(self, (type, name)):
+    def p_field_1(self, info):
         " field ::= Id Id "
+        type, name = info
         return Field(type, name)
 
-    def p_field_2(self, (type, _, name)):
+    def p_field_2(self, info):
         " field ::= Id * Id "
+        type, _, name = info
         return Field(type, name, seq=1)
 
-    def p_field_3(self, (type, _, name)):
+    def p_field_3(self, info):
         " field ::= Id ? Id "
+        type, _, name = info
         return Field(type, name, opt=1)
 
-    def p_field_4(self, (type, _)):
+    def p_field_4(self, type_):
         " field ::= Id * "
-        return Field(type, seq=1)
+        return Field(type_[0], seq=1)
 
-    def p_field_5(self, (type, _)):
+    def p_field_5(self, type_):
         " field ::= Id ? "
-        return Field(type, opt=1)
+        return Field(type[0], opt=1)
 
 builtin_types = ("identifier", "string", "int", "bool", "object")