← Back to branch summary

~ubuntu-branches/ubuntu/quantal/enigmail/quantal-security

« back to all changes in this revision

Viewing changes to mozilla/xpcom/typelib/xpt/tools/xpt.py

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2013-09-13 16:02:15 UTC
  • mfrom: (0.12.16)
  • Revision ID: package-import@ubuntu.com-20130913160215-u3g8nmwa0pdwagwc
Tags: 2:1.5.2-0ubuntu0.12.10.1
* New upstream release v1.5.2 for Thunderbird 24

* Build enigmail using a stripped down Thunderbird 17 build system, as it's
  now quite difficult to build the way we were doing previously, with the
  latest Firefox build system
* Add debian/patches/no_libxpcom.patch - Don't link against libxpcom, as it
  doesn't exist anymore (but exists in the build system)
* Add debian/patches/use_sdk.patch - Use the SDK version of xpt.py and
  friends
* Drop debian/patches/ipc-pipe_rename.diff (not needed anymore)
* Drop debian/patches/makefile_depth.diff (not needed anymore)

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/xpcom/typelib/xpt/tools/xpt.py
 
1
#!/usr/bin/env python
 
2
# Copyright 2010,2011 Mozilla Foundation. All rights reserved.
 
3
#
 
4
# Redistribution and use in source and binary forms, with or without
 
5
# modification, are permitted provided that the following conditions are
 
6
# met:
 
7
#
 
8
#   1. Redistributions of source code must retain the above copyright
 
9
#      notice, this list of conditions and the following disclaimer.
 
10
#
 
11
#   2. Redistributions in binary form must reproduce the above copyright
 
12
#      notice, this list of conditions and the following disclaimer in
 
13
#      the documentation and/or other materials provided with the
 
14
#      distribution.
 
15
#
 
16
# THIS SOFTWARE IS PROVIDED BY THE MOZILLA FOUNDATION ``AS IS'' AND ANY
 
17
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
18
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
19
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE MOZILLA FOUNDATION OR
 
20
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
21
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
22
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
23
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
24
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
25
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
26
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
#
 
28
# The views and conclusions contained in the software and documentation
 
29
# are those of the authors and should not be interpreted as representing
 
30
# official policies, either expressed or implied, of the Mozilla
 
31
# Foundation.
 
32
 
 
33
"""
 
34
A module for working with XPCOM Type Libraries.
 
35
 
 
36
The XPCOM Type Library File Format is described at:
 
37
http://www.mozilla.org/scriptable/typelib_file.html . It is used
 
38
to provide type information for calling methods on XPCOM objects
 
39
from scripting languages such as JavaScript.
 
40
 
 
41
This module provides a set of classes representing the parts of
 
42
a typelib in a high-level manner, as well as methods for reading
 
43
and writing them from files.
 
44
 
 
45
The usable public interfaces are currently:
 
46
Typelib.read(input_file) - read a typelib from a file on disk or file-like
 
47
                           object, return a Typelib object.
 
48
 
 
49
xpt_dump(filename)     - read a typelib from a file on disk, dump
 
50
                         the contents to stdout in a human-readable
 
51
                         format.
 
52
 
 
53
Typelib()              - construct a new Typelib object
 
54
Interface()            - construct a new Interface object
 
55
Method()               - construct a new object representing a method
 
56
                         defined on an Interface
 
57
Constant()             - construct a new object representing a constant
 
58
                         defined on an Interface
 
59
Param()                - construct a new object representing a parameter
 
60
                         to a method
 
61
SimpleType()           - construct a new object representing a simple
 
62
                         data type
 
63
InterfaceType()        - construct a new object representing a type that
 
64
                         is an IDL-defined interface
 
65
 
 
66
"""
 
67
 
 
68
from __future__ import with_statement
 
69
import os, sys
 
70
import struct
 
71
import operator
 
72
 
 
73
# header magic
 
74
XPT_MAGIC = "XPCOM\nTypeLib\r\n\x1a"
 
75
TYPELIB_VERSION = (1, 2)
 
76
 
 
77
class FileFormatError(Exception):
 
78
    pass
 
79
 
 
80
class DataError(Exception):
 
81
    pass
 
82
 
 
83
# Magic for creating enums
 
84
def M_add_class_attribs(attribs):
 
85
    def foo(name, bases, dict_):
 
86
        for v, k in attribs:
 
87
            dict_[k] = v
 
88
        return type(name, bases, dict_)
 
89
    return foo
 
90
 
 
91
def enum(*names):
 
92
    class Foo(object):
 
93
        __metaclass__ = M_add_class_attribs(enumerate(names))
 
94
        def __setattr__(self, name, value):  # this makes it read-only
 
95
            raise NotImplementedError
 
96
    return Foo()
 
97
 
 
98
# Descriptor types as described in the spec
 
99
class Type(object):
 
100
    """
 
101
    Data type of a method parameter or return value. Do not instantiate
 
102
    this class directly. Rather, use one of its subclasses.
 
103
    
 
104
    """
 
105
    _prefixdescriptor = struct.Struct(">B")
 
106
    Tags = enum(
 
107
        # The first 18 entries are SimpleTypeDescriptor
 
108
        'int8',
 
109
        'int16',
 
110
        'int32',
 
111
        'int64',
 
112
        'uint8',
 
113
        'uint16',
 
114
        'uint32',
 
115
        'uint64',
 
116
        'float',
 
117
        'double',
 
118
        'boolean',
 
119
        'char',
 
120
        'wchar_t',
 
121
        'void',
 
122
        # the following four values are only valid as pointers
 
123
        'nsIID',
 
124
        'DOMString',
 
125
        'char_ptr',
 
126
        'wchar_t_ptr',
 
127
        # InterfaceTypeDescriptor
 
128
        'Interface',
 
129
        # InterfaceIsTypeDescriptor
 
130
        'InterfaceIs',
 
131
        # ArrayTypeDescriptor
 
132
        'Array',
 
133
        # StringWithSizeTypeDescriptor
 
134
        'StringWithSize',
 
135
        # WideStringWithSizeTypeDescriptor
 
136
        'WideStringWithSize',
 
137
        #XXX: These are also SimpleTypes (but not in the spec)
 
138
        # http://hg.mozilla.org/mozilla-central/annotate/0e0e2516f04e/xpcom/typelib/xpt/tools/xpt_dump.c#l69
 
139
        'UTF8String',
 
140
        'CString',
 
141
        'AString',
 
142
        'jsval',
 
143
        )
 
144
 
 
145
    def __init__(self, pointer=False, reference=False):
 
146
        self.pointer = pointer
 
147
        self.reference = reference
 
148
        if reference and not pointer:
 
149
            raise Exception("If reference is True pointer must be True too")
 
150
 
 
151
    @staticmethod
 
152
    def decodeflags(byte):
 
153
        """
 
154
        Given |byte|, an unsigned uint8 containing flag bits,
 
155
        decode the flag bits as described in
 
156
        http://www.mozilla.org/scriptable/typelib_file.html#TypeDescriptor
 
157
        and return a dict of flagname: (True|False) suitable
 
158
        for passing to Type.__init__ as **kwargs.
 
159
        
 
160
        """
 
161
        return {'pointer': bool(byte & 0x80),
 
162
                'reference': bool(byte & 0x20),
 
163
                }
 
164
 
 
165
    def encodeflags(self):
 
166
        """
 
167
        Encode the flag bits of this Type object. Returns a byte.
 
168
 
 
169
        """
 
170
        flags = 0
 
171
        if self.pointer:
 
172
            flags |= 0x80
 
173
        if self.reference:
 
174
            flags |= 0x20
 
175
        return flags
 
176
 
 
177
    @staticmethod
 
178
    def read(typelib, map, data_pool, offset):
 
