idl-parser 0.3.2__tar.gz → 0.4.1__tar.gz

{idl_parser-0.3.2/idl_parser.egg-info → idl_parser-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idl_parser
-Version: 0.3.2
+Version: 0.4.1
 Summary: Very simple OMG IDL (Interface Definition Language) parser. This parses IDL files and outputs intermediate class objects.
 Author-email: ysuga <ysuga@ysuga.net>
 License-Expression: GPL-3.0-or-later

{idl_parser-0.3.2 → idl_parser-0.4.1}/README.md

@@ -81,6 +81,7 @@ More examples are in the [examples](examples/) folder:
 | [`enum_example.py`](examples/enum_example.py) | enums and their values |
 | [`union_example.py`](examples/union_example.py) | unions: discriminator kinds, case and `default` labels, member types |
 | [`annotation_example.py`](examples/annotation_example.py) | IDL 4 annotations (`@key`, `@range`, ...) and struct keys |
+| [`valuetype_example.py`](examples/valuetype_example.py) | value types and event types: state members, `factory`, inheritance, `supports`, boxed value types |
 | [`scoped_name_example.py`](examples/scoped_name_example.py) | same-named types in several modules: relative (`X`, `C::X`) and absolute (`::B::X`) names |
 
 Run them with e.g. `python examples/union_example.py` (in a source checkout no install is needed).

{idl_parser-0.3.2 → idl_parser-0.4.1}/docs/api/index.rst

@@ -8,6 +8,7 @@ API Reference
    idl_parser.parser
    idl_parser.module
    idl_parser.interface
+   idl_parser.valuetype
    idl_parser.struct
    idl_parser.enum
    idl_parser.bitmask
@@ -15,6 +16,8 @@ API Reference
    idl_parser.union
    idl_parser.typedef
    idl_parser.const
+   idl_parser.native
+   idl_parser.definitions
    idl_parser.pragma
    idl_parser.type
    idl_parser.node

idl_parser-0.4.1/examples/valuetype_example.py

@@ -0,0 +1,149 @@
+"""Example: read IDL value types (``valuetype``) and event types (``eventtype``).
+
+Shows how to get
+- the state members of a value type, with ``public`` / ``private``,
+- its initializers (``factory``), operations and attributes,
+- base value types (``: truncatable B``) and supported interfaces (``supports I``),
+- the ``abstract`` / ``custom`` modifiers,
+- a boxed value type (``valuetype V long;``) and the type it wraps,
+- an event type, read the same way as a value type,
+- value types and event types used as member and argument types,
+- a value type as a plain dict (``to_dic``).
+
+Run::
+
+    python examples/valuetype_example.py
+"""
+import json
+
+import _path  # noqa: F401  (use the idl_parser of this checkout)
+
+from idl_parser import parser
+
+IDL = '''
+module sensors {
+  exception InvalidRange { string reason; };
+
+  interface Resettable {
+    void reset();
+  };
+
+  // An abstract value type has operations only (no state).
+  abstract valuetype Describable {
+    string describe();
+  };
+
+  valuetype Reading : Describable {
+    public double value;
+    public string unit;
+    private long long raw;
+    factory create(in double value, in string unit) raises (InvalidRange);
+    double scaled(in double factor);
+    readonly attribute boolean valid;
+  };
+
+  // Inherits Reading; "truncatable" lets a receiver that does not know
+  // RangedReading use it as a Reading.
+  valuetype RangedReading : truncatable Reading supports Resettable {
+    public double min, max;
+  };
+
+  // A custom value type marshals itself.
+  custom valuetype Calibration {
+    public sequence<double> coefficients;
+  };
+
+  // A value type can refer to itself (a linked list).
+  valuetype ReadingNode {
+    public Reading item;
+    public ReadingNode next;
+  };
+
+  // Boxed value types wrap a single type; the value may be null.
+  valuetype OptionalName string;
+  valuetype OptionalValues sequence<double>;
+
+  // An event type has the same form as a value type.
+  eventtype Alarm {
+    public string message;
+    public long level;
+  };
+  eventtype CriticalAlarm : Alarm { };
+
+  struct Snapshot {
+    Reading latest;
+    OptionalName label;
+  };
+
+  interface Monitor {
+    Reading read();
+    void notify(in Alarm alarm);
+  };
+};
+'''
+
+
+def print_valuetype(v):
+    modifiers = [m for m in ('abstract', 'custom') if getattr(v, 'is_' + m)]
+    kind = 'eventtype' if v.is_eventtype else 'valuetype'
+    print(' '.join(modifiers + [kind, v.full_path]))
+    if v.is_boxed:
+        print('  boxed type:', v.boxed_type.name)
+        return
+    if v.inheritances:
+        print('  inherits: %s%s' % ('truncatable ' if v.is_truncatable else '',
+                                    ', '.join(b.full_path for b in v.inheritances)))
+    if v.supports:
+        print('  supports:', ', '.join(i.full_path for i in v.supports))
+    for m in v.state_members:
+        print('  %s %s %s' % (m.visibility, m.type, m.name))
+    for f in v.factories:
+        params = ', '.join(a.to_simple_dic() for a in f.arguments)
+        print('  factory %s(%s) raises %s' % (f.name, params, f.raises))
+    for op in v.methods:
+        params = ', '.join(a.to_simple_dic() for a in op.arguments)
+        print('  operation %s %s(%s)' % (op.returns.name, op.name, params))
+    for a in v.attributes:
+        print('  %sattribute %s %s' % ('readonly ' if a.readonly else '', a.type, a.name))
+
+
+def main():
+    global_module = parser.IDLParser().load(IDL)
+    sensors = global_module.module_by_name('sensors')
+
+    # All value types and event types in a module
+    print('valuetypes in module sensors:', [v.name for v in sensors.valuetypes])
+    print('eventtypes in module sensors:', [e.name for e in sensors.eventtypes])
+    print()
+
+    for v in sensors.valuetypes + sensors.eventtypes:
+        print_valuetype(v)
+        print()
+
+    # Look up by name; the exceptions of a factory are resolved like those of an operation.
+    reading = sensors.valuetype_by_name('Reading')
+    create = reading.factory_by_name('create')
+    print('Reading.create raises:', [x.full_path for x in create.exceptions])
+    print('Reading.raw is public:', reading.state_member_by_name('raw').is_public)
+
+    # A self-referencing member resolves to the value type itself.
+    node = sensors.valuetype_by_name('ReadingNode')
+    print('ReadingNode.next type is ReadingNode:', node.state_member_by_name('next').type is node)
+    print()
+
+    # Value types and event types can be member, return and argument types.
+    snapshot = sensors.struct_by_name('Snapshot')
+    for m in snapshot.members:
+        print('Snapshot.%s: %s %s' % (m.name, m.type.classname, m.type.full_path))
+    monitor = sensors.interface_by_name('Monitor')
+    print('Monitor.read returns:', monitor.method_by_name('read').returns.obj.full_path)
+    alarm = monitor.method_by_name('notify').argument_by_name('alarm')
+    print('Monitor.notify(alarm) is an eventtype:', alarm.type.obj.is_eventtype)
+    print()
+
+    # The whole value type as a dict (handy for JSON or code generators)
+    print(json.dumps(sensors.valuetype_by_name('RangedReading').to_dic(), indent=2))
+
+
+if __name__ == '__main__':
+    main()

{idl_parser-0.3.2 → idl_parser-0.4.1}/idl_parser/bitset.py

@@ -245,13 +245,11 @@ class IDLBitset(node.IDLNode):
         return candidates
 
     def _find_base(self, name, ln, fn):
+        from .module import definition_scopes
         bitsets = {}
-        def collect(m):
+        for m in definition_scopes(self.root_node, self):
             for b in m.bitsets:
                 bitsets[b.full_path.lstrip(':')] = b
-            for sub in m.modules:
-                collect(sub)
-        collect(self.root_node)
         for c in self._scopes(name):
             if c in bitsets:
                 return bitsets[c]
@@ -259,13 +257,11 @@ class IDLBitset(node.IDLNode):
             ln, fn, 'Can not find "%s" bitset which is the base of "%s"' % (name, self.name))
 
     def _find_const(self, name):
