�
)/�Uc�����������@@��s���d��Z��d�d�l�m�Z�d�d�l�Z�d�d�l�Z�d�d�l�m�Z�d�d�l�m�Z�m	�Z	�m
�Z
�d�d�l�m�Z�m�Z�d�d�l
�m�Z�m�Z�m�Z�d�Z�d�Z�d	�Z�d
�Z�d�Z�d�Z�d
�Z�d�Z�e�e�e�e�g�Z�d�Z�d�Z�e�e�g�Z�d�Z�d�Z�e�e�g�Z�d�Z �d�Z!�d�Z"�d�Z#�d�Z$�d�Z%�d�Z&�d�Z'�d�Z(�d�Z)�e �e!�e"�e#�e$�e%�e&�e'�e(�e)�g
�Z*�e�e�e�e*�Z+�d�Z,�d�Z-�d�Z.�d �Z/�d�Z0�d!�Z1�d"�Z2�d#�Z3�d$�Z4�d%�Z5�d&�Z6�d'�Z7�d(�Z8�d)�Z9�d*�Z:�d+�Z;�d,�Z<�d-�Z=�d.�Z>�d/�Z?�d0�Z@�d1�ZA�d�ZB�d�ZC�d2�ZD�d�ZE�d�ZF�e.�e:�e;�e/�e0�e1�e2�e3�e4�e5�e6�e7�e8�e9�e<�e=�e>�e?�e@�eA�eB�eC�eD�eE�eF�g�ZG�d3�ZH�d4�ZI�eH�eI�g�ZJ�eG�eJ�ZK�e/�e0�g�ZL�g��eK�D]�ZM�eM�eL�k�r�eM�^�q�ZN�d5�ZO�d6�ZP�d7�ZQ�eO�eP�eQ�g�ZR�d8�ZS�d9�ZT�eS�eT�g�ZU�d:�ZV�d;�ZW�d<�ZX�eV�eW�eX�g�ZY�d=�ZZ�d>�Z[�d?�Z\�d@�Z]�eZ�e[�e\�e]�g�Z^�e�j_�dA�e�j`���Za�e�j_�dB�e�j`�e�jb�B��Zc�e�j_�dC�e�j`�e�jb�B��Zd�e�j_�dD�e�j`�e�jb�B��Ze�e�j_�dE�e�j`�e�jb�B��Zf�e�j_�dF�e�j`�e�jb�B��Zg�e�j_�dG�e�j`�e�jb�B��Zh�e�j_�dH�e�j`�e�jb�B��Zi�e�j_�dI�e�j`�e�jb�B��Zj�e�j_�dJ�e�j`�e�jb�B��Zk�e�j_�dK�e�j`�e�jb�B��Zl�dL�jm�e+���jn�dM�dN���Zo�e�j_�dO�eo�dP�e�j`�e�jb�Be�jp�B��Zq�e�j_�dQ�e�j`�e�jb�B��Zr�e�j_�dR�e�j`�e�jb�Be�jp�B��Zs�dS�e�f�dT�������YZt�dU�eu�f�dV�������YZv�dW�ev�f�dX�������YZw�dY�ev�f�dZ�������YZx�d[�ev�f�d\�������YZy�e�d]�d^�d_�d`�da�g���Zz�e�d]�d^�d_�d�g���Z{�db�eu�f�dc�������YZ|�dd�eu�f�de�������YZ}�d�S(f���sp��
GTK-Doc comment block format
----------------------------

A GTK-Doc comment block is built out of multiple parts. Each part can be further
divided into fields which are separated by a colon ("``:``") delimiter.

Known parts and the fields they are constructed from look like the following
(optional fields are enclosed in square brackets)::

    ┌───────────────────────────────────────────────────────────┐
    │ /**                                                       │ ─▷ start token
    ├────────────────────┬──────────────────────────────────────┤
    │  * identifier_name │ [: annotations]                      │ ─▷ identifier part
    ├────────────────────┼─────────────────┬────────────────────┤
    │  * @parameter_name │ [: annotations] │ : description      │ ─▷ parameter part
    ├────────────────────┴─────────────────┴────────────────────┤
    │  *                                                        │ ─▷ comment block description
    │  * comment_block_description                              │
    ├─────────────┬─────────────────┬───────────┬───────────────┤
    │  * tag_name │ [: annotations] │ [: value] │ : description │ ─▷ tag part
    ├─────────────┴─────────────────┴───────────┴───────────────┤
    │  */                                                       │ ─▷ end token
    └───────────────────────────────────────────────────────────┘

There are two conditions that must be met before a comment block is recognized
as a GTK-Doc comment block:

#. The comment block is opened with a GTK-Doc start token ("``/**``")
#. The first line following the start token contains a valid identifier part

Once a GTK-Doc comment block has been identified as such and has been stripped
from its start and end tokens the remaining parts have to be written in a
specific order:

#. There must be exactly 1 `identifier` part on the first line of the
   comment block which consists of:

   * a required `identifier_name` field
   * an optional `annotations` field

#. Zero or more `parameter` parts, each consisting of:

   * a required `parameter_name` field
   * an optional `annotations` field
   * a required `description` field (can be the empty string)

#. One optional `comment block description` part which must begin with at
   least 1 empty line signaling the start of this part.

#. Zero or more `tag` parts, each consisting of:

   * a required `tag_name` field
   * an optional `annotations` field
   * an optional `value` field
   * a required `description` field (can be the empty string)

Additionally, the following restrictions are in effect:

#. Separating parts with an empty line:

   * `identifier` and `parameter` parts cannot be separated from each other by
     an empty line as this would signal the start of the
     `comment block description` part (see above).
   * it is required to separate the `comment block description` part from the
     `identifier` or `parameter` parts with an empty line (see above)
   * `comment block description` and `tag` parts can optionally be separated
     by an empty line

#. Parts and fields cannot span multiple lines, except for:

   * the `comment_block_description` part
   * `parameter description` and `tag description` fields

#. Taking the above restrictions into account, spanning multiple paragraphs is
   limited to the `comment block description` part and `tag description` fields.

Refer to the `GTK-Doc manual`_ for more detailed usage information.

.. _GTK-Doc manual:
        http://developer.gnome.org/gtk-doc-manual/1.18/documenting.html.en