179
        """
 
180
        Read a TypeDescriptor at |offset| from the mmaped file |map| with
 
181
        data pool offset |data_pool|. Returns (Type, next offset),
 
182
        where |next offset| is an offset suitable for reading the data
 
183
        following this TypeDescriptor.
 
184
        
 
185
        """
 
186
        start = data_pool + offset - 1
 
187
        (data,) = Type._prefixdescriptor.unpack(map[start:start + Type._prefixdescriptor.size])
 
188
        # first three bits are the flags
 
189
        flags = data & 0xE0
 
190
        flags = Type.decodeflags(flags)
 
191
        # last five bits is the tag
 
192
        tag = data & 0x1F
 
193
        offset += Type._prefixdescriptor.size
 
194
        t = None
 
195
        if tag <= Type.Tags.wchar_t_ptr or tag >= Type.Tags.UTF8String:
 
196
            t = SimpleType.get(data, tag, flags)
 
197
        elif tag == Type.Tags.Interface:
 
198
            t, offset = InterfaceType.read(typelib, map, data_pool, offset, flags)
 
199
        elif tag == Type.Tags.InterfaceIs:
 
200
            t, offset = InterfaceIsType.read(typelib, map, data_pool, offset, flags)
 
201
        elif tag == Type.Tags.Array:
 
202
            t, offset = ArrayType.read(typelib, map, data_pool, offset, flags)
 
203
        elif tag == Type.Tags.StringWithSize:
 
204
            t, offset = StringWithSizeType.read(typelib, map, data_pool, offset, flags)
 
205
        elif tag == Type.Tags.WideStringWithSize:
 
206
            t, offset = WideStringWithSizeType.read(typelib, map, data_pool, offset, flags)
 
207
        return t, offset
 
208
 
 
209
    def write(self, typelib, file):
 
210
        """
 
211
        Write a TypeDescriptor to |file|, which is assumed
 
212
        to be seeked to the proper position. For types other than
 
213
        SimpleType, this is not sufficient for writing the TypeDescriptor,
 
214
        and the subclass method must be called.
 
215
 
 
216
        """
 
217
        file.write(Type._prefixdescriptor.pack(self.encodeflags() | self.tag))
 
218
 
 
219
class SimpleType(Type):
 
220
    """
 
221
    A simple data type. (SimpleTypeDescriptor from the typelib specification.)
 
222
 
 
223
    """
 
224
    _cache = {}
 
225
 
 
226
    def __init__(self, tag, **kwargs):
 
227
        Type.__init__(self, **kwargs)
 
228
        self.tag = tag
 
229
 
 
230
    @staticmethod
 
231
    def get(data, tag, flags):
 
232
        """
 
233
        Get a SimpleType object representing |data| (a TypeDescriptorPrefix).
 
234
        May return an already-created object. If no cached object is found,
 
235
        construct one with |tag| and |flags|.
 
236
        
 
237
        """
 
238
        if data not in SimpleType._cache:
 
239
            SimpleType._cache[data] = SimpleType(tag, **flags)
 
240
        return SimpleType._cache[data]
 
241
 
 
242
    def __str__(self):
 
243
        s = "unknown"
 
244
        if self.tag == Type.Tags.char_ptr and self.pointer:
 
245
            return "string"
 
246
        if self.tag == Type.Tags.wchar_t_ptr and self.pointer:
 
247
            return "wstring"
 
248
        for t in dir(Type.Tags):
 
249
            if self.tag == getattr(Type.Tags, t):
 
250
                s = t
 
251
                break
 
252
 
 
253
        if self.pointer:
 
254
            if self.reference:
 
255
                s += " &"
 
256
            else:
 
257
                s += " *"
 
258
        return s
 
259
 
 
260
class InterfaceType(Type):
 
261
    """
 
262
    A type representing a pointer to an IDL-defined interface.
 
263
    (InterfaceTypeDescriptor from the typelib specification.)
 
264
 
 
265
    """
 
266
    _descriptor = struct.Struct(">H")
 
267
 
 
268
    def __init__(self, iface, pointer=True, **kwargs):
 
269
        if not pointer:
 
270
            raise DataError, "InterfaceType is not valid with pointer=False"
 
271
        Type.__init__(self, pointer=pointer, **kwargs)
 
272
        self.iface = iface
 
273
        self.tag = Type.Tags.Interface
 
274
 
 
275
    @staticmethod
 
276
    def read(typelib, map, data_pool, offset, flags):
 
277
        """
 
278
        Read an InterfaceTypeDescriptor at |offset| from the mmaped
 
279
        file |map| with data pool offset |data_pool|.
 
280
        Returns (InterfaceType, next offset),
 
281
        where |next offset| is an offset suitable for reading the data
 
282
        following this InterfaceTypeDescriptor.
 
283
        
 
284
        """
 
285
        if not flags['pointer']:
 
286
            return None, offset
 
287
        start = data_pool + offset - 1
 
288
        (iface_index,) = InterfaceType._descriptor.unpack(map[start:start + InterfaceType._descriptor.size])
 
289
        offset += InterfaceType._descriptor.size
 
290
        iface = None
 
291
        # interface indices are 1-based
 
292
        if iface_index > 0 and iface_index <= len(typelib.interfaces):
 
293
            iface = typelib.interfaces[iface_index - 1]
 
294
        return InterfaceType(iface, **flags), offset
 
295
 
 
296
    def write(self, typelib, file):
 
297
        """
 
298
        Write an InterfaceTypeDescriptor to |file|, which is assumed
 
299
        to be seeked to the proper position.
 
300
 
 
301
        """
 
302
        Type.write(self, typelib, file)
 
303
        # write out the interface index (1-based)
 
304
        file.write(InterfaceType._descriptor.pack(typelib.interfaces.index(self.iface) + 1))
 
305
 
 
306
    def __str__(self):
 
307
        if self.iface:
 
308
            return self.iface.name
 
309
        return "unknown interface"
 
310
 
 
311
class InterfaceIsType(Type):
 
312
    """
 
313
    A type representing an interface described by one of the other
 
314
    arguments to the method. (InterfaceIsTypeDescriptor from the
 
315
    typelib specification.)
 
316
    
 
317
    """
 
318
    _descriptor = struct.Struct(">B")
 
319
    _cache = {}
 
320
 
 
321
    def __init__(self, param_index, pointer=True, **kwargs):
 
322
        if not pointer:
 
323
            raise DataError, "InterfaceIsType is not valid with pointer=False"
 
324
        Type.__init__(self, pointer=pointer, **kwargs)
 
325
        self.param_index = param_index
 
326
        self.tag = Type.Tags.InterfaceIs
 
327
 
 
328
    @staticmethod
 
329
    def read(typelib, map, data_pool, offset, flags):
 
330
        """
 
331
        Read an InterfaceIsTypeDescriptor at |offset| from the mmaped
 
332
        file |map| with data pool offset |data_pool|.
 
333
        Returns (InterfaceIsType, next offset),
 
334
        where |next offset| is an offset suitable for reading the data
 
335
        following this InterfaceIsTypeDescriptor.
 
336
        May return a cached value.
 
337
        
 
338
        """
 
339
        if not flags['pointer']:
 
340
            return None, offset
 
341
        start = data_pool + offset - 1
 
342
        (param_index,) = InterfaceIsType._descriptor.unpack(map[start:start + InterfaceIsType._descriptor.size])
 
343
        offset += InterfaceIsType._descriptor.size
 
344
        if param_index not in InterfaceIsType._cache:
 
345
            InterfaceIsType._cache[param_index] = InterfaceIsType(param_index, **flags)
 
346
        return InterfaceIsType._cache[param_index], offset
 
347
 
 
348
    def write(self, typelib, file):
 
