giscanner/gidlwriter.py

   1 from __future__ import with_statement
   2
   3 from .gobjecttreebuilder import (GLibBoxed, GLibEnum, GLibEnumMember,
   4                                  GLibFlags, GLibObject, GLibInterface)
   5 from .treebuilder import Class, Enum, Function, Interface
   6 from .xmlwriter import XMLWriter
   7
   8
   9 class GIDLWriter(XMLWriter):
  10     def __init__(self, namespace, nodes):
  11         super(GIDLWriter, self).__init__()
  12         self._write_api(namespace, nodes)
  13
  14     def _write_api(self, namespace, nodes):
  15         with self.tagcontext('api', [('version', '1.0')]):
  16             self._write_namespace(namespace, nodes)
  17
  18     def _write_namespace(self, namespace, nodes):
  19         with self.tagcontext('namespace', [('name', namespace)]):
  20             for node in nodes:
  21                 self._write_node(node)
  22
  23     def _write_node(self, node):
  24         if isinstance(node, Function):
  25             self._write_function(node)
  26         elif isinstance(node, Enum):
  27             self._write_enum(node)
  28         elif isinstance(node, (Class, Interface)):
  29             self._write_class(node)
  30         elif isinstance(node, GLibBoxed):
  31             self._write_boxed(node)
  32         else:
  33             print 'WRITER: Unhandled node', node
  34
  35     def _write_function(self, func, tag_name='function'):
  36         attrs = [('name', func.name),
  37                  ('symbol', func.symbol)]
  38         with self.tagcontext(tag_name, attrs):
  39             self._write_return_type(func.retval)
  40             self._write_parameters(func.parameters)
  41
  42     def _write_method(self, method):
  43         self._write_function(method, tag_name='method')
  44
  45     def _write_constructor(self, method):
  46         self._write_function(method, tag_name='constructor')
  47
  48     def _write_return_type(self, return_):
  49         if not return_:
  50             return
  51         self.write_tag('return-type', [('type', return_.type)])
  52
  53     def _write_parameters(self, parameters):
  54         if not parameters:
  55             return
  56         with self.tagcontext('parameters'):
  57             for parameter in parameters:
  58                 self._write_parameter(parameter)
  59
  60     def _write_parameter(self, parameter):
  61         self.write_tag('parameter', [('name', parameter.name),
  62                                      ('type', parameter.type)])
  63
  64     def _write_enum(self, enum):
  65         attrs = [('name', enum.name)]
  66         tag_name = 'enum'
  67         if isinstance(enum, GLibEnum):
  68             attrs.extend([('type-name', enum.type_name),
  69                           ('get-type', enum.get_type)])
  70             if isinstance(enum, GLibFlags):
  71                 tag_name = 'flags'
  72
  73         with self.tagcontext(tag_name, attrs):
  74             for member in enum.members:
  75                 self._write_member(member)
  76
  77     def _write_member(self, member):
  78         attrs = [('name', member.name),
  79                  ('value', str(member.value))]
  80         if isinstance(member, GLibEnumMember):
  81             attrs.append(('nick', member.nick))
  82         self.write_tag('member', attrs)
  83
  84     def _write_class(self, node):
  85         attrs = [('name', node.name)]
  86         if isinstance(node, Class):
  87             tag_name = 'object'
  88             if node.parent is not None:
  89                 attrs.append(('parent', node.parent))
  90         else:
  91             tag_name = 'interface'
  92         if isinstance(node, (GLibObject, GLibInterface)):
  93             attrs.append(('type-name', node.type_name))
  94             attrs.append(('get-type', node.get_type))
  95         with self.tagcontext(tag_name, attrs):
  96             if isinstance(node, Class):
  97                 for method in node.constructors:
  98                     self._write_constructor(method)
  99             for method in node.methods:
 100                 self._write_method(method)
 101             for prop in node.properties:
 102                 self._write_property(prop)
 103
 104     def _write_boxed(self, boxed):
 105         attrs = [('name', boxed.name),
 106                  ('type-name', boxed.type_name),
 107                  ('get-type', boxed.get_type)]
 108
 109         with self.tagcontext('boxed', attrs):
 110             for method in boxed.constructors:
 111                 self._write_constructor(method)
 112             for method in boxed.methods:
 113                 self._write_method(method)
 114
 115     def _write_property(self, prop):
 116         attrs = [('name', prop.name),
 117                  ('prop', prop.type)]
 118         self.write_tag('property', attrs)