+        from .module import definition_scopes
         consts = {}
-        def collect(m):
+        for m in definition_scopes(self.root_node, self):
             for c in m.consts:
                 consts[(m.full_path.lstrip(':') + sep + c.name).lstrip(':')] = c
-            for sub in m.modules:
-                collect(sub)
-        collect(self.root_node)
         for c in self._scopes(name):
             if c in consts:
                 return consts[c]

idl_parser-0.4.1/idl_parser/definitions.py

@@ -0,0 +1,416 @@
+"""Type and constant definitions shared by modules and interfaces.
+
+A ``module`` and an ``interface`` can both hold ``struct``, ``union``,
+``enum``, ``typedef``, ``const``, ``exception``, ``native``, ``bitmask`` and
+``bitset`` definitions (issue #101). :class:`IDLDefinitionScope` keeps them
+and parses them for both.
+"""
+import sys
+
+from . import node
+from . import struct, typedef, enum, const, union, bitmask, bitset, native
+from .exception import InvalidIDLSyntaxError
+
+# Keywords that start a definition handled by IDLDefinitionScope.parse_definition().
+definition_keywords = ('typedef', 'struct', 'exception', 'enum', 'bitmask',
+                       'bitset', 'union', 'native', 'const')
+
+
+class IDLDefinitionScope(object):
+    """Mixin for a scope that holds type and constant definitions.
+
+    Used by :class:`~idl_parser.module.IDLModule` and
+    :class:`~idl_parser.interface.IDLInterface`.
+    """
+
+    def _init_definitions(self):
+        self._typedefs = []
+        self._structs = []
+        self._forward_structs = []
+        self._exceptions = []
+        self._enums = []
+        self._bitmasks = []
+        self._bitsets = []
+        self._unions = []
+        self._forward_unions = []
+        self._consts = []
+        self._natives = []
+
+    def parse_definition(self, token, token_buf, filepath=None, annotations=()):
+        """Parse a definition whose keyword ``token`` is already consumed.
+
+        :param token: The keyword (one of :data:`definition_keywords`).
+        :param token_buf: :class:`~idl_parser.token_buffer.TokenBuffer` to read from.
+        :param filepath: File name recorded in the parsed nodes.
+        :param annotations: Annotations written before the keyword.
+        :return: False if ``token`` does not start a definition (nothing is read).
+        :raises ~idl_parser.exception.InvalidIDLSyntaxError: The definition is
+            not valid IDL.
+        """
+        pending_annotations = list(annotations)
+        if token == 'typedef':
+            blocks = []
+            while True:
+                ln, fn, t = token_buf.pop()
+                if t == None:
+                    raise InvalidIDLSyntaxError()
+                elif t == ';':
+                    break
+                else:
+                    blocks.append(t)
+            t = typedef.IDLTypedef(self)
+            anns, blocks = node.parse_annotations(blocks)
+            t._add_annotations(pending_annotations + anns)
+            t.parse_blocks(blocks, filepath=filepath)
+            t_ = self.typedef_by_name(t.name)
+            if t_:
+                if self._verbose: sys.stdout.write('# Error. Same Typedef Defined (%s)\n' % t.name)
+            else:
+                self._typedefs.append(t)
+
+        elif token == 'struct':
+            ln, fn, name_ = token_buf.pop()
+            s_ = self.struct_by_name(name_)
+            s = struct.IDLStruct(name_, self)
+            s._add_annotations(pending_annotations)
+            s.parse_tokens(token_buf, filepath=filepath)
+            if s.is_forward:
+                # Forward declaration ("struct A;"): remember the name only.
+                # The definition, if any, is added to structs when it appears.
+                if name_ not in self._forward_structs:
+                    self._forward_structs.append(name_)
+            elif s_:
+                if self._verbose: sys.stdout.write('# Error. Same Struct Defined (%s)\n' % name_)
+            #    raise InvalidIDLSyntaxError
+            else:
+                self._structs.append(s)
+
+        elif token == 'exception':
+            ln, fn, name_ = token_buf.pop()
+            s = struct.IDLException(name_, self)
+            s._add_annotations(pending_annotations)
+            s.parse_tokens(token_buf, filepath=filepath)
+            if self.exception_by_name(name_):
+                if self._verbose: sys.stdout.write('# Error. Same Exception Defined (%s)\n' % name_)
+            else:
+                self._exceptions.append(s)
+
+        elif token == 'enum':
+            ln, fn, name_ = token_buf.pop()
+            s = enum.IDLEnum(name_, self)
+            s._add_annotations(pending_annotations)
+            s.parse_tokens(token_buf, filepath)
+            s_ = self.enum_by_name(name_)
+            if s_:
+                if self._verbose: sys.stdout.write('# Error. Same Enum Defined (%s)\n' % name_)
+            #    raise InvalidIDLSyntaxError
+            else:
+                self._enums.append(s)
+
+        elif token == 'bitmask':
+            ln, fn, name_ = token_buf.pop()
+            s = bitmask.IDLBitmask(name_, self, pending_annotations)
+            s.parse_tokens(token_buf, filepath)
+            if self.bitmask_by_name(name_):
+                if self._verbose: sys.stdout.write('# Error. Same Bitmask Defined (%s)\n' % name_)
+            else:
+                self._bitmasks.append(s)
+
+        elif token == 'bitset':
+            ln, fn, name_ = token_buf.pop()
+            s = bitset.IDLBitset(name_, self)
+            s._add_annotations(pending_annotations)
+            s.parse_tokens(token_buf, filepath)
+            if self.bitset_by_name(name_):
+                if self._verbose: sys.stdout.write('# Error. Same Bitset Defined (%s)\n' % name_)
+            else:
+                self._bitsets.append(s)
+
+        elif token == 'union':
+            ln, fn, name_ = token_buf.pop()
+            s = union.IDLUnion(name_, self)
+            s._add_annotations(pending_annotations)
+            s.parse_tokens(token_buf, filepath)
+            if s.is_forward:
+                # Forward declaration ("union A;"): remember the name only.
+                if name_ not in self._forward_unions:
+                    self._forward_unions.append(name_)
+            elif self.union_by_name(name_):
+                if self._verbose: sys.stdout.write('# Error. Same Union Defined (%s)\n' % name_)
+            #    raise InvalidIDLSyntaxError
+            else:
+                self._unions.append(s)
+
+        elif token == 'native':
+            # "native N;": a type with a name only (issue #93).
+            ln, fn, name_ = token_buf.pop()
+            if name_ is None or name_ in (';', '{', '}'):
+                raise InvalidIDLSyntaxError(ln, fn, 'No name after "native"')
+            ln2, fn2, t = token_buf.pop()
+            if t != ';':
+                raise InvalidIDLSyntaxError(ln, fn, 'No ";" after "native %s"' % name_)
+            n = native.IDLNative(name_, self, filepath=filepath)
+            n._add_annotations(pending_annotations)
+            if self.native_by_name(name_):
+                if self._verbose: sys.stdout.write('# Error. Same Native Defined (%s)\n' % name_)
+            else:
+                self._natives.append(n)
+
+        elif token == 'const':
+            values = []
+            while True:
+                ln, fn, t = token_buf.pop()
+                if t is None:
+                    if self._verbose: sys.stdout.write('# Error. No ";" after const.\n')
+                    raise InvalidIDLSyntaxError(message='No ";" after const definition')
+                if t == ';':
+                    break
+                values.append(t)
+
+            # Split at '=': "<type> <name> = <value>" (issue #52).
+            # The value is every token after '=', so that an
+            # expression such as "1 + 2" is kept whole.
+            if '=' not in values:
+                raise InvalidIDLSyntaxError(ln, fn, 'No "=" in const definition "%s"' % ' '.join(values))
+            eq = values.index('=')
+            if eq < 2:
+                raise InvalidIDLSyntaxError(ln, fn, 'No type or name in const definition "%s"' % ' '.join(values))
+            if eq == len(values) - 1:
+                raise InvalidIDLSyntaxError(ln, fn, 'No value in const definition "%s"' % ' '.join(values))
+            value_ = ' '.join(values[eq+1:])
+            name_ = values[eq-1]
+            typename = ' '.join(values[:eq-1])
+            s = const.IDLConst(name_, typename, value_, self, filepath=filepath)
+            s._add_annotations(pending_annotations)
+            s_ = self.const_by_name(name_)
+            if s_:
+                if self._verbose: sys.stdout.write('# Error. Same Const Defined (%s)\n' % name_)
+            else:
+                self._consts.append(s)
+
+        else:
+            return False
+        return True
+
+    @property
+    def has_definitions(self):
+        """True if any type or constant is defined in this scope."""
+        return any((self._typedefs, self._structs, self._exceptions, self._enums,
+                    self._bitmasks, self._bitsets, self._unions, self._consts,
+                    self._natives))
+
+    @property
+    def structs(self):
+        """Structs defined directly in this scope (list of :class:`~idl_parser.struct.IDLStruct`)."""
+        return self._structs
+
+    def struct_by_name(self, name):
+        """The struct named ``name`` (not scoped) in this scope, or None."""
+        for s in self.structs:
+            if s.name == name:
+                return s
+        return None
+
+    @property
+    def forward_structs(self):
+        """Names of structs forward-declared ("struct A;") in this scope,
+        in declaration order, whether or not they are defined later."""
+        return list(self._forward_structs)
+
+    @property
+    def undefined_forward_structs(self):
+        """Forward-declared struct names that have no definition in this scope."""
+        return [n for n in self._forward_structs if self.struct_by_name(n) is None]
+
+    def for_each_struct(self, func, filter=None):
+        """Call ``func`` with each struct and return the results as a list.
+
+        :param filter: If given, only the structs for which ``filter(struct)`` is
+            true are passed to ``func``.
+        """
+        retval = []
+        for m in self.structs:
+            if filter:
+                if filter(m):
+                    retval.append(func(m))
+                pass
+            else:
+                retval.append(func(m))
+        return retval
+
+    @property
+    def exceptions(self):
+        """Exceptions defined directly in this scope (list of :class:`~idl_parser.struct.IDLException`)."""
+        return self._exceptions
+
+    def exception_by_name(self, name):
+        """The exception named ``name`` (not scoped) in this scope, or None."""
+        for x in self.exceptions:
+            if x.name == name:
+                return x
+        return None
+
+    def for_each_exception(self, func):
+        """Call ``func`` with each exception and return the results as a list."""
+        return [func(x) for x in self.exceptions]
+
+    @property
+    def enums(self):
+        """Enums defined directly in this scope (list of :class:`~idl_parser.enum.IDLEnum`)."""
+        return self._enums
+
+    def enum_by_name(self, name):
+        """The enum named ``name`` (not scoped) in this scope, or None."""
+        for e in self.enums:
+            if e.name == name:
+                return e
+        return None
+
+    def for_each_enum(self, func):
+        """Call ``func`` with each enum and return the results as a list."""
+        retval = []
+        for m in self.enums:
+            retval.append(func(m))
+        return retval
+
+    @property
+    def bitmasks(self):
+        """Bitmasks defined directly in this scope (list of :class:`~idl_parser.bitmask.IDLBitmask`)."""
+        return self._bitmasks
+
+    def bitmask_by_name(self, name):
+        """The bitmask named ``name`` (not scoped) in this scope, or None."""
+        for b in self.bitmasks:
+            if b.name == name:
+                return b
+        return None
+
+    def for_each_bitmask(self, func):
+        """Call ``func`` with each bitmask and return the results as a list."""
+        return [func(b) for b in self.bitmasks]
+
+    @property
+    def bitsets(self):
+        """Bitsets defined directly in this scope (list of :class:`~idl_parser.bitset.IDLBitset`)."""
+        return self._bitsets
+
+    def bitset_by_name(self, name):
+        """The bitset named ``name`` (not scoped) in this scope, or None."""
+        for b in self.bitsets:
+            if b.name == name:
+                return b
+        return None
+
+    def for_each_bitset(self, func):
+        """Call ``func`` with each bitset and return the results as a list."""
+        return [func(b) for b in self.bitsets]
+
+    @property
+    def unions(self):
+        """Unions defined directly in this scope (list of :class:`~idl_parser.union.IDLUnion`)."""
+        return self._unions
+
+    def union_by_name(self, name):
+        """The union named ``name`` (not scoped) in this scope, or None."""
+        for u in self.unions:
+            if u.name == name:
+                return u
+        return None
+
+    @property
+    def forward_unions(self):
+        """Names of unions forward-declared ("union A;") in this scope,
+        in declaration order, whether or not they are defined later."""
+        return list(self._forward_unions)
+
+    @property
+    def undefined_forward_unions(self):
+        """Forward-declared union names that have no definition in this scope."""
+        return [n for n in self._forward_unions if self.union_by_name(n) is None]
+
+    def for_each_union(self, func):
+        """Call ``func`` with each union and return the results as a list."""
+        retval = []
+        for m in self.unions:
+            retval.append(func(m))
+        return retval
+
+    @property
+    def consts(self):
+        """Constants defined directly in this scope (list of :class:`~idl_parser.const.IDLConst`)."""
+        return self._consts
+
+    def const_by_name(self, name):
+        """The constant named ``name`` (not scoped) in this scope, or None."""
+        for c in self.consts:
+            if c.name == name:
+                return c
+        return None
+
+    def for_each_const(self, func):
+        """Call ``func`` with each constant and return the results as a list."""
+        retval = []
+        for m in self.consts:
+            retval.append(func(m))
+        return retval
+
+    @property
+    def natives(self):
+        """Native types declared directly in this scope (list of :class:`~idl_parser.native.IDLNative`)."""
+        return self._natives
+
+    def native_by_name(self, name):
+        """The native type named ``name`` (not scoped) in this scope, or None."""
+        for n in self.natives:
+            if n.name == name:
+                return n
+        return None
+
+    def for_each_native(self, func):
+        """Call ``func`` with each native type and return the results as a list."""
+        return [func(n) for n in self.natives]
+
+    @property
+    def typedefs(self):
+        """Typedefs defined directly in this scope (list of :class:`~idl_parser.typedef.IDLTypedef`)."""
+        return self._typedefs
+
+    def typedef_by_name(self, name):
+        """The typedef named ``name`` (not scoped) in this scope, or None."""
+        for t in self.typedefs:
+            if t.name == name:
+                return t
+        return None
+
+    def for_each_typedef(self, func):
+        """Call ``func`` with each typedef.
+
+        Unlike the other ``for_each_*`` methods, it returns None.
+        """
+        retval = []
+        for m in self.typedefs:
+            retval.append(func(m))
+
+    def _definitions_simple_dic(self, quiet=False):
+        """``to_simple_dic()`` of the definitions in this scope, grouped by kind."""
+        return ([s.to_simple_dic(quiet) for s in self.structs] +
+                [x.to_simple_dic(quiet) for x in self.exceptions] +
+                [e.to_simple_dic(quiet) for e in self.enums] +
+                [b.to_simple_dic(quiet) for b in self.bitmasks] +
+                [b.to_simple_dic(quiet) for b in self.bitsets] +
+                [u.to_simple_dic(quiet) for u in self.unions] +
+                [t.to_simple_dic(quiet) for t in self.typedefs] +
+                [n.to_simple_dic(quiet) for n in self.natives] +
+                [c.to_simple_dic(quiet) for c in self.consts])
+
+    def _definitions_dic(self):
+        """``to_dic()`` of the definitions in this scope, keyed by kind."""
+        return { 'typedefs' : [t.to_dic() for t in self.typedefs],
+                 'natives' : [n.to_dic() for n in self.natives],
+                 'structs' : [s.to_dic() for s in self.structs],
+                 'exceptions' : [x.to_dic() for x in self.exceptions],
+                 'enums' : [e.to_dic() for e in self.enums],
+                 'bitmasks' : [b.to_dic() for b in self.bitmasks],
+                 'bitsets' : [b.to_dic() for b in self.bitsets],
+                 'unions' : [u.to_dic() for u in self.unions],
+                 'consts' : [c.to_dic() for c in self.consts] }