349
        """
 
350
        Write an InterfaceIsTypeDescriptor to |file|, which is assumed
 
351
        to be seeked to the proper position.
 
352
 
 
353
        """
 
354
        Type.write(self, typelib, file)
 
355
        file.write(InterfaceIsType._descriptor.pack(self.param_index))
 
356
 
 
357
    def __str__(self):
 
358
        return "InterfaceIs *"
 
359
 
 
360
class ArrayType(Type):
 
361
    """
 
362
    A type representing an Array of elements of another type, whose
 
363
    size and length are passed as separate parameters to a method.
 
364
    (ArrayTypeDescriptor from the typelib specification.)
 
365
    
 
366
    """
 
367
    _descriptor = struct.Struct(">BB")
 
368
 
 
369
    def __init__(self, element_type, size_is_arg_num, length_is_arg_num,
 
370
                 pointer=True, **kwargs):
 
371
        if not pointer:
 
372
            raise DataError, "ArrayType is not valid with pointer=False"
 
373
        Type.__init__(self, pointer=pointer, **kwargs)
 
374
        self.element_type = element_type
 
375
        self.size_is_arg_num = size_is_arg_num
 
376
        self.length_is_arg_num = length_is_arg_num
 
377
        self.tag = Type.Tags.Array
 
378
 
 
379
    @staticmethod
 
380
    def read(typelib, map, data_pool, offset, flags):
 
381
        """
 
382
        Read an ArrayTypeDescriptor at |offset| from the mmaped
 
383
        file |map| with data pool offset |data_pool|.
 
384
        Returns (ArrayType, next offset),
 
385
        where |next offset| is an offset suitable for reading the data
 
386
        following this ArrayTypeDescriptor.
 
387
        """
 
388
        if not flags['pointer']:
 
389
            return None, offset
 
390
        start = data_pool + offset - 1
 
391
        (size_is_arg_num, length_is_arg_num) = ArrayType._descriptor.unpack(map[start:start + ArrayType._descriptor.size])
 
392
        offset += ArrayType._descriptor.size
 
393
        t, offset = Type.read(typelib, map, data_pool, offset)
 
394
        return ArrayType(t, size_is_arg_num, length_is_arg_num, **flags), offset
 
395
 
 
396
    def write(self, typelib, file):
 
397
        """
 
398
        Write an ArrayTypeDescriptor to |file|, which is assumed
 
399
        to be seeked to the proper position.
 
400
 
 
401
        """
 
402
        Type.write(self, typelib, file)
 
403
        file.write(ArrayType._descriptor.pack(self.size_is_arg_num,
 
404
                                              self.length_is_arg_num))
 
405
        self.element_type.write(typelib, file)
 
406
 
 
407
    def __str__(self):
 
408
        return "%s []" % str(self.element_type)
 
409
 
 
410
class StringWithSizeType(Type):
 
411
    """
 
412
    A type representing a UTF-8 encoded string whose size and length
 
413
    are passed as separate arguments to a method. (StringWithSizeTypeDescriptor
 
414
    from the typelib specification.)
 
415
 
 
416
    """
 
417
    _descriptor = struct.Struct(">BB")
 
418
 
 
419
    def __init__(self, size_is_arg_num, length_is_arg_num,
 
420
                 pointer=True, **kwargs):
 
421
        if not pointer:
 
422
            raise DataError, "StringWithSizeType is not valid with pointer=False"
 
423
        Type.__init__(self, pointer=pointer, **kwargs)
 
424
        self.size_is_arg_num = size_is_arg_num
 
425
        self.length_is_arg_num = length_is_arg_num
 
426
        self.tag = Type.Tags.StringWithSize
 
427
 
 
428
    @staticmethod
 
429
    def read(typelib, map, data_pool, offset, flags):
 
430
        """
 
431
        Read an StringWithSizeTypeDescriptor at |offset| from the mmaped
 
432
        file |map| with data pool offset |data_pool|.
 
433
        Returns (StringWithSizeType, next offset),
 
434
        where |next offset| is an offset suitable for reading the data
 
435
        following this StringWithSizeTypeDescriptor.
 
436
        """
 
437
        if not flags['pointer']:
 
438
            return None, offset
 
439
        start = data_pool + offset - 1
 
440
        (size_is_arg_num, length_is_arg_num) = StringWithSizeType._descriptor.unpack(map[start:start + StringWithSizeType._descriptor.size])
 
441
        offset += StringWithSizeType._descriptor.size
 
442
        return StringWithSizeType(size_is_arg_num, length_is_arg_num, **flags), offset
 
443
 
 
444
    def write(self, typelib, file):
 
445
        """
 
446
        Write a StringWithSizeTypeDescriptor to |file|, which is assumed
 
447
        to be seeked to the proper position.
 
448
 
 
449
        """
 
450
        Type.write(self, typelib, file)
 
451
        file.write(StringWithSizeType._descriptor.pack(self.size_is_arg_num,
 
452
                                                       self.length_is_arg_num))
 
453
 
 
454
    def __str__(self):
 
455
        return "string_s"
 
456
 
 
457
class WideStringWithSizeType(Type):
 
458
    """
 
459
    A type representing a UTF-16 encoded string whose size and length
 
460
    are passed as separate arguments to a method.
 
461
    (WideStringWithSizeTypeDescriptor from the typelib specification.)
 
462
 
 
463
    """
 
464
    _descriptor = struct.Struct(">BB")
 
465
 
 
466
    def __init__(self, size_is_arg_num, length_is_arg_num,
 
467
                 pointer=True, **kwargs):
 
468
        if not pointer:
 
469
            raise DataError, "WideStringWithSizeType is not valid with pointer=False"
 
470
        Type.__init__(self, pointer=pointer, **kwargs)
 
471
        self.size_is_arg_num = size_is_arg_num
 
472
        self.length_is_arg_num = length_is_arg_num
 
473
        self.tag = Type.Tags.WideStringWithSize
 
474
 
 
475
    @staticmethod
 
476
    def read(typelib, map, data_pool, offset, flags):
 
477
        """
 
478
        Read an WideStringWithSizeTypeDescriptor at |offset| from the mmaped
 
479
        file |map| with data pool offset |data_pool|.
 
480
        Returns (WideStringWithSizeType, next offset),
 
481
        where |next offset| is an offset suitable for reading the data
 
482
        following this WideStringWithSizeTypeDescriptor.
 
483
        """
 
484
        if not flags['pointer']:
 
485
            return None, offset
 
486
        start = data_pool + offset - 1
 
487
        (size_is_arg_num, length_is_arg_num) = WideStringWithSizeType._descriptor.unpack(map[start:start + WideStringWithSizeType._descriptor.size])
 
488
        offset += WideStringWithSizeType._descriptor.size
 
489
        return WideStringWithSizeType(size_is_arg_num, length_is_arg_num, **flags), offset
 
490
 
 
491
    def write(self, typelib, file):
 
492
        """
 
493
        Write a WideStringWithSizeTypeDescriptor to |file|, which is assumed
 
494
        to be seeked to the proper position.
 
495
 
 
496
        """
 
497
        Type.write(self, typelib, file)
 
498
        file.write(WideStringWithSizeType._descriptor.pack(self.size_is_arg_num,
 
499
                                                           self.length_is_arg_num))
 
500
 
 
501
    def __str__(self):
 
502
        return "wstring_s"
 
503
 
 
504
class Param(object):
 
505
    """
 
506
    A parameter to a method, or the return value of a method.
 
507
    (ParamDescriptor from the typelib specification.)
 
508
 
 
509
    """
 
510
    _descriptorstart = struct.Struct(">B")
 
511
 
 
512
    def __init__(self, type, in_=True, out=False, retval=False,
 
513
                 shared=False, dipper=False, optional=False):
 
514
        """
 
515
        Construct a Param object with the specified |type| and
 
516
        flags. Params default to "in".
 
517
 
 
518
        """
 