i����(���t���absolute_importN(���t
���namedtuple(���t���net���gtt���lti���(���t���Countert���OrderedDict(���t���Positiont���warnt���errori���i���t
���deprecatedt���returnst���sincet	���stabilityt���descriptions���return valuet���returns
���returns valuet
���attributess���get value funcs���ref funcs	���rename tos���set value funct���transfert���types
���unref funct���valuet���virtualt���(t���)s
���allow-nonet���arrayt���closuret���constructort���destroys���element-typet���foreigns���get-value-funct���int���inoutt���methodt���nullablet���optionalt���outs���ref-funcs	���rename-tot���scopes���set-value-funct���skips
���unref-funct	���attributes���in-outs
���fixed-sizet���lengths���zero-terminateds���callee-allocatess���caller-allocatest���asynct���callt���notifiedt	���containert���floatingt���fullt���nones
���\r\n|\r|\nsV��
    ^                                                    # start
    (?P<code>.*?)                                        # whitespace, code, ...
    \s*                                                  # 0 or more whitespace characters
    (?P<token>/\*{2}(?![\*/]))                           # 1 forward slash character followed
                                                         #   by exactly 2 asterisk characters
                                                         #   and not followed by a slash character
    \s*                                                  # 0 or more whitespace characters
    (?P<comment>.*?)                                     # GTK-Doc comment text
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s���
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<comment>.*?)                                     # GTK-Doc comment text
    \s*                                                  # 0 or more whitespace characters
    (?P<token>\*+/)                                      # 1 or more asterisk characters followed
                                                         #   by exactly 1 forward slash character
    (?P<code>.*?)                                        # whitespace, code, ...
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s
��
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<comment>.*?)                                     # invalid comment text
    \s*                                                  # 0 or more whitespace characters
    \*                                                   # 1 asterisk character
    \s?                                                  # 0 or 1 whitespace characters
                                                         #   WARNING: removing more than 1
                                                         #   whitespace character breaks
                                                         #   embedded example program indentation
    ss���
    ^
    (?P<indentation>\s*)                                 # 0 or more whitespace characters
    .*
    $
    s����
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s0��
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    SECTION                                              # SECTION
    \s*                                                  # 0 or more whitespace characters
    (?P<delimiter>:?)                                    # delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<section_name>\w\S+?)                             # section name
    \s*                                                  # 0 or more whitespace characters
    :?                                                   # invalid delimiter
    \s*                                                  # 0 or more whitespace characters
    $
    sz��
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<symbol_name>[\w-]*\w)                            # symbol name
    \s*                                                  # 0 or more whitespace characters
    (?P<delimiter>:?)                                    # delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<fields>.*?)                                      # annotations + description
    \s*                                                  # 0 or more whitespace characters
    :?                                                   # invalid delimiter
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s���
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<class_name>[\w]+)                                # class name
    \s*                                                  # 0 or more whitespace characters
    :{1}                                                 # 1 required colon
    \s*                                                  # 0 or more whitespace characters
    (?P<property_name>[\w-]*\w)                          # property name
    \s*                                                  # 0 or more whitespace characters
    (?P<delimiter>:?)                                    # delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<fields>.*?)                                      # annotations + description
    \s*                                                  # 0 or more whitespace characters
    :?                                                   # invalid delimiter
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s���
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<class_name>[\w]+)                                # class name
    \s*                                                  # 0 or more whitespace characters
    :{2}                                                 # 2 required colons
    \s*                                                  # 0 or more whitespace characters
    (?P<signal_name>[\w-]*\w)                            # signal name
    \s*                                                  # 0 or more whitespace characters
    (?P<delimiter>:?)                                    # delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<fields>.*?)                                      # annotations + description
    \s*                                                  # 0 or more whitespace characters
    :?                                                   # invalid delimiter
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s'��
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    @                                                    # @ character
    (?P<parameter_name>[\w-]*\w|.*?\.\.\.)               # parameter name
    \s*                                                  # 0 or more whitespace characters
    :{1}                                                 # 1 required delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<fields>.*?)                                      # annotations + description
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    t���|t��� s���\ss����
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<tag_name>s��)                 # tag name
    \s*                                                  # 0 or more whitespace characters
    :{1}                                                 # 1 required delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<fields>.*?)                                      # annotations + value + description
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s���
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<value>([0-9\.])*)                                # value
    \s*                                                  # 0 or more whitespace characters
    (?P<delimiter>:?)                                    # delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<description>.*?)                                 # description
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    s���
    ^                                                    # start
    \s*                                                  # 0 or more whitespace characters
    (?P<value>(stable|unstable|private|internal)?)       # value
    \s*                                                  # 0 or more whitespace characters
    (?P<delimiter>:?)                                    # delimiter
    \s*                                                  # 0 or more whitespace characters
    (?P<description>.*?)                                 # description
    \s*                                                  # 0 or more whitespace characters
    $                                                    # end
    t���GtkDocAnnotationsc�����������B@��s ���e��Z�d��Z�d�Z�d�d���Z�RS(���s����
    An ordered dictionary mapping annotation names to annotation options (if any). Annotation
    options can be either a :class:`list`, a :class:`giscanner.collections.OrderedDict`
    (depending on the annotation name)or :const:`None`.
    t���positionc���������C@��s���t��j�|����|�|��_�d��S(���N(���R���t���__init__R0���(���t���selfR0���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR1������s����
N(���t���__name__t
���__module__t���__doc__t	���__slots__t���NoneR1���(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR/������s���t���GtkDocAnnotatablec�����������B@��s7��e��Z�d��Z�d!�Z�d"�Z�d#�d���Z�d����Z�d����Z�d����Z	�d#�d#�d#�d#�d���Z
�d����Z�d	����Z�d
����Z
�d����Z�d����Z�d
����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z �d����Z!�d����Z"�d ����Z#�RS($���sK���
    Base class for GTK-Doc comment block parts that can be annotated.
    R0���t���annotationsc���������C@��s���|�|��_��t����|��_�d��S(���N(���R0���R/���R9���(���R2���R0���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR1�����s����	c���������C@��s���d�|��j��f�S(���Ns���<GtkDocAnnotatable %r %r>(���R9���(���R2���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���__repr__��s����c���������C@��s����|��j��r��|��j��j�}�x��|��j��j����D]��\�}�}�|�|��j�k�rr�t�|��d�|�j�d�d�����}�|�|�|�|���q%�|�t�k�r��t�d�|�f�|���q%�t�d�|�f�|���q%�Wn��d�S(���sa���
        Validate annotations stored by the :class:`GtkDocAnnotatable` instance, if any.
        t
���_do_validate_t���-t���_s���unexpected annotation: %ss���unknown annotation: %sN(���R9���R0���t���itemst���valid_annotationst���getattrt���replacet���ALL_ANNOTATIONSR���(���R2���R0���t���ann_namet���optionst���validate(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyRE�����s����	c���	������C@��s����|�d�k�r�d�}�n
�d�|�f�}�|�d�k�r7�d�}�n"�|�d�k�rL�d�}�n
�d�|�f�}�|�|�|���r��t��d�|�|�|�|�f�|���n��d	�S(
���s,��
        Validate the number of options held by an annotation according to the test
        ``operator(n_options, expected_n_options)``.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param n_options: number of options held by the annotation
        :param expected_n_options: number of expected options
        :param operator: an operator function from python's :mod:`operator` module, for example
                         :func:`operator.ne` or :func:`operator.lt`
        :param message: warning message used when the test
                        ``operator(n_options, expected_n_options)`` fails.
        i����R,���s���%ds
���no optionsi���s
���one options
���%d optionss���"%s" annotation %s %s, %s givenN(���R���(	���R2���R0���RC���t	���n_optionst���expected_n_optionst���operatort���messaget���tt���s(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_validate_options3��s����	
		
c���
������C@��s����t��|���}�|�d�k	�r7�|��j�|�|�|�|�t�d���n��|�d�k	�rb�|��j�|�|�|�|�t�d���n��|�d�k	�r��|��j�|�|�|�|�t�d���n��|�r��|�d�k	�r��|�d�}	�|	�|�k�r��t�d�|�|	�f�|���q��n��d�S(���s���
        Validate an annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to be validated
        :param choices: an iterable of allowed option names or :const:`None` to skip this test
        :param exact_n_options: exact number of expected options or :const:`None` to skip this test
        :param min_n_options: minimum number of expected options or :const:`None` to skip this test
        :param max_n_options: maximum number of expected options or :const:`None` to skip this test
        t���needss���takes at leasts
���takes at mosti����s$���invalid "%s" annotation option: "%s"N(���t���lenR7���RL���R���R���R���R���(
���R2���R0���RC���RD���t���choicest���exact_n_optionst
���min_n_optionst
���max_n_optionsRF���t���option(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_validate_annotationS��s����			
c���������C@��s���|��j��|�|�|�d�d��d�S(���sm��
        Validate the ``(allow-none)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options held by the annotation
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_allow_noneu��s����
c���������C@��s;��t��|���d�k�r�d�Sx|�j����D]\�}�}�|�t�k�r��y�t�|���Wq3t�t�f�k
�r��|�d�k�r��t�d�|�|�f�|���q��t�d�|�|�|�f�|���q3Xq#�|�t�k�r��|�d�k	�r3|�d
�k�r3t�d�|�|�|�f�|���q3q#�|�t	�k�r|�d�k�r3t�d�|�f�|���q3q#�t�d	�|�|�f�|���q#�Wd�S(���sh��
        Validate the ``(array)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options held by the annotation
        i����Ns)���"%s" annotation option "%s" needs a valuesB���invalid "%s" annotation option "%s" value "%s", must be an integert���0t���1s>���invalid "%s" annotation option "%s" value "%s", must be 0 or 1s-���"%s" annotation option "length" needs a values$���invalid "%s" annotation option: "%s"(���RV���RW���(
���RN���R>���t���OPT_ARRAY_FIXED_SIZEt���intt	���TypeErrort
���ValueErrorR7���R���t���OPT_ARRAY_ZERO_TERMINATEDt���OPT_ARRAY_LENGTH(���R2���R0���RC���RD���RS���R���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_array���s0����






c���������C@��s���d�S(���sb��
        Validate the ``(attributes)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        N(����(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_attributes���s����c���������C@��s���|��j��|�|�|�d�d��d�S(���s_��
        Validate the ``(closure)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RR���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_closure���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sc��
        Validate the ``(constructor)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_constructor���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s_��
        Validate the ``(destroy)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_destroy���s����
c���������C@��s#���|��j��|�|�|�d�d�d�d��d�S(���s_��
        Validate the ``(element)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RQ���i���RR���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_element_type���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s_��
        Validate the ``(foreign)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_foreign���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sb��
        Validate the ``(value-func)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_get_value_func���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sZ��
        Validate the ``(in)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_in���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s^��
        Validate the ``(in-out)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_inout��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s^��
        Validate the ``(method)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_method��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sk��
        Validate the ``(nullable)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options held by the annotation
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_nullable ��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sk��
        Validate the ``(optional)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options held by the annotation
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_optional,��s����
c���������C@��s#���|��j��|�|�|�d�d�d�t��d�S(���s[��
        Validate the ``(out)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RR���i���RO���N(���RT���t���OUT_OPTIONS(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_out8��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s`��
        Validate the ``(ref-func)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_ref_funcE��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sa��
        Validate the ``(rename-to)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_rename_toQ��s����
c���������C@��s#���|��j��|�|�|�d�d�d�t��d�S(���s]��
        Validate the ``(scope)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���RO���N(���RT���t
���SCOPE_OPTIONS(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_scope]��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sb��
        Validate the ``(value-func)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_set_value_funcj��s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s\��
        Validate the ``(skip)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i����N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_skipv��s����
c���������C@��s#���|��j��|�|�|�d�d�d�t��d�S(���s`��
        Validate the ``(transfer)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���RO���N(���RT���t���TRANSFER_OPTIONS(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_transfer���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s\��
        Validate the ``(type)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_type���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���sb��
        Validate the ``(unref-func)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_unref_func���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s]��
        Validate the ``(value)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_value���s����
c���������C@��s���|��j��|�|�|�d�d��d�S(���s_��
        Validate the ``(virtual)`` annotation.

        :param position: :class:`giscanner.message.Position` of the line in the source file
                         containing the annotation to be validated
        :param ann_name: name of the annotation holding the options to validate
        :param options: annotation options to validate
        RP���i���N(���RT���(���R2���R0���RC���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_do_validate_virtual���s����
(���s���positions���annotations(����N($���R3���R4���R5���R6���R?���R7���R1���R:���RE���RL���RT���RU���R^���R_���R`���Ra���Rb���Rc���Rd���Re���Rf���Rg���Rh���Ri���Rj���Rl���Rm���Rn���Rp���Rq���Rr���Rt���Ru���Rv���Rw���Rx���(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR8�����sD���				 !		&	
												
			
			
			t���GtkDocParameterc�����������B@��s\���e��Z�d��Z�d�Z�e�e�e�e�e�e	�e
�e�e�e
�e�e�e�e�e�f�Z�d�d���Z�d����Z�RS(���s.���
    Represents a GTK-Doc parameter part.
    t���nameR���c���������C@��s&���t��j�|��|���|�|��_�d��|��_�d��S(���N(���R8���R1���Rz���R7���R���(���R2���Rz���R0���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR1������s����	c���������C@��s���d�|��j��|��j�f�S(���Ns���<GtkDocParameter %r %r>(���Rz���R9���(���R2���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR:������s����(���s���names���descriptionN(���R3���R4���R5���R6���t���ANN_ALLOW_NONEt	���ANN_ARRAYt���ANN_ATTRIBUTESt���ANN_CLOSUREt���ANN_DESTROYt���ANN_ELEMENT_TYPEt���ANN_INt	���ANN_INOUTt���ANN_OUTt	���ANN_SCOPEt���ANN_SKIPt���ANN_TRANSFERt���ANN_TYPEt���ANN_OPTIONALt���ANN_NULLABLER?���R7���R1���R:���(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyRy������s���	t	���GtkDocTagc��������	���B@��sJ���e��Z�d��Z�d�Z�e�e�e�e�e�e	�e
�e�e�f	�Z
�d�d���Z�d����Z�RS(���s(���
    Represents a GTK-Doc tag part.
    Rz���R���R���c���������C@��s/���t��j�|��|���|�|��_�d��|��_�d��|��_�d��S(���N(���R8���R1���Rz���R7���R���R���(���R2���Rz���R0���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR1������s����		c���������C@��s���d�|��j��|��j�f�S(���Ns���<GtkDocTag %r %r>(���Rz���R9���(���R2���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR:������s����(���s���names���values���descriptionN(���R3���R4���R5���R6���R{���R|���R}���R����R����R����R����R����R����R?���R7���R1���R:���(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR�������s���t���GtkDocCommentBlockc�����������B@��sk���e��Z�d��Z�d�Z�e�e�e�e�e�e	�e
�e�e�e
�e�e�e�e�f�Z�d
�d���Z�d	����Z�d
����Z�d����Z�RS(���s-���
    Represents a GTK-Doc comment block.
    t���code_beforet
���code_aftert���indentationRz���t���paramsR���t���tagsc���������C@��sY���t��j�|��|���d��|��_�d��|��_�g��|��_�|�|��_�t����|��_�d��|��_	�t����|��_
�d��S(���N(���R8���R1���R7���R����R����R����Rz���R���R����R���R����(���R2���Rz���R0���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR1������s����					c���������C@��s���t��|��j�|�j���S(���N(���t���cmpRz���(���R2���t���other(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���__cmp__��s����c���������C@��s���d�|��j��|��j�f�S(���Ns���<GtkDocCommentBlock %r %r>(���Rz���R9���(���R2���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR:��� ��s����c���������C@��sY���t��j�|����x!�|��j�j����D]�}�|�j����q�Wx!�|��j�j����D]�}�|�j����qA�Wd�S(���sz���
        Validate annotations applied to the :class:`GtkDocCommentBlock` identifier, parameters
        and tags.
        N(���R8���RE���R����t���valuesR����(���R2���t���paramt���tag(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyRE���#��s
����
(���s���code_befores
���code_afters���indentations���names���paramss���descriptions���tagsN(���R3���R4���R5���R6���R}���t���ANN_CONSTRUCTORt���ANN_FOREIGNt���ANN_GET_VALUE_FUNCt
���ANN_METHODt���ANN_REF_FUNCt
���ANN_RENAME_TOt���ANN_SET_VALUE_FUNCR����R����R����t���ANN_UNREF_FUNCt	���ANN_VALUEt	���ANN_VFUNCR?���R7���R1���R����R:���RE���(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR�������s����		t���Resultt���successR9���t	���start_post���end_post���GtkDocCommentBlockParserc�����������B@��sq���e��Z�d��Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z�d����Z	�d����Z
�e�d	���Z�e�e�d
���Z
�RS(���s���
    Parse GTK-Doc comment blocks into a parse tree built out of :class:`GtkDocCommentBlock`,
    :class:`GtkDocParameter`, :class:`GtkDocTag` and :class:`GtkDocAnnotations`
    objects. This parser tries to accept malformed input whenever possible and does
    not cause the process to exit on syntax errors. It does however emit:

        * warning messages at the slightest indication of recoverable malformed input and
        * error messages for unrecoverable malformed input

    whenever possible. Recoverable, in this context, means that we can serialize the
    :class:`GtkDocCommentBlock` instance using a :class:`GtkDocCommentBlockWriter` without
    information being lost. It is usually a good idea to heed these warning and error messages
    as malformed input can result in both:

        * invalid GTK-Doc output (HTML, pdf, ...) when the comment blocks are parsed
          with GTK-Doc's gtkdoc-mkdb
        * unexpected introspection behavior, for example missing parameters in the
          generated .gir and .typelib files

    .. NOTE:: :class:`GtkDocCommentBlockParser` functionality is heavily based on gtkdoc-mkdb's
        `ScanSourceFile()`_ function and is currently in sync with GTK-Doc
        commit `47abcd5`_.

    .. _ScanSourceFile():
           http://git.gnome.org/browse/gtk-doc/tree/gtkdoc-mkdb.in#n3722
    .. _47abcd5:
           https://git.gnome.org/browse/gtk-doc/commit/?id=47abcd53b8489ebceec9e394676512a181c1f1f6
    c���	������C@��s����i��}�x��|�D]��\�}�}�}�y�|��j��|�|�|���}�Wn*�t�k
�ra�t�d�t�|�|�����q
�n�X|�d�k	�r
�|�j�|�k�r��|�|�j�}�t�j�j�|�j	�j
���}�t�d�|�j�|�j	�j�|���f�|�j	���n��|�|�|�j�<q
�q
�W|�S(���s����
        Parse multiple GTK-Doc comment blocks.

        :param comments: an iterable of ``(comment, filename, lineno)`` tuples
        :returns: a dictionary mapping identifier names to :class:`GtkDocCommentBlock` objects
        s����unrecoverable parse error, please file a GObject-Introspection bugreport including the complete comment block at the indicated location.sJ���multiple comment blocks documenting '%s:' identifier (already seen at %s).N(
���t���parse_comment_blockt	���ExceptionR	���R���R7���Rz���t���ost���patht���dirnameR0���t���filenameR���t���format(	���R2���t���commentst���comment_blockst���commentR����t���linenot
���comment_blockt	���firstseenR����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���parse_comment_blocksV��s"����


c���0������C@��s���d�}�d�}�t��|�|���}�t�j�t�d�|���j�d���}�t�|���}�t�j�|�d���}	�|	�ru|�d�k�r��t��|�|���}
�d�|	�j�d���d�}�t	�d�|�d�|�f�|
���d8�S|	�j�d���}�|	�j�d	���}�|�rt��|�|���}
�d�|	�j�d���d�}�t�d
�|�d�|�f�|
���n��|�rkt��|�|���}
�d�|	�j
�d	���d�}�t�d�|�d�|�f�|
���|�|�d�<qy|�d�=n�d8�St�j�|�d���}	�|	�rh|	�j�d���}�|	�j�d	���}�|�rt��|�|�|�d���}
�d�|	�j�d���d�}�t�d
�|�d�|�f�|
���n��|�r^t��|�|�|�d���}
�d�|	�j�d	���d�}�t�d�|�d�|�f�|
���|�|�d�<ql|�d�=n�d8�Sd8�}�t�}
�g��}�d8�}�d8�}�d8�}�d8�}�t�}�x_|�D]W}�|�d�7}�t��|�|���}
�|�}�d�}�t�j�|���}	�|�j�|	�j�d�����t�j�|���}	�|	�rs|	�j�d	���}�|�rNd�|	�j
�d	���d�}�t	�d�|�|�f�|
���n��|	�j�d���}�|�|	�j�d���}�n��t�j�|���}	�t�|	�j�d���j�d�d�����}�|�d8�k�rNt�j�|���}	�|	�r�d�|	�j�d���f�}�d8�}�d8�}�d8�}�n)t�j�|���}	�|	�rVd�|	�j�d���|	�j�d���f�}�|	�j�d���}�|	�j�d���}�|	�j
�d���}�n��t�j�|���}	�|	�r�d�|	�j�d���|	�j�d���f�}�|	�j�d���}�|	�j�d���}�|	�j
�d���}�n[�t�j�|���}	�|	�rd�|	�j�d���f�}�|	�j�d���}�|	�j�d���}�|	�j
�d���}�n��|	�rt�}�|�}�t�|�|���}�|�|�_�|�|�_�|�r|��j�|
�|�|�|�|���}�|�j�r|�|�j�j����r�d8�}	�d8�}�d8�}�d8�}�q|�j �|�_ �|�r|�j �r|�|	�j
�d���}�d�|�d�}�t�d�|�d�|�|�f�|
���qqqn��|	�s�|
�sHt!�}
�d�|�d�}�t	�d�|�|�f�|
���qHq�q�n��t"�j�|���}	�|	�r�|�}�|	�j�d ���}�|�j#����}�|	�j�d���}�|	�j
�d���} �d�|	�j
�d ���|�d�}�|�t�t$�g�k�r�t�d!�|�|�|�f�|
���n��t$�}�|�t%�k�r�t%�}�|�st!�}�n�t	�d"�|�j&�f�|
���t'�t%�|
���}!�|�r�|��j(�|
�|�| �|�|���}	�|	�j�r�|	�j �|!�_ �|	�j)�|!�_)�q�n��|!�|�j*�t%�<|!�}�q�nJ�|�d#�k�s�|�j+�d$���r�|�d$�k�r�t�d%�|�|�|�f�|
���d$�}�n��|�|�j,�j-����k�rt	�d&�|�|�j&�|�|�f�|
���n��t.�|�|
���}"�|�ru|��j(�|
�|�| �|�|���}	�|	�j�ru|	�j �|"�_ �|	�j)�|"�_)�qun��|"�|�j,�|�<|"�}�q�n��t/�j�|���r�|�t�t$�g�k�r�t0�}�|�}�q�n��t1�j�|���}	�|	�r�
|�|�k�r�
|�}�|	�j�d'���}#�|#�j#����}$�|	�j�d���}%�|	�j
�d���}&�d�|	�j
�d'���|�d�}�|$�t2�k�r't�d(�|#�|�|�f�|
���|$�j�d�d)���}'�|$�t3�k�r�
d�}(�|��j(�|
�|	�j
�d'���|�|�|%�j����t�t���}	�|	�j�r!x��|	�j �D]��})�|��j4�|
�|�|�|)���}*�t�|*���}+�|+�d�k�r
d*�|(�|*�d�f�}(�q�	|+�d+�k�rA
d,�|(�|*�d�|*�d�f�}(�q�	t	�d-�|�|�f�|
���d8�}(�q�	W|(�r�
d*�|'�|(�j����f�}(�|��j5�|
�|�|&�|�|(���\�}'�},�|�j �j6�d.���}-�|-�r�
t	�d/�|�|�f�|
���q�
|,�|�j �|'�<q�
q!q�|��j5�|
�|�|&�|�d*�|'�|%�f���\�}'�}.�|.�|�j �|'�<q�n`�|$�t7�k�r�t�d0�|�|�f�|
���t0�}�|�j)�d8�k�rk|%�|�_)�q�|�j)�d1�|%�f�7_)�q�n��|�t0�k�s�|�t$�k�r�|�j)�s�|�t�k�r�|�j,�r�|�j)�r�t8�}�n��|�t8�k�rt8�}�t�d2�|#�|�|�f�|
���n��|$�t9�t%�t:�t;�g�k�r�|�s(t!�}�n�t	�d3�|�j&�f�|
���t'�t%�|
���}!�|%�r�|��j(�|
�|�|&�|�|%���}	�|	�j�r�|	�j �|!�_ �|	�j)�|!�_)�q�n��|!�|�j*�t%�<|!�}�q�q�
|$�|�j*�j-����k�r�t	�d4�|#�|�j&�|�|�f�|
���n��t'�|$�|
���}!�|%�r�
|��j(�|
�|�|&�|�|%���}	�|	�j�r�
|	�j �rB
t	�d5�|#�f�|
���n��|$�t<�t=�g�k�r�
t>�j�|	�j)���}	�|	�j�d6���|!�_?�|	�j�d7���|!�_)�q�
|$�t@�k�r�
tA�j�|	�j)���}	�|	�j�d6���jB����|!�_?�|	�j�d7���|!�_)�q�
q�
n��|!�|�j*�|$�<|!�}�q�n��t/�j�|���d8�k�r|�jC����}�n��|�t�t0�g�k�r�|�j)�s^|�t�k�r^|��jD�|�|�|�|
���q^n��|�j)�d8�k�ry|�|�_)�q�|�j)�d�|�7_)�q�q�|�t$�t8�g�k�r�|�j)�s�|��jD�|�|�|�|
���n��|�j)�d8�k�r�|�|�_)�q�|�j)�d�|�7_)�q�q�q�W|�r�|�j)�r"|�j)�j����|�_)�n��x$�|�j*�jE����D]�}!�|��jF�|!���q2Wx$�|�j,�jE����D]�}/�|��jF�|/���qYW|�|�_G�|�jH����|�Sd8�Sd8�S(9���s���
        Parse a single GTK-Doc comment block.

        :param comment: string representing the GTK-Doc comment block including it's
                        start ("``/**``") and end ("``*/``") tokens.
        :param filename: source file name where the comment block originated from
        :param lineno: line number in the source file where the comment block starts
        :returns: a :class:`GtkDocCommentBlock` object or ``None``
        t����s���
i����i���R.���t���codet���^s-���Skipping invalid GTK-Doc comment block:
%s
%sR����sM���GTK-Doc comment block start token "/**" should not be preceded by code:
%s
%ssU���GTK-Doc comment block start token "/**" should not be followed by comment text:
%s
%si����sJ���GTK-Doc comment block end token "*/" should not be followed by code:
%s
%ssR���GTK-Doc comment block end token "*/" should not be preceded by comment text:
%s
%sR����s���invalid comment text:
%s
%ss���	s���  s
���SECTION:%st���section_names���%s:%st
���class_namet
���property_namet	���delimitert���fieldss���%s::%st���signal_names���%st���symbol_names���missing ":" at column %s:
%s
%ss-���identifier not found on the first line:
%s
%st���parameter_names2���"@%s" parameter unexpected at this location:
%s
%ss;���encountered multiple "Returns" parameters or tags for "%s".t���Varargss���...s?���"@%s" parameter is deprecated, please use "@..." instead:
%s
%ss4���multiple "@%s" parameters for identifier "%s":
%s
%st���tag_names|���GObject-Introspection specific GTK-Doc tag "%s" has been deprecated, please use annotations on the identifier instead:
%s
%sR<���s���%s %si���s���%s %s=%ss2���malformed "Attributes:" tag will be ignored:
%s
%sR���s9���Duplicate "Attributes:" annotation will be ignored:
%s
%ss5���GTK-Doc tag "Description:" has been deprecated:
%s
%ss���
%ss,���"%s:" tag unexpected at this location:
%s
%ss>���encountered multiple return value parameters or tags for "%s".s.���multiple "%s:" tags for identifier "%s":
%s
%ss(���annotations not supported for tag "%s:".R���R���N(I���R���t���ret���subt
���LINE_BREAK_REt���splitRN���t���COMMENT_BLOCK_START_REt���matcht���endR	���R7���t���groupR���t���startt���COMMENT_BLOCK_END_REt���Falset���INDENTATION_REt���appendt���COMMENT_ASTERISK_RERA���t
���SECTION_REt���PROPERTY_REt	���SIGNAL_REt	���SYMBOL_REt���PART_IDENTIFIERR����R����R����t���_parse_annotationsR����R����t���stripR9���t���Truet���PARAMETER_REt���lowert���PART_PARAMETERSt���TAG_RETURNSRz���R����t
���_parse_fieldsR���R����t���endswithR����t���keysRy���t
���EMPTY_LINE_REt���PART_DESCRIPTIONt���TAG_REt���DEPRECATED_GI_ANN_TAGSt���TAG_ATTRIBUTESt���_parse_annotation_options_listt���_parse_annotationt���gett���TAG_DESCRIPTIONt	���PART_TAGSt
���TAG_RETURNt���TAG_RETURN_VALUEt���TAG_RETURNS_VALUEt���TAG_DEPRECATEDt	���TAG_SINCEt���TAG_VALUE_VERSION_RER���t
���TAG_STABILITYt���TAG_VALUE_STABILITY_REt
���capitalizet���rstript+���_validate_multiline_annotation_continuationR����t���_clean_description_fieldR����RE���(0���R2���R����R����R����R����R����t���comment_block_post
���comment_linest���comment_lines_lent���resultR0���t���markerR����t���identifier_warnedt���block_indentt���line_indentt���part_indentt���in_partt���current_partt���returns_seent���linet
���original_linet
���column_offsett���identifier_namet���identifier_delimitert���identifier_fieldst���identifier_fields_startt���rest���marker_positiont
���param_namet���param_name_lowert���param_fieldst���param_fields_startR����t	���parameterR����t���tag_name_lowert
���tag_fieldst���tag_fields_startRC���t���transformedt
���annotationt���ann_optionsRF���t
���docannotationt���stored_annotationRD���R����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR����z��s����









!							



	
			

	
			

!
				




	


	

		
			

				


		

		
c���������C@��sz���|�j��rv�|�j��j����d�k�r*�d�|�_��qv�t�j�|�j��j�d�d���d���ra�|�j��j����|�_��qv�|�j��j����|�_��n��d�S(���s����
        Remove extraneous leading and trailing whitespace from description fields.

        :param part: a GTK-Doc comment block part having a description field
        R����s���
i���i����N(���R���R����R7���R����R����R����R����(���R2���t���part(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR����a��s����	"c���������C@��s]���|��j��|�|�|�|���}�|�j�rY�|�j�rY�d�|�j�|�d�}�t�d�|�|�f�|���n��d�S(���s0��
        Validate annotatable parts' source text ensuring annotations don't span multiple lines.
        For example, the following comment block would result in a warning being emitted for
        the forth line::

            /**
             * shiny_function:
             * @array_: (out caller-allocates) (array)
             *          (element-type utf8) (transfer full): A beautiful array
             */

        :param line: line to validate, stripped from  ("``*/``") at start of the line.
        :param original_line: original line (including  ("``*/``"))  being validated
        :param column_offset: number of characters stripped from `line` when   ("``*/``")
                              was removed
        :param position: :class:`giscanner.message.Position` of `line` in the source file
        R.���R����s9���ignoring invalid multiline annotation continuation:
%s
%sN(���R����R����R9���R����R	���(���R2���R���R��R��R0���R����R����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR����q��s����
c���������C@��s����g��}�|�r}�|�j��d���}�|�d�k�rk�d�|�|�d�}�t�d�|�|�f�|���|��j�|�|�|�|���}�q}�|�j�d���}�n��|�S(���s���
        Parse annotation options into a list. For example::

            ┌──────────────────────────────────────────────────────────────┐
            │ 'option1 option2 option3'                                    │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ ['option1', 'option2', 'option3']                            │ ◁─ parsed options
            └──────────────────────────────────────────────────────────────┘

        :param position: :class:`giscanner.message.Position` of `line` in the source file
        :param column: start column of the `options` in the source file
        :param line: complete source line
        :param options: annotation options to parse
        :returns: a list of annotation options
        t���=i����R.���R����sS���invalid annotation options: expected a "list" but received "key=value pairs":
%s
%s(���t���findR���t!���_parse_annotation_options_unknownR����(���R2���R0���t���columnR���RD���t���parsedR����R����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR�������s����
c���
������C@��sx���t�����}�|�rt�xb�|�j�d���D]N�}�|�j�d�d���}�|�d�}�t�|���d�k�r]�|�d�n�d�}	�|	�|�|�<q�Wn��|�S(���s���
        Parse annotation options into a dict. For example::

            ┌──────────────────────────────────────────────────────────────┐
            │ 'option1=value1 option2 option3=value2'                      │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ {'option1': 'value1', 'option2': None, 'option3': 'value2'}  │ ◁─ parsed options
            └──────────────────────────────────────────────────────────────┘

        :param position: :class:`giscanner.message.Position` of `line` in the source file
        :param column: start column of the `options` in the source file
        :param line: complete source line
        :param options: annotation options to parse
        :returns: an ordered dictionary of annotation options
        R.���R��i���i����i���N(���R���R����RN���R7���(
���R2���R0���R��R���RD���R��t���pt���partst���keyR���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_parse_annotation_options_dict���s����	
"c���������C@��s���|�r�|�j�����g�Sd�S(���s��
        Parse annotation options into a list holding a single item. This is used when the
        annotation options to parse in not known to be a list nor dict. For example::

            ┌──────────────────────────────────────────────────────────────┐
            │ '   option1 option2   option3=value1   '                     │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ ['option1 option2   option3=value1']                         │ ◁─ parsed options
            └──────────────────────────────────────────────────────────────┘

        :param position: :class:`giscanner.message.Position` of `line` in the source file
        :param column: start column of the `options` in the source file
        :param line: complete source line
        :param options: annotation options to parse
        :returns: a list of annotation options
        N(���R����(���R2���R0���R��R���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR�����s����c���
������C@��s���|�j��d�t���j��d�t���}�|�j�d�d���}�|�d�j����}�t�|���d�k�r\�|�d�n�d�}�|�t�k�r��d�|�d�}�t�d�t�t	�|�|�f�|���t	�}�n��|�t
�k�rod�|�d�}�t�d�t
�t�|�|�f�|���t�}�|��j�|�|�|�|���}�t�|���}	�|	�d�k�r|�d�}�qo|	�d�k�rCd	�|�d�|�d�f�}�qod�|�d�}�t
�d
�|�|�f�|���d�Sn��|�t�|���d�7}�|�t�k�r�|��j�|�|�|�|���}�n?�|�t�k�r�|��j�|�|�|�|���}�n�|��j�|�|�|�|���}�|�|�f�S(
���s}��
        Parse an annotation into the annotation name and a list or dict (depending on the
        name of the annotation) holding the options. For example::

            ┌──────────────────────────────────────────────────────────────┐
            │ 'name opt1=value1 opt2=value2 opt3'                          │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ 'name', {'opt1': 'value1', 'opt2':'value2', 'opt3':None}     │ ◁─ parsed annotation
            └──────────────────────────────────────────────────────────────┘

            ┌──────────────────────────────────────────────────────────────┐
            │ 'name   opt1 opt2'                                           │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ 'name', ['opt1', 'opt2']                                     │ ◁─ parsed annotation
            └──────────────────────────────────────────────────────────────┘

            ┌──────────────────────────────────────────────────────────────┐
            │ 'unkownname   unknown list of options'                       │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ 'unkownname', ['unknown list of options']                    │ ◁─ parsed annotation
            └──────────────────────────────────────────────────────────────┘

        :param position: :class:`giscanner.message.Position` of `line` in the source file
        :param column: start column of the `annotation` in the source file
        :param line: complete source line
        :param annotation: annotation to parse
        :returns: a tuple containing the annotation name and options
        t���<t���>R.���i���i����i���R����sC���"%s" annotation has been deprecated, please use "%s" instead:
%s
%ss���%s=%ss9���malformed "(attribute)" annotation will be ignored:
%s
%sN(���NN(���RA���t���ANN_LPARt���ANN_RPARR����R����RN���R7���t
���ANN_INOUT_ALTR���R����t
���ANN_ATTRIBUTER}���R����R	���t���LIST_ANNOTATIONSt���DICT_ANNOTATIONSR��R��(
���R2���R0���R��R���R��R��RC���R��R����RF���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR�������sF����"	

	c���������C@��s&��|�r�t��|���}�n�g��}�d�}�d�}�d�}	�g��}
�d�}�d�}�x�t�|���D]w\�}�}
�|
�j����}�|
�t�k�r��|�d�7}�|�d�k�r��|�}�n��|	�t�k�r��d�|�|�d�}�t�d�|�|�f�|���t�t�d	�d	�d	���S|�d�k�r�|
�j�|
���q�n�|
�t	�k�r{|�d�8}�|	�t�k�rTd�|�|�d�}�t�d�|�|�f�|���t�t�d	�d	�d	���S|�d�k��r�d�|�|�d�}�t�d�|�|�f�|���t�t�d	�d	�d	���S|�d�k�rk|�d�}�|�t
�k�rF|��j�|�|�|�|�d�j�|
���j
������\�}�}�|�d	�k	�rb|�|�k�r6d�|�|�d�}�t�d�|�|�|�f�|���n��|�|�|�<qbn�|�j�d�j�|
���j
������g��}
�q�|
�j�|
���nB�|�r�|�d�k�r�|
�j�|
���q�n�|�d�k�r�Pn
�|
�j�|
���|
�}	�qL�W|�d�k�rd�|�|�d�}�t�d�|�|�f�|���t�t�d	�d	�d	���St�t
�|�|�|���Sd	�S(
���s���
        Parse annotations into a :class:`GtkDocAnnotations` object.

        :param position: :class:`giscanner.message.Position` of `line` in the source file
        :param column: start column of the `annotations` in the source file
        :param line: complete source line
        :param fields: string containing the fields to parse
        :param parse_options: whether options will be parsed into a :class:`GtkDocAnnotations`
                              object or into a :class:`list`
        :returns: if `parse_options` evaluates to True a :class:`GtkDocAnnotations` object,
                  a :class:`list` otherwise. If `line` does not contain any annotations,
                  :const:`None`
        i����R����i���R.���R����s:���unexpected parentheses, annotations will be ignored:
%s
%ss:���unbalanced parentheses, annotations will be ignored:
%s
%ss ���multiple "%s" annotations:
%s
%sN(���R/���t	���enumeratet���isspaceR"��R	���t���_ParseAnnotationsResultR����R7���R����R#��R����R����t���joinR����(���R2���R0���R��R���R����t
���parse_optionst���parsed_annotationst���it���parens_levelt	���prev_chart���char_bufferR����R����t���cur_chart���cur_char_is_spaceR����Rz���RD���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR����*��s�����
	




		


c���������C@��s����d�}�|��j��|�|�|�|�|���}�|�j�r��|�|�j�j����}�|�r��|�r��|�j�d���re�|�d�}�q��|�j�d�k�r��|�|�j�}	�d�|	�d�}
�t�d�|	�d�|�|
�f�|���q��q��n��t�|�j�|�j�|���S(���s���
        Parse annotations out of field data. For example::

            ┌──────────────────────────────────────────────────────────────┐
            │ '(skip): description of some parameter                       │ ─▷ source
            ├──────────────────────────────────────────────────────────────┤
            │ ({'skip': []}, 'description of some parameter')              │ ◁─ annotations and
            └──────────────────────────────────────────────────────────────┘    remaining fields

        :param position: :class:`giscanner.message.Position` of `line` in the source file
        :param column: start column of `fields` in the source file
        :param line: complete source line
        :param fields: string containing the fields to parse
        :param parse_options: whether options will be parsed into a :class:`GtkDocAnnotations`
                              object or into a :class:`list`
        :param validate_description_field: :const:`True` to validate the description field
        :returns: if `parse_options` evaluates to True a :class:`GtkDocAnnotations` object,
                  a :class:`list` otherwise. If `line` does not contain any annotations,
                  :const:`None` and a string holding the remaining fields
        R����t���:i���i����R.���R����s���missing ":" at column %s:
%s
%s(���R����R����R����R����t
���startswithR���t���_ParseFieldsResultR9���(���R2���R0���R��R���R����R,��t���validate_description_fieldt���description_fieldR����R��R����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR�������s����	

(���R3���R4���R5���R����R����R����R����R����R��R��R����R����R����R����(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR����8��s���	$	���			 			Lct���GtkDocCommentBlockWriterc�����������B@��s>���e��Z�d��Z�e�d���Z�d����Z�d����Z�d����Z�d����Z�RS(���sU���
    Serialized :class:`GtkDocCommentBlock` objects into GTK-Doc comment blocks.
    c���������C@��s
���|�|��_��d��S(���N(���t���indent(���R2���R:��(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR1������s����c���������C@��s����g��}�x��|�j�����D]��\�}�}�|�r��t�|�t���rF�d�j�|���}�n]�d�}�xH�|�j�����D]:�\�}�}�|�r��|�d�|�|�f�7}�qY�|�d�|�f�7}�qY�W|�j����}�|�j�d�|�|�f���q�|�j�d�|�f���q�Wd�j�|���S(���sA
��
        Serialize an annotation field. For example::

            ┌──────────────────────────────────────────────────────────────┐
            │ {'name': {'opt1': 'value1', 'opt2':'value2', 'opt3':None}    │ ◁─ GtkDocAnnotations
            ├──────────────────────────────────────────────────────────────┤
            │ '(name opt1=value1 opt2=value2 opt3)'                        │ ─▷ serialized
            └──────────────────────────────────────────────────────────────┘

            ┌──────────────────────────────────────────────────────────────┐
            │ {'name': ['opt1', 'opt2']}                                   │ ◁─ GtkDocAnnotations
            ├──────────────────────────────────────────────────────────────┤
            │ '(name opt1 opt2)'                                           │ ─▷ serialized
            └──────────────────────────────────────────────────────────────┘

            ┌──────────────────────────────────────────────────────────────┐
            │ {'unkownname': ['unknown list of options']}                  │ ◁─ GtkDocAnnotations
            ├──────────────────────────────────────────────────────────────┤
            │ '(unkownname unknown list of options)'                       │ ─▷ serialized
            └──────────────────────────────────────────────────────────────┘

        :param annotations: :class:`GtkDocAnnotations` to be serialized
        :returns: a string
        R.���R����s���%s=%s s���%s s���(%s %s)s���(%s)(���R>���t
���isinstancet���listR+��R����R����(���R2���R9���t
���serializedRC���RD���t���serialize_optionsR��R���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_serialize_annotations���s����c���������C@��s����d�|�j��f�}�|�j�r6�|�d�|��j�|�j���7}�n��|�j�ry�|�j�j�d���re�|�d�|�j�7}�q��|�d�|�j�7}�n
�|�d�7}�|�j�d���S(���s����
        Serialize a parameter.

        :param parameter: :class:`GtkDocParameter` to be serialized
        :returns: a string
        s���@%ss���: s���
R4��(���Rz���R9���R?��R���R5��R����(���R2���R
��R=��(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_serialize_parameter���s����			
c���������C@��s����|�j��j����}�|�j�r5�|�d�|��j�|�j���7}�n��|�j�rR�|�d�|�j�7}�n��|�j�r��|�j�j�d���r��|�d�|�j�7}�q��|�d�|�j�7}�n��|�j�r��|�j�r��|�d�7}�n��|�j�d���S(���sv���
        Serialize a tag.

        :param tag: :class:`GtkDocTag` to be serialized
        :returns: a string
        s���: s���
R4��(���Rz���R����R9���R?��R���R���R5��R����(���R2���R����R=��(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���_serialize_tag��s����				
c���������C@��s���|�d�k�r�d�Sg��}�|�j�j�d���r;�|�j�|�j���nO�|�j�rs�|��j�|�j���}�|�j�d�|�j�|�f���n�|�j�d�|�j�f���x-�|�j�j����D]�}�|�j�|��j	�|�����q��W|�j
�r��|�j�d���x*�|�j
�j�d���D]�}�|�j�|���q��Wn��|�j�rF|�j�d���x0�|�j�j����D]�}�|�j�|��j
�|�����q#Wn��|��j�r�t�|�j���j�d���d�d�prd�}�|�j�d	���r�|�}�|�d�}	�q�|�d
� }�|�}	�n�d�}�d�}	�d�}
�xX�|
�t�|���k��r|�|
�}�|�r�d�|	�|�f�|�|
�<n�d�|	�f�|�|
�<|
�d�7}
�q�W|�j�d�d
�|�f���|�j�d�|	�f���|�j�rh|�j�d�d�|�j�f���n��|�j�r�|�j�d�|�j�f���n��d�j�|���Sd�S(���s����
        Serialize a :class:`GtkDocCommentBlock` object.

        :param block: :class:`GtkDocCommentBlock` to be serialized
        :returns: a string
        R����t���SECTIONs���%s: %ss���%s:s���
i���i����R.���s���	i����s���%s* %s
s���%s*
s���%s/**
s���%s*/
s���%s
N(���R7���Rz���R5��R����R9���R?��R����R����t���extendR@��R���R����R����RA��R:��R���R����t���most_commonR����RN���t���insertR����R����R+��(���R2���t���blockt���linesR9���R����t���lR����R:��t���start_indentR����R.��R���(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���write*��sT����		
	
	&

	
		(	���R3���R4���R5���R����R1���R?��R@��RA��RJ��(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyR9�����s���	1		(~���R5���t
���__future__R����R����R����t���collectionsR���RH���R���R���R���R���R���RI���R���R���R	���R����R����R����R����R����R����R����R����t���GTKDOC_TAGSR����R����t���DEPRECATED_GTKDOC_TAGSR����R����t���DEPRECATED_GI_TAGSR����t���TAG_GET_VALUE_FUNCt���TAG_REF_FUNCt
���TAG_RENAME_TOt���TAG_SET_VALUE_FUNCt���TAG_TRANSFERt���TAG_TYPEt���TAG_UNREF_FUNCt	���TAG_VALUEt	���TAG_VFUNCR����t���ALL_TAGSR"��R#��R{���R|���R}���R~���R����R���R����R����R����R����R����R����R����R����R����R����R����R����R����R����R����R����R����R����R����t���GI_ANNSR%��R$��t���DEPRECATED_GI_ANNSRB���R'��t���annR&��RX���R]���R\���t
���ARRAY_OPTIONSt���OPT_OUT_CALLEE_ALLOCATESt���OPT_OUT_CALLER_ALLOCATESRk���t���OPT_SCOPE_ASYNCt���OPT_SCOPE_CALLt���OPT_SCOPE_NOTIFIEDRo���t���OPT_TRANSFER_CONTAINERt���OPT_TRANSFER_FLOATINGt���OPT_TRANSFER_FULLt���OPT_TRANSFER_NONERs���t���compilet���UNICODER����t���VERBOSER����R����R����R����R����R����R����R����R����R����R+��RA���t	���_all_tagst
���IGNORECASER����R����R����R/���t���objectR8���Ry���R����R����R*��R6��R����R9��(����(����(����sz���/home/vagrant/ruby-gnome2.win64/gobject-introspection/vendor/local/lib/gobject-introspection/giscanner/annotationparser.pyt���<module>j���st��						
%				

���@�������