{idl_parser-0.3.2 → idl_parser-0.4.1}/idl_parser/exception.py

@@ -54,7 +54,8 @@ class InvalidDataTypeException(IDLParserException):
     pass
 
 class IDLCanNotFindException(IDLParserException):
-    """An ``#include`` file or a base interface / bitset can not be found."""
+    """An ``#include`` file, a base interface / bitset or an exception in
+    ``raises (...)`` can not be found."""
     pass
 
 
@@ -63,18 +64,18 @@ class IDLParserWarning(UserWarning):
     pass
 
 class UnknownIDLSyntaxWarning(IDLParserWarning):
-    """A word that starts no known definition was found in a module or the
-    global scope (a misspelled keyword such as ``strcut``), and the definition
-    it starts was skipped (issue #76).
+    """No longer issued: an unknown word in a module or the global scope (a
+    misspelled keyword such as ``strcut``) is an :class:`InvalidIDLSyntaxError`
+    since 0.4.0 (issue #94).
 
-    This will become an :class:`InvalidIDLSyntaxError` in a future release.
-    To get the error now, turn the warning into an exception::
-
-        warnings.simplefilter('error', UnknownIDLSyntaxWarning)
+    It was issued from 0.3.2 (issue #76), and is kept so that code referring
+    to it (``warnings.simplefilter('error', UnknownIDLSyntaxWarning)``) still
+    works.
     """
     pass
 
 class UnsupportedIDLSyntaxWarning(IDLParserWarning):
     """A valid IDL definition that idl_parser does not support yet
-    (``exception``, ``valuetype``, ``component``, ...) was skipped (issue #76)."""
+    (``component``, ``home``, ...) was skipped (issue #76). ``valuetype``
+    and ``eventtype`` are parsed since issue #99."""
     pass