519
 
 
520
        self.type = type
 
521
        self.in_ = in_
 
522
        self.out = out
 
523
        self.retval = retval
 
524
        self.shared = shared
 
525
        self.dipper = dipper
 
526
        self.optional = optional
 
527
 
 
528
    @staticmethod
 
529
    def decodeflags(byte):
 
530
        """
 
531
        Given |byte|, an unsigned uint8 containing flag bits,
 
532
        decode the flag bits as described in
 
533
        http://www.mozilla.org/scriptable/typelib_file.html#ParamDescriptor
 
534
        and return a dict of flagname: (True|False) suitable
 
535
        for passing to Param.__init__ as **kwargs
 
536
        """
 
537
        return {'in_': bool(byte & 0x80),
 
538
                'out': bool(byte & 0x40),
 
539
                'retval': bool(byte & 0x20),
 
540
                'shared': bool(byte & 0x10),
 
541
                'dipper': bool(byte & 0x08),
 
542
                #XXX: Not in the spec, see:
 
543
                # http://hg.mozilla.org/mozilla-central/annotate/0e0e2516f04e/xpcom/typelib/xpt/public/xpt_struct.h#l456
 
544
                'optional': bool(byte & 0x04),
 
545
                }
 
546
 
 
547
    def encodeflags(self):
 
548
        """
 
549
        Encode the flags of this Param. Return a byte suitable for
 
550
        writing to a typelib file.
 
551
 
 
552
        """
 
553
        flags = 0
 
554
        if self.in_:
 
555
            flags |= 0x80
 
556
        if self.out:
 
557
            flags |= 0x40
 
558
        if self.retval:
 
559
            flags |= 0x20
 
560
        if self.shared:
 
561
            flags |= 0x10
 
562
        if self.dipper:
 
563
            flags |= 0x08
 
564
        if self.optional:
 
565
            flags |= 0x04
 
566
        return flags
 
567
 
 
568
    @staticmethod
 
569
    def read(typelib, map, data_pool, offset):
 
570
        """
 
571
        Read a ParamDescriptor at |offset| from the mmaped file |map| with
 
572
        data pool offset |data_pool|. Returns (Param, next offset),
 
573
        where |next offset| is an offset suitable for reading the data
 
574
        following this ParamDescriptor.
 
575
        """
 
576
        start = data_pool + offset - 1
 
577
        (flags,) = Param._descriptorstart.unpack(map[start:start + Param._descriptorstart.size])
 
578
        # only the first five bits are flags
 
579
        flags &= 0xFC
 
580
        flags = Param.decodeflags(flags)
 
581
        offset += Param._descriptorstart.size
 
582
        t, offset = Type.read(typelib, map, data_pool, offset)
 
583
        p = Param(t, **flags)
 
584
        return p, offset
 
585
 
 
586
    def write(self, typelib, file):
 
587
        """
 
588
        Write a ParamDescriptor to |file|, which is assumed to be seeked
 
589
        to the correct position.
 
590
 
 
591
        """
 
592
        file.write(Param._descriptorstart.pack(self.encodeflags()))
 
593
        self.type.write(typelib, file)
 
594
 
 
595
    def prefix(self):
 
596
        """
 
597
        Return a human-readable string representing the flags set
 
598
        on this Param.
 
599
 
 
600
        """
 
601
        s = ""
 
602
        if self.out:
 
603
            if self.in_:
 
604
                s = "inout "
 
605
            else:
 
606
                s = "out "
 
607
        else:
 
608
            s = "in "
 
609
        if self.dipper:
 
610
            s += "dipper "
 
611
        if self.retval:
 
612
            s += "retval "
 
613
        if self.shared:
 
614
            s += "shared "
 
615
        if self.optional:
 
616
            s += "optional "
 
617
        return s
 
618
 
 
619
    def __str__(self):
 
620
        return self.prefix() + str(self.type)
 
621
 
 
622
class Method(object):
 
623
    """
 
624
    A method of an interface, defining its associated parameters
 
625
    and return value.
 
626
    (MethodDescriptor from the typelib specification.)
 
627
    
 
628
    """
 
629
    _descriptorstart = struct.Struct(">BIB")
 
630
 
 
631
    def __init__(self, name, result,
 
632
                 params=[], getter=False, setter=False, notxpcom=False,
 
633
                 constructor=False, hidden=False, optargc=False,
 
634
                 implicit_jscontext=False):
 
635
        self.name = name
 
636
        self._name_offset = 0
 
637
        self.getter = getter
 
638
        self.setter = setter
 
639
        self.notxpcom = notxpcom
 
640
        self.constructor = constructor
 
641
        self.hidden = hidden
 
642
        self.optargc = optargc
 
643
        self.implicit_jscontext = implicit_jscontext
 
644
        self.params = list(params)
 
645
        if result and not isinstance(result, Param):
 
646
            raise Exception("result must be a Param!")
 
647
        self.result = result
 
648
 
 
649
    def read_params(self, typelib, map, data_pool, offset, num_args):
 
650
        """
 
651
        Read |num_args| ParamDescriptors representing this Method's arguments
 
652
        from the mmaped file |map| with data pool at the offset |data_pool|,
 
653
        starting at |offset| into self.params. Returns the offset
 
654
        suitable for reading the data following the ParamDescriptor array.
 
655
        
 
656
        """
 
657
        for i in range(num_args):
 
658
            p, offset = Param.read(typelib, map, data_pool, offset)
 
659
            self.params.append(p)
 
660
        return offset
 
661
 
 
662
    def read_result(self, typelib, map, data_pool, offset):
 
663
        """
 
664
        Read a ParamDescriptor representing this Method's return type
 
665
        from the mmaped file |map| with data pool at the offset |data_pool|,
 
666
        starting at |offset| into self.result. Returns the offset
 
667
        suitable for reading the data following the ParamDescriptor.
 
668
        
 
669
        """
 
670
        self.result, offset = Param.read(typelib, map, data_pool, offset)
 
671
        return offset
 
672
 
 
673
    @staticmethod
 
674
    def decodeflags(byte):
 
675
        """
 
676
        Given |byte|, an unsigned uint8 containing flag bits,
 
677
        decode the flag bits as described in
 
678
        http://www.mozilla.org/scriptable/typelib_file.html#MethodDescriptor
 
679
        and return a dict of flagname: (True|False) suitable
 
680
        for passing to Method.__init__ as **kwargs
 
681
        
 
682
        """
 
683
        return {'getter': bool(byte & 0x80),
 
684
                'setter': bool(byte & 0x40),
 
685
                'notxpcom': bool(byte & 0x20),
 
686
                'constructor': bool(byte & 0x10),
 
687
                'hidden': bool(byte & 0x08),
 
688
                # Not in the spec, see
 
689
                # http://hg.mozilla.org/mozilla-central/annotate/0e0e2516f04e/xpcom/typelib/xpt/public/xpt_struct.h#l489
 
690
                'optargc': bool(byte & 0x04),
 
691
                'implicit_jscontext': bool(byte & 0x02),
 
692
                }
 
693
 
 
694
    def encodeflags(self):
 
695
        """
 
696
        Encode the flags of this Method object, return a byte suitable
 
697
        for writing to a typelib file.
 
698
 
 
699
        """
 
700
        flags = 0
 
701
        if self.getter:
 
702
            flags |= 0x80
 
703
        if self.setter:
 
704
            flags |= 0x40
 
705
        if self.notxpcom:
 
706
            flags |= 0x20
 
707
        if self.constructor:
 
708
            flags |= 0x10
 
709
        if self.hidden:
 
710
            flags |= 0x08
 
711
        if self.optargc:
 
712
            flags |= 0x04
 
713
        if self.implicit_jscontext:
 
714
            flags |= 0x02
 
