idl-parser 0.6.0__tar.gz → 0.6.2__tar.gz

{idl_parser-0.6.0 → idl_parser-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idl_parser
-Version: 0.6.0
+Version: 0.6.2
 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
@@ -112,6 +112,7 @@ More examples are in the ``examples`` folder of the repository:
 - ``typedef_template_module_example.py``: types declared inside a typedef (``typedef enum E { ... } EE;``), and template modules, which are skipped with a warning
 - ``union_example.py``: unions (discriminator kinds, case and ``default`` labels, member types)
 - ``annotation_example.py``: IDL 4 annotations (``@key``, ``@range``, ...) and struct keys
+- ``repository_id_example.py``: repository IDs (``IDL:omg.org/CosNaming/NamingContext:1.0``) from ``#pragma prefix`` / ``ID`` / ``version``, ``typeid`` and ``typeprefix``
 - ``scoped_name_example.py``: same-named types in several modules (relative ``X``, ``C::X`` and absolute ``::B::X`` names)
 
 https://github.com/sugarsweetrobotics/idl_parser/tree/main/examples

{idl_parser-0.6.0 → idl_parser-0.6.2}/README.md

@@ -90,6 +90,7 @@ More examples are in the [examples](examples/) folder:
 | [`valuetype_example.py`](examples/valuetype_example.py) | value types and event types: state members, `factory`, inheritance, `supports`, boxed value types |
 | [`include_dirs_example.py`](examples/include_dirs_example.py) | IDL files that `#include` each other across several include directories |
 | [`conditional_include_example.py`](examples/conditional_include_example.py) | `#include` in `#if` / `#elif` / `#else` branches: only the files of the kept branch are read |
+| [`repository_id_example.py`](examples/repository_id_example.py) | repository IDs (`IDL:omg.org/CosNaming/NamingContext:1.0`) from `#pragma prefix` / `ID` / `version`, `typeid` and `typeprefix` |
 | [`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.6.0 → idl_parser-0.6.2}/README.rst

@@ -89,6 +89,7 @@ More examples are in the ``examples`` folder of the repository:
 - ``typedef_template_module_example.py``: types declared inside a typedef (``typedef enum E { ... } EE;``), and template modules, which are skipped with a warning
 - ``union_example.py``: unions (discriminator kinds, case and ``default`` labels, member types)
 - ``annotation_example.py``: IDL 4 annotations (``@key``, ``@range``, ...) and struct keys
+- ``repository_id_example.py``: repository IDs (``IDL:omg.org/CosNaming/NamingContext:1.0``) from ``#pragma prefix`` / ``ID`` / ``version``, ``typeid`` and ``typeprefix``
 - ``scoped_name_example.py``: same-named types in several modules (relative ``X``, ``C::X`` and absolute ``::B::X`` names)
 
 https://github.com/sugarsweetrobotics/idl_parser/tree/main/examples

{idl_parser-0.6.0 → idl_parser-0.6.2}/docs/api/index.rst

@@ -21,6 +21,7 @@ API Reference
    idl_parser.definitions
    idl_parser.preprocessor
    idl_parser.pragma
+   idl_parser.repository_id
    idl_parser.type
    idl_parser.node
    idl_parser.token_buffer

idl_parser-0.6.2/examples/repository_id_example.py

@@ -0,0 +1,62 @@
+"""Example: repository IDs (``IDL:omg.org/CosNaming/NamingContext:1.0``).
+
+Shows that
+- each definition has ``repository_id``,
+- ``#pragma prefix`` adds a prefix to the definitions after it, up to the
+  end of its scope,
+- ``#pragma version`` changes the version, and ``#pragma ID`` / ``typeid``
+  give the whole ID,
+- ``typeprefix`` adds a prefix to a scope and everything in it.
+
+Run::
+
+    python examples/repository_id_example.py
+"""
+import _path  # noqa: F401  (use the idl_parser of this checkout)
+
+from idl_parser import parser
+
+IDL = '''
+#pragma prefix "omg.org"
+module CosNaming {
+  typedef string Istring;
+  interface NamingContext {
+    exception NotFound { long why; };
+    void unbind(in Istring n) raises (NotFound);
+  };
+#pragma version NamingContext 1.1
+};
+
+module Legacy {
+  struct Point { long x; long y; };
+  typeid Point "DCE:9e2f5c1a-0001:1";
+  struct Size { long w; long h; };
+};
+
+module Robot {
+  typeprefix Robot "example.com";
+  interface Arm { void move(in long x); };
+};
+'''
+
+
+def main():
+    g = parser.IDLParser().load(IDL)
+    naming = g.module_by_name('CosNaming')
+    nc = naming.interface_by_name('NamingContext')
+    legacy = g.module_by_name('Legacy')
+    arm = g.module_by_name('Robot').interface_by_name('Arm')
+    for node, label in [(naming, 'CosNaming'),
+                        (naming.typedef_by_name('Istring'), 'CosNaming::Istring'),
+                        (nc, 'CosNaming::NamingContext'),
+                        (nc.exceptions[0], 'CosNaming::NamingContext::NotFound'),
+                        (nc.method_by_name('unbind'), 'CosNaming::NamingContext::unbind'),
+                        (legacy.struct_by_name('Point'), 'Legacy::Point'),
+                        (legacy.struct_by_name('Size'), 'Legacy::Size'),
+                        (arm, 'Robot::Arm'),
+                        (arm.method_by_name('move'), 'Robot::Arm::move')]:
+        print('%-36s %s' % (label, node.repository_id))
+
+
+if __name__ == '__main__':
+    main()

{idl_parser-0.6.0 → idl_parser-0.6.2}/examples/union_example.py

@@ -29,7 +29,7 @@ module shapes {
 
   typedef sequence<Point2D> PointSeq;
 
-  struct Rectangle {
+  struct Rect {
     Point2D top_left;
     double width;
     double height;
@@ -40,7 +40,7 @@ module shapes {
     case CIRCLE:
       double radius;
     case RECTANGLE:
-      Rectangle rect;
+      Rect rect;
     case POLYGON:
       PointSeq vertices;
     case POINT:

{idl_parser-0.6.0 → idl_parser-0.6.2}/idl_parser/bitmask.py

@@ -107,7 +107,7 @@ class IDLBitmask(node.IDLNode):
     def value_by_name(self, name):
         """The value named ``name`` (an :class:`IDLBitValue`), or None."""
         for v in self._values:
-            if v.name == name:
+            if v.name == node.unescape(name):
                 return v
         return None
 
@@ -198,4 +198,5 @@ class IDLBitmask(node.IDLNode):
         v._filepath = self.filepath
         v._add_annotations(annotations)
         self._values.append(v)
+        node.check_unique_names([b.name for b in self._values], 'bitmask "%s"' % self.name, ln, fn)
 

{idl_parser-0.6.0 → idl_parser-0.6.2}/idl_parser/bitset.py

@@ -137,7 +137,7 @@ class IDLBitset(node.IDLNode):
     def bitfield_by_name(self, name):
         """The named bitfield ``name`` (an :class:`IDLBitfield`; the base bitset is searched too), or None."""
         for b in self.members:
-            if b.name == name:
+            if b.name == node.unescape(name):
                 return b
         return None
 
@@ -229,6 +229,14 @@ class IDLBitset(node.IDLNode):
             self._bitfields.append(b)
             self._own_bits += bits
 
+        # Bitfield names are unique, also with the base bitfields, and
+        # ignoring case (issue #143); unnamed bitfields have no name
+        names, b = [], self
+        while b is not None:
+            names = [f.name for f in b.bitfields] + names
+            b = b._base
+        node.check_unique_names([n for n in names if n], 'bitset "%s"' % self.name, ln, fn)
+
         if self.bit_size > MAX_BITS:
             raise exception.InvalidIDLSyntaxError(
                 ln, fn, 'Bitset "%s" has %d bits (must be %d or less)' % (self.name, self.bit_size, MAX_BITS))

idl_parser-0.6.2/idl_parser/const.py

@@ -0,0 +1,271 @@
+"""IDL constants."""
+import decimal
+import os, sys, traceback
+
+from . import node
+from . import const_expr
+from . import type as idl_type
+from .token_buffer import split_tokens
+from .exception import InvalidConstExpressionError
+sep = '::'
+
+# Floating-point types and the largest finite value of each (issue #137)
+_float_types = {'float': 3.4028234663852886e38, 'double': None, 'long double': None}
+
+
+class IDLConst(node.IDLNode):
+    """A ``const`` definition, such as ``const long MAX = 10;``.
+
+    :param name: Constant name.
+    :param typename: Type name as written (``'long'``, ``'string'``, ...).
+    :param value: Value as written, which may be an expression (``'1 + 2'``).
+        The value of a constant of an integer type is evaluated
+        (:attr:`value`, issue #130).
+    :param parent: Enclosing :class:`~idl_parser.module.IDLModule`.
+    :param filepath: File the constant was defined in.
+    """
+    def __init__(self, name, typename, value, parent, filepath=None):
+        super(IDLConst, self).__init__('IDLConst', name, parent)
+        self._typename = typename
+        self._verbose = True
+        self._value = value
+        self._filepath= filepath
+        self._int_value = None
+        self._typed_value = None
+        self._evaluated = False
+        self._base_type = None
+
+    def _evaluate(self, line_number=None, file_name=None):
+        """Evaluate the value with the type of the constant (issues #130, #137).
+
+        :raises ~idl_parser.exception.InvalidConstExpressionError: The value
+            is not a valid value of the type, or is out of its range.
+        """
+        base = self._resolve_base_type()
+        self._base_type = base
+        if base is None:
+            return  # a type that has no values (or is not defined)
+        def error(reason):
+            return InvalidConstExpressionError(
+                line_number, file_name, 'Invalid value "%s" of const "%s": %s'
+                % (self._value, self.name, reason))
+        try:
+            value = self._evaluate_as(base, error)
+        except const_expr.ConstExprError as e:
+            raise error(e)
+        self._typed_value = value
+        self._evaluated = True
+        if base in const_expr.integer_types:
+            self._int_value = value
+
+    def _resolve_base_type(self):
+        """The type the constant's type stands for, typedefs followed: a
+        primitive type name (``'long'``, ``'double'``, ``'string'``, ...),
+        ``'fixed'``, or an :class:`~idl_parser.enum.IDLEnum`. None for any
+        other type."""
+        name = ' '.join(self.typename.split())
+        scope = self.parent
+        self._string_bound = None
+        for _ in range(32):  # a typedef of a typedef of ...
+            if name in const_expr.integer_types or name in _float_types or \
+                    name in ('char', 'wchar', 'boolean', 'string', 'wstring'):
+                return name
+            bounded = idl_type.parse_bounded_string(name)
+            if bounded is not None:
+                self._string_bound = const_expr.evaluate_positive(
+                    bounded[1], scope, 'bound of "%s"' % name)
+                return bounded[0]
+            if name == 'fixed' or idl_type.parse_fixed(name) is not None:
+                return 'fixed'
+            typs = self.root_node.find_types(name, scope=scope)
+            if not typs:
+                return None
+            if typs[0].is_enum:
+                return typs[0]
+            if not typs[0].is_typedef:
+                return None
+            scope = typs[0].parent
+            name = ' '.join(str(typs[0].type).split())
+        return None
+
+    def _evaluate_as(self, base, error):
+        """The value of the constant for the type ``base`` (see
+        :meth:`_resolve_base_type`)."""
+        text = self._value
+        if not isinstance(base, str):  # an enum
+            value = base.find_enumerator(text)
+            if value is None:
+                value = self._const_of(text, lambda v: getattr(v, 'parent', None) is base)
+            if value is None:
+                raise error('not an enumerator of %s' % base.full_path.lstrip(':'))
+            return value
+        if base in const_expr.integer_types:
+            value = const_expr.evaluate(text, self.parent)
+            low, high = const_expr.integer_ranges[base]
+            if not low <= value <= high:
+                raise error('%d is out of the range of %s' % (value, base))
+            return value
+        if base in _float_types:
+            value = const_expr.evaluate_real(text, self.parent, 'float')
+            limit = _float_types[base]
+            if value != value or value in (float('inf'), float('-inf')) or \
+                    (limit is not None and abs(value) > limit):
+                raise error('%r is out of the range of %s' % (value, base))
+            return value
+        if base == 'fixed':
+            value = const_expr.evaluate_real(text, self.parent, 'fixed')
+            if len(value.as_tuple().digits) > 31:
+                raise error('a fixed-point value has at most 31 digits')
+            return value
+        if base == 'boolean':
+            value = const_expr.parse_boolean_literal(text)
+            if value is None:
+                value = self._const_of(text, lambda v: isinstance(v, bool))
+            if value is None:
+                raise error('not TRUE or FALSE')
+            return value
+        if base in ('char', 'wchar'):
+            value = const_expr.parse_char_literal(text, wide=base == 'wchar')
+            if value is None:
+                value = self._const_of(text, lambda v: isinstance(v, str) and len(v) == 1)
+            if value is None:
+                raise error('not a character literal')
+            if base == 'char' and ord(value) > 255:
+                raise error('%r is not a char' % value)
+            return value
+        # string / wstring: adjacent literals are joined ("a" "b" -> "ab")
+        parts = []
+        for token in split_tokens(text):
+            literal = token[1:] if base == 'wstring' and token.startswith('L"') else token
+            if len(literal) >= 2 and literal[0] == '"' and literal[-1] == '"':
+                parts.append(const_expr.unescape(literal[1:-1]))
+                continue
+            value = self._const_of(token, lambda v: isinstance(v, str))
+            if value is None:
+                raise error('not a string literal')
+            parts.append(value)
+        value = ''.join(parts)
+        if base == 'string' and any(ord(c) > 255 for c in value):
+            raise error('a string holds only 8-bit characters; use wstring')
+        if self._string_bound is not None and len(value) > self._string_bound:
+            raise error('%d characters are more than the bound %d' % (len(value), self._string_bound))
+        return value
+
+    def _const_of(self, name, accept):
+        """The value of the constant named ``name`` if ``accept(value)``,
+        otherwise None."""
+        try:
+            c = const_expr.find_const(name, self.parent)
+        except Exception:
+            return None
+        if c is None or c is self or not c._evaluated or not accept(c._typed_value):
+            return None
+        return c._typed_value
+
+    @property
+    def is_integer(self):
+        """True if the type is an integer type (``long``, ``unsigned short``,
+        ``int32``, ``octet``, ..., or a typedef of one)."""
+        return self._base_type in const_expr.integer_types
+
+    @property
+    def int_value(self):
+        """The value of a constant of an integer type as an int
+        (``const long M = N * 2;`` -> ``6`` when ``N`` is 3), otherwise None."""
+        return self._int_value
+
+    def to_simple_dic(self, quiet=False, full_path=False, recursive=False, member_only=False):
+        """A compact summary: ``{'const NAME': {'type': ..., 'value': ...}}``.
+
+        :param quiet: Return ``'const TYPE NAME = VALUE'`` instead.
+        :param full_path: Use :attr:`full_path` as the name.
+        """
+        name = self.full_path if full_path else self.name
+        if quiet:
+            value = self._plain_value()
+            if isinstance(value, str) or not self._evaluated:
+                value = self.value_string  # keep the quotes of a literal
+            return 'const %s %s = %s' % (self.typename, name, value)
+        dic = { 'const %s' % name : { 'type' : self.typename,
+                                      'value' : self._plain_value() } }
+        return dic
+
+    def to_dic(self):
+        """The constant as a plain dict (for JSON or YAML output).
+
+        ``'value'`` is :attr:`value`, except that a fixed-point value is a
+        string (``'1.25'``) and an enumerator its scoped name (``'M::RED'``).
+        """
+        dic = { 'name' : self.name,
+                'filepath' : self.filepath,
+                'classname' : self.classname,
+                'typename' : self.typename,
+                'value' : self._plain_value() }
+        return self._with_annotations(dic)
+
+    def _plain_value(self):
+        """:attr:`value` as a str, int, float or bool (for JSON)."""
+        value = self.value
+        if isinstance(value, decimal.Decimal):
+            return str(value)
+        if isinstance(value, node.IDLNode):
+            return value.full_path.lstrip(':')
+        return value
+
+    @property
+    def typename(self):
+        """Type name as written."""
+        return self._typename
+
+    @property
+    def type(self):
+        """The type of the constant, looked up from the scope of the constant.
+
+        For ``const fixed F = 1.25d;`` it is an
+        :class:`~idl_parser.type.IDLFixed` whose digits and scale are those
+        of the value (``fixed<3, 2>``, issue #137).
+        """
+        if ' '.join(self.typename.split()) == 'fixed':
+            digits, scale = _fixed_digits(self.value) if self._evaluated else (1, 0)
+            return idl_type.IDLFixed(idl_type.fixed_name(digits, scale), self)
+        return self.root_node.find_types(self.typename, scope=self)[0]
+
+    @property
+    def value(self):
+        """Value of the constant, evaluated with its type (issues #130, #137):
+
+        - integer types: an int (``const long X = 1 + 2;`` -> ``3``)
+        - ``float`` / ``double`` / ``long double``: a float
+          (``const double D = 1.0 / 4;`` -> ``0.25``)
+        - ``fixed``: a :class:`decimal.Decimal` (``1.25d`` -> ``Decimal('1.25')``)
+        - ``string`` / ``wstring``: a str without the quotes, escapes
+          replaced and adjacent literals joined (``"a" "b"`` -> ``'ab'``)
+        - ``char`` / ``wchar``: a str of one character
+        - ``boolean``: a bool
+        - an enum: the :class:`~idl_parser.enum.IDLEnumValue`
+
+        Typedefs of these types are followed, and the names of other
+        constants can be used. For other types the value is the text as
+        written (see :attr:`value_string`).
+        """
+        if self._evaluated:
+            return self._typed_value
+        return self._value
+
+    @property
+    def value_string(self):
+        """Value as written (a string; ``'1 + 2'`` is kept whole)."""
+        return self._value
+
+    @property
+    def full_path(self):
+        """Scoped name (``'M::MAX'``; ``'::MAX'`` at the global scope)."""
+        return self.parent.full_path + sep + self.name
+
+
+def _fixed_digits(value):
+    """(digits, scale) of a fixed-point value: ``Decimal('1.25')`` -> ``(3, 2)``."""
+    t = value.as_tuple()
+    scale = max(0, -t.exponent)
+    digits = len(t.digits) + max(0, t.exponent)
+    return max(digits, scale, 1), scale