Remove obsolete __repr__() and repr_serialize() on AST elements, change spacing

diff --git a/ast.py b/ast.py
index cad09e6..7dd0fde 100644 (file)
--- a/ast.py
+++ b/ast.py
@@ -41,10 +41,6 @@ class Item(element.Element):
       Item if factory is None else factory
     )
     return result
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'ast.Item({0:s})'.format(', '.join(params))
   # GENERATE END
   def post_process(
     self,
@@ -81,10 +77,18 @@ class AST(element.Element):
       self.code_props = code_props
     def serialize(self, ref_list):
       element.Element.serialize(self, ref_list)
-      self.set('name', element.serialize_str(self.name))
+      self.set(
+        'name',
+        element.serialize_str(self.name)
+      )
       self.set(
         'code_props',
-        ' '.join([element.serialize_ref(i, ref_list) for i in self.code_props])
+        ' '.join(
+          [
+            element.serialize_ref(i, ref_list)
+            for i in self.code_props
+          ]
+        )
       )
     def deserialize(self, ref_list):
       element.Element.deserialize(self, ref_list)
@@ -101,22 +105,6 @@ class AST(element.Element):
       result.name = self.name
       result.code_props = self.code_props
       return result
-    def repr_serialize(self, params):
-      element.Element.repr_serialize(self, params)
-      if self.name != '':
-        params.append(
-          'name = {0:s}'.format(repr(self.name))
-        )
-      if len(self.code_props):
-        params.append(
-          'code_props = [{0:s}]'.format(
-            ', '.join([repr(i) for i in self.code_props])
-          )
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TagOrSymbol({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Tag(TagOrSymbol):
@@ -145,10 +133,6 @@ class AST(element.Element):
         Tag if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Tag({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Symbol(TagOrSymbol):
@@ -184,12 +168,26 @@ class AST(element.Element):
       self.character_set = character_set
     def serialize(self, ref_list):
       AST.TagOrSymbol.serialize(self, ref_list)
-      self.set('_type', element.serialize_int(self._type))
-      self.set('_tag', element.serialize_int(self._tag))
-      self.set('precedence', element.serialize_int(self.precedence))
+      self.set(
+        '_type',
+        element.serialize_int(self._type)
+      )
+      self.set(
+        '_tag',
+        element.serialize_int(self._tag)
+      )
+      self.set(
+        'precedence',
+        element.serialize_int(self.precedence)
+      )
       self.set(
         'character_set',
-        ' '.join([element.serialize_int(i) for i in self.character_set])
+        ' '.join(
+          [
+            element.serialize_int(i)
+            for i in self.character_set
+          ]
+        )
       )
     def deserialize(self, ref_list):
       AST.TagOrSymbol.deserialize(self, ref_list)
@@ -210,30 +208,6 @@ class AST(element.Element):
       result.precedence = self.precedence
       result.character_set = self.character_set
       return result
-    def repr_serialize(self, params):
-      AST.TagOrSymbol.repr_serialize(self, params)
-      if self._type != -1:
-        params.append(
-          '_type = {0:s}'.format(repr(self._type))
-        )
-      if self._tag != -1:
-        params.append(
-          '_tag = {0:s}'.format(repr(self._tag))
-        )
-      if self.precedence != -1:
-        params.append(
-          'precedence = {0:s}'.format(repr(self.precedence))
-        )
-      if len(self.character_set):
-        params.append(
-          'character_set = [{0:s}]'.format(
-            ', '.join([repr(i) for i in self.character_set])
-          )
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Symbol({0:s})'.format(', '.join(params))
     # GENERATE END
 
   # syntax classes
@@ -259,10 +233,6 @@ class AST(element.Element):
         BracedPredicate if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.BracedPredicate({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Char(element.Element):
@@ -287,10 +257,6 @@ class AST(element.Element):
         Char if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Char({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Int(element.Element):
@@ -315,10 +281,6 @@ class AST(element.Element):
         Int if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Int({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Production(element.Element):
@@ -344,10 +306,6 @@ class AST(element.Element):
           Item if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.Item({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -406,10 +364,6 @@ class AST(element.Element):
           Action if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.Action({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -494,7 +448,10 @@ class AST(element.Element):
         self.value = value
       def serialize(self, ref_list):
         AST.Production.Item.serialize(self, ref_list)
-        self.set('value', element.serialize_int(self.value))
+        self.set(
+          'value',
+          element.serialize_int(self.value)
+        )
       def deserialize(self, ref_list):
         AST.Production.Item.deserialize(self, ref_list)
         self.value = element.deserialize_int(self.get('value', '-1'))
@@ -505,16 +462,6 @@ class AST(element.Element):
         )
         result.value = self.value
         return result
-      def repr_serialize(self, params):
-        AST.Production.Item.repr_serialize(self, params)
-        if self.value != -1:
-          params.append(
-            'value = {0:s}'.format(repr(self.value))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.DPrec({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Empty(Item):
@@ -539,10 +486,6 @@ class AST(element.Element):
           Empty if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.Empty({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -583,10 +526,6 @@ class AST(element.Element):
           Merge if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.Merge({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Prec(Item):
@@ -609,7 +548,10 @@ class AST(element.Element):
         self.symbol = symbol
       def serialize(self, ref_list):
         AST.Production.Item.serialize(self, ref_list)
-        self.set('symbol', element.serialize_int(self.symbol))
+        self.set(
+          'symbol',
+          element.serialize_int(self.symbol)
+        )
       def deserialize(self, ref_list):
         AST.Production.Item.deserialize(self, ref_list)
         self.symbol = element.deserialize_int(self.get('symbol', '-1'))
@@ -620,16 +562,6 @@ class AST(element.Element):
         )
         result.symbol = self.symbol
         return result
-      def repr_serialize(self, params):
-        AST.Production.Item.repr_serialize(self, params)
-        if self.symbol != -1:
-          params.append(
-            'symbol = {0:s}'.format(repr(self.symbol))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.Prec({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -682,8 +614,14 @@ class AST(element.Element):
         self.has_space = has_space
       def serialize(self, ref_list):
         AST.Production.Item.serialize(self, ref_list)
-        self.set('symbol', element.serialize_int(self.symbol))
-        self.set('has_space', element.serialize_bool(self.has_space))
+        self.set(
+          'symbol',
+          element.serialize_int(self.symbol)
+        )
+        self.set(
+          'has_space',
+          element.serialize_bool(self.has_space)
+        )
       def deserialize(self, ref_list):
         AST.Production.Item.deserialize(self, ref_list)
         self.symbol = element.deserialize_int(self.get('symbol', '-1'))
@@ -696,20 +634,6 @@ class AST(element.Element):
         result.symbol = self.symbol
         result.has_space = self.has_space
         return result
-      def repr_serialize(self, params):
-        AST.Production.Item.repr_serialize(self, params)
-        if self.symbol != -1:
-          params.append(
-            'symbol = {0:s}'.format(repr(self.symbol))
-          )
-        if self.has_space != False:
-          params.append(
-            'has_space = {0:s}'.format(repr(self.has_space))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.SymbolRef({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -809,10 +733,6 @@ class AST(element.Element):
           GroupElement if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.GroupElement({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -917,10 +837,6 @@ class AST(element.Element):
           Space if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Production.Space({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -979,13 +895,34 @@ class AST(element.Element):
       self.take_space_right = take_space_right
     def serialize(self, ref_list):
       element.Element.serialize(self, ref_list)
-      self.set('lhs_nonterminal', element.serialize_int(self.lhs_nonterminal))
-      self.set('n_symbols', element.serialize_int(self.n_symbols))
-      self.set('last_terminal', element.serialize_int(self.last_terminal))
-      self.set('precedence_terminal', element.serialize_int(self.precedence_terminal))
-      self.set('has_empty', element.serialize_bool(self.has_empty))
-      self.set('has_space', element.serialize_bool(self.has_space))
-      self.set('take_space_right', element.serialize_bool(self.take_space_right))
+      self.set(
+        'lhs_nonterminal',
+        element.serialize_int(self.lhs_nonterminal)
+      )
+      self.set(
+        'n_symbols',
+        element.serialize_int(self.n_symbols)
+      )
+      self.set(
+        'last_terminal',
+        element.serialize_int(self.last_terminal)
+      )
+      self.set(
+        'precedence_terminal',
+        element.serialize_int(self.precedence_terminal)
+      )
+      self.set(
+        'has_empty',
+        element.serialize_bool(self.has_empty)
+      )
+      self.set(
+        'has_space',
+        element.serialize_bool(self.has_space)
+      )
+      self.set(
+        'take_space_right',
+        element.serialize_bool(self.take_space_right)
+      )
     def deserialize(self, ref_list):
       element.Element.deserialize(self, ref_list)
       self.lhs_nonterminal = element.deserialize_int(self.get('lhs_nonterminal', '-1'))
@@ -1008,40 +945,6 @@ class AST(element.Element):
       result.has_space = self.has_space
       result.take_space_right = self.take_space_right
       return result
-    def repr_serialize(self, params):
-      element.Element.repr_serialize(self, params)
-      if self.lhs_nonterminal != -1:
-        params.append(
-          'lhs_nonterminal = {0:s}'.format(repr(self.lhs_nonterminal))
-        )
-      if self.n_symbols != -1:
-        params.append(
-          'n_symbols = {0:s}'.format(repr(self.n_symbols))
-        )
-      if self.last_terminal != -1:
-        params.append(
-          'last_terminal = {0:s}'.format(repr(self.last_terminal))
-        )
-      if self.precedence_terminal != -1:
-        params.append(
-          'precedence_terminal = {0:s}'.format(repr(self.precedence_terminal))
-        )
-      if self.has_empty != False:
-        params.append(
-          'has_empty = {0:s}'.format(repr(self.has_empty))
-        )
-      if self.has_space != False:
-        params.append(
-          'has_space = {0:s}'.format(repr(self.has_space))
-        )
-      if self.take_space_right != False:
-        params.append(
-          'take_space_right = {0:s}'.format(repr(self.take_space_right))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Production({0:s})'.format(', '.join(params))
     # GENERATE END
 
     def post_process(
@@ -1185,10 +1088,6 @@ class AST(element.Element):
           Code if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.Code({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1233,7 +1132,10 @@ class AST(element.Element):
         self._type = _type
       def serialize(self, ref_list):
         Item.serialize(self, ref_list)
-        self.set('_type', element.serialize_int(self._type))
+        self.set(
+          '_type',
+          element.serialize_int(self._type)
+        )
       def deserialize(self, ref_list):
         Item.deserialize(self, ref_list)
         self._type = element.deserialize_int(self.get('_type', '-1'))
@@ -1244,16 +1146,6 @@ class AST(element.Element):
         )
         result._type = self._type
         return result
-      def repr_serialize(self, params):
-        Item.repr_serialize(self, params)
-        if self._type != -1:
-          params.append(
-            '_type = {0:s}'.format(repr(self._type))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.CodeProps({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1302,10 +1194,6 @@ class AST(element.Element):
           DefaultPrec if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.DefaultPrec({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class NTerm(Item):
@@ -1330,10 +1218,6 @@ class AST(element.Element):
           NTerm if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.NTerm({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1378,7 +1262,10 @@ class AST(element.Element):
         self._type = _type
       def serialize(self, ref_list):
         Item.serialize(self, ref_list)
-        self.set('_type', element.serialize_int(self._type))
+        self.set(
+          '_type',
+          element.serialize_int(self._type)
+        )
       def deserialize(self, ref_list):
         Item.deserialize(self, ref_list)
         self._type = element.deserialize_int(self.get('_type', '-1'))
@@ -1389,16 +1276,6 @@ class AST(element.Element):
         )
         result._type = self._type
         return result
-      def repr_serialize(self, params):
-        Item.repr_serialize(self, params)
-        if self._type != -1:
-          params.append(
-            '_type = {0:s}'.format(repr(self._type))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.Precedence({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1446,10 +1323,6 @@ class AST(element.Element):
           Start if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.Start({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1494,10 +1367,6 @@ class AST(element.Element):
           Token if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.Token({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1544,10 +1413,6 @@ class AST(element.Element):
           Type if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.Type({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1594,10 +1459,6 @@ class AST(element.Element):
           Union if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1Or2.Union({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1635,10 +1496,6 @@ class AST(element.Element):
         Section1Or2 if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Section1Or2({0:s})'.format(', '.join(params))
     # GENERATE END
     def post_process(
       self,
@@ -1681,10 +1538,6 @@ class AST(element.Element):
           Debug if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Debug({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1719,10 +1572,6 @@ class AST(element.Element):
           Define if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Define({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1803,10 +1652,6 @@ class AST(element.Element):
           Defines if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Defines({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1842,10 +1687,6 @@ class AST(element.Element):
           ErrorVerbose if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.ErrorVerbose({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1878,7 +1719,10 @@ class AST(element.Element):
         self.value = value
       def serialize(self, ref_list):
         Item.serialize(self, ref_list)
-        self.set('value', element.serialize_int(self.value))
+        self.set(
+          'value',
+          element.serialize_int(self.value)
+        )
       def deserialize(self, ref_list):
         Item.deserialize(self, ref_list)
         self.value = element.deserialize_int(self.get('value', '-1'))
@@ -1889,16 +1733,6 @@ class AST(element.Element):
         )
         result.value = self.value
         return result
-      def repr_serialize(self, params):
-        Item.repr_serialize(self, params)
-        if self.value != -1:
-          params.append(
-            'value = {0:s}'.format(repr(self.value))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Expect({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -1931,7 +1765,10 @@ class AST(element.Element):
         self.value = value
       def serialize(self, ref_list):
         Item.serialize(self, ref_list)
-        self.set('value', element.serialize_int(self.value))
+        self.set(
+          'value',
+          element.serialize_int(self.value)
+        )
       def deserialize(self, ref_list):
         Item.deserialize(self, ref_list)
         self.value = element.deserialize_int(self.get('value', '-1'))
@@ -1942,16 +1779,6 @@ class AST(element.Element):
         )
         result.value = self.value
         return result
-      def repr_serialize(self, params):
-        Item.repr_serialize(self, params)
-        if self.value != -1:
-          params.append(
-            'value = {0:s}'.format(repr(self.value))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.ExpectRR({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class FilePrefix(Item):
@@ -1976,10 +1803,6 @@ class AST(element.Element):
           FilePrefix if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.FilePrefix({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class GLRParser(Item):
@@ -2004,10 +1827,6 @@ class AST(element.Element):
           GLRParser if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.GLRParser({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class InitialAction(Item):
@@ -2032,10 +1851,6 @@ class AST(element.Element):
           InitialAction if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.InitialAction({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2071,10 +1886,6 @@ class AST(element.Element):
           Language if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Language({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Lines(Item):
@@ -2099,10 +1910,6 @@ class AST(element.Element):
           Lines if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Lines({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Locations(Item):
@@ -2127,10 +1934,6 @@ class AST(element.Element):
           Locations if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Locations({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2165,10 +1968,6 @@ class AST(element.Element):
           NamePrefix if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.NamePrefix({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2203,10 +2002,6 @@ class AST(element.Element):
           NonDeterministicParser if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.NonDeterministicParser({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Output(Item):
@@ -2231,10 +2026,6 @@ class AST(element.Element):
           Output if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Output({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Param(Item):
@@ -2259,10 +2050,6 @@ class AST(element.Element):
           Param if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Param({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Prologue(Item):
@@ -2287,10 +2074,6 @@ class AST(element.Element):
           Prologue if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Prologue({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2329,10 +2112,6 @@ class AST(element.Element):
           PureParser if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.PureParser({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2367,10 +2146,6 @@ class AST(element.Element):
           Require if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Require({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Skeleton(Item):
@@ -2395,10 +2170,6 @@ class AST(element.Element):
           Skeleton if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Skeleton({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class TokenTable(Item):
@@ -2423,10 +2194,6 @@ class AST(element.Element):
           TokenTable if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.TokenTable({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Verbose(Item):
@@ -2451,10 +2218,6 @@ class AST(element.Element):
           Verbose if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.Verbose({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2489,10 +2252,6 @@ class AST(element.Element):
           YACC if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.YACC({0:s})'.format(', '.join(params))
       # GENERATE END
 
     # GENERATE ELEMENT(str type_prefix, str name_prefix, int api_pure, bool locations, bool error_verbose, str parse_lac, bool debug, bool defines, int expect, bool verbose) BEGIN
@@ -2532,16 +2291,46 @@ class AST(element.Element):
       self.verbose = verbose
     def serialize(self, ref_list):
       AST.Section1Or2.serialize(self, ref_list)
-      self.set('type_prefix', element.serialize_str(self.type_prefix))
-      self.set('name_prefix', element.serialize_str(self.name_prefix))
-      self.set('api_pure', element.serialize_int(self.api_pure))
-      self.set('locations', element.serialize_bool(self.locations))
-      self.set('error_verbose', element.serialize_bool(self.error_verbose))
-      self.set('parse_lac', element.serialize_str(self.parse_lac))
-      self.set('debug', element.serialize_bool(self.debug))
-      self.set('defines', element.serialize_bool(self.defines))
-      self.set('expect', element.serialize_int(self.expect))
-      self.set('verbose', element.serialize_bool(self.verbose))
+      self.set(
+        'type_prefix',
+        element.serialize_str(self.type_prefix)
+      )
+      self.set(
+        'name_prefix',
+        element.serialize_str(self.name_prefix)
+      )
+      self.set(
+        'api_pure',
+        element.serialize_int(self.api_pure)
+      )
+      self.set(
+        'locations',
+        element.serialize_bool(self.locations)
+      )
+      self.set(
+        'error_verbose',
+        element.serialize_bool(self.error_verbose)
+      )
+      self.set(
+        'parse_lac',
+        element.serialize_str(self.parse_lac)
+      )
+      self.set(
+        'debug',
+        element.serialize_bool(self.debug)
+      )
+      self.set(
+        'defines',
+        element.serialize_bool(self.defines)
+      )
+      self.set(
+        'expect',
+        element.serialize_int(self.expect)
+      )
+      self.set(
+        'verbose',
+        element.serialize_bool(self.verbose)
+      )
     def deserialize(self, ref_list):
       AST.Section1Or2.deserialize(self, ref_list)
       self.type_prefix = element.deserialize_str(self.get('type_prefix', ''))
@@ -2570,52 +2359,6 @@ class AST(element.Element):
       result.expect = self.expect
       result.verbose = self.verbose
       return result
-    def repr_serialize(self, params):
-      AST.Section1Or2.repr_serialize(self, params)
-      if self.type_prefix != '':
-        params.append(
-          'type_prefix = {0:s}'.format(repr(self.type_prefix))
-        )
-      if self.name_prefix != '':
-        params.append(
-          'name_prefix = {0:s}'.format(repr(self.name_prefix))
-        )
-      if self.api_pure != -1:
-        params.append(
-          'api_pure = {0:s}'.format(repr(self.api_pure))
-        )
-      if self.locations != False:
-        params.append(
-          'locations = {0:s}'.format(repr(self.locations))
-        )
-      if self.error_verbose != False:
-        params.append(
-          'error_verbose = {0:s}'.format(repr(self.error_verbose))
-        )
-      if self.parse_lac != '':
-        params.append(
-          'parse_lac = {0:s}'.format(repr(self.parse_lac))
-        )
-      if self.debug != False:
-        params.append(
-          'debug = {0:s}'.format(repr(self.debug))
-        )
-      if self.defines != False:
-        params.append(
-          'defines = {0:s}'.format(repr(self.defines))
-        )
-      if self.expect != -1:
-        params.append(
-          'expect = {0:s}'.format(repr(self.expect))
-        )
-      if self.verbose != False:
-        params.append(
-          'verbose = {0:s}'.format(repr(self.verbose))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Section1({0:s})'.format(', '.join(params))
     # GENERATE END
     def post_process(
       self,
@@ -2687,10 +2430,6 @@ class AST(element.Element):
           Rules if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section2.Rules({0:s})'.format(', '.join(params))
       # GENERATE END
       def post_process(
         self,
@@ -2746,10 +2485,6 @@ class AST(element.Element):
         Section2 if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Section2({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class String(element.Element):
@@ -2774,10 +2509,6 @@ class AST(element.Element):
         String if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.String({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TagOrSymbolRef(element.Element):
@@ -2802,10 +2533,6 @@ class AST(element.Element):
         TagOrSymbolRef if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TagOrSymbolRef({0:s})'.format(', '.join(params))
     # GENERATE END
     def post_process(
       self,
@@ -2843,10 +2570,6 @@ class AST(element.Element):
         TagRef if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TagRef({0:s})'.format(', '.join(params))
     # GENERATE END
     def post_process(
       self,
@@ -2891,7 +2614,10 @@ class AST(element.Element):
       self.user_token = user_token
     def serialize(self, ref_list):
       AST.TagOrSymbolRef.serialize(self, ref_list)
-      self.set('user_token', element.serialize_int(self.user_token))
+      self.set(
+        'user_token',
+        element.serialize_int(self.user_token)
+      )
     def deserialize(self, ref_list):
       AST.TagOrSymbolRef.deserialize(self, ref_list)
       self.user_token = element.deserialize_int(self.get('user_token', '-1'))
@@ -2902,16 +2628,6 @@ class AST(element.Element):
       )
       result.user_token = self.user_token
       return result
-    def repr_serialize(self, params):
-      AST.TagOrSymbolRef.repr_serialize(self, params)
-      if self.user_token != -1:
-        params.append(
-          'user_token = {0:s}'.format(repr(self.user_token))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.SymbolRef({0:s})'.format(', '.join(params))
     # GENERATE END
     def post_process(
       self,
@@ -3023,10 +2739,6 @@ class AST(element.Element):
           Item if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.Item({0:s})'.format(', '.join(params))
       # GENERATE END
       def get_text(self, python = False):
         raise NotImplementedError
@@ -3051,7 +2763,10 @@ class AST(element.Element):
         self.character = character
       def serialize(self, ref_list):
         AST.Text.Item.serialize(self, ref_list)
-        self.set('character', element.serialize_int(self.character))
+        self.set(
+          'character',
+          element.serialize_int(self.character)
+        )
       def deserialize(self, ref_list):
         AST.Text.Item.deserialize(self, ref_list)
         self.character = element.deserialize_int(self.get('character', '-1'))
@@ -3062,16 +2777,6 @@ class AST(element.Element):
         )
         result.character = self.character
         return result
-      def repr_serialize(self, params):
-        AST.Text.Item.repr_serialize(self, params)
-        if self.character != -1:
-          params.append(
-            'character = {0:s}'.format(repr(self.character))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.Escape({0:s})'.format(', '.join(params))
       # GENERATE END
       def get_text(self, python = False):
         return chr(self.character)
@@ -3098,8 +2803,14 @@ class AST(element.Element):
         self.index = index
       def serialize(self, ref_list):
         AST.Text.Item.serialize(self, ref_list)
-        self.set('offset', element.serialize_int(self.offset))
-        self.set('index', element.serialize_int(self.index))
+        self.set(
+          'offset',
+          element.serialize_int(self.offset)
+        )
+        self.set(
+          'index',
+          element.serialize_int(self.index)
+        )
       def deserialize(self, ref_list):
         AST.Text.Item.deserialize(self, ref_list)
         self.offset = element.deserialize_int(self.get('offset', '-1'))
@@ -3112,20 +2823,6 @@ class AST(element.Element):
         result.offset = self.offset
         result.index = self.index
         return result
-      def repr_serialize(self, params):
-        AST.Text.Item.repr_serialize(self, params)
-        if self.offset != -1:
-          params.append(
-            'offset = {0:s}'.format(repr(self.offset))
-          )
-        if self.index != -1:
-          params.append(
-            'index = {0:s}'.format(repr(self.index))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.StackLocation({0:s})'.format(', '.join(params))
       # GENERATE END
       def get_text(self, python = False):
         return (
@@ -3158,9 +2855,18 @@ class AST(element.Element):
         self.index = index
       def serialize(self, ref_list):
         AST.Text.Item.serialize(self, ref_list)
-        self.set('tag_name', element.serialize_str(self.tag_name))
-        self.set('offset', element.serialize_int(self.offset))
-        self.set('index', element.serialize_int(self.index))
+        self.set(
+          'tag_name',
+          element.serialize_str(self.tag_name)
+        )
+        self.set(
+          'offset',
+          element.serialize_int(self.offset)
+        )
+        self.set(
+          'index',
+          element.serialize_int(self.index)
+        )
       def deserialize(self, ref_list):
         AST.Text.Item.deserialize(self, ref_list)
         self.tag_name = element.deserialize_str(self.get('tag_name', ''))
@@ -3175,24 +2881,6 @@ class AST(element.Element):
         result.offset = self.offset
         result.index = self.index
         return result
-      def repr_serialize(self, params):
-        AST.Text.Item.repr_serialize(self, params)
-        if self.tag_name != '':
-          params.append(
-            'tag_name = {0:s}'.format(repr(self.tag_name))
-          )
-        if self.offset != -1:
-          params.append(
-            'offset = {0:s}'.format(repr(self.offset))
-          )
-        if self.index != -1:
-          params.append(
-            'index = {0:s}'.format(repr(self.index))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.StackReference({0:s})'.format(', '.join(params))
       # GENERATE END
       def get_text(self, python = False):
         return (
@@ -3241,10 +2929,6 @@ class AST(element.Element):
           ValueLocation if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.ValueLocation({0:s})'.format(', '.join(params))
       # GENERATE END
       def get_text(self, python = False):
         return '(yyloc)'
@@ -3269,7 +2953,10 @@ class AST(element.Element):
         self.tag_name = tag_name
       def serialize(self, ref_list):
         AST.Text.Item.serialize(self, ref_list)
-        self.set('tag_name', element.serialize_str(self.tag_name))
+        self.set(
+          'tag_name',
+          element.serialize_str(self.tag_name)
+        )
       def deserialize(self, ref_list):
         AST.Text.Item.deserialize(self, ref_list)
         self.tag_name = element.deserialize_str(self.get('tag_name', ''))
@@ -3280,16 +2967,6 @@ class AST(element.Element):
         )
         result.tag_name = self.tag_name
         return result
-      def repr_serialize(self, params):
-        AST.Text.Item.repr_serialize(self, params)
-        if self.tag_name != '':
-          params.append(
-            'tag_name = {0:s}'.format(repr(self.tag_name))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.ValueReference({0:s})'.format(', '.join(params))
       # GENERATE END
       def get_text(self, python = False):
         return (
@@ -3319,10 +2996,6 @@ class AST(element.Element):
         Text if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Text({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_text(self, python = False):
       return ''.join(
@@ -3356,10 +3029,6 @@ class AST(element.Element):
         BracedCode if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.BracedCode({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ID(Text):
@@ -3384,10 +3053,6 @@ class AST(element.Element):
         ID if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ID({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Section3(Text):
@@ -3412,10 +3077,6 @@ class AST(element.Element):
         Section3 if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Section3({0:s})'.format(', '.join(params))
     # GENERATE END
     def post_process(
       self,
@@ -3474,47 +3135,109 @@ class AST(element.Element):
     element.Element.serialize(self, ref_list)
     self.set(
       'top_text',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.top_text])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.top_text
+        ]
+      )
     )
     self.set(
       'before_union_text',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.before_union_text])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.before_union_text
+        ]
+      )
     )
     self.set(
       'requires_text',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.requires_text])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.requires_text
+        ]
+      )
+    )
+    self.set(
+      'union_name',
+      element.serialize_str(self.union_name)
     )
-    self.set('union_name', element.serialize_str(self.union_name))
     self.set(
       'union_text',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.union_text])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.union_text
+        ]
+      )
     )
     self.set(
       'after_union_text',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.after_union_text])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.after_union_text
+        ]
+      )
     )
     self.set(
       'initial_action_text',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.initial_action_text])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.initial_action_text
+        ]
+      )
     )
     self.set(
       'tags',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.tags])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.tags
+        ]
+      )
     )
     self.set(
       'symbols',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.symbols])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.symbols
+        ]
+      )
+    )
+    self.set(
+      'n_productions',
+      element.serialize_int(self.n_productions)
     )
-    self.set('n_productions', element.serialize_int(self.n_productions))
     self.set(
       'productions',
-      ' '.join([element.serialize_ref(i, ref_list) for i in self.productions])
+      ' '.join(
+        [
+          element.serialize_ref(i, ref_list)
+          for i in self.productions
+        ]
+      )
+    )
+    self.set(
+      'first_nonterminal',
+      element.serialize_int(self.first_nonterminal)
+    )
+    self.set(
+      'start_nonterminal',
+      element.serialize_int(self.start_nonterminal)
     )
-    self.set('first_nonterminal', element.serialize_int(self.first_nonterminal))
-    self.set('start_nonterminal', element.serialize_int(self.start_nonterminal))
     self.set(
       'associativities',
-      ' '.join([element.serialize_int(i) for i in self.associativities])
+      ' '.join(
+        [
+          element.serialize_int(i)
+          for i in self.associativities
+        ]
+      )
     )
   def deserialize(self, ref_list):
     element.Element.deserialize(self, ref_list)
@@ -3582,88 +3305,6 @@ class AST(element.Element):
     result.start_nonterminal = self.start_nonterminal
     result.associativities = self.associativities
     return result
-  def repr_serialize(self, params):
-    element.Element.repr_serialize(self, params)
-    if len(self.top_text):
-      params.append(
-        'top_text = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.top_text])
-        )
-      )
-    if len(self.before_union_text):
-      params.append(
-        'before_union_text = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.before_union_text])
-        )
-      )
-    if len(self.requires_text):
-      params.append(
-        'requires_text = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.requires_text])
-        )
-      )
-    if self.union_name != '':
-      params.append(
-        'union_name = {0:s}'.format(repr(self.union_name))
-      )
-    if len(self.union_text):
-      params.append(
-        'union_text = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.union_text])
-        )
-      )
-    if len(self.after_union_text):
-      params.append(
-        'after_union_text = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.after_union_text])
-        )
-      )
-    if len(self.initial_action_text):
-      params.append(
-        'initial_action_text = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.initial_action_text])
-        )
-      )
-    if len(self.tags):
-      params.append(
-        'tags = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.tags])
-        )
-      )
-    if len(self.symbols):
-      params.append(
-        'symbols = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.symbols])
-        )
-      )
-    if self.n_productions != -1:
-      params.append(
-        'n_productions = {0:s}'.format(repr(self.n_productions))
-      )
-    if len(self.productions):
-      params.append(
-        'productions = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.productions])
-        )
-      )
-    if self.first_nonterminal != -1:
-      params.append(
-        'first_nonterminal = {0:s}'.format(repr(self.first_nonterminal))
-      )
-    if self.start_nonterminal != -1:
-      params.append(
-        'start_nonterminal = {0:s}'.format(repr(self.start_nonterminal))
-      )
-    if len(self.associativities):
-      params.append(
-        'associativities = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self.associativities])
-        )
-      )
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'ast.AST({0:s})'.format(', '.join(params))
   # GENERATE END
 
   def post_process(self):

diff --git a/element.py b/element.py
index 2d02217..367a9b7 100644 (file)
--- a/element.py
+++ b/element.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 Nick Downing <nick@ndcode.org>
+# Copyright (C) 2019 Nick Downing <nick@ndcode.org>
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # This program is free software; you can redistribute it and/or modify it under
@@ -40,17 +40,6 @@ class Element(xml.etree.ElementTree._Element_Py):
     result.tail = self.tail
     result[:] = [i.copy() for i in self]
     return result
-  def repr_serialize(self, params):
-    if len(self):
-      params.append(
-        'children = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self])
-        )
-      )
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'element.Element({0:s})'.format(', '.join(params))
 
 bool_to_str = ['false', 'true']
 def serialize_bool(value):

diff --git a/generate_ast.py b/generate_ast.py
index 0e3155f..f65d4f3 100755 (executable)
--- a/generate_ast.py
+++ b/generate_ast.py
@@ -163,7 +163,11 @@ while len(line):
         sys.stdout.write(
           '''{0:s}def serialize(self, ref_list):
 {1:s}  {2:s}.serialize(self, ref_list)
-'''.format(indent, indent, full_base_class)
+'''.format(
+            indent,
+            indent,
+            full_base_class
+          )
         )
         for type, name in fields:
           if type[:5] == 'list(' and type[-1:] == ')':
@@ -171,16 +175,26 @@ while len(line):
             sys.stdout.write(
               '''{0:s}  self.set(
 {1:s}    '{2:s}',
-{3:s}    ' '.join([element.serialize_{4:s}(i{5:s}) for i in self.{6:s}])
-{7:s}  )
+{3:s}    ' '.join(
+{4:s}      [
+{5:s}        element.serialize_{6:s}(i{7:s})
+{8:s}        for i in self.{9:s}
+{10:s}      ]
+{11:s}    )
+{12:s}  )
 '''.format(
                 indent,
                 indent,
                 name,
                 indent,
+                indent,
+                indent,
                 subtype,
                 ', ref_list' if subtype == 'ref' else '',
+                indent,
                 name,
+                indent,
+                indent,
                 indent
               )
             )
@@ -189,34 +203,54 @@ while len(line):
             sys.stdout.write(
               '''{0:s}  self.set(
 {1:s}    '{2:s}',
-{3:s}    ' '.join([element.serialize_{4:s}(i{5:s}) for i in sorted(self.{6:s})])
-{7:s}  )
+{3:s}    ' '.join(
+{4:s}      [
+{5:s}        element.serialize_{6:s}(i{7:s})
+{8:s}        for i in sorted(self.{9:s})
+{10:s}      ]
+{11:s}    )
+{12:s}  )
 '''.format(
                 indent,
                 indent,
                 name,
                 indent,
+                indent,
+                indent,
                 subtype,
                 ', ref_list' if subtype == 'ref' else '',
+                indent,
                 name,
+                indent,
+                indent,
                 indent
               )
             )
           else:
             sys.stdout.write(
-              '''{0:s}  self.set('{1:s}', element.serialize_{2:s}(self.{3:s}{4:s}))
+              '''{0:s}  self.set(
+{1:s}    '{2:s}',
+{3:s}    element.serialize_{4:s}(self.{5:s}{6:s})
+{7:s}  )
 '''.format(
+                indent,
                 indent,
                 name,
+                indent,
                 type,
                 name,
-                ', ref_list' if type == 'ref' else ''
+                ', ref_list' if type == 'ref' else '',
+                indent
               )
             )
         sys.stdout.write(
           '''{0:s}def deserialize(self, ref_list):
 {1:s}  {2:s}.deserialize(self, ref_list)
-'''.format(indent, indent, full_base_class)
+'''.format(
+            indent,
+            indent,
+            full_base_class
+          )
         )
         for type, name in fields:
           if type[:5] == 'list(' and type[-1:] == ')':
@@ -299,89 +333,9 @@ while len(line):
           indent
         )
       )
-      if len(fields):
-        sys.stdout.write(
-          '''{0:s}def repr_serialize(self, params):
-{1:s}  {2:s}.repr_serialize(self, params)
-'''.format(
-            indent,
-            indent,
-            full_base_class
-          )
-        )
-        for type, name in fields:
-          if type[:5] == 'list(' and type[-1:] == ')':
-            subtype = type[5:-1]
-            sys.stdout.write(
-              '''{0:s}  if len(self.{1:s}):
-{2:s}    params.append(
-{3:s}      '{4:s} = [{{0:s}}]'.format(
-{5:s}        ', '.join([repr(i) for i in self.{6:s}])
-{7:s}      )
-{8:s}    )
-'''.format(
-                indent,
-                name,
-                indent,
-                indent,
-                name,
-                indent,
-                name,
-                indent,
-                indent
-              )
-            )
-          elif type[:4] == 'set(' and type[-1:] == ')':
-            subtype = type[4:-1]
-            sys.stdout.write(
-              '''{0:s}  if len(self.{1:s}):
-{2:s}    params.append(
-{3:s}      '{4:s} = set([{{0:s}}])'.format(
-{5:s}        ', '.join([repr(i) for i in sorted(self.{6:s})])
-{7:s}      )
-{8:s}    )
-'''.format(
-                indent,
-                name,
-                indent,
-                indent,
-                name,
-                indent,
-                name,
-                indent,
-                indent
-              )
-            )
-          else:
-            sys.stdout.write(
-              '''{0:s}  if self.{1:s} != {2:s}:
-{3:s}    params.append(
-{4:s}      '{5:s} = {{0:s}}'.format(repr(self.{6:s}))
-{7:s}    )
-'''.format(
-                indent,
-                name,
-                default_value[type],
-                indent,
-                indent,
-                name,
-                name,
-                indent
-              )
-            )
       sys.stdout.write(
-        '''{0:s}def __repr__(self):
-{1:s}  params = []
-{2:s}  self.repr_serialize(params)
-{3:s}  return '{4:s}{5:s}({{0:s}})'.format(', '.join(params))
-{6:s}# GENERATE END
+        '''{0:s}# GENERATE END
 '''.format(
-          indent,
-          indent,
-          indent,
-          indent,
-          package_name,
-          '.'.join([i for _, i, _, _ in stack]),
           indent
         )
       )

diff --git a/tests_ast/ast.py b/tests_ast/ast.py
index 8d65d71..6293472 100644 (file)
--- a/tests_ast/ast.py
+++ b/tests_ast/ast.py
@@ -38,10 +38,6 @@ class Text(element.Element):
       Text if factory is None else factory
     )
     return result
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'ast.Text({0:s})'.format(', '.join(params))
   # GENERATE END
   def get_text(self):
     return element.get_text(self, 0)
@@ -69,10 +65,6 @@ class AST(element.Element):
         Expr if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Expr({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       raise NotImplementedException()
@@ -100,10 +92,6 @@ class AST(element.Element):
           Mantissa if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Num.Mantissa({0:s})'.format(', '.join(params))
       # GENERATE END
 
     class Fraction(Text):
@@ -128,10 +116,6 @@ class AST(element.Element):
           Fraction if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Num.Fraction({0:s})'.format(', '.join(params))
       # GENERATE END
 
     # GENERATE ELEMENT() BEGIN
@@ -155,10 +139,6 @@ class AST(element.Element):
         Num if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Num({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       mantissa = self[0].get_text()
@@ -187,10 +167,6 @@ class AST(element.Element):
         Add if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Add({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       return self[0].eval() + self[1].eval()
@@ -217,10 +193,6 @@ class AST(element.Element):
         Sub if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Sub({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       return self[0].eval() - self[1].eval()
@@ -247,10 +219,6 @@ class AST(element.Element):
         Mul if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Mul({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       return self[0].eval() * self[1].eval()
@@ -277,10 +245,6 @@ class AST(element.Element):
         Div if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Div({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       return self[0].eval() / self[1].eval()
@@ -307,10 +271,6 @@ class AST(element.Element):
         Neg if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Neg({0:s})'.format(', '.join(params))
     # GENERATE END
     def eval(self):
       return -self[0].eval()
@@ -336,10 +296,6 @@ class AST(element.Element):
       AST if factory is None else factory
     )
     return result
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'ast.AST({0:s})'.format(', '.join(params))
   # GENERATE END
 
 # GENERATE FACTORY(element.Element) BEGIN