715
        return flags
 
716
 
 
717
    @staticmethod
 
718
    def read(typelib, map, data_pool, offset):
 
719
        """
 
720
        Read a MethodDescriptor at |offset| from the mmaped file |map| with
 
721
        data pool offset |data_pool|. Returns (Method, next offset),
 
722
        where |next offset| is an offset suitable for reading the data
 
723
        following this MethodDescriptor.
 
724
        
 
725
        """
 
726
        start = data_pool + offset - 1
 
727
        flags, name_offset, num_args = Method._descriptorstart.unpack(map[start:start + Method._descriptorstart.size])
 
728
        # only the first seven bits are flags
 
729
        flags &= 0xFE
 
730
        flags = Method.decodeflags(flags)
 
731
        name = Typelib.read_string(map, data_pool, name_offset)
 
732
        m = Method(name, None, **flags)
 
733
        offset += Method._descriptorstart.size
 
734
        offset = m.read_params(typelib, map, data_pool, offset, num_args)
 
735
        offset = m.read_result(typelib, map, data_pool, offset)
 
736
        return m, offset
 
737
 
 
738
    def write(self, typelib, file):
 
739
        """
 
740
        Write a MethodDescriptor to |file|, which is assumed to be
 
741
        seeked to the right position.
 
742
 
 
743
        """
 
744
        file.write(Method._descriptorstart.pack(self.encodeflags(),
 
745
                                                self._name_offset,
 
746
                                                len(self.params)))
 
747
        for p in self.params:
 
748
            p.write(typelib, file)
 
749
        self.result.write(typelib, file)
 
750
 
 
751
    def write_name(self, file, data_pool_offset):
 
752
        """
 
753
        Write this method's name to |file|.
 
754
        Assumes that |file| is currently seeked to an unused portion
 
755
        of the data pool.
 
756
 
 
757
        """
 
758
        if self.name:
 
759
            self._name_offset = file.tell() - data_pool_offset + 1
 
760
            file.write(self.name + "\x00")
 
761
        else:
 
762
            self._name_offset = 0
 
763
 
 
764
class Constant(object):
 
765
    """
 
766
    A constant value of a specific type defined on an interface.
 
767
    (ConstantDesciptor from the typelib specification.)
 
768
 
 
769
    """
 
770
    _descriptorstart = struct.Struct(">I")
 
771
    # Actual value is restricted to this set of types
 
772
    #XXX: the spec lies, the source allows a bunch more
 
773
    # http://hg.mozilla.org/mozilla-central/annotate/9c85f9aaec8c/xpcom/typelib/xpt/src/xpt_struct.c#l689
 
774
    typemap = {Type.Tags.int16: '>h',
 
775
               Type.Tags.uint16: '>H',
 
776
               Type.Tags.int32: '>i',
 
777
               Type.Tags.uint32: '>I'}
 
778
 
 
779
    def __init__(self, name, type, value):
 
780
        self.name = name
 
781
        self._name_offset = 0
 
782
        self.type = type
 
783
        self.value = value
 
784
 
 
785
    @staticmethod
 
786
    def read(typelib, map, data_pool, offset):
 
787
        """
 
788
        Read a ConstDescriptor at |offset| from the mmaped file |map| with
 
789
        data pool offset |data_pool|. Returns (Constant, next offset),
 
790
        where |next offset| is an offset suitable for reading the data
 
791
        following this ConstDescriptor.
 
792
        
 
793
        """
 
794
        start = data_pool + offset - 1
 
795
        (name_offset,) = Constant._descriptorstart.unpack(map[start:start + Constant._descriptorstart.size])
 
796
        name = Typelib.read_string(map, data_pool, name_offset)
 
797
        offset += Constant._descriptorstart.size
 
798
        # Read TypeDescriptor
 
799
        t, offset = Type.read(typelib, map, data_pool, offset)
 
800
        c = None
 
801
        if isinstance(t, SimpleType) and t.tag in Constant.typemap:
 
802
            tt = Constant.typemap[t.tag]
 
803
            start = data_pool + offset - 1
 
804
            (val,) = struct.unpack(tt, map[start:start + struct.calcsize(tt)])
 
805
            offset += struct.calcsize(tt)
 
806
            c = Constant(name, t, val)
 
807
        return c, offset
 
808
 
 
809
    def write(self, typelib, file):
 
810
        """
 
811
        Write a ConstDescriptor to |file|, which is assumed
 
812
        to be seeked to the proper position.
 
813
 
 
814
        """
 
815
        file.write(Constant._descriptorstart.pack(self._name_offset))
 
816
        self.type.write(typelib, file)
 
817
        tt = Constant.typemap[self.type.tag]
 
818
        file.write(struct.pack(tt, self.value))
 
819
 
 
820
    def write_name(self, file, data_pool_offset):
 
821
        """
 
822
        Write this constants's name to |file|.
 
823
        Assumes that |file| is currently seeked to an unused portion
 
824
        of the data pool.
 
825
 
 
826
        """
 
827
        if self.name:
 
828
            self._name_offset = file.tell() - data_pool_offset + 1
 
829
            file.write(self.name + "\x00")
 
830
        else:
 
831
            self._name_offset = 0
 
832
 
 
833
    def __repr__(self):
 
834
        return "Constant(%s, %s, %d)" % (self.name, str(self.type), self.value)
 
835
 
 
836
class Interface(object):
 
837
    """
 
838
    An Interface represents an object, with its associated methods
 
839
    and constant values.
 
840
    (InterfaceDescriptor from the typelib specification.)
 
841
    
 
842
    """
 
843
    _direntry = struct.Struct(">16sIII")
 
844
    _descriptorstart = struct.Struct(">HH")
 
845
 
 
846
    UNRESOLVED_IID = "00000000-0000-0000-0000-000000000000"
 
847
 
 
848
    def __init__(self, name, iid=UNRESOLVED_IID, namespace="",
 
849
                 resolved=False, parent=None, methods=[], constants=[],
 
850
                 scriptable=False, function=False, builtinclass=False):
 
851
        self.resolved = resolved
 
852
        #TODO: should validate IIDs!
 
853
        self.iid = iid
 
854
        self.name = name
 
855
        self.namespace = namespace
 
856
        # if unresolved, all the members following this are unusable
 
857
        self.parent = parent
 
858
        self.methods = list(methods)
 
859
        self.constants = list(constants)
 
860
        self.scriptable = scriptable
 
861
        self.function = function
 
862
        self.builtinclass = builtinclass
 
863
        # For sanity, if someone constructs an Interface and passes
 
864
        # in methods or constants, then it's resolved.
 
865
        if self.methods or self.constants:
 
866
            # make sure it has a valid IID
 
867
            if self.iid == Interface.UNRESOLVED_IID:
 
868
                raise DataError, "Cannot instantiate Interface %s containing methods or constants with an unresolved IID" % self.name
 
869
            self.resolved = True
 
870
        # These are only used for writing out the interface
 
871
        self._descriptor_offset = 0
 
872
        self._name_offset = 0
 
873
        self._namespace_offset = 0
 
874
        self.xpt_filename = None
 
875
 
 
876
    def __repr__(self):
 
877
        return "Interface('%s', '%s', '%s', methods=%s)" % (self.name, self.iid, self.namespace, self.methods)
 
878
 
 
879
    def __str__(self):
 
880
        return "Interface(name='%s', iid='%s')" % (self.name, self.iid)
 
881
 
 
882
    def __hash__(self):
 
883
        return hash((self.name, self.iid))
 
884
 
 
885
    def __cmp__(self, other):
 
886
        c = cmp(self.iid, other.iid)
 
887
        if c != 0:
 
888
            return c
 
889
        c = cmp(self.name, other.name)
 
890
        if c != 0:
 
891
            return c
 
892
        c = cmp(self.namespace, other.namespace)
 
893
        if c != 0:
 
894
            return c
 
895
        # names and IIDs are the same, check resolved
 
896
        if self.resolved != other.resolved:
 
897
            if self.resolved:
 
898
                return -1
 
899
            else:
 
900
                return 1
 
901
        else:
 
902
            # both unresolved, but names and IIDs are the same, so equal
 
903
            return 0
 
904
        #TODO: actually compare methods etc
 
905
        return 0
 
906
 
 
907
    def read_descriptor(self, typelib, map, data_pool):
 
908
        offset = self._descriptor_offset
 
909
        if offset == 0:
 
910
            return
 
911
        start = data_pool + offset - 1
 
912
        parent, num_methods = Interface._descriptorstart.unpack(map[start:start + Interface._descriptorstart.size])
 
913
        if parent > 0 and parent <= len(typelib.interfaces):
 
914
            self.parent = typelib.interfaces[parent - 1]
 
915
        # Read methods
 
916
        offset += Interface._descriptorstart.size
 
917
        for i in range(num_methods):
 
918
            m, offset = Method.read(typelib, map, data_pool, offset)
 
919
            self.methods.append(m)
 
920
        # Read constants
 
921
        start = data_pool + offset - 1
 
922
        (num_constants, ) = struct.unpack(">H", map[start:start + struct.calcsize(">H")])
 
923
        offset = offset + struct.calcsize(">H")
 
924
        for i in range(num_constants):
 
925
            c, offset = Constant.read(typelib, map, data_pool, offset)
 
926
            self.constants.append(c)
 
927
        # Read flags
 
928
        start = data_pool + offset - 1
 
929
        (flags, ) = struct.unpack(">B", map[start:start + struct.calcsize(">B")])
 
930
        offset = offset + struct.calcsize(">B")
 
931
        # only the first two bits are flags
 
932
        flags &= 0xE0
 
933
        if flags & 0x80:
 
934
            self.scriptable = True
 
935
        if flags & 0x40:
 
936
            self.function = True
 
937
        if flags & 0x20:
 
938
            self.builtinclass = True
 
939
        self.resolved = True
 
940
 
 
941
    def write_directory_entry(self, file):
 
942
        """
 
943
        Write an InterfaceDirectoryEntry for this interface
 
944
        to |file|, which is assumed to be seeked to the correct offset.
 
945
 
 
946
        """
 
947
        file.write(Interface._direntry.pack(Typelib.string_to_iid(self.iid),
 
948
                                            self._name_offset,
 
949
                                            self._namespace_offset,
 
950
                                            self._descriptor_offset))
 
951
 
 
952
    def write(self, typelib, file, data_pool_offset):
 
953
        """
 
954
        Write an InterfaceDescriptor to |file|, which is assumed
 
955
        to be seeked to the proper position. If this interface
 
956
        is not resolved, do not write any data.
 
957
 
 
958
        """
 
959
        if not self.resolved:
 
960
            self._descriptor_offset = 0
 
961
            return
 
962
        self._descriptor_offset = file.tell() - data_pool_offset + 1
 
963
        parent_idx = 0
 
964
        if self.parent:
 
965
            parent_idx = typelib.interfaces.index(self.parent) + 1
 
966
        file.write(Interface._descriptorstart.pack(parent_idx, len(self.methods)))
 
967
        for m in self.methods:
 
968
            m.write(typelib, file)
 
969
        file.write(struct.pack(">H", len(self.constants)))
 
970
        for c in self.constants:
 
971
            c.write(typelib, file)
 
972
        flags = 0
 
973
        if self.scriptable:
 
974
            flags |= 0x80
 
975
        if self.function:
 
976
            flags |= 0x40
 
977
        if self.builtinclass:
 
978
            flags |= 0x20
 
979
        file.write(struct.pack(">B", flags))
 
980
 
 
981
    def write_names(self, file, data_pool_offset):
 
982
        """
 
983
        Write this interface's name and namespace to |file|,
 
984
        as well as the names of all of its methods and constants.
 
985
        Assumes that |file| is currently seeked to an unused portion
 
986
        of the data pool.
 
987
 
 
988
        """
 
989
        if self.name:
 
990
            self._name_offset = file.tell() - data_pool_offset + 1
 
991
            file.write(self.name + "\x00")
 
992
        else:
 
993
            self._name_offset = 0
 
994
        if self.namespace:
 
995
            self._namespace_offset = file.tell() - data_pool_offset + 1
 
996
            file.write(self.namespace + "\x00")
 
997
        else:
 
998
            self._namespace_offset = 0
 
999
        for m in self.methods:
 
1000
            m.write_name(file, data_pool_offset)
 
1001
        for c in self.constants:
 
1002
            c.write_name(file, data_pool_offset)
 
1003
 
 
1004
class Typelib(object):
 
1005
    """
 
1006
    A typelib represents one entire typelib file and all the interfaces
 
1007
    referenced within, whether defined entirely within the typelib or
 
1008
    merely referenced by name or IID.
 
1009
 
 
1010
    Typelib objects may be instantiated directly and populated with data,
 
1011
    or the static Typelib.read method may be called to read one from a file.
 
1012
 
 
1013
    """
 
1014
    _header = struct.Struct(">16sBBHIII")
 
1015
 
 
1016
    def __init__(self, version=TYPELIB_VERSION, interfaces=[], annotations=[]):
 
1017
        """
 
1018
        Instantiate a new Typelib.
 
1019
 
 
1020
        """
 
1021
        self.version = version
 
1022
        self.interfaces = list(interfaces)
 
1023
        self.annotations = list(annotations)
 
1024
        self.filename = None
 
1025
 
 
1026
    @staticmethod
 
1027
    def iid_to_string(iid):
 
1028
        """
 
1029
        Convert a 16-byte IID into a UUID string.
 
1030
 
 
1031
        """
 
1032
        def hexify(s):
 
1033
            return ''.join(["%02x" % ord(x) for x in s])
 
1034
 
 
1035
        return "%s-%s-%s-%s-%s" % (hexify(iid[:4]), hexify(iid[4:6]),
 
1036
                                   hexify(iid[6:8]), hexify(iid[8:10]),
 
1037
                                   hexify(iid[10:]))
 
1038
 
 
1039
    @staticmethod
 
1040
    def string_to_iid(iid_str):
 
1041
        """
 
1042
        Convert a UUID string into a 16-byte IID.
 
1043
 
 
1044
        """
 
1045
        s = iid_str.replace('-','')
 
1046
        return ''.join([chr(int(s[i:i+2], 16)) for i in range(0, len(s), 2)])
 
1047
 
 
1048
    @staticmethod
 
1049
    def read_string(map, data_pool, offset):
 
1050
        if offset == 0:
 
1051
            return ""
 
1052
        sz = map.find('\x00', data_pool + offset - 1)
 
1053
        if sz == -1:
 
1054
            return ""
 
1055
        return map[data_pool + offset - 1:sz]
 
1056
 
 
1057
    @staticmethod
 
1058
    def read(input_file):
 
1059
        """
 
1060
        Read a typelib from |input_file| and return
 
1061
        the constructed Typelib object. |input_file| can be a filename
 
1062
        or a file-like object.
 
1063
 
 
1064
        """
 
1065
        filename = ""
 
1066
        data = None
 
1067
        expected_size = None
 
1068
        if isinstance(input_file, basestring):
 
1069
            filename = input_file
 
1070
            with open(input_file, "rb") as f:
 
1071
                st = os.fstat(f.fileno())
 
1072
                data = f.read(st.st_size)
 
1073
                expected_size = st.st_size
 
1074
        else:
 
1075
            data = input_file.read()
 
1076
 
 
1077
        (magic,
 
1078
         major_ver,
 
1079
         minor_ver,
 
1080
         num_interfaces,
 
1081
         file_length,
 
1082
         interface_directory_offset,
 
1083
         data_pool_offset) = Typelib._header.unpack(data[:Typelib._header.size])
 
1084
        if magic != XPT_MAGIC:
 
1085
            raise FileFormatError, "Bad magic: %s" % magic
 
1086
        xpt = Typelib((major_ver, minor_ver))
 
1087
        xpt.filename = filename
 
1088
        if expected_size and file_length != expected_size:
 
1089
            raise FileFormatError, "File is of wrong length, got %d bytes, expected %d" % (expected_size, file_length)
 
1090
        #XXX: by spec this is a zero-based file offset. however,
 
1091
        # the xpt_xdr code always subtracts 1 from data offsets
 
1092
        # (because that's what you do in the data pool) so it
 
1093
        # winds up accidentally treating this as 1-based.
 
1094
        # Filed as: https://bugzilla.mozilla.org/show_bug.cgi?id=575343
 
1095
        interface_directory_offset -= 1
 
1096
        # make a half-hearted attempt to read Annotations,
 
1097
        # since XPIDL doesn't produce any anyway.
 
1098
        start = Typelib._header.size
 
1099
        (anno, ) = struct.unpack(">B", data[start:start + struct.calcsize(">B")])
 
1100
        islast = anno & 0x80
 
1101
        tag = anno & 0x7F
 
1102
        if tag == 0: # EmptyAnnotation
 
1103
            xpt.annotations.append(None)
 
1104
        # We don't bother handling PrivateAnnotations or anything
 
1105
 
 
1106
        for i in range(num_interfaces):
 
1107
            # iid, name, namespace, interface_descriptor
 
1108
            start = interface_directory_offset + i * Interface._direntry.size
 
1109
            end = interface_directory_offset + (i+1) * Interface._direntry.size
 
1110
            ide = Interface._direntry.unpack(data[start:end])
 
1111
            iid = Typelib.iid_to_string(ide[0])
 
1112
            name = Typelib.read_string(data, data_pool_offset, ide[1])
 
1113
            namespace = Typelib.read_string(data, data_pool_offset, ide[2])
 
1114
            iface = Interface(name, iid, namespace)
 
1115
            iface._descriptor_offset = ide[3]
 
1116
            iface.xpt_filename = xpt.filename
 
1117
            xpt.interfaces.append(iface)
 
1118
        for iface in xpt.interfaces:
 
1119
            iface.read_descriptor(xpt, data, data_pool_offset)
 
1120
        return xpt
 
1121
 
 
1122
    def __repr__(self):
 
1123
        return "<Typelib with %d interfaces>" % len(self.interfaces)
 
1124
 
 
1125
    def _sanityCheck(self):
 
1126
        """
 
1127
        Check certain assumptions about data contained in this typelib.
 
1128
        Sort the interfaces array by IID, check that all interfaces
 
1129
        referenced by methods exist in the array.
 
1130
 
 
1131
        """
 
1132
        self.interfaces.sort()
 
1133
        for i in self.interfaces:
 
1134
            if i.parent and i.parent not in self.interfaces:
 
1135
                raise DataError, "Interface %s has parent %s not present in typelib!" % (i.name, i.parent.name)
 
1136
            for m in i.methods:
 
1137
                for n, p in enumerate(m.params):
 
1138
                    if isinstance(p, InterfaceType) and \
 
1139
                        p.iface not in self.interfaces:
 
1140
                        raise DataError, "Interface method %s::%s, parameter %d references interface %s not present in typelib!" % (i.name, m.name, n, p.iface.name)
 
1141
                if isinstance(m.result, InterfaceType) and m.result.iface not in self.interfaces:
 
1142
                    raise DataError, "Interface method %s::%s, result references interface %s not present in typelib!" % (i.name, m.name, m.result.iface.name)
 
1143
 
 
1144
    def writefd(self, fd):
 
1145
        # write out space for a header + one empty annotation,
 
1146
        # padded to 4-byte alignment.
 
1147
        headersize = (Typelib._header.size + 1)
 
1148
        if headersize % 4:
 
1149
            headersize += 4 - headersize % 4
 
1150
        fd.write("\x00" * headersize)
 
1151
        # save this offset, it's the interface directory offset.
 
1152
        interface_directory_offset = fd.tell()
 
1153
        # write out space for an interface directory
 
1154
        fd.write("\x00" * Interface._direntry.size * len(self.interfaces))
 
1155
        # save this offset, it's the data pool offset.
 
1156
        data_pool_offset = fd.tell()
 
1157
        # write out all the interface descriptors to the data pool
 
1158
        for i in self.interfaces:
 
1159
            i.write_names(fd, data_pool_offset)
 
1160
            i.write(self, fd, data_pool_offset)
 
1161
        # now, seek back and write the header
 
1162
        file_len = fd.tell()
 
1163
        fd.seek(0)
 
1164
        fd.write(Typelib._header.pack(XPT_MAGIC,
 
1165
                                      TYPELIB_VERSION[0],
 
1166
                                      TYPELIB_VERSION[1],
 
1167
                                      len(self.interfaces),
 
1168
                                      file_len,
 
1169
                                      interface_directory_offset,
 
1170
                                      data_pool_offset))
 
1171
        # write an empty annotation
 
1172
        fd.write(struct.pack(">B", 0x80))
 
1173
        # now write the interface directory
 
1174
        #XXX: bug-compatible with existing xpt lib, put it one byte
 
1175
        # ahead of where it's supposed to be.
 
1176
        fd.seek(interface_directory_offset - 1)
 
1177
        for i in self.interfaces:
 
1178
            i.write_directory_entry(fd)
 
1179
 
 
1180
    def write(self, output_file):
 
1181
        """
 
1182
        Write the contents of this typelib to |output_file|,
 
1183
        which can be either a filename or a file-like object.
 
1184
 
 
1185
        """
 
1186
        self._sanityCheck()
 
1187
        if isinstance(output_file, basestring):
 
1188
            with open(output_file, "wb") as f:
 
1189
                self.writefd(f)
 
1190
        else:
 
1191
            self.writefd(output_file)
 
1192
 
 
1193
    def dump(self, out):
 
1194
        """
 
1195
        Print a human-readable listing of the contents of this typelib
 
1196
        to |out|, in the format of xpt_dump.
 
1197
        
 
1198
        """
 
1199
        out.write("""Header:
 
1200
   Major version:         %d
 
1201
   Minor version:         %d
 
1202
   Number of interfaces:  %d
 
1203
   Annotations:\n""" % (self.version[0], self.version[1], len(self.interfaces)))
 
1204
        for i, a in enumerate(self.annotations):
 
1205
            if a is None:
 
1206
                out.write("      Annotation #%d is empty.\n" % i)
 
1207
        out.write("\nInterface Directory:\n")
 
1208
        for i in self.interfaces:
 
1209
            out.write("   - %s::%s (%s):\n" % (i.namespace, i.name, i.iid))
 
1210
            if not i.resolved:
 
1211
                out.write("      [Unresolved]\n")
 
1212
            else:
 
1213
                if i.parent:
 
1214
                    out.write("      Parent: %s::%s\n" % (i.parent.namespace,
 
1215
                                                    i.parent.name))
 
1216
                out.write("""      Flags:
 
1217
         Scriptable: %s
 
1218
         BuiltinClass: %s
 
1219
         Function: %s\n""" % (i.scriptable and "TRUE" or "FALSE",
 
1220
                              i.builtinclass and "TRUE" or "FALSE",
 
1221
                              i.function and "TRUE" or "FALSE"))
 
1222
                out.write("      Methods:\n")
 
1223
                if len(i.methods) == 0:
 
1224
                    out.write("         No Methods\n")
 
1225
                else:
 
1226
                    for m in i.methods:
 
1227
                        out.write("   %s%s%s%s%s%s%s %s %s(%s);\n" % (
 
1228
                            m.getter and "G" or " ",
 
1229
                            m.setter and "S" or " ",
 
1230
                            m.hidden and "H" or " ",
 
1231
                            m.notxpcom and "N" or " ",
 
1232
                            m.constructor and "C" or " ",
 
1233
                            m.optargc and "O" or " ",
 
1234
                            m.implicit_jscontext and "J" or " ",
 
1235
                            str(m.result.type),
 
1236
                            m.name,
 
1237
                            m.params and ", ".join(str(p) for p in m.params) or ""
 
1238
                            ))
 
1239
                out.write("      Constants:\n")
 
1240
                if len(i.constants) == 0:
 
1241
                    out.write("         No Constants\n")
 
1242
                else:
 
1243
                    for c in i.constants:
 
1244
                        out.write("         %s %s = %d;\n" % (c.type, c.name, c.value))
 
1245
 
 
1246
def xpt_dump(file):
 
1247
    """
 
1248
    Dump the contents of |file| to stdout in the format of xpt_dump.
 
1249
 
 
1250
    """
 
1251
    t = Typelib.read(file)
 
1252
    t.dump(sys.stdout)
 
1253
 
 
1254
def xpt_link(inputs):
 
1255
    """
 
1256
    Link all of the xpt files in |inputs| together and return the result
 
1257
    as a Typelib object. All entries in inputs may be filenames or
 
1258
    file-like objects.
 
1259
 
 
1260
    """
 
1261
    def read_input(i):
 
1262
        if isinstance(i, Typelib):
 
1263
            return i
 
1264
        return Typelib.read(i)
 
1265
 
 
1266
    if not inputs:
 
1267
        print >>sys.stderr, "Usage: xpt_link <destination file> <input files>"
 
1268
        return None
 
1269
    # This is the aggregate list of interfaces.
 
1270
    interfaces = []
 
1271
    # This will be a dict of replaced interface -> replaced with
 
1272
    # containing interfaces that were replaced with interfaces from
 
1273
    # another typelib, and the interface that replaced them.
 
1274
    merged_interfaces = {}
 
1275
    for f in inputs:
 
1276
        t = read_input(f)
 
1277
        interfaces.extend(t.interfaces)
 
1278
    # Sort interfaces by name so we can merge adjacent duplicates
 
1279
    interfaces.sort(key=operator.attrgetter('name'))
 
1280
 
 
1281
    Result = enum('Equal',     # Interfaces the same, doesn't matter
 
1282
                  'NotEqual',  # Interfaces differ, keep both
 
1283
                  'KeepFirst', # Replace second interface with first
 
1284
                  'KeepSecond')# Replace first interface with second
 
1285
        
 
1286
    def compare(i, j):
 
1287
        """
 
1288
        Compare two interfaces, determine if they're equal or
 
1289
        completely different, or should be merged (and indicate which
 
1290
        one to keep in that case).
 
1291
 
 
1292
        """
 
1293
        if i == j:
 
1294
            # Arbitrary, just pick one
 
1295
            return Result.Equal
 
1296
        if i.name != j.name:
 
1297
            if i.iid == j.iid and i.iid != Interface.UNRESOLVED_IID:
 
1298
                # Same IID but different names: raise an exception.
 
1299
                raise DataError, \
 
1300
                    "Typelibs contain definitions of interface %s" \
 
1301
                    " with different names (%s (%s) vs %s (%s))!" % \
 
1302
                    (i.iid, i.name, i.xpt_filename, j.name, j.xpt_filename)
 
1303
            # Otherwise just different interfaces.
 
1304
            return Result.NotEqual
 
1305
        # Interfaces have the same name, so either they need to be merged
 
1306
        # or there's a data error. Sort out which one to keep
 
1307
        if i.resolved != j.resolved:
 
1308
            # prefer resolved interfaces over unresolved
 
1309
            if j.resolved:
 
1310
                assert i.iid == j.iid or i.iid == Interface.UNRESOLVED_IID
 
1311
                # keep j
 
1312
                return Result.KeepSecond
 
1313
            else:
 
1314
                assert i.iid == j.iid or j.iid == Interface.UNRESOLVED_IID
 
1315
                # replace j with i
 
1316
                return Result.KeepFirst
 
1317
        elif i.iid != j.iid:
 
1318
            # Prefer unresolved interfaces with valid IIDs
 
1319
            if j.iid == Interface.UNRESOLVED_IID:
 
1320
                # replace j with i
 
1321
                assert not j.resolved
 
1322
                return Result.KeepFirst
 
1323
            elif i.iid == Interface.UNRESOLVED_IID:
 
1324
                # keep j
 
1325
                assert not i.resolved
 
1326
                return Result.KeepSecond
 
1327
            else:
 
1328
                # Same name but different IIDs: raise an exception.
 
1329
                raise DataError, \
 
1330
                    "Typelibs contain definitions of interface %s" \
 
1331
                                " with different IIDs (%s (%s) vs %s (%s))!" % \
 
1332
                                (i.name, i.iid, i.xpt_filename, \
 
1333
                                 j.iid, j.xpt_filename)
 
1334
        raise DataError, "No idea what happened here: %s:%s (%s), %s:%s (%s)" % \
 
1335
            (i.name, i.iid, i.xpt_filename, j.name, j.iid, j.xpt_filename)
 
1336
    
 
1337
    # Compare interfaces pairwise to find duplicates that should be merged.
 
1338
    i = 1
 
1339
    while i < len(interfaces):
 
1340
        res = compare(interfaces[i-1], interfaces[i])
 
1341
        if res == Result.NotEqual:
 
1342
            i += 1
 
1343
        elif res == Result.Equal:
 
1344
            # Need to drop one but it doesn't matter which
 
1345
            del interfaces[i]
 
1346
        elif res == Result.KeepFirst:
 
1347
            merged_interfaces[interfaces[i]] = interfaces[i-1]
 
1348
            del interfaces[i]
 
1349
        elif res == Result.KeepSecond:
 
1350
            merged_interfaces[interfaces[i-1]] = interfaces[i]
 
1351
            del interfaces[i-1]
 
1352
    
 
1353
    # Now fixup any merged interfaces
 
1354
    def checkType(t):
 
1355
        if isinstance(t, InterfaceType) and t.iface in merged_interfaces:
 
1356
            t.iface = merged_interfaces[t.iface]
 
1357
        elif isinstance(t, ArrayType) and \
 
1358
             isinstance(t.element_type, InterfaceType) and \
 
1359
             t.element_type.iface in merged_interfaces:
 
1360
            t.element_type.iface = merged_interfaces[t.element_type.iface]
 
1361
 
 
1362
    for i in interfaces:
 
1363
        # Replace parent references
 
1364
        if i.parent in merged_interfaces:
 
1365
            i.parent = merged_interfaces[i.parent]
 
1366
        for m in i.methods:
 
1367
            # Replace InterfaceType params and return values
 
1368
            checkType(m.result.type)
 
1369
            for p in m.params:
 
1370
                checkType(p.type)
 
1371
    # Re-sort interfaces (by IID)
 
1372
    interfaces.sort()
 
1373
    return Typelib(interfaces=interfaces)
 
1374
 
 
1375
if __name__ == '__main__':
 
1376
    if len(sys.argv) < 3:
 
1377
        print >>sys.stderr, "xpt <dump|link> <files>"
 
1378
        sys.exit(1)
 
1379
    if sys.argv[1] == 'dump':
 
1380
        xpt_dump(sys.argv[2])
 
1381
    elif sys.argv[1] == 'link':
 
1382
        xpt_link(sys.argv[3:]).write(sys.argv[2])
 
1383