ruamel.yaml-0.15.89/0000775000175100001440000000000013435603756014611 5ustar anthonusers00000000000000ruamel.yaml-0.15.89/scalarstring.py0000664000175100001440000001056413411245344017652 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals from ruamel.yaml.compat import text_type from ruamel.yaml.anchor import Anchor if False: # MYPY from typing import Text, Any, Dict, List # NOQA __all__ = [ 'ScalarString', 'LiteralScalarString', 'FoldedScalarString', 'SingleQuotedScalarString', 'DoubleQuotedScalarString', 'PlainScalarString', # PreservedScalarString is the old name, as it was the first to be preserved on rt, # use LiteralScalarString instead 'PreservedScalarString', ] class ScalarString(text_type): __slots__ = Anchor.attrib def __new__(cls, *args, **kw): # type: (Any, Any) -> Any anchor = kw.pop('anchor', None) # type: ignore ret_val = text_type.__new__(cls, *args, **kw) # type: ignore if anchor is not None: ret_val.yaml_set_anchor(anchor, always_dump=True) return ret_val def replace(self, old, new, maxreplace=-1): # type: (Any, Any, int) -> Any return type(self)((text_type.replace(self, old, new, maxreplace))) @property def anchor(self): # type: () -> Any if not hasattr(self, Anchor.attrib): setattr(self, Anchor.attrib, Anchor()) return getattr(self, Anchor.attrib) def yaml_anchor(self, any=False): # type: (bool) -> Any if not hasattr(self, Anchor.attrib): return None if any or self.anchor.always_dump: return self.anchor return None def yaml_set_anchor(self, value, always_dump=False): # type: (Any, bool) -> None self.anchor.value = value self.anchor.always_dump = always_dump class LiteralScalarString(ScalarString): __slots__ = 'comment' # the comment after the | on the first line style = '|' def __new__(cls, value, anchor=None): # type: (Text, Any) -> Any return ScalarString.__new__(cls, value, anchor=anchor) PreservedScalarString = LiteralScalarString class FoldedScalarString(ScalarString): __slots__ = ('fold_pos', 'comment') # the comment after the > on the first line style = '>' def __new__(cls, value, anchor=None): # type: (Text, Any) -> Any return ScalarString.__new__(cls, value, anchor=anchor) class SingleQuotedScalarString(ScalarString): __slots__ = () style = "'" def __new__(cls, value, anchor=None): # type: (Text, Any) -> Any return ScalarString.__new__(cls, value, anchor=anchor) class DoubleQuotedScalarString(ScalarString): __slots__ = () style = '"' def __new__(cls, value, anchor=None): # type: (Text, Any) -> Any return ScalarString.__new__(cls, value, anchor=anchor) class PlainScalarString(ScalarString): __slots__ = () style = '' def __new__(cls, value, anchor=None): # type: (Text, Any) -> Any return ScalarString.__new__(cls, value, anchor=anchor) def preserve_literal(s): # type: (Text) -> Text return LiteralScalarString(s.replace('\r\n', '\n').replace('\r', '\n')) def walk_tree(base, map=None): # type: (Any, Any) -> None """ the routine here walks over a simple yaml tree (recursing in dict values and list items) and converts strings that have multiple lines to literal scalars You can also provide an explicit (ordered) mapping for multiple transforms (first of which is executed): map = ruamel.yaml.compat.ordereddict map['\n'] = preserve_literal map[':'] = SingleQuotedScalarString walk_tree(data, map=map) """ from ruamel.yaml.compat import string_types, MutableMapping, MutableSequence if map is None: map = {'\n': preserve_literal} if isinstance(base, MutableMapping): for k in base: v = base[k] # type: Text if isinstance(v, string_types): for ch in map: if ch in v: base[k] = map[ch](v) break else: walk_tree(v) elif isinstance(base, MutableSequence): for idx, elem in enumerate(base): if isinstance(elem, string_types): for ch in map: if ch in elem: # type: ignore base[idx] = map[ch](elem) break else: walk_tree(elem) ruamel.yaml-0.15.89/constructor.py0000664000175100001440000021013413417444506017545 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division import datetime import base64 import binascii import re import sys import types import warnings # fmt: off from ruamel.yaml.error import (MarkedYAMLError, MarkedYAMLFutureWarning, MantissaNoDotYAML1_1Warning) from ruamel.yaml.nodes import * # NOQA from ruamel.yaml.nodes import (SequenceNode, MappingNode, ScalarNode) from ruamel.yaml.compat import (utf8, builtins_module, to_str, PY2, PY3, # NOQA ordereddict, text_type, nprint, nprintf, version_tnf, Hashable, MutableSequence, MutableMapping) from ruamel.yaml.comments import * # NOQA from ruamel.yaml.comments import (CommentedMap, CommentedOrderedMap, CommentedSet, CommentedKeySeq, CommentedSeq, TaggedScalar, CommentedKeyMap) from ruamel.yaml.scalarstring import (SingleQuotedScalarString, DoubleQuotedScalarString, LiteralScalarString, FoldedScalarString, PlainScalarString, ScalarString,) from ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt from ruamel.yaml.scalarfloat import ScalarFloat from ruamel.yaml.scalarbool import ScalarBoolean from ruamel.yaml.timestamp import TimeStamp from ruamel.yaml.util import RegExp if False: # MYPY from typing import Any, Dict, List, Set, Generator, Union, Optional # NOQA __all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor', 'ConstructorError', 'RoundTripConstructor'] # fmt: on class ConstructorError(MarkedYAMLError): pass class DuplicateKeyFutureWarning(MarkedYAMLFutureWarning): pass class DuplicateKeyError(MarkedYAMLFutureWarning): pass class BaseConstructor(object): yaml_constructors = {} # type: Dict[Any, Any] yaml_multi_constructors = {} # type: Dict[Any, Any] def __init__(self, preserve_quotes=None, loader=None): # type: (Optional[bool], Any) -> None self.loader = loader if self.loader is not None and getattr(self.loader, '_constructor', None) is None: self.loader._constructor = self self.loader = loader self.yaml_base_dict_type = dict self.yaml_base_list_type = list self.constructed_objects = {} # type: Dict[Any, Any] self.recursive_objects = {} # type: Dict[Any, Any] self.state_generators = [] # type: List[Any] self.deep_construct = False self._preserve_quotes = preserve_quotes self.allow_duplicate_keys = version_tnf((0, 15, 1), (0, 16)) @property def composer(self): # type: () -> Any if hasattr(self.loader, 'typ'): return self.loader.composer try: return self.loader._composer except AttributeError: sys.stdout.write('slt {}\n'.format(type(self))) sys.stdout.write('slc {}\n'.format(self.loader._composer)) sys.stdout.write('{}\n'.format(dir(self))) raise @property def resolver(self): # type: () -> Any if hasattr(self.loader, 'typ'): return self.loader.resolver return self.loader._resolver def check_data(self): # type: () -> Any # If there are more documents available? return self.composer.check_node() def get_data(self): # type: () -> Any # Construct and return the next document. if self.composer.check_node(): return self.construct_document(self.composer.get_node()) def get_single_data(self): # type: () -> Any # Ensure that the stream contains a single document and construct it. node = self.composer.get_single_node() if node is not None: return self.construct_document(node) return None def construct_document(self, node): # type: (Any) -> Any data = self.construct_object(node) while bool(self.state_generators): state_generators = self.state_generators self.state_generators = [] for generator in state_generators: for _dummy in generator: pass self.constructed_objects = {} self.recursive_objects = {} self.deep_construct = False return data def construct_object(self, node, deep=False): # type: (Any, bool) -> Any """deep is True when creating an object/mapping recursively, in that case want the underlying elements available during construction """ if node in self.constructed_objects: return self.constructed_objects[node] if deep: old_deep = self.deep_construct self.deep_construct = True if node in self.recursive_objects: return self.recursive_objects[node] # raise ConstructorError( # None, None, 'found unconstructable recursive node', node.start_mark # ) self.recursive_objects[node] = None constructor = None # type: Any tag_suffix = None if node.tag in self.yaml_constructors: constructor = self.yaml_constructors[node.tag] else: for tag_prefix in self.yaml_multi_constructors: if node.tag.startswith(tag_prefix): tag_suffix = node.tag[len(tag_prefix) :] constructor = self.yaml_multi_constructors[tag_prefix] break else: if None in self.yaml_multi_constructors: tag_suffix = node.tag constructor = self.yaml_multi_constructors[None] elif None in self.yaml_constructors: constructor = self.yaml_constructors[None] elif isinstance(node, ScalarNode): constructor = self.__class__.construct_scalar elif isinstance(node, SequenceNode): constructor = self.__class__.construct_sequence elif isinstance(node, MappingNode): constructor = self.__class__.construct_mapping if tag_suffix is None: data = constructor(self, node) else: data = constructor(self, tag_suffix, node) if isinstance(data, types.GeneratorType): generator = data data = next(generator) if self.deep_construct: for _dummy in generator: pass else: self.state_generators.append(generator) self.constructed_objects[node] = data del self.recursive_objects[node] if deep: self.deep_construct = old_deep return data def construct_scalar(self, node): # type: (Any) -> Any if not isinstance(node, ScalarNode): raise ConstructorError( None, None, 'expected a scalar node, but found %s' % node.id, node.start_mark ) return node.value def construct_sequence(self, node, deep=False): # type: (Any, bool) -> Any """deep is True when creating an object/mapping recursively, in that case want the underlying elements available during construction """ if not isinstance(node, SequenceNode): raise ConstructorError( None, None, 'expected a sequence node, but found %s' % node.id, node.start_mark ) return [self.construct_object(child, deep=deep) for child in node.value] def construct_mapping(self, node, deep=False): # type: (Any, bool) -> Any """deep is True when creating an object/mapping recursively, in that case want the underlying elements available during construction """ if not isinstance(node, MappingNode): raise ConstructorError( None, None, 'expected a mapping node, but found %s' % node.id, node.start_mark ) total_mapping = self.yaml_base_dict_type() if getattr(node, 'merge', None) is not None: todo = [(node.merge, False), (node.value, False)] else: todo = [(node.value, True)] for values, check in todo: mapping = self.yaml_base_dict_type() # type: Dict[Any, Any] for key_node, value_node in values: # keys can be list -> deep key = self.construct_object(key_node, deep=True) # lists are not hashable, but tuples are if not isinstance(key, Hashable): if isinstance(key, list): key = tuple(key) if PY2: try: hash(key) except TypeError as exc: raise ConstructorError( 'while constructing a mapping', node.start_mark, 'found unacceptable key (%s)' % exc, key_node.start_mark, ) else: if not isinstance(key, Hashable): raise ConstructorError( 'while constructing a mapping', node.start_mark, 'found unhashable key', key_node.start_mark, ) value = self.construct_object(value_node, deep=deep) if check: if self.check_mapping_key(node, key_node, mapping, key, value): mapping[key] = value else: mapping[key] = value total_mapping.update(mapping) return total_mapping def check_mapping_key(self, node, key_node, mapping, key, value): # type: (Any, Any, Any, Any, Any) -> bool """return True if key is unique""" if key in mapping: if not self.allow_duplicate_keys: mk = mapping.get(key) if PY2: if isinstance(key, unicode): key = key.encode('utf-8') if isinstance(value, unicode): value = value.encode('utf-8') if isinstance(mk, unicode): mk = mk.encode('utf-8') args = [ 'while constructing a mapping', node.start_mark, 'found duplicate key "{}" with value "{}" ' '(original value: "{}")'.format(key, value, mk), key_node.start_mark, """ To suppress this check see: http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys """, """\ Duplicate keys will become an error in future releases, and are errors by default when using the new API. """, ] if self.allow_duplicate_keys is None: warnings.warn(DuplicateKeyFutureWarning(*args)) else: raise DuplicateKeyError(*args) return False return True def check_set_key(self, node, key_node, setting, key): # type: (Any, Any, Any, Any, Any) -> None if key in setting: if not self.allow_duplicate_keys: if PY2: if isinstance(key, unicode): key = key.encode('utf-8') args = [ 'while constructing a set', node.start_mark, 'found duplicate key "{}"'.format(key), key_node.start_mark, """ To suppress this check see: http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys """, """\ Duplicate keys will become an error in future releases, and are errors by default when using the new API. """, ] if self.allow_duplicate_keys is None: warnings.warn(DuplicateKeyFutureWarning(*args)) else: raise DuplicateKeyError(*args) def construct_pairs(self, node, deep=False): # type: (Any, bool) -> Any if not isinstance(node, MappingNode): raise ConstructorError( None, None, 'expected a mapping node, but found %s' % node.id, node.start_mark ) pairs = [] for key_node, value_node in node.value: key = self.construct_object(key_node, deep=deep) value = self.construct_object(value_node, deep=deep) pairs.append((key, value)) return pairs @classmethod def add_constructor(cls, tag, constructor): # type: (Any, Any) -> None if 'yaml_constructors' not in cls.__dict__: cls.yaml_constructors = cls.yaml_constructors.copy() cls.yaml_constructors[tag] = constructor @classmethod def add_multi_constructor(cls, tag_prefix, multi_constructor): # type: (Any, Any) -> None if 'yaml_multi_constructors' not in cls.__dict__: cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() cls.yaml_multi_constructors[tag_prefix] = multi_constructor class SafeConstructor(BaseConstructor): def construct_scalar(self, node): # type: (Any) -> Any if isinstance(node, MappingNode): for key_node, value_node in node.value: if key_node.tag == u'tag:yaml.org,2002:value': return self.construct_scalar(value_node) return BaseConstructor.construct_scalar(self, node) def flatten_mapping(self, node): # type: (Any) -> Any """ This implements the merge key feature http://yaml.org/type/merge.html by inserting keys from the merge dict/list of dicts if not yet available in this node """ merge = [] # type: List[Any] index = 0 while index < len(node.value): key_node, value_node = node.value[index] if key_node.tag == u'tag:yaml.org,2002:merge': if merge: # double << key args = [ 'while constructing a mapping', node.start_mark, 'found duplicate key "{}"'.format(key_node.value), key_node.start_mark, """ To suppress this check see: http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys """, """\ Duplicate keys will become an error in future releases, and are errors by default when using the new API. """, ] if self.allow_duplicate_keys is None: warnings.warn(DuplicateKeyFutureWarning(*args)) else: raise DuplicateKeyError(*args) del node.value[index] if isinstance(value_node, MappingNode): self.flatten_mapping(value_node) merge.extend(value_node.value) elif isinstance(value_node, SequenceNode): submerge = [] for subnode in value_node.value: if not isinstance(subnode, MappingNode): raise ConstructorError( 'while constructing a mapping', node.start_mark, 'expected a mapping for merging, but found %s' % subnode.id, subnode.start_mark, ) self.flatten_mapping(subnode) submerge.append(subnode.value) submerge.reverse() for value in submerge: merge.extend(value) else: raise ConstructorError( 'while constructing a mapping', node.start_mark, 'expected a mapping or list of mappings for merging, ' 'but found %s' % value_node.id, value_node.start_mark, ) elif key_node.tag == u'tag:yaml.org,2002:value': key_node.tag = u'tag:yaml.org,2002:str' index += 1 else: index += 1 if bool(merge): node.merge = merge # separate merge keys to be able to update without duplicate node.value = merge + node.value def construct_mapping(self, node, deep=False): # type: (Any, bool) -> Any """deep is True when creating an object/mapping recursively, in that case want the underlying elements available during construction """ if isinstance(node, MappingNode): self.flatten_mapping(node) return BaseConstructor.construct_mapping(self, node, deep=deep) def construct_yaml_null(self, node): # type: (Any) -> Any self.construct_scalar(node) return None # YAML 1.2 spec doesn't mention yes/no etc any more, 1.1 does bool_values = { u'yes': True, u'no': False, u'true': True, u'false': False, u'on': True, u'off': False, } def construct_yaml_bool(self, node): # type: (Any) -> bool value = self.construct_scalar(node) return self.bool_values[value.lower()] def construct_yaml_int(self, node): # type: (Any) -> int value_s = to_str(self.construct_scalar(node)) value_s = value_s.replace('_', "") sign = +1 if value_s[0] == '-': sign = -1 if value_s[0] in '+-': value_s = value_s[1:] if value_s == '0': return 0 elif value_s.startswith('0b'): return sign * int(value_s[2:], 2) elif value_s.startswith('0x'): return sign * int(value_s[2:], 16) elif value_s.startswith('0o'): return sign * int(value_s[2:], 8) elif self.resolver.processing_version == (1, 1) and value_s[0] == '0': return sign * int(value_s, 8) elif self.resolver.processing_version == (1, 1) and ':' in value_s: digits = [int(part) for part in value_s.split(':')] digits.reverse() base = 1 value = 0 for digit in digits: value += digit * base base *= 60 return sign * value else: return sign * int(value_s) inf_value = 1e300 while inf_value != inf_value * inf_value: inf_value *= inf_value nan_value = -inf_value / inf_value # Trying to make a quiet NaN (like C99). def construct_yaml_float(self, node): # type: (Any) -> float value_so = to_str(self.construct_scalar(node)) value_s = value_so.replace('_', "").lower() sign = +1 if value_s[0] == '-': sign = -1 if value_s[0] in '+-': value_s = value_s[1:] if value_s == '.inf': return sign * self.inf_value elif value_s == '.nan': return self.nan_value elif self.resolver.processing_version != (1, 2) and ':' in value_s: digits = [float(part) for part in value_s.split(':')] digits.reverse() base = 1 value = 0.0 for digit in digits: value += digit * base base *= 60 return sign * value else: if self.resolver.processing_version != (1, 2) and 'e' in value_s: # value_s is lower case independent of input mantissa, exponent = value_s.split('e') if '.' not in mantissa: warnings.warn(MantissaNoDotYAML1_1Warning(node, value_so)) return sign * float(value_s) if PY3: def construct_yaml_binary(self, node): # type: (Any) -> Any try: value = self.construct_scalar(node).encode('ascii') except UnicodeEncodeError as exc: raise ConstructorError( None, None, 'failed to convert base64 data into ascii: %s' % exc, node.start_mark, ) try: if hasattr(base64, 'decodebytes'): return base64.decodebytes(value) else: return base64.decodestring(value) except binascii.Error as exc: raise ConstructorError( None, None, 'failed to decode base64 data: %s' % exc, node.start_mark ) else: def construct_yaml_binary(self, node): # type: (Any) -> Any value = self.construct_scalar(node) try: return to_str(value).decode('base64') except (binascii.Error, UnicodeEncodeError) as exc: raise ConstructorError( None, None, 'failed to decode base64 data: %s' % exc, node.start_mark ) timestamp_regexp = RegExp( u"""^(?P[0-9][0-9][0-9][0-9]) -(?P[0-9][0-9]?) -(?P[0-9][0-9]?) (?:((?P[Tt])|[ \\t]+) # explictly not retaining extra spaces (?P[0-9][0-9]?) :(?P[0-9][0-9]) :(?P[0-9][0-9]) (?:\\.(?P[0-9]*))? (?:[ \\t]*(?PZ|(?P[-+])(?P[0-9][0-9]?) (?::(?P[0-9][0-9]))?))?)?$""", re.X, ) def construct_yaml_timestamp(self, node, values=None): # type: (Any, Any) -> Any if values is None: try: match = self.timestamp_regexp.match(node.value) except TypeError: match = None if match is None: raise ConstructorError( None, None, 'failed to construct timestamp from "{}"'.format(node.value), node.start_mark, ) values = match.groupdict() year = int(values['year']) month = int(values['month']) day = int(values['day']) if not values['hour']: return datetime.date(year, month, day) hour = int(values['hour']) minute = int(values['minute']) second = int(values['second']) fraction = 0 if values['fraction']: fraction_s = values['fraction'][:6] while len(fraction_s) < 6: fraction_s += '0' fraction = int(fraction_s) if len(values['fraction']) > 6 and int(values['fraction'][6]) > 4: fraction += 1 delta = None if values['tz_sign']: tz_hour = int(values['tz_hour']) minutes = values['tz_minute'] tz_minute = int(minutes) if minutes else 0 delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) if values['tz_sign'] == '-': delta = -delta # should do something else instead (or hook this up to the preceding if statement # in reverse # if delta is None: # return datetime.datetime(year, month, day, hour, minute, second, fraction) # return datetime.datetime(year, month, day, hour, minute, second, fraction, # datetime.timezone.utc) # the above is not good enough though, should provide tzinfo. In Python3 that is easily # doable drop that kind of support for Python2 as it has not native tzinfo data = datetime.datetime(year, month, day, hour, minute, second, fraction) if delta: data -= delta return data def construct_yaml_omap(self, node): # type: (Any) -> Any # Note: we do now check for duplicate keys omap = ordereddict() yield omap if not isinstance(node, SequenceNode): raise ConstructorError( 'while constructing an ordered map', node.start_mark, 'expected a sequence, but found %s' % node.id, node.start_mark, ) for subnode in node.value: if not isinstance(subnode, MappingNode): raise ConstructorError( 'while constructing an ordered map', node.start_mark, 'expected a mapping of length 1, but found %s' % subnode.id, subnode.start_mark, ) if len(subnode.value) != 1: raise ConstructorError( 'while constructing an ordered map', node.start_mark, 'expected a single mapping item, but found %d items' % len(subnode.value), subnode.start_mark, ) key_node, value_node = subnode.value[0] key = self.construct_object(key_node) assert key not in omap value = self.construct_object(value_node) omap[key] = value def construct_yaml_pairs(self, node): # type: (Any) -> Any # Note: the same code as `construct_yaml_omap`. pairs = [] # type: List[Any] yield pairs if not isinstance(node, SequenceNode): raise ConstructorError( 'while constructing pairs', node.start_mark, 'expected a sequence, but found %s' % node.id, node.start_mark, ) for subnode in node.value: if not isinstance(subnode, MappingNode): raise ConstructorError( 'while constructing pairs', node.start_mark, 'expected a mapping of length 1, but found %s' % subnode.id, subnode.start_mark, ) if len(subnode.value) != 1: raise ConstructorError( 'while constructing pairs', node.start_mark, 'expected a single mapping item, but found %d items' % len(subnode.value), subnode.start_mark, ) key_node, value_node = subnode.value[0] key = self.construct_object(key_node) value = self.construct_object(value_node) pairs.append((key, value)) def construct_yaml_set(self, node): # type: (Any) -> Any data = set() # type: Set[Any] yield data value = self.construct_mapping(node) data.update(value) def construct_yaml_str(self, node): # type: (Any) -> Any value = self.construct_scalar(node) if PY3: return value try: return value.encode('ascii') except UnicodeEncodeError: return value def construct_yaml_seq(self, node): # type: (Any) -> Any data = self.yaml_base_list_type() # type: List[Any] yield data data.extend(self.construct_sequence(node)) def construct_yaml_map(self, node): # type: (Any) -> Any data = self.yaml_base_dict_type() # type: Dict[Any, Any] yield data value = self.construct_mapping(node) data.update(value) def construct_yaml_object(self, node, cls): # type: (Any, Any) -> Any data = cls.__new__(cls) yield data if hasattr(data, '__setstate__'): state = self.construct_mapping(node, deep=True) data.__setstate__(state) else: state = self.construct_mapping(node) data.__dict__.update(state) def construct_undefined(self, node): # type: (Any) -> None raise ConstructorError( None, None, 'could not determine a constructor for the tag %r' % utf8(node.tag), node.start_mark, ) SafeConstructor.add_constructor(u'tag:yaml.org,2002:null', SafeConstructor.construct_yaml_null) SafeConstructor.add_constructor(u'tag:yaml.org,2002:bool', SafeConstructor.construct_yaml_bool) SafeConstructor.add_constructor(u'tag:yaml.org,2002:int', SafeConstructor.construct_yaml_int) SafeConstructor.add_constructor( u'tag:yaml.org,2002:float', SafeConstructor.construct_yaml_float ) SafeConstructor.add_constructor( u'tag:yaml.org,2002:binary', SafeConstructor.construct_yaml_binary ) SafeConstructor.add_constructor( u'tag:yaml.org,2002:timestamp', SafeConstructor.construct_yaml_timestamp ) SafeConstructor.add_constructor(u'tag:yaml.org,2002:omap', SafeConstructor.construct_yaml_omap) SafeConstructor.add_constructor( u'tag:yaml.org,2002:pairs', SafeConstructor.construct_yaml_pairs ) SafeConstructor.add_constructor(u'tag:yaml.org,2002:set', SafeConstructor.construct_yaml_set) SafeConstructor.add_constructor(u'tag:yaml.org,2002:str', SafeConstructor.construct_yaml_str) SafeConstructor.add_constructor(u'tag:yaml.org,2002:seq', SafeConstructor.construct_yaml_seq) SafeConstructor.add_constructor(u'tag:yaml.org,2002:map', SafeConstructor.construct_yaml_map) SafeConstructor.add_constructor(None, SafeConstructor.construct_undefined) if PY2: class classobj: pass class Constructor(SafeConstructor): def construct_python_str(self, node): # type: (Any) -> Any return utf8(self.construct_scalar(node)) def construct_python_unicode(self, node): # type: (Any) -> Any return self.construct_scalar(node) if PY3: def construct_python_bytes(self, node): # type: (Any) -> Any try: value = self.construct_scalar(node).encode('ascii') except UnicodeEncodeError as exc: raise ConstructorError( None, None, 'failed to convert base64 data into ascii: %s' % exc, node.start_mark, ) try: if hasattr(base64, 'decodebytes'): return base64.decodebytes(value) else: return base64.decodestring(value) except binascii.Error as exc: raise ConstructorError( None, None, 'failed to decode base64 data: %s' % exc, node.start_mark ) def construct_python_long(self, node): # type: (Any) -> int val = self.construct_yaml_int(node) if PY3: return val return int(val) def construct_python_complex(self, node): # type: (Any) -> Any return complex(self.construct_scalar(node)) def construct_python_tuple(self, node): # type: (Any) -> Any return tuple(self.construct_sequence(node)) def find_python_module(self, name, mark): # type: (Any, Any) -> Any if not name: raise ConstructorError( 'while constructing a Python module', mark, 'expected non-empty name appended to the tag', mark, ) try: __import__(name) except ImportError as exc: raise ConstructorError( 'while constructing a Python module', mark, 'cannot find module %r (%s)' % (utf8(name), exc), mark, ) return sys.modules[name] def find_python_name(self, name, mark): # type: (Any, Any) -> Any if not name: raise ConstructorError( 'while constructing a Python object', mark, 'expected non-empty name appended to the tag', mark, ) if u'.' in name: lname = name.split('.') lmodule_name = lname lobject_name = [] # type: List[Any] while len(lmodule_name) > 1: lobject_name.insert(0, lmodule_name.pop()) module_name = '.'.join(lmodule_name) try: __import__(module_name) # object_name = '.'.join(object_name) break except ImportError: continue else: module_name = builtins_module lobject_name = [name] try: __import__(module_name) except ImportError as exc: raise ConstructorError( 'while constructing a Python object', mark, 'cannot find module %r (%s)' % (utf8(module_name), exc), mark, ) module = sys.modules[module_name] object_name = '.'.join(lobject_name) obj = module while lobject_name: if not hasattr(obj, lobject_name[0]): raise ConstructorError( 'while constructing a Python object', mark, 'cannot find %r in the module %r' % (utf8(object_name), module.__name__), mark, ) obj = getattr(obj, lobject_name.pop(0)) return obj def construct_python_name(self, suffix, node): # type: (Any, Any) -> Any value = self.construct_scalar(node) if value: raise ConstructorError( 'while constructing a Python name', node.start_mark, 'expected the empty value, but found %r' % utf8(value), node.start_mark, ) return self.find_python_name(suffix, node.start_mark) def construct_python_module(self, suffix, node): # type: (Any, Any) -> Any value = self.construct_scalar(node) if value: raise ConstructorError( 'while constructing a Python module', node.start_mark, 'expected the empty value, but found %r' % utf8(value), node.start_mark, ) return self.find_python_module(suffix, node.start_mark) def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False): # type: (Any, Any, Any, Any, bool) -> Any if not args: args = [] if not kwds: kwds = {} cls = self.find_python_name(suffix, node.start_mark) if PY3: if newobj and isinstance(cls, type): return cls.__new__(cls, *args, **kwds) else: return cls(*args, **kwds) else: if newobj and isinstance(cls, type(classobj)) and not args and not kwds: instance = classobj() instance.__class__ = cls return instance elif newobj and isinstance(cls, type): return cls.__new__(cls, *args, **kwds) else: return cls(*args, **kwds) def set_python_instance_state(self, instance, state): # type: (Any, Any) -> None if hasattr(instance, '__setstate__'): instance.__setstate__(state) else: slotstate = {} # type: Dict[Any, Any] if isinstance(state, tuple) and len(state) == 2: state, slotstate = state if hasattr(instance, '__dict__'): instance.__dict__.update(state) elif state: slotstate.update(state) for key, value in slotstate.items(): setattr(object, key, value) def construct_python_object(self, suffix, node): # type: (Any, Any) -> Any # Format: # !!python/object:module.name { ... state ... } instance = self.make_python_instance(suffix, node, newobj=True) self.recursive_objects[node] = instance yield instance deep = hasattr(instance, '__setstate__') state = self.construct_mapping(node, deep=deep) self.set_python_instance_state(instance, state) def construct_python_object_apply(self, suffix, node, newobj=False): # type: (Any, Any, bool) -> Any # Format: # !!python/object/apply # (or !!python/object/new) # args: [ ... arguments ... ] # kwds: { ... keywords ... } # state: ... state ... # listitems: [ ... listitems ... ] # dictitems: { ... dictitems ... } # or short format: # !!python/object/apply [ ... arguments ... ] # The difference between !!python/object/apply and !!python/object/new # is how an object is created, check make_python_instance for details. if isinstance(node, SequenceNode): args = self.construct_sequence(node, deep=True) kwds = {} # type: Dict[Any, Any] state = {} # type: Dict[Any, Any] listitems = [] # type: List[Any] dictitems = {} # type: Dict[Any, Any] else: value = self.construct_mapping(node, deep=True) args = value.get('args', []) kwds = value.get('kwds', {}) state = value.get('state', {}) listitems = value.get('listitems', []) dictitems = value.get('dictitems', {}) instance = self.make_python_instance(suffix, node, args, kwds, newobj) if bool(state): self.set_python_instance_state(instance, state) if bool(listitems): instance.extend(listitems) if bool(dictitems): for key in dictitems: instance[key] = dictitems[key] return instance def construct_python_object_new(self, suffix, node): # type: (Any, Any) -> Any return self.construct_python_object_apply(suffix, node, newobj=True) Constructor.add_constructor(u'tag:yaml.org,2002:python/none', Constructor.construct_yaml_null) Constructor.add_constructor(u'tag:yaml.org,2002:python/bool', Constructor.construct_yaml_bool) Constructor.add_constructor(u'tag:yaml.org,2002:python/str', Constructor.construct_python_str) Constructor.add_constructor( u'tag:yaml.org,2002:python/unicode', Constructor.construct_python_unicode ) if PY3: Constructor.add_constructor( u'tag:yaml.org,2002:python/bytes', Constructor.construct_python_bytes ) Constructor.add_constructor(u'tag:yaml.org,2002:python/int', Constructor.construct_yaml_int) Constructor.add_constructor( u'tag:yaml.org,2002:python/long', Constructor.construct_python_long ) Constructor.add_constructor( u'tag:yaml.org,2002:python/float', Constructor.construct_yaml_float ) Constructor.add_constructor( u'tag:yaml.org,2002:python/complex', Constructor.construct_python_complex ) Constructor.add_constructor(u'tag:yaml.org,2002:python/list', Constructor.construct_yaml_seq) Constructor.add_constructor( u'tag:yaml.org,2002:python/tuple', Constructor.construct_python_tuple ) Constructor.add_constructor(u'tag:yaml.org,2002:python/dict', Constructor.construct_yaml_map) Constructor.add_multi_constructor( u'tag:yaml.org,2002:python/name:', Constructor.construct_python_name ) Constructor.add_multi_constructor( u'tag:yaml.org,2002:python/module:', Constructor.construct_python_module ) Constructor.add_multi_constructor( u'tag:yaml.org,2002:python/object:', Constructor.construct_python_object ) Constructor.add_multi_constructor( u'tag:yaml.org,2002:python/object/apply:', Constructor.construct_python_object_apply ) Constructor.add_multi_constructor( u'tag:yaml.org,2002:python/object/new:', Constructor.construct_python_object_new ) class RoundTripConstructor(SafeConstructor): """need to store the comments on the node itself, as well as on the items """ def construct_scalar(self, node): # type: (Any) -> Any if not isinstance(node, ScalarNode): raise ConstructorError( None, None, 'expected a scalar node, but found %s' % node.id, node.start_mark ) if node.style == '|' and isinstance(node.value, text_type): lss = LiteralScalarString(node.value, anchor=node.anchor) if node.comment and node.comment[1]: lss.comment = node.comment[1][0] # type: ignore return lss if node.style == '>' and isinstance(node.value, text_type): fold_positions = [] # type: List[int] idx = -1 while True: idx = node.value.find('\a', idx + 1) if idx < 0: break fold_positions.append(idx - len(fold_positions)) fss = FoldedScalarString(node.value.replace('\a', ''), anchor=node.anchor) if node.comment and node.comment[1]: fss.comment = node.comment[1][0] # type: ignore if fold_positions: fss.fold_pos = fold_positions # type: ignore return fss elif bool(self._preserve_quotes) and isinstance(node.value, text_type): if node.style == "'": return SingleQuotedScalarString(node.value, anchor=node.anchor) if node.style == '"': return DoubleQuotedScalarString(node.value, anchor=node.anchor) if node.anchor: return PlainScalarString(node.value, anchor=node.anchor) return node.value def construct_yaml_int(self, node): # type: (Any) -> Any width = None # type: Any value_su = to_str(self.construct_scalar(node)) try: sx = value_su.rstrip('_') underscore = [len(sx) - sx.rindex('_') - 1, False, False] # type: Any except ValueError: underscore = None except IndexError: underscore = None value_s = value_su.replace('_', "") sign = +1 if value_s[0] == '-': sign = -1 if value_s[0] in '+-': value_s = value_s[1:] if value_s == '0': return 0 elif value_s.startswith('0b'): if self.resolver.processing_version > (1, 1) and value_s[2] == '0': width = len(value_s[2:]) if underscore is not None: underscore[1] = value_su[2] == '_' underscore[2] = len(value_su[2:]) > 1 and value_su[-1] == '_' return BinaryInt( sign * int(value_s[2:], 2), width=width, underscore=underscore, anchor=node.anchor, ) elif value_s.startswith('0x'): # default to lower-case if no a-fA-F in string if self.resolver.processing_version > (1, 1) and value_s[2] == '0': width = len(value_s[2:]) hex_fun = HexInt # type: Any for ch in value_s[2:]: if ch in 'ABCDEF': # first non-digit is capital hex_fun = HexCapsInt break if ch in 'abcdef': break if underscore is not None: underscore[1] = value_su[2] == '_' underscore[2] = len(value_su[2:]) > 1 and value_su[-1] == '_' return hex_fun( sign * int(value_s[2:], 16), width=width, underscore=underscore, anchor=node.anchor, ) elif value_s.startswith('0o'): if self.resolver.processing_version > (1, 1) and value_s[2] == '0': width = len(value_s[2:]) if underscore is not None: underscore[1] = value_su[2] == '_' underscore[2] = len(value_su[2:]) > 1 and value_su[-1] == '_' return OctalInt( sign * int(value_s[2:], 8), width=width, underscore=underscore, anchor=node.anchor, ) elif self.resolver.processing_version != (1, 2) and value_s[0] == '0': return sign * int(value_s, 8) elif self.resolver.processing_version != (1, 2) and ':' in value_s: digits = [int(part) for part in value_s.split(':')] digits.reverse() base = 1 value = 0 for digit in digits: value += digit * base base *= 60 return sign * value elif self.resolver.processing_version > (1, 1) and value_s[0] == '0': # not an octal, an integer with leading zero(s) if underscore is not None: # cannot have a leading underscore underscore[2] = len(value_su) > 1 and value_su[-1] == '_' return ScalarInt(sign * int(value_s), width=len(value_s), underscore=underscore) elif underscore: # cannot have a leading underscore underscore[2] = len(value_su) > 1 and value_su[-1] == '_' return ScalarInt( sign * int(value_s), width=None, underscore=underscore, anchor=node.anchor ) elif node.anchor: return ScalarInt(sign * int(value_s), width=None, anchor=node.anchor) else: return sign * int(value_s) def construct_yaml_float(self, node): # type: (Any) -> Any def leading_zeros(v): # type: (Any) -> int lead0 = 0 idx = 0 while idx < len(v) and v[idx] in '0.': if v[idx] == '0': lead0 += 1 idx += 1 return lead0 # underscore = None m_sign = False # type: Any value_so = to_str(self.construct_scalar(node)) value_s = value_so.replace('_', "").lower() sign = +1 if value_s[0] == '-': sign = -1 if value_s[0] in '+-': m_sign = value_s[0] value_s = value_s[1:] if value_s == '.inf': return sign * self.inf_value if value_s == '.nan': return self.nan_value if self.resolver.processing_version != (1, 2) and ':' in value_s: digits = [float(part) for part in value_s.split(':')] digits.reverse() base = 1 value = 0.0 for digit in digits: value += digit * base base *= 60 return sign * value if 'e' in value_s: try: mantissa, exponent = value_so.split('e') exp = 'e' except ValueError: mantissa, exponent = value_so.split('E') exp = 'E' if self.resolver.processing_version != (1, 2): # value_s is lower case independent of input if '.' not in mantissa: warnings.warn(MantissaNoDotYAML1_1Warning(node, value_so)) lead0 = leading_zeros(mantissa) width = len(mantissa) prec = mantissa.find('.') if m_sign: width -= 1 e_width = len(exponent) e_sign = exponent[0] in '+-' # nprint('sf', width, prec, m_sign, exp, e_width, e_sign) return ScalarFloat( sign * float(value_s), width=width, prec=prec, m_sign=m_sign, m_lead0=lead0, exp=exp, e_width=e_width, e_sign=e_sign, anchor=node.anchor, ) width = len(value_so) prec = value_so.index('.') # you can use index, this would not be float without dot lead0 = leading_zeros(value_so) return ScalarFloat( sign * float(value_s), width=width, prec=prec, m_sign=m_sign, m_lead0=lead0, anchor=node.anchor, ) def construct_yaml_str(self, node): # type: (Any) -> Any value = self.construct_scalar(node) if isinstance(value, ScalarString): return value if PY3: return value try: return value.encode('ascii') except AttributeError: # in case you replace the node dynamically e.g. with a dict return value except UnicodeEncodeError: return value def construct_rt_sequence(self, node, seqtyp, deep=False): # type: (Any, Any, bool) -> Any if not isinstance(node, SequenceNode): raise ConstructorError( None, None, 'expected a sequence node, but found %s' % node.id, node.start_mark ) ret_val = [] if node.comment: seqtyp._yaml_add_comment(node.comment[:2]) if len(node.comment) > 2: seqtyp.yaml_end_comment_extend(node.comment[2], clear=True) if node.anchor: from ruamel.yaml.serializer import templated_id if not templated_id(node.anchor): seqtyp.yaml_set_anchor(node.anchor) for idx, child in enumerate(node.value): ret_val.append(self.construct_object(child, deep=deep)) if child.comment: seqtyp._yaml_add_comment(child.comment, key=idx) seqtyp._yaml_set_idx_line_col( idx, [child.start_mark.line, child.start_mark.column] ) return ret_val def flatten_mapping(self, node): # type: (Any) -> Any """ This implements the merge key feature http://yaml.org/type/merge.html by inserting keys from the merge dict/list of dicts if not yet available in this node """ def constructed(value_node): # type: (Any) -> Any # If the contents of a merge are defined within the # merge marker, then they won't have been constructed # yet. But if they were already constructed, we need to use # the existing object. if value_node in self.constructed_objects: value = self.constructed_objects[value_node] else: value = self.construct_object(value_node, deep=False) return value # merge = [] merge_map_list = [] # type: List[Any] index = 0 while index < len(node.value): key_node, value_node = node.value[index] if key_node.tag == u'tag:yaml.org,2002:merge': if merge_map_list: # double << key args = [ 'while constructing a mapping', node.start_mark, 'found duplicate key "{}"'.format(key_node.value), key_node.start_mark, """ To suppress this check see: http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys """, """\ Duplicate keys will become an error in future releases, and are errors by default when using the new API. """, ] if self.allow_duplicate_keys is None: warnings.warn(DuplicateKeyFutureWarning(*args)) else: raise DuplicateKeyError(*args) del node.value[index] if isinstance(value_node, MappingNode): merge_map_list.append((index, constructed(value_node))) # self.flatten_mapping(value_node) # merge.extend(value_node.value) elif isinstance(value_node, SequenceNode): # submerge = [] for subnode in value_node.value: if not isinstance(subnode, MappingNode): raise ConstructorError( 'while constructing a mapping', node.start_mark, 'expected a mapping for merging, but found %s' % subnode.id, subnode.start_mark, ) merge_map_list.append((index, constructed(subnode))) # self.flatten_mapping(subnode) # submerge.append(subnode.value) # submerge.reverse() # for value in submerge: # merge.extend(value) else: raise ConstructorError( 'while constructing a mapping', node.start_mark, 'expected a mapping or list of mappings for merging, ' 'but found %s' % value_node.id, value_node.start_mark, ) elif key_node.tag == u'tag:yaml.org,2002:value': key_node.tag = u'tag:yaml.org,2002:str' index += 1 else: index += 1 return merge_map_list # if merge: # node.value = merge + node.value def _sentinel(self): # type: () -> None pass def construct_mapping(self, node, maptyp, deep=False): # type: ignore # type: (Any, Any, bool) -> Any if not isinstance(node, MappingNode): raise ConstructorError( None, None, 'expected a mapping node, but found %s' % node.id, node.start_mark ) merge_map = self.flatten_mapping(node) # mapping = {} if node.comment: maptyp._yaml_add_comment(node.comment[:2]) if len(node.comment) > 2: maptyp.yaml_end_comment_extend(node.comment[2], clear=True) if node.anchor: from ruamel.yaml.serializer import templated_id if not templated_id(node.anchor): maptyp.yaml_set_anchor(node.anchor) last_key, last_value = None, self._sentinel for key_node, value_node in node.value: # keys can be list -> deep key = self.construct_object(key_node, deep=True) # lists are not hashable, but tuples are if not isinstance(key, Hashable): if isinstance(key, MutableSequence): key_s = CommentedKeySeq(key) if key_node.flow_style is True: key_s.fa.set_flow_style() elif key_node.flow_style is False: key_s.fa.set_block_style() key = key_s elif isinstance(key, MutableMapping): key_m = CommentedKeyMap(key) if key_node.flow_style is True: key_m.fa.set_flow_style() elif key_node.flow_style is False: key_m.fa.set_block_style() key = key_m if PY2: try: hash(key) except TypeError as exc: raise ConstructorError( 'while constructing a mapping', node.start_mark, 'found unacceptable key (%s)' % exc, key_node.start_mark, ) else: if not isinstance(key, Hashable): raise ConstructorError( 'while constructing a mapping', node.start_mark, 'found unhashable key', key_node.start_mark, ) value = self.construct_object(value_node, deep=deep) if self.check_mapping_key(node, key_node, maptyp, key, value): if key_node.comment and len(key_node.comment) > 4 and key_node.comment[4]: if last_value is None: key_node.comment[0] = key_node.comment.pop(4) maptyp._yaml_add_comment(key_node.comment, value=last_key) else: key_node.comment[2] = key_node.comment.pop(4) maptyp._yaml_add_comment(key_node.comment, key=key) key_node.comment = None if key_node.comment: maptyp._yaml_add_comment(key_node.comment, key=key) if value_node.comment: maptyp._yaml_add_comment(value_node.comment, value=key) maptyp._yaml_set_kv_line_col( key, [ key_node.start_mark.line, key_node.start_mark.column, value_node.start_mark.line, value_node.start_mark.column, ], ) maptyp[key] = value last_key, last_value = key, value # could use indexing # do this last, or <<: before a key will prevent insertion in instances # of collections.OrderedDict (as they have no __contains__ if merge_map: maptyp.add_yaml_merge(merge_map) def construct_setting(self, node, typ, deep=False): # type: (Any, Any, bool) -> Any if not isinstance(node, MappingNode): raise ConstructorError( None, None, 'expected a mapping node, but found %s' % node.id, node.start_mark ) if node.comment: typ._yaml_add_comment(node.comment[:2]) if len(node.comment) > 2: typ.yaml_end_comment_extend(node.comment[2], clear=True) if node.anchor: from ruamel.yaml.serializer import templated_id if not templated_id(node.anchor): typ.yaml_set_anchor(node.anchor) for key_node, value_node in node.value: # keys can be list -> deep key = self.construct_object(key_node, deep=True) # lists are not hashable, but tuples are if not isinstance(key, Hashable): if isinstance(key, list): key = tuple(key) if PY2: try: hash(key) except TypeError as exc: raise ConstructorError( 'while constructing a mapping', node.start_mark, 'found unacceptable key (%s)' % exc, key_node.start_mark, ) else: if not isinstance(key, Hashable): raise ConstructorError( 'while constructing a mapping', node.start_mark, 'found unhashable key', key_node.start_mark, ) # construct but should be null value = self.construct_object(value_node, deep=deep) # NOQA self.check_set_key(node, key_node, typ, key) if key_node.comment: typ._yaml_add_comment(key_node.comment, key=key) if value_node.comment: typ._yaml_add_comment(value_node.comment, value=key) typ.add(key) def construct_yaml_seq(self, node): # type: (Any) -> Any data = CommentedSeq() data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) if node.comment: data._yaml_add_comment(node.comment) yield data data.extend(self.construct_rt_sequence(node, data)) self.set_collection_style(data, node) def construct_yaml_map(self, node): # type: (Any) -> Any data = CommentedMap() data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) yield data self.construct_mapping(node, data, deep=True) self.set_collection_style(data, node) def set_collection_style(self, data, node): # type: (Any, Any) -> None if len(data) == 0: return if node.flow_style is True: data.fa.set_flow_style() elif node.flow_style is False: data.fa.set_block_style() def construct_yaml_object(self, node, cls): # type: (Any, Any) -> Any data = cls.__new__(cls) yield data if hasattr(data, '__setstate__'): state = SafeConstructor.construct_mapping(self, node, deep=True) data.__setstate__(state) else: state = SafeConstructor.construct_mapping(self, node) data.__dict__.update(state) def construct_yaml_omap(self, node): # type: (Any) -> Any # Note: we do now check for duplicate keys omap = CommentedOrderedMap() omap._yaml_set_line_col(node.start_mark.line, node.start_mark.column) if node.flow_style is True: omap.fa.set_flow_style() elif node.flow_style is False: omap.fa.set_block_style() yield omap if node.comment: omap._yaml_add_comment(node.comment[:2]) if len(node.comment) > 2: omap.yaml_end_comment_extend(node.comment[2], clear=True) if not isinstance(node, SequenceNode): raise ConstructorError( 'while constructing an ordered map', node.start_mark, 'expected a sequence, but found %s' % node.id, node.start_mark, ) for subnode in node.value: if not isinstance(subnode, MappingNode): raise ConstructorError( 'while constructing an ordered map', node.start_mark, 'expected a mapping of length 1, but found %s' % subnode.id, subnode.start_mark, ) if len(subnode.value) != 1: raise ConstructorError( 'while constructing an ordered map', node.start_mark, 'expected a single mapping item, but found %d items' % len(subnode.value), subnode.start_mark, ) key_node, value_node = subnode.value[0] key = self.construct_object(key_node) assert key not in omap value = self.construct_object(value_node) if key_node.comment: omap._yaml_add_comment(key_node.comment, key=key) if subnode.comment: omap._yaml_add_comment(subnode.comment, key=key) if value_node.comment: omap._yaml_add_comment(value_node.comment, value=key) omap[key] = value def construct_yaml_set(self, node): # type: (Any) -> Any data = CommentedSet() data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) yield data self.construct_setting(node, data) def construct_undefined(self, node): # type: (Any) -> Any try: if isinstance(node, MappingNode): data = CommentedMap() data._yaml_set_line_col(node.start_mark.line, node.start_mark.column) if node.flow_style is True: data.fa.set_flow_style() elif node.flow_style is False: data.fa.set_block_style() data.yaml_set_tag(node.tag) yield data if node.anchor: data.yaml_set_anchor(node.anchor) self.construct_mapping(node, data) return elif isinstance(node, ScalarNode): data2 = TaggedScalar() data2.value = self.construct_scalar(node) data2.style = node.style data2.yaml_set_tag(node.tag) yield data2 if node.anchor: data2.yaml_set_anchor(node.anchor, always_dump=True) return elif isinstance(node, SequenceNode): data3 = CommentedSeq() data3._yaml_set_line_col(node.start_mark.line, node.start_mark.column) if node.flow_style is True: data3.fa.set_flow_style() elif node.flow_style is False: data3.fa.set_block_style() data3.yaml_set_tag(node.tag) yield data3 if node.anchor: data3.yaml_set_anchor(node.anchor) data3.extend(self.construct_sequence(node)) return except: # NOQA pass raise ConstructorError( None, None, 'could not determine a constructor for the tag %r' % utf8(node.tag), node.start_mark, ) def construct_yaml_timestamp(self, node, values=None): # type: (Any, Any) -> Any try: match = self.timestamp_regexp.match(node.value) except TypeError: match = None if match is None: raise ConstructorError( None, None, 'failed to construct timestamp from "{}"'.format(node.value), node.start_mark, ) values = match.groupdict() if not values['hour']: return SafeConstructor.construct_yaml_timestamp(self, node, values) for part in ['t', 'tz_sign', 'tz_hour', 'tz_minute']: if values[part]: break else: return SafeConstructor.construct_yaml_timestamp(self, node, values) year = int(values['year']) month = int(values['month']) day = int(values['day']) hour = int(values['hour']) minute = int(values['minute']) second = int(values['second']) fraction = 0 if values['fraction']: fraction_s = values['fraction'][:6] while len(fraction_s) < 6: fraction_s += '0' fraction = int(fraction_s) if len(values['fraction']) > 6 and int(values['fraction'][6]) > 4: fraction += 1 delta = None if values['tz_sign']: tz_hour = int(values['tz_hour']) minutes = values['tz_minute'] tz_minute = int(minutes) if minutes else 0 delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) if values['tz_sign'] == '-': delta = -delta if delta: dt = datetime.datetime(year, month, day, hour, minute) dt -= delta data = TimeStamp(dt.year, dt.month, dt.day, dt.hour, dt.minute, second, fraction) data._yaml['delta'] = delta tz = values['tz_sign'] + values['tz_hour'] if values['tz_minute']: tz += ':' + values['tz_minute'] data._yaml['tz'] = tz else: data = TimeStamp(year, month, day, hour, minute, second, fraction) if values['tz']: # no delta data._yaml['tz'] = values['tz'] if values['t']: data._yaml['t'] = True return data def construct_yaml_bool(self, node): # type: (Any) -> Any b = SafeConstructor.construct_yaml_bool(self, node) if node.anchor: return ScalarBoolean(b, anchor=node.anchor) return b RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:null', RoundTripConstructor.construct_yaml_null ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:bool', RoundTripConstructor.construct_yaml_bool ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:int', RoundTripConstructor.construct_yaml_int ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:float', RoundTripConstructor.construct_yaml_float ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:binary', RoundTripConstructor.construct_yaml_binary ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:timestamp', RoundTripConstructor.construct_yaml_timestamp ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:omap', RoundTripConstructor.construct_yaml_omap ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:pairs', RoundTripConstructor.construct_yaml_pairs ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:set', RoundTripConstructor.construct_yaml_set ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:str', RoundTripConstructor.construct_yaml_str ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:seq', RoundTripConstructor.construct_yaml_seq ) RoundTripConstructor.add_constructor( u'tag:yaml.org,2002:map', RoundTripConstructor.construct_yaml_map ) RoundTripConstructor.add_constructor(None, RoundTripConstructor.construct_undefined) ruamel.yaml-0.15.89/compat.py0000664000175100001440000002060413430633221016431 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function # partially from package six by Benjamin Peterson import sys import os import types import traceback from abc import abstractmethod # fmt: off if False: # MYPY from typing import Any, Dict, Optional, List, Union, BinaryIO, IO, Text, Tuple, Optional # NOQA # fmt: on _DEFAULT_YAML_VERSION = (1, 2) try: from ruamel.ordereddict import ordereddict except: # NOQA try: from collections import OrderedDict except ImportError: from ordereddict import OrderedDict # type: ignore # to get the right name import ... as ordereddict doesn't do that class ordereddict(OrderedDict): # type: ignore if not hasattr(OrderedDict, 'insert'): def insert(self, pos, key, value): # type: (int, Any, Any) -> None if pos >= len(self): self[key] = value return od = ordereddict() od.update(self) for k in od: del self[k] for index, old_key in enumerate(od): if pos == index: self[key] = value self[old_key] = od[old_key] PY2 = sys.version_info[0] == 2 PY3 = sys.version_info[0] == 3 if PY3: def utf8(s): # type: (str) -> str return s def to_str(s): # type: (str) -> str return s def to_unicode(s): # type: (str) -> str return s else: if False: unicode = str def utf8(s): # type: (unicode) -> str return s.encode('utf-8') def to_str(s): # type: (str) -> str return str(s) def to_unicode(s): # type: (str) -> unicode return unicode(s) # NOQA if PY3: string_types = str integer_types = int class_types = type text_type = str binary_type = bytes MAXSIZE = sys.maxsize unichr = chr import io StringIO = io.StringIO BytesIO = io.BytesIO # have unlimited precision no_limit_int = int from collections.abc import Hashable, MutableSequence, MutableMapping, Mapping # NOQA else: string_types = basestring # NOQA integer_types = (int, long) # NOQA class_types = (type, types.ClassType) text_type = unicode # NOQA binary_type = str # to allow importing unichr = unichr # type: ignore from StringIO import StringIO as _StringIO StringIO = _StringIO import cStringIO BytesIO = cStringIO.StringIO # have unlimited precision no_limit_int = long # NOQA not available on Python 3 from collections import Hashable, MutableSequence, MutableMapping, Mapping # NOQA if False: # MYPY # StreamType = Union[BinaryIO, IO[str], IO[unicode], StringIO] # StreamType = Union[BinaryIO, IO[str], StringIO] # type: ignore StreamType = Any StreamTextType = Union[Text, StreamType] VersionType = Union[List[int], str, Tuple[int, int]] if PY3: builtins_module = 'builtins' else: builtins_module = '__builtin__' UNICODE_SIZE = 4 if sys.maxunicode > 65535 else 2 def with_metaclass(meta, *bases): # type: (Any, Any) -> Any """Create a base class with a metaclass.""" return meta('NewBase', bases, {}) DBG_TOKEN = 1 DBG_EVENT = 2 DBG_NODE = 4 _debug = None # type: Optional[int] if 'RUAMELDEBUG' in os.environ: _debugx = os.environ.get('RUAMELDEBUG') if _debugx is None: _debug = 0 else: _debug = int(_debugx) if bool(_debug): class ObjectCounter(object): def __init__(self): # type: () -> None self.map = {} # type: Dict[Any, Any] def __call__(self, k): # type: (Any) -> None self.map[k] = self.map.get(k, 0) + 1 def dump(self): # type: () -> None for k in sorted(self.map): sys.stdout.write('{} -> {}'.format(k, self.map[k])) object_counter = ObjectCounter() # used from yaml util when testing def dbg(val=None): # type: (Any) -> Any global _debug if _debug is None: # set to true or false _debugx = os.environ.get('YAMLDEBUG') if _debugx is None: _debug = 0 else: _debug = int(_debugx) if val is None: return _debug return _debug & val class Nprint(object): def __init__(self, file_name=None): # type: (Any) -> None self._max_print = None # type: Any self._count = None # type: Any self._file_name = file_name def __call__(self, *args, **kw): # type: (Any, Any) -> None if not bool(_debug): return out = sys.stdout if self._file_name is None else open(self._file_name, 'a') dbgprint = print # to fool checking for print statements by dv utility kw1 = kw.copy() kw1['file'] = out dbgprint(*args, **kw1) out.flush() if self._max_print is not None: if self._count is None: self._count = self._max_print self._count -= 1 if self._count == 0: dbgprint('forced exit\n') traceback.print_stack() out.flush() sys.exit(0) if self._file_name: out.close() def set_max_print(self, i): # type: (int) -> None self._max_print = i self._count = None nprint = Nprint() nprintf = Nprint('/var/tmp/ruamel.yaml.log') # char checkers following production rules def check_namespace_char(ch): # type: (Any) -> bool if u'\x21' <= ch <= u'\x7E': # ! to ~ return True if u'\xA0' <= ch <= u'\uD7FF': return True if (u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF': # excl. byte order mark return True if u'\U00010000' <= ch <= u'\U0010FFFF': return True return False def check_anchorname_char(ch): # type: (Any) -> bool if ch in u',[]{}': return False return check_namespace_char(ch) def version_tnf(t1, t2=None): # type: (Any, Any) -> Any from ruamel.yaml import version_info # NOQA if version_info < t1: return True if t2 is not None and version_info < t2: return None return False class MutableSliceableSequence(MutableSequence): # type: ignore __slots__ = () def __getitem__(self, index): # type: (Any) -> Any if not isinstance(index, slice): return self.__getsingleitem__(index) return type(self)([self[i] for i in range(*index.indices(len(self)))]) # type: ignore def __setitem__(self, index, value): # type: (Any, Any) -> None if not isinstance(index, slice): return self.__setsingleitem__(index, value) assert iter(value) # nprint(index.start, index.stop, index.step, index.indices(len(self))) if index.step is None: del self[index.start : index.stop] for elem in reversed(value): self.insert(0 if index.start is None else index.start, elem) else: range_parms = index.indices(len(self)) nr_assigned_items = (range_parms[1] - range_parms[0] - 1) // range_parms[2] + 1 # need to test before changing, in case TypeError is caught if nr_assigned_items < len(value): raise TypeError( 'too many elements in value {} < {}'.format(nr_assigned_items, len(value)) ) elif nr_assigned_items > len(value): raise TypeError( 'not enough elements in value {} > {}'.format( nr_assigned_items, len(value) ) ) for idx, i in enumerate(range(*range_parms)): self[i] = value[idx] def __delitem__(self, index): # type: (Any) -> None if not isinstance(index, slice): return self.__delsingleitem__(index) # nprint(index.start, index.stop, index.step, index.indices(len(self))) for i in reversed(range(*index.indices(len(self)))): del self[i] @abstractmethod def __getsingleitem__(self, index): # type: (Any) -> Any raise IndexError @abstractmethod def __setsingleitem__(self, index, value): # type: (Any, Any) -> None raise IndexError @abstractmethod def __delsingleitem__(self, index): # type: (Any) -> None raise IndexError ruamel.yaml-0.15.89/anchor.py0000664000175100001440000000035213373303256016426 0ustar anthonusers00000000000000 anchor_attrib = '_yaml_anchor' class Anchor(object): __slots__ = 'value', 'always_dump' attrib = anchor_attrib def __init__(self): # type: () -> None self.value = None self.always_dump = False ruamel.yaml-0.15.89/PKG-INFO0000664000175100001440000010342113435603756015707 0ustar anthonusers00000000000000Metadata-Version: 1.1 Name: ruamel.yaml Version: 0.15.89 Summary: ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order Home-page: https://bitbucket.org/ruamel/yaml Author: Anthon van der Neut Author-email: a.van.der.neut@ruamel.eu License: MIT license Description: ruamel.yaml =========== ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python. :version: 0.15.89 :updated: 2019-02-27 :documentation: http://yaml.readthedocs.io :repository: https://bitbucket.org/ruamel/ :pypi: https://pypi.org/project/ruamel.yaml/ Starting with version 0.15.0 the way YAML files are loaded and dumped is changing. See the API doc for details. Currently existing functionality will throw a warning before being changed/removed. **For production systems you should pin the version being used with ``ruamel.yaml<=0.15``**. There might be bug fixes in the 0.14 series, but new functionality is likely only to be available via the new API. If your package uses ``ruamel.yaml`` and is not listed on PyPI, drop me an email, preferably with some information on how you use the package (or a link to bitbucket/github) and I'll keep you informed when the status of the API is stable enough to make the transition. * `Overview `_ * `Installing `_ * `Basic Usage `_ * `Details `_ * `Examples `_ * `API `_ * `Differences with PyYAML `_ .. image:: https://readthedocs.org/projects/yaml/badge/?version=stable :target: https://yaml.readthedocs.org/en/stable .. image:: https://bestpractices.coreinfrastructure.org/projects/1128/badge :target: https://bestpractices.coreinfrastructure.org/projects/1128 .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/license.svg :target: https://opensource.org/licenses/MIT .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/pypi.svg :target: https://pypi.org/project/ruamel.yaml/ .. image:: https://bitbucket.org/ruamel/oitnb/raw/default/_doc/_static/oitnb.svg :target: https://pypi.org/project/oitnb/ .. image:: http://www.mypy-lang.org/static/mypy_badge.svg :target: http://mypy-lang.org/ ChangeLog ========= .. should insert NEXT: at the beginning of line for next key (with empty line) 0.15.89 (2019-02-27): - fix for items with flow-mapping in block sequence output on single line (reported by `Zahari Dim `__) - fix for safe dumping erroring in creation of representereror when dumping namedtuple (reported and solution by `Jaakko Kantojärvi `__) 0.15.88 (2019-02-12): - fix inclusing of python code from the subpackage data (containing extra tests, reported by `Florian Apolloner `__) 0.15.87 (2019-01-22): - fix problem with empty lists and the code to reinsert merge keys (reported via email by Zaloo) 0.15.86 (2019-01-16): - reinsert merge key in its old position (reported by grumbler on `__) - fix for issue with non-ASCII anchor names (reported and fix provided by Dandaleon Flux via email) - fix for issue when parsing flow mapping value starting with colon (in pure Python only) (reported by `FichteFoll `__) 0.15.85 (2019-01-08): - the types used by ``SafeConstructor`` for mappings and sequences can now by set by assigning to ``XXXConstructor.yaml_base_dict_type`` (and ``..._list_type``), preventing the need to copy two methods with 50+ lines that had ``var = {}`` hardcoded. (Implemented to help solve an feature request by `Anthony Sottile `__ in an easier way) 0.15.84 (2019-01-07): - fix for ``CommentedMap.copy()`` not returning ``CommentedMap``, let alone copying comments etc. (reported by `Anthony Sottile `__) 0.15.83 (2019-01-02): - fix for bug in roundtripping aliases used as key (reported via email by Zaloo) 0.15.82 (2018-12-28): - anchors and aliases on scalar int, float, string and bool are now preserved. Anchors do not need a referring alias for these (reported by `Alex Harvey `__) - anchors no longer lost on tagged objects when roundtripping (reported by `Zaloo `__) 0.15.81 (2018-12-06): - fix issue dumping methods of metaclass derived classes (reported and fix provided by `Douglas Raillard `__) 0.15.80 (2018-11-26): - fix issue emitting BEL character when round-tripping invalid folded input (reported by Isaac on `StackOverflow `__) 0.15.79 (2018-11-21): - fix issue with anchors nested deeper than alias (reported by gaFF on `StackOverflow `__) 0.15.78 (2018-11-15): - fix setup issue for 3.8 (reported by `Sidney Kuyateh `__) 0.15.77 (2018-11-09): - setting `yaml.sort_base_mapping_type_on_output = False`, will prevent explicit sorting by keys in the base representer of mappings. Roundtrip already did not do this. Usage only makes real sense for Python 3.6+ (feature request by `Sebastian Gerber `__). - implement Python version check in YAML metadata in ``_test/test_z_data.py`` 0.15.76 (2018-11-01): - fix issue with empty mapping and sequence loaded as flow-style (mapping reported by `Min RK `__, sequence by `Maged Ahmed `__) 0.15.75 (2018-10-27): - fix issue with single '?' scalar (reported by `Terrance `__) - fix issue with duplicate merge keys (prompted by `answering `__ a `StackOverflow question `__ by `math `__) 0.15.74 (2018-10-17): - fix dropping of comment on rt before sequence item that is sequence item (reported by `Thorsten Kampe `__) 0.15.73 (2018-10-16): - fix irregular output on pre-comment in sequence within sequence (reported by `Thorsten Kampe `__) - allow non-compact (i.e. next line) dumping sequence/mapping within sequence. 0.15.72 (2018-10-06): - fix regression on explicit 1.1 loading with the C based scanner/parser (reported by `Tomas Vavra `__) 0.15.71 (2018-09-26): - some of the tests now live in YAML files in the `yaml.data `__ repository. ``_test/test_z_data.py`` processes these. - fix regression where handcrafted CommentedMaps could not be initiated (reported by `Dan Helfman `__) - fix regression with non-root literal scalars that needed indent indicator (reported by `Clark Breyman `__) - tag:yaml.org,2002:python/object/apply now also uses __qualname__ on PY3 (reported by `Douglas RAILLARD `__) - issue with self-referring object creation (reported and fix by `Douglas RAILLARD `__) 0.15.70 (2018-09-21): - reverted CommentedMap and CommentedSeq to subclass ordereddict resp. list, reimplemented merge maps so that both ``dict(**commented_map_instance)`` and JSON dumping works. This also allows checking with ``isinstance()`` on ``dict`` resp. ``list``. (Proposed by `Stuart Berg `__, with feedback from `blhsing `__ on `StackOverflow `__) 0.15.69 (2018-09-20): - fix issue with dump_all gobbling end-of-document comments on parsing (reported by `Pierre B. `__) 0.15.68 (2018-09-20): - fix issue with parsabel, but incorrect output with nested flow-style sequences (reported by `Dougal Seeley `__) - fix issue with loading Python objects that have __setstate__ and recursion in parameters (reported by `Douglas RAILLARD `__) 0.15.67 (2018-09-19): - fix issue with extra space inserted with non-root literal strings (Issue reported and PR with fix provided by `Naomi Seyfer `__.) 0.15.66 (2018-09-07): - fix issue with fold indicating characters inserted in safe_load-ed folded strings (reported by `Maximilian Hils `__). 0.15.65 (2018-09-07): - fix issue #232 revert to throw ParserError for unexcpected ``]`` and ``}`` instead of IndexError. (Issue reported and PR with fix provided by `Naomi Seyfer `__.) - added ``key`` and ``reverse`` parameter (suggested by Jannik Klemm via email) - indent root level literal scalars that have directive or document end markers at the beginning of a line 0.15.64 (2018-08-30): - support round-trip of tagged sequences: ``!Arg [a, {b: 1}]`` - single entry mappings in flow sequences now written by default without braces, set ``yaml.brace_single_entry_mapping_in_flow_sequence=True`` to force getting ``[a, {b: 1}, {c: {d: 2}}]`` instead of the default ``[a, b: 1, c: {d: 2}]`` - fix issue when roundtripping floats starting with a dot such as ``.5`` (reported by `Harrison Gregg `__) 0.15.63 (2018-08-29): - small fix only necessary for Windows users that don't use wheels. 0.15.62 (2018-08-29): - C based reader/scanner & emitter now allow setting of 1.2 as YAML version. ** The loading/dumping is still YAML 1.1 code**, so use the common subset of YAML 1.2 and 1.1 (reported by `Ge Yang `__) 0.15.61 (2018-08-23): - support for round-tripping folded style scalars (initially requested by `Johnathan Viduchinsky `__) - update of C code - speed up of scanning (~30% depending on the input) 0.15.60 (2018-08-18): - again allow single entry map in flow sequence context (reported by `Lee Goolsbee `__) - cleanup for mypy - spurious print in library (reported by `Lele Gaifax `__), now automatically checked 0.15.59 (2018-08-17): - issue with C based loader and leading zeros (reported by `Tom Hamilton Stubber `__) 0.15.58 (2018-08-17): - simple mappings can now be used as keys when round-tripping:: {a: 1, b: 2}: hello world although using the obvious operations (del, popitem) on the key will fail, you can mutilate it by going through its attributes. If you load the above YAML in `d`, then changing the value is cumbersome: d = {CommentedKeyMap([('a', 1), ('b', 2)]): "goodbye"} and changing the key even more so: d[CommentedKeyMap([('b', 1), ('a', 2)])] = d.pop( CommentedKeyMap([('a', 1), ('b', 2)])) (you can use a `dict` instead of a list of tuples (or ordereddict), but that might result in a different order, of the keys of the key, in the output) - check integers to dump with 1.2 patterns instead of 1.1 (reported by `Lele Gaifax `__) 0.15.57 (2018-08-15): - Fix that CommentedSeq could no longer be used in adding or do a sort (reported by `Christopher Wright `__) 0.15.56 (2018-08-15): - fix issue with ``python -O`` optimizing away code (reported, and detailed cause pinpointed, by `Alex Grönholm `__) 0.15.55 (2018-08-14): - unmade ``CommentedSeq`` a subclass of ``list``. It is now indirectly a subclass of the standard ``collections.abc.MutableSequence`` (without .abc if you are still on Python2.7). If you do ``isinstance(yaml.load('[1, 2]'), list)``) anywhere in your code replace ``list`` with ``MutableSequence``. Directly, ``CommentedSeq`` is a subclass of the abstract baseclass ``ruamel.yaml.compat.MutableScliceableSequence``, with the result that *(extended) slicing is supported on ``CommentedSeq``*. (reported by `Stuart Berg `__) - duplicate keys (or their values) with non-ascii now correctly report in Python2, instead of raising a Unicode error. (Reported by `Jonathan Pyle `__) 0.15.54 (2018-08-13): - fix issue where a comment could pop-up twice in the output (reported by `Mike Kazantsev `__ and by `Nate Peterson `__) - fix issue where JSON object (mapping) without spaces was not parsed properly (reported by `Marc Schmidt `__) - fix issue where comments after empty flow-style mappings were not emitted (reported by `Qinfench Chen `__) 0.15.53 (2018-08-12): - fix issue with flow style mapping with comments gobbled newline (reported by `Christopher Lambert `__) - fix issue where single '+' under YAML 1.2 was interpreted as integer, erroring out (reported by `Jethro Yu `__) 0.15.52 (2018-08-09): - added `.copy()` mapping representation for round-tripping (``CommentedMap``) to fix incomplete copies of merged mappings (reported by `Will Richards `__) - Also unmade that class a subclass of ordereddict to solve incorrect behaviour for ``{**merged-mapping}`` and ``dict(**merged-mapping)`` (reported independently by `Tim Olsson `__ and `Filip Matzner `__) 0.15.51 (2018-08-08): - Fix method name dumps (were not dotted) and loads (reported by `Douglas Raillard `__) - Fix spurious trailing white-space caused when the comment start column was no longer reached and there was no actual EOL comment (e.g. following empty line) and doing substitutions, or when quotes around scalars got dropped. (reported by `Thomas Guillet `__) 0.15.50 (2018-08-05): - Allow ``YAML()`` as a context manager for output, thereby making it much easier to generate multi-documents in a stream. - Fix issue with incorrect type information for `load()` and `dump()` (reported by `Jimbo Jim `__) 0.15.49 (2018-08-05): - fix preservation of leading newlines in root level literal style scalar, and preserve comment after literal style indicator (``| # some comment``) Both needed for round-tripping multi-doc streams in `ryd `__. 0.15.48 (2018-08-03): - housekeeping: ``oitnb`` for formatting, mypy 0.620 upgrade and conformity 0.15.47 (2018-07-31): - fix broken 3.6 manylinux1, the result of an unclean ``build`` (reported by `Roman Sichnyi `__) 0.15.46 (2018-07-29): - fixed DeprecationWarning for importing from ``collections`` on 3.7 (issue 210, reported by `Reinoud Elhorst `__). It was `difficult to find why tox/pytest did not report `__ and as time consuming to actually `fix `__ the tests. 0.15.45 (2018-07-26): - After adding failing test for ``YAML.load_all(Path())``, remove StopIteration (PR provided by `Zachary Buhman `__, also reported by `Steven Hiscocks `__. 0.15.44 (2018-07-14): - Correct loading plain scalars consisting of numerals only and starting with `0`, when not explicitly specifying YAML version 1.1. This also fixes the issue about dumping string `'019'` as plain scalars as reported by `Min RK `__, that prompted this chance. 0.15.43 (2018-07-12): - merge PR33: Python2.7 on Windows is narrow, but has no ``sysconfig.get_config_var('Py_UNICODE_SIZE')``. (merge provided by `Marcel Bargull `__) - ``register_class()`` now returns class (proposed by `Mike Nerone `__} 0.15.42 (2018-07-01): - fix regression showing only on narrow Python 2.7 (py27mu) builds (with help from `Marcel Bargull `__ and `Colm O'Connor `__). - run pre-commit ``tox`` on Python 2.7 wide and narrow, as well as 3.4/3.5/3.6/3.7/pypy 0.15.41 (2018-06-27): - add detection of C-compile failure (investigation prompted by `StackOverlow `__ by `Emmanuel Blot `__), which was removed while no longer dependent on ``libyaml``, C-extensions compilation still needs a compiler though. 0.15.40 (2018-06-18): - added links to landing places as suggested in issue 190 by `KostisA `__ - fixes issue #201: decoding unicode escaped tags on Python2, reported by `Dan Abolafia `__ 0.15.39 (2018-06-17): - merge PR27 improving package startup time (and loading when regexp not actually used), provided by `Marcel Bargull `__ 0.15.38 (2018-06-13): - fix for losing precision when roundtripping floats by `Rolf Wojtech `__ - fix for hardcoded dir separator not working for Windows by `Nuno André `__ - typo fix by `Andrey Somov `__ 0.15.37 (2018-03-21): - again trying to create installable files for 187 0.15.36 (2018-02-07): - fix issue 187, incompatibility of C extension with 3.7 (reported by Daniel Blanchard) 0.15.35 (2017-12-03): - allow ``None`` as stream when specifying ``transform`` parameters to ``YAML.dump()``. This is useful if the transforming function doesn't return a meaningful value (inspired by `StackOverflow `__ by `rsaw `__). 0.15.34 (2017-09-17): - fix for issue 157: CDumper not dumping floats (reported by Jan Smitka) 0.15.33 (2017-08-31): - support for "undefined" round-tripping tagged scalar objects (in addition to tagged mapping object). Inspired by a use case presented by Matthew Patton on `StackOverflow `__. - fix issue 148: replace cryptic error message when using !!timestamp with an incorrectly formatted or non- scalar. Reported by FichteFoll. 0.15.32 (2017-08-21): - allow setting ``yaml.default_flow_style = None`` (default: ``False``) for for ``typ='rt'``. - fix for issue 149: multiplications on ``ScalarFloat`` now return ``float`` (reported by jan.brezina@tul.cz) 0.15.31 (2017-08-15): - fix Comment dumping 0.15.30 (2017-08-14): - fix for issue with "compact JSON" not parsing: ``{"in":{},"out":{}}`` (reported on `StackOverflow `__ by `mjalkio `_ 0.15.29 (2017-08-14): - fix issue #51: different indents for mappings and sequences (reported by Alex Harvey) - fix for flow sequence/mapping as element/value of block sequence with sequence-indent minus dash-offset not equal two. 0.15.28 (2017-08-13): - fix issue #61: merge of merge cannot be __repr__-ed (reported by Tal Liron) 0.15.27 (2017-08-13): - fix issue 62, YAML 1.2 allows ``?`` and ``:`` in plain scalars if non-ambigious (reported by nowox) - fix lists within lists which would make comments disappear 0.15.26 (2017-08-10): - fix for disappearing comment after empty flow sequence (reported by oit-tzhimmash) 0.15.25 (2017-08-09): - fix for problem with dumping (unloaded) floats (reported by eyenseo) 0.15.24 (2017-08-09): - added ScalarFloat which supports roundtripping of 23.1, 23.100, 42.00E+56, 0.0, -0.0 etc. while keeping the format. Underscores in mantissas are not preserved/supported (yet, is anybody using that?). - (finally) fixed longstanding issue 23 (reported by `Antony Sottile `__), now handling comment between block mapping key and value correctly - warn on YAML 1.1 float input that is incorrect (triggered by invalid YAML provided by Cecil Curry) - allow setting of boolean representation (`false`, `true`) by using: ``yaml.boolean_representation = [u'False', u'True']`` 0.15.23 (2017-08-01): - fix for round_tripping integers on 2.7.X > sys.maxint (reported by ccatterina) 0.15.22 (2017-07-28): - fix for round_tripping singe excl. mark tags doubling (reported and fix by Jan Brezina) 0.15.21 (2017-07-25): - fix for writing unicode in new API, (reported on `StackOverflow `__ 0.15.20 (2017-07-23): - wheels for windows including C extensions 0.15.19 (2017-07-13): - added object constructor for rt, decorator ``yaml_object`` to replace YAMLObject. - fix for problem using load_all with Path() instance - fix for load_all in combination with zero indent block style literal (``pure=True`` only!) 0.15.18 (2017-07-04): - missing ``pure`` attribute on ``YAML`` useful for implementing `!include` tag constructor for `including YAML files in a YAML file `__ - some documentation improvements - trigger of doc build on new revision 0.15.17 (2017-07-03): - support for Unicode supplementary Plane **output** (input was already supported, triggered by `this `__ Stack Overflow Q&A) 0.15.16 (2017-07-01): - minor typing issues (reported and fix provided by `Manvendra Singh `__ - small doc improvements 0.15.15 (2017-06-27): - fix for issue 135, typ='safe' not dumping in Python 2.7 (reported by Andrzej Ostrowski `__) 0.15.14 (2017-06-25): - fix for issue 133, in setup.py: change ModuleNotFoundError to ImportError (reported and fix by `Asley Drake `__) 0.15.13 (2017-06-24): - suppress duplicate key warning on mappings with merge keys (reported by Cameron Sweeney) 0.15.12 (2017-06-24): - remove fatal dependency of setup.py on wheel package (reported by Cameron Sweeney) 0.15.11 (2017-06-24): - fix for issue 130, regression in nested merge keys (reported by `David Fee `__) 0.15.10 (2017-06-23): - top level PreservedScalarString not indented if not explicitly asked to - remove Makefile (not very useful anyway) - some mypy additions 0.15.9 (2017-06-16): - fix for issue 127: tagged scalars were always quoted and seperated by a newline when in a block sequence (reported and largely fixed by `Tommy Wang `__) 0.15.8 (2017-06-15): - allow plug-in install via ``install ruamel.yaml[jinja2]`` 0.15.7 (2017-06-14): - add plug-in mechanism for load/dump pre resp. post-processing 0.15.6 (2017-06-10): - a set() with duplicate elements now throws error in rt loading - support for toplevel column zero literal/folded scalar in explicit documents 0.15.5 (2017-06-08): - repeat `load()` on a single `YAML()` instance would fail. 0.15.4 (2017-06-08): - `transform` parameter on dump that expects a function taking a string and returning a string. This allows transformation of the output before it is written to stream. This forces creation of the complete output in memory! - some updates to the docs 0.15.3 (2017-06-07): - No longer try to compile C extensions on Windows. Compilation can be forced by setting the environment variable `RUAMEL_FORCE_EXT_BUILD` to some value before starting the `pip install`. 0.15.2 (2017-06-07): - update to conform to mypy 0.511: mypy --strict 0.15.1 (2017-06-07): - `duplicate keys `__ in mappings generate an error (in the old API this change generates a warning until 0.16) - dependecy on ruamel.ordereddict for 2.7 now via extras_require 0.15.0 (2017-06-04): - it is now allowed to pass in a ``pathlib.Path`` as "stream" parameter to all load/dump functions - passing in a non-supported object (e.g. a string) as "stream" will result in a much more meaningful YAMLStreamError. - assigning a normal string value to an existing CommentedMap key or CommentedSeq element will result in a value cast to the previous value's type if possible. - added ``YAML`` class for new API 0.14.12 (2017-05-14): - fix for issue 119, deepcopy not returning subclasses (reported and PR by Constantine Evans ) 0.14.11 (2017-05-01): - fix for issue 103 allowing implicit documents after document end marker line (``...``) in YAML 1.2 0.14.10 (2017-04-26): - fix problem with emitting using cyaml 0.14.9 (2017-04-22): - remove dependency on ``typing`` while still supporting ``mypy`` (http://stackoverflow.com/a/43516781/1307905) - fix unclarity in doc that stated 2.6 is supported (reported by feetdust) 0.14.8 (2017-04-19): - fix Text not available on 3.5.0 and 3.5.1, now proactively setting version guards on all files (reported by `João Paulo Magalhães `__) 0.14.7 (2017-04-18): - round trip of integers (decimal, octal, hex, binary) now preserve leading zero(s) padding and underscores. Underscores are presumed to be at regular distances (i.e. ``0o12_345_67`` dumps back as ``0o1_23_45_67`` as the space from the last digit to the underscore before that is the determining factor). 0.14.6 (2017-04-14): - binary, octal and hex integers are now preserved by default. This was a known deficiency. Working on this was prompted by the issue report (112) from devnoname120, as well as the additional experience with `.replace()` on `scalarstring` classes. - fix issues 114: cannot install on Buildozer (reported by mixmastamyk). Setting env. var ``RUAMEL_NO_PIP_INSTALL_CHECK`` will suppress ``pip``-check. 0.14.5 (2017-04-04): - fix issue 109: None not dumping correctly at top level (reported by Andrea Censi) - fix issue 110: .replace on Preserved/DoubleQuoted/SingleQuoted ScalarString would give back "normal" string (reported by sandres23) 0.14.4 (2017-03-31): - fix readme 0.14.3 (2017-03-31): - fix for 0o52 not being a string in YAML 1.1 (reported on `StackOverflow Q&A 43138503 `__ by `Frank D `__) 0.14.2 (2017-03-23): - fix for old default pip on Ubuntu 14.04 (reported by Sébastien Maccagnoni-Munch) 0.14.1 (2017-03-22): - fix Text not available on 3.5.0 and 3.5.1 (reported by Charles Bouchard-Légaré) 0.14.0 (2017-03-21): - updates for mypy --strict - preparation for moving away from inheritance in Loader and Dumper, calls from e.g. the Representer to the Serializer.serialize() are now done via the attribute .serializer.serialize(). Usage of .serialize() outside of Serializer will be deprecated soon - some extra tests on main.py functions ---- For older changes see the file `CHANGES `_ Keywords: yaml 1.2 parser round-trip preserve quotes order config Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: Jython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Processing :: Markup ruamel.yaml-0.15.89/CHANGES0000664000175100001440000011356513435603465015614 0ustar anthonusers00000000000000[0, 15, 89]: 2019-02-27 - fix for items with flow-mapping in block sequence output on single line (reported by `Zahari Dim `__) - fix for safe dumping erroring in creation of representereror when dumping namedtuple (reported and solution by `Jaakko Kantojärvi `__) [0, 15, 88]: 2019-02-12 - fix inclusing of python code from the subpackage data (containing extra tests, reported by `Florian Apolloner `__) [0, 15, 88]: 2019-02-12 - fix inclusing of python code from the subpackage data (containing extra tests, reported by `Florian Apolloner `__) [0, 15, 87]: 2019-01-22 - fix problem with empty lists and the code to reinsert merge keys (reported via email by Zaloo) [0, 15, 87]: 2019-01-22 - fix problem with empty lists and the code to reinsert merge keys (reported via email by Zaloo) [0, 15, 86]: 2019-01-16 - reinsert merge key in its old position (reported by grumbler on `__) - fix for issue with non-ASCII anchor names (reported and fix provided by Dandaleon Flux via email) - fix for issue when parsing flow mapping value starting with colon (in pure Python only) (reported by `FichteFoll `__) [0, 15, 86]: 2019-01-15 - reinsert merge key in its old position (reported by grumbler on `__) - fix for issue with non-ASCII anchor names (reported and fix provided by Dandaleon Flux via email) - fix for issue when parsing flow mapping value starting with colon (in pure Python only) (reported by `FichteFoll `__) [0, 15, 85]: 2019-01-08 - the types used by `SafeConstructor` for mappings and sequences can now by set by assigning to `XXXConstructor.yaml_base_dict_type` (and `..._list_type`), preventing the need to copy two methods with 50+ lines that had `var = {}` hardcoded. (Implemented to help solve an feature request by `Anthony Sottile `__ in an easier way) [0, 15, 84]: 2019-01-07 - fix for `CommentedMap.copy()` not returning `CommentedMap`, let alone copying comments etc. (reported by `Anthony Sottile `__) [0, 15, 83]: 2019-01-02 - fix for bug in roundtripping aliases used as key (reported via email by Zaloo) [0, 15, 82]: 2018-12-28 - anchors and aliases on scalar int, float, string and bool are now preserved. Anchors do not need a referring alias for these (reported by `Alex Harvey `__) - anchors no longer lost on tagged objects when roundtripping (reported by `Zaloo `__) [0, 15, 81]: 2018-12-06 - fix issue saving methods of metaclass derived classes (reported and fix provided by `Douglas Raillard `__) [0, 15, 80]: 2018-11-26 - fix issue emitting BEL character when round-tripping invalid folded input (reported by Isaac on `StackOverflow `__) [0, 15, 79]: 2018-11-21 - fix issue with anchors nested deeper than alias (reported by gaFF on `StackOverflow `__) [0, 15, 79]: 2018-11-21 - fix issue with anchors nested deeper than alias (reported by gaFF on `StackOverflow `__) [0, 15, 78]: 2018-11-15 - fix setup issue for 3.8 (reported by `Sidney Kuyateh `__) [0, 15, 77]: 2018-11-09 - setting `yaml.sort_base_mapping_type_on_output = False`, will prevent explicit sorting by keys in the base representer of mappings. Roundtrip already did not do this. Usage only makes real sense for Python 3.6+ (feature request by `Sebastian Gerber `__). - implement Python version check in YAML metadata in ``_test/test_z_data.py`` [0, 15, 76]: 2018-11-01 - fix issue with empty mapping and sequence loaded as flow-style (mapping reported by `Min RK `__, sequence by `Maged Ahmed `__) [0, 15, 75]: 2018-10-27 - fix issue with single '?' scalar (reported by `Terrance `__) - fix issue with duplicate merge keys (prompted by `answering `__ a `StackOverflow question `__ by `math `__) [0, 15, 75]: 2018-10-27 - fix issue with single '?' scalar (reported by `Terrance `__) - fix issue with duplicate merge keys (prompted by `answering `__ a `StackOverflow question `__ by `math `__) [0, 15, 74]: 2018-10-17 - fix dropping of comment on rt before sequence item that is sequence item (reported by `Thorsten Kampe `__) [0, 15, 73]: 2018-10-16 - fix irregular output on pre-comment in sequence within sequence (reported by `Thorsten Kampe `__) - allow non-compact (i.e. next line) dumping sequence/mapping within sequence. [0, 15, 72]: 2018-10-06 - fix regression on explicit 1.1 loading with the C based scanner/parser (reported by `Tomas Vavra `__) [0, 15, 72]: 2018-10-06 - fix regression on explicit 1.1 loading with the C based scanner/parser (reported by `Tomas Vavra `__) [0, 15, 71]: 2018-09-26 - fix regression where handcrafted CommentedMaps could not be initiated (reported by `Dan Helfman `__) - fix regression with non-root literal scalars that needed indent indicator (reported by `Clark Breyman `__) - tag:yaml.org,2002:python/object/apply now also uses __qualname__ on PY3 (reported by `Douglas RAILLARD `__) [0, 15, 70]: 2018-09-21 - reverted CommentedMap and CommentedSeq to subclass ordereddict resp. list, reimplemented merge maps so that both ``dict(**commented_map_instance)`` and JSON dumping works. This also allows checking with ``isinstance()`` on ``dict`` resp. ``list``. (Proposed by `Stuart Berg `__, with feedback from `blhsing `__ on `StackOverflow `__) [0, 15, 69]: 2018-09-20 - fix issue with dump_all gobbling end-of-document comments on parsing (reported by `Pierre B. `__) [0, 15, 68]: 2018-09-20 - fix issue with parsabel, but incorrect output with nested flow-style sequences (reported by `Dougal Seeley `__) - fix issue with loading Python objects that have __setstate__ and recursion in parameters (reported by `Douglas RAILLARD `__) [0, 15, 67]: 2018-09-19 - fix issue with extra space inserted with non-root literal strings (Issue reported and PR with fix provided by `Naomi Seyfer `__.) [0, 15, 66]: 2018-09-07 - fix issue with fold indicating characters inserted in safe_load-ed folded strings (reported by `Maximilian Hils `__). [0, 15, 65]: 2018-09-07 - fix issue #232 revert to throw ParserError for unexcpected ``]`` and ``}`` instead of IndexError. (Issue reported and PR with fix provided by `Naomi Seyfer `__.) - added ``key`` and ``reverse`` parameter (suggested by Jannik Klemm via email) - indent root level literal scalars that have directive or document end markers at the beginning of a line [0, 15, 64]: 2018-08-30 - support round-trip of tagged sequences: ``!Arg [a, {b: 1}]`` - single entry mappings in flow sequences now written by default without quotes set ``yaml.brace_single_entry_mapping_in_flow_sequence=True`` to force getting ``[a, {b: 1}, {c: {d: 2}}]`` instead of the default ``[a, b: 1, c: {d: 2}]`` - fix issue when roundtripping floats starting with a dot such as ``.5`` (reported by `Harrison Gregg `__) [0, 15, 63]: 2018-08-29 - small fix only necessary for Windows users that don't use wheels. [0, 15, 62]: 2018-08-29 - C based reader/scanner & emitter now allow setting of 1.2 as YAML version. ** The loading/dumping is still YAML 1.1 code**, so use the common subset of YAML 1.2 and 1.1 (reported by `Ge Yang `__) [0, 15, 61]: 2018-08-23 - support for round-tripping folded style scalars (initially requested by `Johnathan Viduchinsky `__) - update of C code - speed up of scanning (~30% depending on the input) [0, 15, 60]: 2018-08-18 - cleanup for mypy - spurious print in library (reported by `Lele Gaifax `__), now automatically checked [0, 15, 59]: 2018-08-17 - issue with C based loader and leading zeros (reported by `Tom Hamilton Stubber `__) [0, 15, 59]: 2018-08-17 - issue with C based loader and leading zeros (reported by `Tom Hamilton Stubber `__) [0, 15, 58]: 2018-08-17 - simple mappings can now be used as keys when round-tripping:: {a: 1, b: 2}: hello world although using the obvious operations (del, popitem) on the key will fail, you can mutilate it by going through its attributes. If you load the above YAML in `d`, then changing the value is cumbersome: d = {CommentedKeyMap([('a', 1), ('b', 2)]): "goodbye"} and changing the key even more so: d[CommentedKeyMap([('b', 1), ('a', 2)])] = d.pop( CommentedKeyMap([('a', 1), ('b', 2)])) (you can use a `dict` instead of a list of tuples (or ordereddict), but that might result in a different order, of the keys of the key, in the output) - check integers to dump with 1.2 patterns instead of 1.1 (reported by `Lele Gaifax `__) [0, 15, 57]: 2018-08-15 - Fix that CommentedSeq could no longer be used in adding or do a copy (reported by `Christopher Wright `__) [0, 15, 56]: 2018-08-15 - fix issue with ``python -O`` optimizing away code (reported, and detailed cause pinpointed, by `Alex Grönholm `__ [0, 15, 55]: 2018-08-14 - unmade ``CommentedSeq`` a subclass of ``list``. It is now indirectly a subclass of the standard ``collections.abc.MutableSequence`` (without .abc if you are still on Python2.7). If you do ``isinstance(yaml.load('[1, 2]'), list)``) anywhere in your code replace ``list`` with ``MutableSequence``. Directly, ``CommentedSeq`` is a subclass of the abstract baseclass ``ruamel.yaml.compat.MutableScliceableSequence``, with the result that *(extended) slicing is supported on ``CommentedSeq``*. (reported by `Stuart Berg `__) - duplicate keys (or their values) with non-ascii now correctly report in Python2, instead of raising a Unicode error. (Reported by `Jonathan Pyle `__) [0, 15, 54]: 2018-08-13 - fix issue where a comment could pop-up twice in the output (reported by `Mike Kazantsev `__ and by `Nate Peterson `__) - fix issue where JSON object (mapping) without spaces was not parsed properly (reported by `Marc Schmidt `__) - fix issue where comments after empty flow-style mappings were not emitted (reported by `Qinfench Chen `__) [0, 15, 53]: 2018-08-12 - fix issue with flow style mapping with comments gobbled newline (reported by `Christopher Lambert `__) - fix issue where single '+' under YAML 1.2 was interpreted as integer, erroring out (reported by `Jethro Yu `__) [0, 15, 52]: 2018-08-09 - added `.copy()` mapping representation for round-tripping (``CommentedMap``) to fix incomplete copies of merged mappings (reported by `Will Richards `__) - Also unmade that class a subclass of ordereddict to solve incorrect behaviour for ``{**merged-mapping}`` and ``dict(**merged-mapping)`` (reported by `Filip Matzner `__) [0, 15, 51]: 2018-08-08 - Fix method name dumps (were not dotted) and loads (reported by `Douglas Raillard `__) - Fix spurious trailing white-space caused when the comment start column was no longer reached and there was no actual EOL comment (e.g. following empty line) and doing substitutions, or when quotes around scalars got dropped. (reported by `Thomas Guillet `__) [0, 15, 50]: 2018-08-05 - Allow ``YAML()`` as a context manager for output, thereby making it much easier to generate multi-documents in a stream. - Fix issue with incorrect type information for `load()` and `dump()` (reported by `Jimbo Jim `__) [0, 15, 49]: 2018-08-05 - fix preservation of leading newlines in root level literal style scalar, and preserve comment after literal style indicator (``| # some comment``) Both needed for round-tripping multi-doc streams in `ryd `__. [0, 15, 48]: 2018-08-03 - housekeeping: ``oitnb`` for formatting, mypy 0.620 upgrade and conformity [0, 15, 47]: 2018-07-31 - fix broken 3.6 manylinux1 (result of an unclean ``build`` (reported by `Roman Sichnyi `__) [0, 15, 46]: 2018-07-29 - fixed DeprecationWarning for importing from ``collections`` on 3.7 (issue 210, reported by `Reinoud Elhorst `__). It was `difficult to find why tox/pytest did not report `__ and as time consuming to actually `fix `__ the tests. [0, 15, 46]: 2018-07-29 - fixed DeprecationWarning for importing from ``collections`` on 3.7 (issue 210, reported by `Reinoud Elhorst `__). It was `difficult to find why tox/pytest did not report `__ and as time consuming to actually `fix `__ the tests. [0, 15, 45]: 2018-07-29 - fixed DeprecationWarning for importing from ``collections`` on 3.7 (issue 210, reported by `Reinoud Elhorst `__). It was `difficult to find why tox/pytest did not report `__ and as time consuming to actually `fix `__ the tests. [0, 15, 45]: 2018-07-26 - After adding failing test for ``YAML.load_all(Path())``, remove StopIteration (PR provided by `Zachary Buhman `__, also reported by `Steven Hiscocks `__. [0, 15, 45]: 2018-07-26 - After adding failing test for ``YAML.load_all(Path())``, remove StopIteration (PR provided by `Zachary Buhman `__, also reported by `Steven Hiscocks `__. [0, 15, 44]: 2018-07-14 - Correct loading plain scalars consisting of numerals only and starting with `0`, when not explicitly specifying YAML version 1.1. This also fixes the issue about dumping string `'019'` as plain scalars as reported by `Min RK `__, that prompted this chance. [0, 15, 43]: 2018-07-12 - merge PR33: Python2.7 on Windows is narrow, but has no ``sysconfig.get_config_var('Py_UNICODE_SIZE')``. (merge provided by `Marcel Bargull `__) - ``register_class()`` now returns class (proposed by `Mike Nerone `__} [0, 15, 42]: 2018-07-01 - fix regression showing only on narrow Python 2.7 (py27mu) builds (with help from `Marcel Bargull `__ and `Colm O'Connor <>`__). - run pre-commit ``tox`` on Python 2.7 wide and narrow, as well as 3.4/3.5/3.6/3.7/pypy [0, 15, 41]: 2018-06-27 - add detection of C-compile failure (investigation prompted by `StackOverlow `__ by `Emmanuel Blot `__), which was removed while no longer dependent on ``libyaml``, C-extensions compilation still needs a compiler though. [0, 15, 40]: 2018-06-18 - added links to landing places as suggested in issue 190 by `KostisA `__ - fixes issue #201: decoding unicode escaped tags on Python2, reported by `Dan Abolafia `__ [0, 15, 39]: 2018-06-16 - merge PR27 improving package startup time (and loading when regexp not actually used), provided by `Marcel Bargull `__ [0, 15, 38]: 2018-06-13 - fix for losing precision when roundtripping floats by `Rolf Wojtech `__ - fix for hardcoded dir separator not working for Windows by `Nuno André `__ - typo fix by `Andrey Somov `__ [0, 15, 37]: 2018-03-21 - again trying to create installable files for 187 [0, 15, 36]: 2018-02-07 - fix issue 187, incompatibility of C extension with 3.7 (reported by Daniel Blanchard) [0, 15, 35]: 2017-12-03 - allow ``None`` as stream when specifying ``transform`` parameters to ``YAML.dump()``. This is useful if the transforming function doesn't return a meaningful value (inspired by `StackOverflow `__ by `rsaw `__). [0, 15, 34]: 2017-09-17 - fix for issue 157: CDumper not dumping floats (reported by Jan Smitka) [0, 15, 33]: 2017-08-31 - support for "undefined" round-tripping tagged scalar objects (in addition to tagged mapping object). Inspired by a use case presented by Matthew Patton on `StackOverflow `__. - fix issue 148: replace cryptic error message when using !!timestamp with an incorrectly formatted or non- scalar. Reported by FichteFoll. [0, 15, 32]: 2017-08-21 - allow setting ``yaml.default_flow_style = None`` (default: ``False``) for for ``typ='rt'``. - fix for issue 149: multiplications on ``ScalarFloat`` now return ``float`` [0, 15, 31]: 2017-08-15 - fix Comment dumping [0, 15, 30]: 2017-08-14 - fix for issue with "compact JSON" not parsing: ``{"in":{},"out":{}}`` (reported on `StackOverflow `_ by `mjalkio `_ [0, 15, 29]: 2017-08-14 - fix issue #51: different indents for mappings and sequences (reported by Alex Harvey) - fix for flow sequence/mapping as element/value of block sequence with sequence-indent minus dash-offset not equal two. [0, 15, 28]: 2017-08-13 - fix issue #61: merge of merge cannot be __repr__-ed (reported by Tal Liron) [0, 15, 27]: 2017-08-13 - fix issue 62, YAML 1.2 allows ``?`` and ``:`` in plain scalars if non-ambigious (reported by nowox) - fix lists within lists which would make comments disappear [0, 15, 26]: 2017-08-10 - fix for disappearing comment after empty flow sequence (reported by oit-tzhimmash) [0, 15, 25]: 2017-08-09 - fix for problem with dumping (unloaded) floats (reported by eyenseo) [0, 15, 24]: 2017-08-09 - added ScalarFloat which supports roundtripping of 23.1, 23.100, 42.00E+56, 0.0, -0.0 etc. while keeping the format. Underscores in mantissas are not preserved/supported (yet, is anybody using that?). - (finally) fixed longstanding issue 23 (reported by `Antony Sottile `_), now handling comment between block mapping key and value correctly - warn on YAML 1.1 float input that is incorrect (triggered by invalid YAML provided by Cecil Curry) - allow setting of boolean representation (`false`, `true`) by using: ``yaml.boolean_representation = [u'False', u'True']`` [0, 15, 23]: 2017-08-01 - fix for round_tripping integers on 2.7.X > sys.maxint (reported by ccatterina) [0, 15, 22]: 2017-07-28 - fix for round_tripping singe excl. mark tags doubling (reported and fix by Jan Brezina) [0, 15, 21]: 2017-07-25 - fix for writing unicode in new API, https://stackoverflow.com/a/45281922/1307905 [0, 15, 20]: 2017-07-23 - wheels for windows including C extensions [0, 15, 19]: 2017-07-13 - added object constructor for rt, decorator ``yaml_object`` to replace YAMLObject. - fix for problem using load_all with Path() instance - fix for load_all in combination with zero indent block style literal (``pure=True`` only!) [0, 15, 18]: 2017-07-04 - missing ``pure`` attribute on ``YAML`` useful for implementing `!include` tag constructor for `including YAML files in a YAML file `_ - some documentation improvements - trigger of doc build on new revision [0, 15, 17]: 2017-07-03 - support for Unicode supplementary Plane **output** with allow_unicode (input was already supported, triggered by `this `_ Stack Overflow Q&A) [0, 15, 16]: 2017-07-01 - minor typing issues (reported and fix provided by `Manvendra Singh `_) - small doc improvements [0, 15, 15]: 2017-06-27 - fix for issue 135, typ='safe' not dumping in Python 2.7 (reported by Andrzej Ostrowski `_) [0, 15, 14]: 2017-06-25 - setup.py: change ModuleNotFoundError to ImportError (reported and fix by Asley Drake) [0, 15, 13]: 2017-06-24 - suppress duplicate key warning on mappings with merge keys (reported by Cameron Sweeney) [0, 15, 12]: 2017-06-24 - remove fatal dependency of setup.py on wheel package (reported by Cameron Sweeney) [0, 15, 11]: 2017-06-24 - fix for issue 130, regression in nested merge keys (reported by `David Fee `_) [0, 15, 10]: 2017-06-24 - fix for issue 130, regression in nested merge keys (reported by `David Fee `_) [0, 15, 10]: 2017-06-23 - top level PreservedScalarString not indented if not explicitly asked to - remove Makefile (not very useful anyway) - some mypy additions [0, 15, 9]: 2017-06-16 - fix for issue 127: tagged scalars were always quoted and seperated by a newline when in a block sequence (reported and largely fixed by `Tommy Wang `_) [0, 15, 8]: 2017-06-15 - allow plug-in install via ``install ruamel.yaml[jinja2]`` [0, 15, 8]: 2017-06-15 - allow plug-in install via ``install ruamel.yaml[jinja2]`` [0, 15, 7]: 2017-06-14 - add plug-in mechanism for load/dump pre resp. post-processing [0, 15, 6]: 2017-06-10 - a set() with duplicate elements now throws error in rt loading - support for toplevel column zero literal/folded scalar in explicit documents [0, 15, 5]: 2017-06-08 - repeat `load()` on a single `YAML()` instance would fail. (0, 15, 4) 2017-06-08: | - `transform` parameter on dump that expects a function taking a string and returning a string. This allows transformation of the output before it is written to stream. - some updates to the docs (0, 15, 3) 2017-06-07: - No longer try to compile C extensions on Windows. Compilation can be forced by setting the environment variable `RUAMEL_FORCE_EXT_BUILD` to some value before starting the `pip install`. (0, 15, 2) 2017-06-07: - update to conform to mypy 0.511:mypy --strict (0, 15, 1) 2017-06-07: - Any `duplicate keys `_ in mappings generate an error (in the old API this change generates a warning until 0.16) - dependecy on ruamel.ordereddict for 2.7 now via extras_require (0, 15, 0) 2017-06-04: - it is now allowed to pass in a ``pathlib.Path`` as "stream" parameter to all load/dump functions - passing in a non-supported object (e.g. a string) as "stream" will result in a much more meaningful YAMLStreamError. - assigning a normal string value to an existing CommentedMap key or CommentedSeq element will result in a value cast to the previous value's type if possible. (0, 14, 12) 2017-05-14: - fix for issue 119, deepcopy not returning subclasses (reported and PR by Constantine Evans ) (0, 14, 11) 2017-05-01: - fix for issue 103 allowing implicit documents after document end marker line (``...``) in YAML 1.2 (0, 14, 10) 2017-04-26: - fix problem with emitting using cyaml (0, 14, 9) 2017-04-22: - remove dependency on ``typing`` while still supporting ``mypy`` (http://stackoverflow.com/a/43516781/1307905) - fix unclarity in doc that stated 2.6 is supported (reported by feetdust) (0, 14, 8) 2017-04-19: - fix Text not available on 3.5.0 and 3.5.1, now proactively setting version guards on all files (reported by `João Paulo Magalhães `_) (0, 14, 7) 2017-04-18: - round trip of integers (decimal, octal, hex, binary) now preserve leading zero(s) padding and underscores. Underscores are presumed to be at regular distances (i.e. ``0o12_345_67`` dumps back as ``0o1_23_45_67`` as the space from the last digit to the underscore before that is the determining factor). (0, 14, 6) 2017-04-14: - binary, octal and hex integers are now preserved by default. This was a known deficiency. Working on this was prompted by the issue report (112) from devnoname120, as well as the additional experience with `.replace()` on `scalarstring` classes. - fix issues 114 cannot install on Buildozer (reported by mixmastamyk). Setting env. var ``RUAMEL_NO_PIP_INSTALL_CHECK`` will suppress ``pip``-check. (0, 14, 5) 2017-04-04: - fix issue 109 None not dumping correctly at top level (reported by Andrea Censi) - fix issue 110 .replace on Preserved/DoubleQuoted/SingleQuoted ScalarString would give back "normal" string (reported by sandres23) (0, 14, 4) 2017-03-31: - fix readme (0, 14, 3) 2017-03-31: - fix for 0o52 not being a string in YAML 1.1 (reported on `StackOverflow Q&A 43138503>`_ by `Frank D `_ (0, 14, 2) 2017-03-23: - fix for old default pip on Ubuntu 14.04 (reported by Sébastien Maccagnoni-Munch) (0.14.1) 2017-03-22: - fix Text not available on 3.5.0 and 3.5.1 (reported by Charles Bouchard-Légaré) (0.14.0) 2017-03-21: - updates for mypy --strict - preparation for moving away from inheritance in Loader and Dumper, calls from e.g. the Representer to the Serializer.serialize() are now done via the attribute .serializer.serialize(). Usage of .serialize() outside of Serializer will be deprecated soon - some extra tests on main.py functions (0.13.14) 2017-02-12: - fix for issue 97, clipped block scalar followed by empty lines and comment would result in two CommentTokens of which the first was dropped. (reported by Colm O'Connor) (0.13.13) 2017-01-28: - fix for issue 96, prevent insertion of extra empty line if indented mapping entries are separated by an empty line (reported by Derrick Sawyer) (0.13.11) 2017-01-23: - allow ':' in flow style scalars if not followed by space. Also don't quote such scalar as this is no longer necessary. - add python 3.6 manylinux wheel to PyPI (0.13.10) 2017-01-22: - fix for issue 93, insert spurious blank line before single line comment between indented sequence elements (reported by Alex) (0.13.9) 2017-01-18: - fix for issue 92, wrong import name reported by the-corinthian (0.13.8) 2017-01-18: - fix for issue 91, when a compiler is unavailable reported by Maximilian Hils - fix for deepcopy issue with TimeStamps not preserving 'T', reported on `StackOverflow Q&A `_ by `Quuxplusone `_ (0.13.7) 2016-12-27: - fix for issue 85, constructor.py importing unicode_literals caused mypy to fail on 2.7 (reported by Peter Amstutz) (0.13.6) 2016-12-27: - fix for issue 83, collections.OrderedDict not representable by SafeRepresenter (reported by Frazer McLean) (0.13.5) 2016-12-25: - fix for issue 84, deepcopy not properly working (reported by Peter Amstutz) (0.13.4) 2016-12-05: - another fix for issue 82, change to non-global resolver data broke implicit type specification (0.13.3) 2016-12-05: - fix for issue 82, deepcopy not working (reported by code monk) (0.13.2) 2016-11-28: - fix for comments after empty (null) values (reported by dsw2127 and cokelaer) (0.13.1) 2016-11-22: - optimisations on memory usage when loading YAML from large files (py3 -50%, py2 -85%) (0.13.0) 2016-11-20: - if ``load()`` or ``load_all()`` is called with only a single argument (stream or string) a UnsafeLoaderWarning will be issued once. If appropriate you can surpress this warning by filtering it. Explicitly supplying the ``Loader=ruamel.yaml.Loader`` argument, will also prevent it from being issued. You should however consider using ``safe_load()``, ``safe_load_all()`` if your YAML input does not use tags. - allow adding comments before and after keys (based on `StackOveflow Q&A `_ by `msinn `_) (0.12.18) 2016-11-16: - another fix for numpy (re-reported independently by PaulG & Nathanial Burdic) (0.12.17) 2016-11-15: - only the RoundTripLoader included the Resolver that supports YAML 1.2 now all loaders do (reported by mixmastamyk) (0.12.16) 2016-11-13: - allow dot char (and many others) in anchor name Fix issue 72 (reported by Shalon Wood) - | Slightly smarter behaviour dumping strings when no style is specified. Single string scalars that start with single quotes or have newlines now are dumped double quoted "'abc\nklm'" instead of '''abc klm''' (0.12.14) 2016-09-21: - preserve round-trip sequences that are mapping keys (prompted by stackoverflow question 39595807 from Nowox) (0.12.13) 2016-09-15: - Fix for issue #60 representation of CommentedMap with merge keys incorrect (reported by Tal Liron) (0.12.11) 2016-09-06: - Fix issue 58 endless loop in scanning tokens (reported by Christopher Lambert) (0.12.10) 2016-09-05: - Make previous fix depend on unicode char width (32 bit unicode support is a problem on MacOS reported by David Tagatac) (0.12.8) 2016-09-05: - To be ignored Unicode characters were not properly regex matched (no specific tests, PR by Haraguroicha Hsu) (0.12.7) 2016-09-03: - fixing issue 54 empty lines with spaces (reported by Alex Harvey) (0.12.6) 2016-09-03: - fixing issue 46 empty lines between top-level keys were gobbled (but not between sequence elements, nor between keys in netsted mappings (reported by Alex Harvey) (0.12.5) 2016-08-20: - fixing issue 45 preserving datetime formatting (submitted by altuin) Several formatting parameters are preserved with some normalisation: - preserve 'T', 't' is replaced by 'T', multiple spaces between date and time reduced to one. - optional space before timezone is removed - still using microseconds, but now rounded (.1234567 -> .123457) - Z/-5/+01:00 preserved (0.12.4) 2016-08-19: - Fix for issue 44: missing preserve_quotes keyword argument (reported by M. Crusoe) (0.12.3) 2016-08-17: - correct 'in' operation for merged CommentedMaps in round-trip mode (implementation inspired by J.Ngo, but original not working for merges) - iteration over round-trip loaded mappings, that contain merges. Also keys(), items(), values() (Py3/Py2) and iterkeys(), iteritems(), itervalues(), viewkeys(), viewitems(), viewvalues() (Py2) - reuse of anchor name now generates warning, not an error. Round-tripping such anchors works correctly. This inherited PyYAML issue was brought to attention by G. Coddut (and was long standing https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=515634) suppressing the warning:: import warnings from ruamel.yaml.error import ReusedAnchorWarning warnings.simplefilter("ignore", ReusedAnchorWarning) (0.12.2) 2016-08-16: - minor improvements based on feedback from M. Crusoe https://bitbucket.org/ruamel/yaml/issues/42/ (0.12.0) 2016-08-16: - drop support for Python 2.6 - include initial Type information (inspired by M. Crusoe) (0.11.15) 2016-08-07: - Change to prevent FutureWarning in NumPy, as reported by tgehring ("comparison to None will result in an elementwise object comparison in the future") (0.11.14) 2016-07-06: - fix preserve_quotes missing on original Loaders (as reported by Leynos, bitbucket issue 38) (0.11.13) 2016-07-06: - documentation only, automated linux wheels (0.11.12) 2016-07-06: - added support for roundtrip of single/double quoted scalars using: ruamel.yaml.round_trip_load(stream, preserve_quotes=True) (0.11.10) 2016-05-02: - added .insert(pos, key, value, comment=None) to CommentedMap (0.11.10) 2016-04-19: - indent=2, block_seq_indent=2 works as expected (0.11.0) 2016-02-18: - RoundTripLoader loads 1.2 by default (no sexagesimals, 012 octals nor yes/no/on/off booleans (0.10.11) 2015-09-17: - Fix issue 13: dependency on libyaml to be installed for yaml.h (0.10.10) 2015-09-15: - Python 3.5 tested with tox - pypy full test (old PyYAML tests failed on too many open file handles) (0.10.6-0.10.9) 2015-09-14: - Fix for issue 9 - Fix for issue 11: double dump losing comments - Include libyaml code - move code from 'py' subdir for proper namespace packaging. (0.10.5) 2015-08-25: - preservation of newlines after block scalars. Contributed by Sam Thursfield. (0.10) 2015-06-22: - preservation of hand crafted anchor names ( not of the form "idNNN") - preservation of map merges ( <<< ) (0.9) 2015-04-18: - collections read in by the RoundTripLoader now have a ``lc`` property that can be quired for line and column ( ``lc.line`` resp. ``lc.col``) (0.8) 2015-04-15: - bug fix for non-roundtrip save of ordereddict - adding/replacing end of line comments on block style mappings/sequences (0.7.2) 2015-03-29: - support for end-of-line comments on flow style sequences and mappings (0.7.1) 2015-03-27: - RoundTrip capability of flow style sequences ( 'a: b, c, d' ) (0.7) 2015-03-26: - tests (currently failing) for inline sequece and non-standard spacing between block sequence dash and scalar (Anthony Sottile) - initial possibility (on list, i.e. CommentedSeq) to set the flow format explicitly - RoundTrip capability of flow style sequences ( 'a: b, c, d' ) (0.6.1) 2015-03-15: - setup.py changed so ruamel.ordereddict no longer is a dependency if not on CPython 2.x (used to test only for 2.x, which breaks pypy 2.5.0 reported by Anthony Sottile) (0.6) 2015-03-11: - basic support for scalars with preserved newlines - html option for yaml command - check if yaml C library is available before trying to compile C extension - include unreleased change in PyYAML dd 20141128 (0.5) 2015-01-14: - move configobj -> YAML generator to own module - added dependency on ruamel.base (based on feedback from Sess (0.4) 20141125: - move comment classes in own module comments - fix omap pre comment - make !!omap and !!set take parameters. There are still some restrictions: - no comments before the !!tag - extra tests (0.3) 20141124: - fix value comment occuring as on previous line (looking like eol comment) - INI conversion in yaml + tests - (hidden) test in yaml for debugging with auto command - fix for missing comment in middel of simple map + test (0.2) 20141123: - add ext/_yaml.c etc to the source tree - tests for yaml to work on 2.6/3.3/3.4 - change install so that you can include ruamel.yaml instead of ruamel.yaml.py - add "yaml" utility with initial subcommands (test rt, from json) (0.1) 20141122: - merge py2 and py3 code bases - remove support for 2.5/3.0/3.1/3.2 (this merge relies on u"" as available in 3.3 and . imports not available in 2.5) - tox.ini for 2.7/3.4/2.6/3.3 - remove lib3/ and tests/lib3 directories and content - commit - correct --verbose for test application - DATA=changed to be relative to __file__ of code - DATA using os.sep - remove os.path from imports as os is already imported - have test_yaml.py exit with value 0 on success, 1 on failures, 2 on error - added support for octal integers starting with '0o' keep support for 01234 as well as 0o1234 - commit - added test_roundtrip_data: requirest a .data file and .roundtrip (empty), yaml_load .data and compare dump against original. - fix grammar as per David Pursehouse: https://bitbucket.org/xi/pyyaml/pull-request/5/fix-grammar-in-error-messages/diff - http://www.json.org/ extra escaped char \/ add .skip-ext as libyaml is not updated - David Fraser: Extract a method to represent keys in mappings, so that a subclass can choose not to quote them, used in repesent_mapping https://bitbucket.org/davidfraser/pyyaml/ - add CommentToken and percolate through parser and composer and constructor - add Comments to wrapped mapping and sequence constructs (not to scalars) - generate YAML with comments - initial README ruamel.yaml-0.15.89/emitter.py0000664000175100001440000017352213435602215016633 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import from __future__ import print_function # Emitter expects events obeying the following grammar: # stream ::= STREAM-START document* STREAM-END # document ::= DOCUMENT-START node DOCUMENT-END # node ::= SCALAR | sequence | mapping # sequence ::= SEQUENCE-START node* SEQUENCE-END # mapping ::= MAPPING-START (node node)* MAPPING-END import sys from ruamel.yaml.error import YAMLError, YAMLStreamError from ruamel.yaml.events import * # NOQA # fmt: off from ruamel.yaml.compat import utf8, text_type, PY2, nprint, dbg, DBG_EVENT, \ check_anchorname_char # fmt: on if False: # MYPY from typing import Any, Dict, List, Union, Text, Tuple, Optional # NOQA from ruamel.yaml.compat import StreamType # NOQA __all__ = ['Emitter', 'EmitterError'] class EmitterError(YAMLError): pass class ScalarAnalysis(object): def __init__( self, scalar, empty, multiline, allow_flow_plain, allow_block_plain, allow_single_quoted, allow_double_quoted, allow_block, ): # type: (Any, Any, Any, bool, bool, bool, bool, bool) -> None self.scalar = scalar self.empty = empty self.multiline = multiline self.allow_flow_plain = allow_flow_plain self.allow_block_plain = allow_block_plain self.allow_single_quoted = allow_single_quoted self.allow_double_quoted = allow_double_quoted self.allow_block = allow_block class Indents(object): # replacement for the list based stack of None/int def __init__(self): # type: () -> None self.values = [] # type: List[Tuple[int, bool]] def append(self, val, seq): # type: (Any, Any) -> None self.values.append((val, seq)) def pop(self): # type: () -> Any return self.values.pop()[0] def last_seq(self): # type: () -> bool # return the seq(uence) value for the element added before the last one # in increase_indent() try: return self.values[-2][1] except IndexError: return False def seq_flow_align(self, seq_indent, column): # type: (int, int) -> int # extra spaces because of dash if len(self.values) < 2 or not self.values[-1][1]: return 0 # -1 for the dash base = self.values[-1][0] if self.values[-1][0] is not None else 0 return base + seq_indent - column - 1 def __len__(self): # type: () -> int return len(self.values) class Emitter(object): # fmt: off DEFAULT_TAG_PREFIXES = { u'!': u'!', u'tag:yaml.org,2002:': u'!!', } # fmt: on MAX_SIMPLE_KEY_LENGTH = 128 def __init__( self, stream, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, brace_single_entry_mapping_in_flow_sequence=None, dumper=None, ): # type: (StreamType, Any, Optional[int], Optional[int], Optional[bool], Any, Optional[int], Optional[bool], Any, Optional[bool], Any) -> None # NOQA self.dumper = dumper if self.dumper is not None and getattr(self.dumper, '_emitter', None) is None: self.dumper._emitter = self self.stream = stream # Encoding can be overriden by STREAM-START. self.encoding = None # type: Optional[Text] self.allow_space_break = None # Emitter is a state machine with a stack of states to handle nested # structures. self.states = [] # type: List[Any] self.state = self.expect_stream_start # type: Any # Current event and the event queue. self.events = [] # type: List[Any] self.event = None # type: Any # The current indentation level and the stack of previous indents. self.indents = Indents() self.indent = None # type: Optional[int] # flow_context is an expanding/shrinking list consisting of '{' and '[' # for each unclosed flow context. If empty list that means block context self.flow_context = [] # type: List[Text] # Contexts. self.root_context = False self.sequence_context = False self.mapping_context = False self.simple_key_context = False # Characteristics of the last emitted character: # - current position. # - is it a whitespace? # - is it an indention character # (indentation space, '-', '?', or ':')? self.line = 0 self.column = 0 self.whitespace = True self.indention = True self.compact_seq_seq = True # dash after dash self.compact_seq_map = True # key after dash # self.compact_ms = False # dash after key, only when excplicit key with ? self.no_newline = None # type: Optional[bool] # set if directly after `- ` # Whether the document requires an explicit document indicator self.open_ended = False # colon handling self.colon = u':' self.prefixed_colon = self.colon if prefix_colon is None else prefix_colon + self.colon # single entry mappings in flow sequence self.brace_single_entry_mapping_in_flow_sequence = ( brace_single_entry_mapping_in_flow_sequence ) # NOQA # Formatting details. self.canonical = canonical self.allow_unicode = allow_unicode # set to False to get "\Uxxxxxxxx" for non-basic unicode like emojis self.unicode_supplementary = sys.maxunicode > 0xffff self.sequence_dash_offset = block_seq_indent if block_seq_indent else 0 self.top_level_colon_align = top_level_colon_align self.best_sequence_indent = 2 self.requested_indent = indent # specific for literal zero indent if indent and 1 < indent < 10: self.best_sequence_indent = indent self.best_map_indent = self.best_sequence_indent # if self.best_sequence_indent < self.sequence_dash_offset + 1: # self.best_sequence_indent = self.sequence_dash_offset + 1 self.best_width = 80 if width and width > self.best_sequence_indent * 2: self.best_width = width self.best_line_break = u'\n' # type: Any if line_break in [u'\r', u'\n', u'\r\n']: self.best_line_break = line_break # Tag prefixes. self.tag_prefixes = None # type: Any # Prepared anchor and tag. self.prepared_anchor = None # type: Any self.prepared_tag = None # type: Any # Scalar analysis and style. self.analysis = None # type: Any self.style = None # type: Any @property def stream(self): # type: () -> Any try: return self._stream except AttributeError: raise YAMLStreamError('output stream needs to specified') @stream.setter def stream(self, val): # type: (Any) -> None if val is None: return if not hasattr(val, 'write'): raise YAMLStreamError('stream argument needs to have a write() method') self._stream = val @property def serializer(self): # type: () -> Any try: if hasattr(self.dumper, 'typ'): return self.dumper.serializer return self.dumper._serializer except AttributeError: return self # cyaml @property def flow_level(self): # type: () -> int return len(self.flow_context) def dispose(self): # type: () -> None # Reset the state attributes (to clear self-references) self.states = [] # type: List[Any] self.state = None def emit(self, event): # type: (Any) -> None if dbg(DBG_EVENT): nprint(event) self.events.append(event) while not self.need_more_events(): self.event = self.events.pop(0) self.state() self.event = None # In some cases, we wait for a few next events before emitting. def need_more_events(self): # type: () -> bool if not self.events: return True event = self.events[0] if isinstance(event, DocumentStartEvent): return self.need_events(1) elif isinstance(event, SequenceStartEvent): return self.need_events(2) elif isinstance(event, MappingStartEvent): return self.need_events(3) else: return False def need_events(self, count): # type: (int) -> bool level = 0 for event in self.events[1:]: if isinstance(event, (DocumentStartEvent, CollectionStartEvent)): level += 1 elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)): level -= 1 elif isinstance(event, StreamEndEvent): level = -1 if level < 0: return False return len(self.events) < count + 1 def increase_indent(self, flow=False, sequence=None, indentless=False): # type: (bool, Optional[bool], bool) -> None self.indents.append(self.indent, sequence) if self.indent is None: # top level if flow: # self.indent = self.best_sequence_indent if self.indents.last_seq() else \ # self.best_map_indent # self.indent = self.best_sequence_indent self.indent = self.requested_indent else: self.indent = 0 elif not indentless: self.indent += ( self.best_sequence_indent if self.indents.last_seq() else self.best_map_indent ) # if self.indents.last_seq(): # if self.indent == 0: # top level block sequence # self.indent = self.best_sequence_indent - self.sequence_dash_offset # else: # self.indent += self.best_sequence_indent # else: # self.indent += self.best_map_indent # States. # Stream handlers. def expect_stream_start(self): # type: () -> None if isinstance(self.event, StreamStartEvent): if PY2: if self.event.encoding and not getattr(self.stream, 'encoding', None): self.encoding = self.event.encoding else: if self.event.encoding and not hasattr(self.stream, 'encoding'): self.encoding = self.event.encoding self.write_stream_start() self.state = self.expect_first_document_start else: raise EmitterError('expected StreamStartEvent, but got %s' % (self.event,)) def expect_nothing(self): # type: () -> None raise EmitterError('expected nothing, but got %s' % (self.event,)) # Document handlers. def expect_first_document_start(self): # type: () -> Any return self.expect_document_start(first=True) def expect_document_start(self, first=False): # type: (bool) -> None if isinstance(self.event, DocumentStartEvent): if (self.event.version or self.event.tags) and self.open_ended: self.write_indicator(u'...', True) self.write_indent() if self.event.version: version_text = self.prepare_version(self.event.version) self.write_version_directive(version_text) self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() if self.event.tags: handles = sorted(self.event.tags.keys()) for handle in handles: prefix = self.event.tags[handle] self.tag_prefixes[prefix] = handle handle_text = self.prepare_tag_handle(handle) prefix_text = self.prepare_tag_prefix(prefix) self.write_tag_directive(handle_text, prefix_text) implicit = ( first and not self.event.explicit and not self.canonical and not self.event.version and not self.event.tags and not self.check_empty_document() ) if not implicit: self.write_indent() self.write_indicator(u'---', True) if self.canonical: self.write_indent() self.state = self.expect_document_root elif isinstance(self.event, StreamEndEvent): if self.open_ended: self.write_indicator(u'...', True) self.write_indent() self.write_stream_end() self.state = self.expect_nothing else: raise EmitterError('expected DocumentStartEvent, but got %s' % (self.event,)) def expect_document_end(self): # type: () -> None if isinstance(self.event, DocumentEndEvent): self.write_indent() if self.event.explicit: self.write_indicator(u'...', True) self.write_indent() self.flush_stream() self.state = self.expect_document_start else: raise EmitterError('expected DocumentEndEvent, but got %s' % (self.event,)) def expect_document_root(self): # type: () -> None self.states.append(self.expect_document_end) self.expect_node(root=True) # Node handlers. def expect_node(self, root=False, sequence=False, mapping=False, simple_key=False): # type: (bool, bool, bool, bool) -> None self.root_context = root self.sequence_context = sequence # not used in PyYAML self.mapping_context = mapping self.simple_key_context = simple_key if isinstance(self.event, AliasEvent): self.expect_alias() elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): if ( self.process_anchor(u'&') and isinstance(self.event, ScalarEvent) and self.sequence_context ): self.sequence_context = False self.process_tag() if isinstance(self.event, ScalarEvent): # nprint('@', self.indention, self.no_newline, self.column) self.expect_scalar() elif isinstance(self.event, SequenceStartEvent): # nprint('@', self.indention, self.no_newline, self.column) i2, n2 = self.indention, self.no_newline # NOQA if self.event.comment: if self.event.flow_style is False and self.event.comment: if self.write_post_comment(self.event): self.indention = False self.no_newline = True if self.write_pre_comment(self.event): pass self.indention = i2 self.no_newline = not self.indention if ( self.flow_level or self.canonical or self.event.flow_style or self.check_empty_sequence() ): self.expect_flow_sequence() else: self.expect_block_sequence() elif isinstance(self.event, MappingStartEvent): if self.event.flow_style is False and self.event.comment: self.write_post_comment(self.event) if self.event.comment and self.event.comment[1]: self.write_pre_comment(self.event) if ( self.flow_level or self.canonical or self.event.flow_style or self.check_empty_mapping() ): self.expect_flow_mapping(single=self.event.nr_items == 1) else: self.expect_block_mapping() else: raise EmitterError('expected NodeEvent, but got %s' % (self.event,)) def expect_alias(self): # type: () -> None if self.event.anchor is None: raise EmitterError('anchor is not specified for alias') self.process_anchor(u'*') self.state = self.states.pop() def expect_scalar(self): # type: () -> None self.increase_indent(flow=True) self.process_scalar() self.indent = self.indents.pop() self.state = self.states.pop() # Flow sequence handlers. def expect_flow_sequence(self): # type: () -> None ind = self.indents.seq_flow_align(self.best_sequence_indent, self.column) self.write_indicator(u' ' * ind + u'[', True, whitespace=True) self.increase_indent(flow=True, sequence=True) self.flow_context.append('[') self.state = self.expect_first_flow_sequence_item def expect_first_flow_sequence_item(self): # type: () -> None if isinstance(self.event, SequenceEndEvent): self.indent = self.indents.pop() popped = self.flow_context.pop() assert popped == '[' self.write_indicator(u']', False) if self.event.comment and self.event.comment[0]: # eol comment on empty flow sequence self.write_post_comment(self.event) elif self.flow_level == 0: self.write_line_break() self.state = self.states.pop() else: if self.canonical or self.column > self.best_width: self.write_indent() self.states.append(self.expect_flow_sequence_item) self.expect_node(sequence=True) def expect_flow_sequence_item(self): # type: () -> None if isinstance(self.event, SequenceEndEvent): self.indent = self.indents.pop() popped = self.flow_context.pop() assert popped == '[' if self.canonical: self.write_indicator(u',', False) self.write_indent() self.write_indicator(u']', False) if self.event.comment and self.event.comment[0]: # eol comment on flow sequence self.write_post_comment(self.event) else: self.no_newline = False self.state = self.states.pop() else: self.write_indicator(u',', False) if self.canonical or self.column > self.best_width: self.write_indent() self.states.append(self.expect_flow_sequence_item) self.expect_node(sequence=True) # Flow mapping handlers. def expect_flow_mapping(self, single=False): # type: (Optional[bool]) -> None ind = self.indents.seq_flow_align(self.best_sequence_indent, self.column) map_init = u'{' if ( single and self.flow_level and self.flow_context[-1] == '[' and not self.canonical and not self.brace_single_entry_mapping_in_flow_sequence ): # single map item with flow context, no curly braces necessary map_init = u'' self.write_indicator(u' ' * ind + map_init, True, whitespace=True) self.flow_context.append(map_init) self.increase_indent(flow=True, sequence=False) self.state = self.expect_first_flow_mapping_key def expect_first_flow_mapping_key(self): # type: () -> None if isinstance(self.event, MappingEndEvent): self.indent = self.indents.pop() popped = self.flow_context.pop() assert popped == '{' # empty flow mapping self.write_indicator(u'}', False) if self.event.comment and self.event.comment[0]: # eol comment on empty mapping self.write_post_comment(self.event) elif self.flow_level == 0: self.write_line_break() self.state = self.states.pop() else: if self.canonical or self.column > self.best_width: self.write_indent() if not self.canonical and self.check_simple_key(): self.states.append(self.expect_flow_mapping_simple_value) self.expect_node(mapping=True, simple_key=True) else: self.write_indicator(u'?', True) self.states.append(self.expect_flow_mapping_value) self.expect_node(mapping=True) def expect_flow_mapping_key(self): # type: () -> None if isinstance(self.event, MappingEndEvent): # if self.event.comment and self.event.comment[1]: # self.write_pre_comment(self.event) self.indent = self.indents.pop() popped = self.flow_context.pop() assert popped in [u'{', u''] if self.canonical: self.write_indicator(u',', False) self.write_indent() if popped != u'': self.write_indicator(u'}', False) if self.event.comment and self.event.comment[0]: # eol comment on flow mapping, never reached on empty mappings self.write_post_comment(self.event) else: self.no_newline = False self.state = self.states.pop() else: self.write_indicator(u',', False) if self.canonical or self.column > self.best_width: self.write_indent() if not self.canonical and self.check_simple_key(): self.states.append(self.expect_flow_mapping_simple_value) self.expect_node(mapping=True, simple_key=True) else: self.write_indicator(u'?', True) self.states.append(self.expect_flow_mapping_value) self.expect_node(mapping=True) def expect_flow_mapping_simple_value(self): # type: () -> None self.write_indicator(self.prefixed_colon, False) self.states.append(self.expect_flow_mapping_key) self.expect_node(mapping=True) def expect_flow_mapping_value(self): # type: () -> None if self.canonical or self.column > self.best_width: self.write_indent() self.write_indicator(self.prefixed_colon, True) self.states.append(self.expect_flow_mapping_key) self.expect_node(mapping=True) # Block sequence handlers. def expect_block_sequence(self): # type: () -> None if self.mapping_context: indentless = not self.indention else: indentless = False if not self.compact_seq_seq and self.column != 0: self.write_line_break() self.increase_indent(flow=False, sequence=True, indentless=indentless) self.state = self.expect_first_block_sequence_item def expect_first_block_sequence_item(self): # type: () -> Any return self.expect_block_sequence_item(first=True) def expect_block_sequence_item(self, first=False): # type: (bool) -> None if not first and isinstance(self.event, SequenceEndEvent): if self.event.comment and self.event.comment[1]: # final comments on a block list e.g. empty line self.write_pre_comment(self.event) self.indent = self.indents.pop() self.state = self.states.pop() self.no_newline = False else: if self.event.comment and self.event.comment[1]: self.write_pre_comment(self.event) nonl = self.no_newline if self.column == 0 else False self.write_indent() ind = self.sequence_dash_offset # if len(self.indents) > 1 else 0 self.write_indicator(u' ' * ind + u'-', True, indention=True) if nonl or self.sequence_dash_offset + 2 > self.best_sequence_indent: self.no_newline = True self.states.append(self.expect_block_sequence_item) self.expect_node(sequence=True) # Block mapping handlers. def expect_block_mapping(self): # type: () -> None if not self.mapping_context and not (self.compact_seq_map or self.column == 0): self.write_line_break() self.increase_indent(flow=False, sequence=False) self.state = self.expect_first_block_mapping_key def expect_first_block_mapping_key(self): # type: () -> None return self.expect_block_mapping_key(first=True) def expect_block_mapping_key(self, first=False): # type: (Any) -> None if not first and isinstance(self.event, MappingEndEvent): if self.event.comment and self.event.comment[1]: # final comments from a doc self.write_pre_comment(self.event) self.indent = self.indents.pop() self.state = self.states.pop() else: if self.event.comment and self.event.comment[1]: # final comments from a doc self.write_pre_comment(self.event) self.write_indent() if self.check_simple_key(): if not isinstance( self.event, (SequenceStartEvent, MappingStartEvent) ): # sequence keys try: if self.event.style == '?': self.write_indicator(u'?', True, indention=True) except AttributeError: # aliases have no style pass self.states.append(self.expect_block_mapping_simple_value) self.expect_node(mapping=True, simple_key=True) if isinstance(self.event, AliasEvent): self.stream.write(u' ') else: self.write_indicator(u'?', True, indention=True) self.states.append(self.expect_block_mapping_value) self.expect_node(mapping=True) def expect_block_mapping_simple_value(self): # type: () -> None if getattr(self.event, 'style', None) != '?': # prefix = u'' if self.indent == 0 and self.top_level_colon_align is not None: # write non-prefixed colon c = u' ' * (self.top_level_colon_align - self.column) + self.colon else: c = self.prefixed_colon self.write_indicator(c, False) self.states.append(self.expect_block_mapping_key) self.expect_node(mapping=True) def expect_block_mapping_value(self): # type: () -> None self.write_indent() self.write_indicator(self.prefixed_colon, True, indention=True) self.states.append(self.expect_block_mapping_key) self.expect_node(mapping=True) # Checkers. def check_empty_sequence(self): # type: () -> bool return ( isinstance(self.event, SequenceStartEvent) and bool(self.events) and isinstance(self.events[0], SequenceEndEvent) ) def check_empty_mapping(self): # type: () -> bool return ( isinstance(self.event, MappingStartEvent) and bool(self.events) and isinstance(self.events[0], MappingEndEvent) ) def check_empty_document(self): # type: () -> bool if not isinstance(self.event, DocumentStartEvent) or not self.events: return False event = self.events[0] return ( isinstance(event, ScalarEvent) and event.anchor is None and event.tag is None and event.implicit and event.value == "" ) def check_simple_key(self): # type: () -> bool length = 0 if isinstance(self.event, NodeEvent) and self.event.anchor is not None: if self.prepared_anchor is None: self.prepared_anchor = self.prepare_anchor(self.event.anchor) length += len(self.prepared_anchor) if ( isinstance(self.event, (ScalarEvent, CollectionStartEvent)) and self.event.tag is not None ): if self.prepared_tag is None: self.prepared_tag = self.prepare_tag(self.event.tag) length += len(self.prepared_tag) if isinstance(self.event, ScalarEvent): if self.analysis is None: self.analysis = self.analyze_scalar(self.event.value) length += len(self.analysis.scalar) return length < self.MAX_SIMPLE_KEY_LENGTH and ( isinstance(self.event, AliasEvent) or (isinstance(self.event, SequenceStartEvent) and self.event.flow_style is True) or (isinstance(self.event, MappingStartEvent) and self.event.flow_style is True) or ( isinstance(self.event, ScalarEvent) and not self.analysis.empty and not self.analysis.multiline ) or self.check_empty_sequence() or self.check_empty_mapping() ) # Anchor, Tag, and Scalar processors. def process_anchor(self, indicator): # type: (Any) -> bool if self.event.anchor is None: self.prepared_anchor = None return False if self.prepared_anchor is None: self.prepared_anchor = self.prepare_anchor(self.event.anchor) if self.prepared_anchor: self.write_indicator(indicator + self.prepared_anchor, True) self.prepared_anchor = None return True def process_tag(self): # type: () -> None tag = self.event.tag if isinstance(self.event, ScalarEvent): if self.style is None: self.style = self.choose_scalar_style() if (not self.canonical or tag is None) and ( (self.style == "" and self.event.implicit[0]) or (self.style != "" and self.event.implicit[1]) ): self.prepared_tag = None return if self.event.implicit[0] and tag is None: tag = u'!' self.prepared_tag = None else: if (not self.canonical or tag is None) and self.event.implicit: self.prepared_tag = None return if tag is None: raise EmitterError('tag is not specified') if self.prepared_tag is None: self.prepared_tag = self.prepare_tag(tag) if self.prepared_tag: self.write_indicator(self.prepared_tag, True) if ( self.sequence_context and not self.flow_level and isinstance(self.event, ScalarEvent) ): self.no_newline = True self.prepared_tag = None def choose_scalar_style(self): # type: () -> Any if self.analysis is None: self.analysis = self.analyze_scalar(self.event.value) if self.event.style == '"' or self.canonical: return '"' if (not self.event.style or self.event.style == '?') and ( self.event.implicit[0] or not self.event.implicit[2] ): if not ( self.simple_key_context and (self.analysis.empty or self.analysis.multiline) ) and ( self.flow_level and self.analysis.allow_flow_plain or (not self.flow_level and self.analysis.allow_block_plain) ): return "" self.analysis.allow_block = True if self.event.style and self.event.style in '|>': if ( not self.flow_level and not self.simple_key_context and self.analysis.allow_block ): return self.event.style if not self.event.style and self.analysis.allow_double_quoted: if "'" in self.event.value or '\n' in self.event.value: return '"' if not self.event.style or self.event.style == "'": if self.analysis.allow_single_quoted and not ( self.simple_key_context and self.analysis.multiline ): return "'" return '"' def process_scalar(self): # type: () -> None if self.analysis is None: self.analysis = self.analyze_scalar(self.event.value) if self.style is None: self.style = self.choose_scalar_style() split = not self.simple_key_context # if self.analysis.multiline and split \ # and (not self.style or self.style in '\'\"'): # self.write_indent() # nprint('xx', self.sequence_context, self.flow_level) if self.sequence_context and not self.flow_level: self.write_indent() if self.style == '"': self.write_double_quoted(self.analysis.scalar, split) elif self.style == "'": self.write_single_quoted(self.analysis.scalar, split) elif self.style == '>': self.write_folded(self.analysis.scalar) elif self.style == '|': self.write_literal(self.analysis.scalar, self.event.comment) else: self.write_plain(self.analysis.scalar, split) self.analysis = None self.style = None if self.event.comment: self.write_post_comment(self.event) # Analyzers. def prepare_version(self, version): # type: (Any) -> Any major, minor = version if major != 1: raise EmitterError('unsupported YAML version: %d.%d' % (major, minor)) return u'%d.%d' % (major, minor) def prepare_tag_handle(self, handle): # type: (Any) -> Any if not handle: raise EmitterError('tag handle must not be empty') if handle[0] != u'!' or handle[-1] != u'!': raise EmitterError("tag handle must start and end with '!': %r" % (utf8(handle))) for ch in handle[1:-1]: if not ( u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' or ch in u'-_' ): raise EmitterError( 'invalid character %r in the tag handle: %r' % (utf8(ch), utf8(handle)) ) return handle def prepare_tag_prefix(self, prefix): # type: (Any) -> Any if not prefix: raise EmitterError('tag prefix must not be empty') chunks = [] # type: List[Any] start = end = 0 if prefix[0] == u'!': end = 1 while end < len(prefix): ch = prefix[end] if ( u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' or ch in u"-;/?!:@&=+$,_.~*'()[]" ): end += 1 else: if start < end: chunks.append(prefix[start:end]) start = end = end + 1 data = utf8(ch) for ch in data: chunks.append(u'%%%02X' % ord(ch)) if start < end: chunks.append(prefix[start:end]) return "".join(chunks) def prepare_tag(self, tag): # type: (Any) -> Any if not tag: raise EmitterError('tag must not be empty') if tag == u'!': return tag handle = None suffix = tag prefixes = sorted(self.tag_prefixes.keys()) for prefix in prefixes: if tag.startswith(prefix) and (prefix == u'!' or len(prefix) < len(tag)): handle = self.tag_prefixes[prefix] suffix = tag[len(prefix) :] chunks = [] # type: List[Any] start = end = 0 while end < len(suffix): ch = suffix[end] if ( u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' or ch in u"-;/?:@&=+$,_.~*'()[]" or (ch == u'!' and handle != u'!') ): end += 1 else: if start < end: chunks.append(suffix[start:end]) start = end = end + 1 data = utf8(ch) for ch in data: chunks.append(u'%%%02X' % ord(ch)) if start < end: chunks.append(suffix[start:end]) suffix_text = "".join(chunks) if handle: return u'%s%s' % (handle, suffix_text) else: return u'!<%s>' % suffix_text def prepare_anchor(self, anchor): # type: (Any) -> Any if not anchor: raise EmitterError('anchor must not be empty') for ch in anchor: if not check_anchorname_char(ch): raise EmitterError( 'invalid character %r in the anchor: %r' % (utf8(ch), utf8(anchor)) ) return anchor def analyze_scalar(self, scalar): # type: (Any) -> Any # Empty scalar is a special case. if not scalar: return ScalarAnalysis( scalar=scalar, empty=True, multiline=False, allow_flow_plain=False, allow_block_plain=True, allow_single_quoted=True, allow_double_quoted=True, allow_block=False, ) # Indicators and special characters. block_indicators = False flow_indicators = False line_breaks = False special_characters = False # Important whitespace combinations. leading_space = False leading_break = False trailing_space = False trailing_break = False break_space = False space_break = False # Check document indicators. if scalar.startswith(u'---') or scalar.startswith(u'...'): block_indicators = True flow_indicators = True # First character or preceded by a whitespace. preceeded_by_whitespace = True # Last character or followed by a whitespace. followed_by_whitespace = len(scalar) == 1 or scalar[1] in u'\0 \t\r\n\x85\u2028\u2029' # The previous character is a space. previous_space = False # The previous character is a break. previous_break = False index = 0 while index < len(scalar): ch = scalar[index] # Check for indicators. if index == 0: # Leading indicators are special characters. if ch in u'#,[]{}&*!|>\'"%@`': flow_indicators = True block_indicators = True if ch in u'?:': # ToDo if self.serializer.use_version == (1, 1): flow_indicators = True elif len(scalar) == 1: # single character flow_indicators = True if followed_by_whitespace: block_indicators = True if ch == u'-' and followed_by_whitespace: flow_indicators = True block_indicators = True else: # Some indicators cannot appear within a scalar as well. if ch in u',[]{}': # http://yaml.org/spec/1.2/spec.html#id2788859 flow_indicators = True if ch == u'?' and self.serializer.use_version == (1, 1): flow_indicators = True if ch == u':': if followed_by_whitespace: flow_indicators = True block_indicators = True if ch == u'#' and preceeded_by_whitespace: flow_indicators = True block_indicators = True # Check for line breaks, special, and unicode characters. if ch in u'\n\x85\u2028\u2029': line_breaks = True if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'): if ( ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF' or u'\uE000' <= ch <= u'\uFFFD' or (self.unicode_supplementary and (u'\U00010000' <= ch <= u'\U0010FFFF')) ) and ch != u'\uFEFF': # unicode_characters = True if not self.allow_unicode: special_characters = True else: special_characters = True # Detect important whitespace combinations. if ch == u' ': if index == 0: leading_space = True if index == len(scalar) - 1: trailing_space = True if previous_break: break_space = True previous_space = True previous_break = False elif ch in u'\n\x85\u2028\u2029': if index == 0: leading_break = True if index == len(scalar) - 1: trailing_break = True if previous_space: space_break = True previous_space = False previous_break = True else: previous_space = False previous_break = False # Prepare for the next character. index += 1 preceeded_by_whitespace = ch in u'\0 \t\r\n\x85\u2028\u2029' followed_by_whitespace = ( index + 1 >= len(scalar) or scalar[index + 1] in u'\0 \t\r\n\x85\u2028\u2029' ) # Let's decide what styles are allowed. allow_flow_plain = True allow_block_plain = True allow_single_quoted = True allow_double_quoted = True allow_block = True # Leading and trailing whitespaces are bad for plain scalars. if leading_space or leading_break or trailing_space or trailing_break: allow_flow_plain = allow_block_plain = False # We do not permit trailing spaces for block scalars. if trailing_space: allow_block = False # Spaces at the beginning of a new line are only acceptable for block # scalars. if break_space: allow_flow_plain = allow_block_plain = allow_single_quoted = False # Spaces followed by breaks, as well as special character are only # allowed for double quoted scalars. if special_characters: allow_flow_plain = allow_block_plain = allow_single_quoted = allow_block = False elif space_break: allow_flow_plain = allow_block_plain = allow_single_quoted = False if not self.allow_space_break: allow_block = False # Although the plain scalar writer supports breaks, we never emit # multiline plain scalars. if line_breaks: allow_flow_plain = allow_block_plain = False # Flow indicators are forbidden for flow plain scalars. if flow_indicators: allow_flow_plain = False # Block indicators are forbidden for block plain scalars. if block_indicators: allow_block_plain = False return ScalarAnalysis( scalar=scalar, empty=False, multiline=line_breaks, allow_flow_plain=allow_flow_plain, allow_block_plain=allow_block_plain, allow_single_quoted=allow_single_quoted, allow_double_quoted=allow_double_quoted, allow_block=allow_block, ) # Writers. def flush_stream(self): # type: () -> None if hasattr(self.stream, 'flush'): self.stream.flush() def write_stream_start(self): # type: () -> None # Write BOM if needed. if self.encoding and self.encoding.startswith('utf-16'): self.stream.write(u'\uFEFF'.encode(self.encoding)) def write_stream_end(self): # type: () -> None self.flush_stream() def write_indicator(self, indicator, need_whitespace, whitespace=False, indention=False): # type: (Any, Any, bool, bool) -> None if self.whitespace or not need_whitespace: data = indicator else: data = u' ' + indicator self.whitespace = whitespace self.indention = self.indention and indention self.column += len(data) self.open_ended = False if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) def write_indent(self): # type: () -> None indent = self.indent or 0 if ( not self.indention or self.column > indent or (self.column == indent and not self.whitespace) ): if bool(self.no_newline): self.no_newline = False else: self.write_line_break() if self.column < indent: self.whitespace = True data = u' ' * (indent - self.column) self.column = indent if self.encoding: data = data.encode(self.encoding) self.stream.write(data) def write_line_break(self, data=None): # type: (Any) -> None if data is None: data = self.best_line_break self.whitespace = True self.indention = True self.line += 1 self.column = 0 if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) def write_version_directive(self, version_text): # type: (Any) -> None data = u'%%YAML %s' % version_text if self.encoding: data = data.encode(self.encoding) self.stream.write(data) self.write_line_break() def write_tag_directive(self, handle_text, prefix_text): # type: (Any, Any) -> None data = u'%%TAG %s %s' % (handle_text, prefix_text) if self.encoding: data = data.encode(self.encoding) self.stream.write(data) self.write_line_break() # Scalar streams. def write_single_quoted(self, text, split=True): # type: (Any, Any) -> None if self.root_context: if self.requested_indent is not None: self.write_line_break() if self.requested_indent != 0: self.write_indent() self.write_indicator(u"'", True) spaces = False breaks = False start = end = 0 while end <= len(text): ch = None if end < len(text): ch = text[end] if spaces: if ch is None or ch != u' ': if ( start + 1 == end and self.column > self.best_width and split and start != 0 and end != len(text) ): self.write_indent() else: data = text[start:end] self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) start = end elif breaks: if ch is None or ch not in u'\n\x85\u2028\u2029': if text[start] == u'\n': self.write_line_break() for br in text[start:end]: if br == u'\n': self.write_line_break() else: self.write_line_break(br) self.write_indent() start = end else: if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u"'": if start < end: data = text[start:end] self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) start = end if ch == u"'": data = u"''" self.column += 2 if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) start = end + 1 if ch is not None: spaces = ch == u' ' breaks = ch in u'\n\x85\u2028\u2029' end += 1 self.write_indicator(u"'", False) ESCAPE_REPLACEMENTS = { u'\0': u'0', u'\x07': u'a', u'\x08': u'b', u'\x09': u't', u'\x0A': u'n', u'\x0B': u'v', u'\x0C': u'f', u'\x0D': u'r', u'\x1B': u'e', u'"': u'"', u'\\': u'\\', u'\x85': u'N', u'\xA0': u'_', u'\u2028': u'L', u'\u2029': u'P', } def write_double_quoted(self, text, split=True): # type: (Any, Any) -> None if self.root_context: if self.requested_indent is not None: self.write_line_break() if self.requested_indent != 0: self.write_indent() self.write_indicator(u'"', True) start = end = 0 while end <= len(text): ch = None if end < len(text): ch = text[end] if ( ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' or not ( u'\x20' <= ch <= u'\x7E' or ( self.allow_unicode and (u'\xA0' <= ch <= u'\uD7FF' or u'\uE000' <= ch <= u'\uFFFD') ) ) ): if start < end: data = text[start:end] self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) start = end if ch is not None: if ch in self.ESCAPE_REPLACEMENTS: data = u'\\' + self.ESCAPE_REPLACEMENTS[ch] elif ch <= u'\xFF': data = u'\\x%02X' % ord(ch) elif ch <= u'\uFFFF': data = u'\\u%04X' % ord(ch) else: data = u'\\U%08X' % ord(ch) self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) start = end + 1 if ( 0 < end < len(text) - 1 and (ch == u' ' or start >= end) and self.column + (end - start) > self.best_width and split ): data = text[start:end] + u'\\' if start < end: start = end self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) self.write_indent() self.whitespace = False self.indention = False if text[start] == u' ': data = u'\\' self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) end += 1 self.write_indicator(u'"', False) def determine_block_hints(self, text): # type: (Any) -> Any indent = 0 indicator = u'' hints = u'' if text: if text[0] in u' \n\x85\u2028\u2029': indent = self.best_sequence_indent hints += text_type(indent) elif self.root_context: for end in ['\n---', '\n...']: pos = 0 while True: pos = text.find(end, pos) if pos == -1: break try: if text[pos + 4] in ' \r\n': break except IndexError: pass pos += 1 if pos > -1: break if pos > 0: indent = self.best_sequence_indent if text[-1] not in u'\n\x85\u2028\u2029': indicator = u'-' elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029': indicator = u'+' hints += indicator return hints, indent, indicator def write_folded(self, text): # type: (Any) -> None hints, _indent, _indicator = self.determine_block_hints(text) self.write_indicator(u'>' + hints, True) if _indicator == u'+': self.open_ended = True self.write_line_break() leading_space = True spaces = False breaks = True start = end = 0 while end <= len(text): ch = None if end < len(text): ch = text[end] if breaks: if ch is None or ch not in u'\n\x85\u2028\u2029\a': if ( not leading_space and ch is not None and ch != u' ' and text[start] == u'\n' ): self.write_line_break() leading_space = ch == u' ' for br in text[start:end]: if br == u'\n': self.write_line_break() else: self.write_line_break(br) if ch is not None: self.write_indent() start = end elif spaces: if ch != u' ': if start + 1 == end and self.column > self.best_width: self.write_indent() else: data = text[start:end] self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) start = end else: if ch is None or ch in u' \n\x85\u2028\u2029\a': data = text[start:end] self.column += len(data) if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) if ch == u'\a': if end < (len(text) - 1) and not text[end + 2].isspace(): self.write_line_break() self.write_indent() end += 2 # \a and the space that is inserted on the fold else: raise EmitterError('unexcpected fold indicator \\a before space') if ch is None: self.write_line_break() start = end if ch is not None: breaks = ch in u'\n\x85\u2028\u2029' spaces = ch == u' ' end += 1 def write_literal(self, text, comment=None): # type: (Any, Any) -> None hints, _indent, _indicator = self.determine_block_hints(text) self.write_indicator(u'|' + hints, True) try: comment = comment[1][0] if comment: self.stream.write(comment) except (TypeError, IndexError): pass if _indicator == u'+': self.open_ended = True self.write_line_break() breaks = True start = end = 0 while end <= len(text): ch = None if end < len(text): ch = text[end] if breaks: if ch is None or ch not in u'\n\x85\u2028\u2029': for br in text[start:end]: if br == u'\n': self.write_line_break() else: self.write_line_break(br) if ch is not None: if self.root_context: idnx = self.indent if self.indent is not None else 0 self.stream.write(u' ' * (_indent + idnx)) else: self.write_indent() start = end else: if ch is None or ch in u'\n\x85\u2028\u2029': data = text[start:end] if bool(self.encoding): data = data.encode(self.encoding) self.stream.write(data) if ch is None: self.write_line_break() start = end if ch is not None: breaks = ch in u'\n\x85\u2028\u2029' end += 1 def write_plain(self, text, split=True): # type: (Any, Any) -> None if self.root_context: if self.requested_indent is not None: self.write_line_break() if self.requested_indent != 0: self.write_indent() else: self.open_ended = True if not text: return if not self.whitespace: data = u' ' self.column += len(data) if self.encoding: data = data.encode(self.encoding) self.stream.write(data) self.whitespace = False self.indention = False spaces = False breaks = False start = end = 0 while end <= len(text): ch = None if end < len(text): ch = text[end] if spaces: if ch != u' ': if start + 1 == end and self.column > self.best_width and split: self.write_indent() self.whitespace = False self.indention = False else: data = text[start:end] self.column += len(data) if self.encoding: data = data.encode(self.encoding) self.stream.write(data) start = end elif breaks: if ch not in u'\n\x85\u2028\u2029': if text[start] == u'\n': self.write_line_break() for br in text[start:end]: if br == u'\n': self.write_line_break() else: self.write_line_break(br) self.write_indent() self.whitespace = False self.indention = False start = end else: if ch is None or ch in u' \n\x85\u2028\u2029': data = text[start:end] self.column += len(data) if self.encoding: data = data.encode(self.encoding) try: self.stream.write(data) except: # NOQA sys.stdout.write(repr(data) + '\n') raise start = end if ch is not None: spaces = ch == u' ' breaks = ch in u'\n\x85\u2028\u2029' end += 1 def write_comment(self, comment, pre=False): # type: (Any, bool) -> None value = comment.value # nprintf('{:02d} {:02d} {!r}'.format(self.column, comment.start_mark.column, value)) if not pre and value[-1] == '\n': value = value[:-1] try: # get original column position col = comment.start_mark.column if comment.value and comment.value.startswith('\n'): # never inject extra spaces if the comment starts with a newline # and not a real comment (e.g. if you have an empty line following a key-value col = self.column elif col < self.column + 1: ValueError except ValueError: col = self.column + 1 # nprint('post_comment', self.line, self.column, value) try: # at least one space if the current column >= the start column of the comment # but not at the start of a line nr_spaces = col - self.column if self.column and value.strip() and nr_spaces < 1: nr_spaces = 1 value = ' ' * nr_spaces + value try: if bool(self.encoding): value = value.encode(self.encoding) except UnicodeDecodeError: pass self.stream.write(value) except TypeError: raise if not pre: self.write_line_break() def write_pre_comment(self, event): # type: (Any) -> bool comments = event.comment[1] if comments is None: return False try: start_events = (MappingStartEvent, SequenceStartEvent) for comment in comments: if isinstance(event, start_events) and getattr(comment, 'pre_done', None): continue if self.column != 0: self.write_line_break() self.write_comment(comment, pre=True) if isinstance(event, start_events): comment.pre_done = True except TypeError: sys.stdout.write('eventtt {} {}'.format(type(event), event)) raise return True def write_post_comment(self, event): # type: (Any) -> bool if self.event.comment[0] is None: return False comment = event.comment[0] self.write_comment(comment) return True ruamel.yaml-0.15.89/scalarint.py0000664000175100001440000001055613411447426017144 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals from .compat import no_limit_int # NOQA from ruamel.yaml.anchor import Anchor if False: # MYPY from typing import Text, Any, Dict, List # NOQA __all__ = ['ScalarInt', 'BinaryInt', 'OctalInt', 'HexInt', 'HexCapsInt', 'DecimalInt'] class ScalarInt(no_limit_int): def __new__(cls, *args, **kw): # type: (Any, Any, Any) -> Any width = kw.pop('width', None) # type: ignore underscore = kw.pop('underscore', None) # type: ignore anchor = kw.pop('anchor', None) # type: ignore v = no_limit_int.__new__(cls, *args, **kw) # type: ignore v._width = width v._underscore = underscore if anchor is not None: v.yaml_set_anchor(anchor, always_dump=True) return v def __iadd__(self, a): # type: ignore # type: (Any) -> Any x = type(self)(self + a) x._width = self._width # type: ignore x._underscore = ( # type: ignore self._underscore[:] if self._underscore is not None else None # type: ignore ) # NOQA return x def __ifloordiv__(self, a): # type: ignore # type: (Any) -> Any x = type(self)(self // a) x._width = self._width # type: ignore x._underscore = ( # type: ignore self._underscore[:] if self._underscore is not None else None # type: ignore ) # NOQA return x def __imul__(self, a): # type: ignore # type: (Any) -> Any x = type(self)(self * a) x._width = self._width # type: ignore x._underscore = ( # type: ignore self._underscore[:] if self._underscore is not None else None # type: ignore ) # NOQA return x def __ipow__(self, a): # type: ignore # type: (Any) -> Any x = type(self)(self ** a) x._width = self._width # type: ignore x._underscore = ( # type: ignore self._underscore[:] if self._underscore is not None else None # type: ignore ) # NOQA return x def __isub__(self, a): # type: ignore # type: (Any) -> Any x = type(self)(self - a) x._width = self._width # type: ignore x._underscore = ( # type: ignore self._underscore[:] if self._underscore is not None else None # type: ignore ) # NOQA return x @property def anchor(self): # type: () -> Any if not hasattr(self, Anchor.attrib): setattr(self, Anchor.attrib, Anchor()) return getattr(self, Anchor.attrib) def yaml_anchor(self, any=False): # type: (bool) -> Any if not hasattr(self, Anchor.attrib): return None if any or self.anchor.always_dump: return self.anchor return None def yaml_set_anchor(self, value, always_dump=False): # type: (Any, bool) -> None self.anchor.value = value self.anchor.always_dump = always_dump class BinaryInt(ScalarInt): def __new__(cls, value, width=None, underscore=None, anchor=None): # type: (Any, Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore, anchor=anchor) class OctalInt(ScalarInt): def __new__(cls, value, width=None, underscore=None, anchor=None): # type: (Any, Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore, anchor=anchor) # mixed casing of A-F is not supported, when loading the first non digit # determines the case class HexInt(ScalarInt): """uses lower case (a-f)""" def __new__(cls, value, width=None, underscore=None, anchor=None): # type: (Any, Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore, anchor=anchor) class HexCapsInt(ScalarInt): """uses upper case (A-F)""" def __new__(cls, value, width=None, underscore=None, anchor=None): # type: (Any, Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore, anchor=anchor) class DecimalInt(ScalarInt): """needed if anchor""" def __new__(cls, value, width=None, underscore=None, anchor=None): # type: (Any, Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore, anchor=anchor) ruamel.yaml-0.15.89/composer.py0000664000175100001440000002014413411156202016772 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import, print_function import warnings from ruamel.yaml.error import MarkedYAMLError, ReusedAnchorWarning from ruamel.yaml.compat import utf8, nprint, nprintf # NOQA from ruamel.yaml.events import ( StreamStartEvent, StreamEndEvent, MappingStartEvent, MappingEndEvent, SequenceStartEvent, SequenceEndEvent, AliasEvent, ScalarEvent, ) from ruamel.yaml.nodes import MappingNode, ScalarNode, SequenceNode if False: # MYPY from typing import Any, Dict, Optional, List # NOQA __all__ = ['Composer', 'ComposerError'] class ComposerError(MarkedYAMLError): pass class Composer(object): def __init__(self, loader=None): # type: (Any) -> None self.loader = loader if self.loader is not None and getattr(self.loader, '_composer', None) is None: self.loader._composer = self self.anchors = {} # type: Dict[Any, Any] @property def parser(self): # type: () -> Any if hasattr(self.loader, 'typ'): self.loader.parser return self.loader._parser @property def resolver(self): # type: () -> Any # assert self.loader._resolver is not None if hasattr(self.loader, 'typ'): self.loader.resolver return self.loader._resolver def check_node(self): # type: () -> Any # Drop the STREAM-START event. if self.parser.check_event(StreamStartEvent): self.parser.get_event() # If there are more documents available? return not self.parser.check_event(StreamEndEvent) def get_node(self): # type: () -> Any # Get the root node of the next document. if not self.parser.check_event(StreamEndEvent): return self.compose_document() def get_single_node(self): # type: () -> Any # Drop the STREAM-START event. self.parser.get_event() # Compose a document if the stream is not empty. document = None # type: Any if not self.parser.check_event(StreamEndEvent): document = self.compose_document() # Ensure that the stream contains no more documents. if not self.parser.check_event(StreamEndEvent): event = self.parser.get_event() raise ComposerError( 'expected a single document in the stream', document.start_mark, 'but found another document', event.start_mark, ) # Drop the STREAM-END event. self.parser.get_event() return document def compose_document(self): # type: (Any) -> Any # Drop the DOCUMENT-START event. self.parser.get_event() # Compose the root node. node = self.compose_node(None, None) # Drop the DOCUMENT-END event. self.parser.get_event() self.anchors = {} return node def compose_node(self, parent, index): # type: (Any, Any) -> Any if self.parser.check_event(AliasEvent): event = self.parser.get_event() alias = event.anchor if alias not in self.anchors: raise ComposerError( None, None, 'found undefined alias %r' % utf8(alias), event.start_mark ) return self.anchors[alias] event = self.parser.peek_event() anchor = event.anchor if anchor is not None: # have an anchor if anchor in self.anchors: # raise ComposerError( # "found duplicate anchor %r; first occurrence" # % utf8(anchor), self.anchors[anchor].start_mark, # "second occurrence", event.start_mark) ws = ( '\nfound duplicate anchor {!r}\nfirst occurrence {}\nsecond occurrence ' '{}'.format((anchor), self.anchors[anchor].start_mark, event.start_mark) ) warnings.warn(ws, ReusedAnchorWarning) self.resolver.descend_resolver(parent, index) if self.parser.check_event(ScalarEvent): node = self.compose_scalar_node(anchor) elif self.parser.check_event(SequenceStartEvent): node = self.compose_sequence_node(anchor) elif self.parser.check_event(MappingStartEvent): node = self.compose_mapping_node(anchor) self.resolver.ascend_resolver() return node def compose_scalar_node(self, anchor): # type: (Any) -> Any event = self.parser.get_event() tag = event.tag if tag is None or tag == u'!': tag = self.resolver.resolve(ScalarNode, event.value, event.implicit) node = ScalarNode( tag, event.value, event.start_mark, event.end_mark, style=event.style, comment=event.comment, anchor=anchor, ) if anchor is not None: self.anchors[anchor] = node return node def compose_sequence_node(self, anchor): # type: (Any) -> Any start_event = self.parser.get_event() tag = start_event.tag if tag is None or tag == u'!': tag = self.resolver.resolve(SequenceNode, None, start_event.implicit) node = SequenceNode( tag, [], start_event.start_mark, None, flow_style=start_event.flow_style, comment=start_event.comment, anchor=anchor, ) if anchor is not None: self.anchors[anchor] = node index = 0 while not self.parser.check_event(SequenceEndEvent): node.value.append(self.compose_node(node, index)) index += 1 end_event = self.parser.get_event() if node.flow_style is True and end_event.comment is not None: if node.comment is not None: nprint( 'Warning: unexpected end_event commment in sequence ' 'node {}'.format(node.flow_style) ) node.comment = end_event.comment node.end_mark = end_event.end_mark self.check_end_doc_comment(end_event, node) return node def compose_mapping_node(self, anchor): # type: (Any) -> Any start_event = self.parser.get_event() tag = start_event.tag if tag is None or tag == u'!': tag = self.resolver.resolve(MappingNode, None, start_event.implicit) node = MappingNode( tag, [], start_event.start_mark, None, flow_style=start_event.flow_style, comment=start_event.comment, anchor=anchor, ) if anchor is not None: self.anchors[anchor] = node while not self.parser.check_event(MappingEndEvent): # key_event = self.parser.peek_event() item_key = self.compose_node(node, None) # if item_key in node.value: # raise ComposerError("while composing a mapping", # start_event.start_mark, # "found duplicate key", key_event.start_mark) item_value = self.compose_node(node, item_key) # node.value[item_key] = item_value node.value.append((item_key, item_value)) end_event = self.parser.get_event() if node.flow_style is True and end_event.comment is not None: node.comment = end_event.comment node.end_mark = end_event.end_mark self.check_end_doc_comment(end_event, node) return node def check_end_doc_comment(self, end_event, node): # type: (Any, Any) -> None if end_event.comment and end_event.comment[1]: # pre comments on an end_event, no following to move to if node.comment is None: node.comment = [None, None] assert not isinstance(node, ScalarEvent) # this is a post comment on a mapping node, add as third element # in the list node.comment.append(end_event.comment[1]) end_event.comment[1] = None ruamel.yaml-0.15.89/scalarbool.py0000664000175100001440000000277313411426132017276 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals """ You cannot subclass bool, and this is necessary for round-tripping anchored bool values (and also if you want to preserve the original way of writing) bool.__bases__ is type 'int', so that is what is used as the basis for ScalarBoolean as well. You can use these in an if statement, but not when testing equivalence """ from ruamel.yaml.anchor import Anchor if False: # MYPY from typing import Text, Any, Dict, List # NOQA __all__ = ['ScalarBoolean'] # no need for no_limit_int -> int class ScalarBoolean(int): def __new__(cls, *args, **kw): # type: (Any, Any, Any) -> Any anchor = kw.pop('anchor', None) # type: ignore b = int.__new__(cls, *args, **kw) # type: ignore if anchor is not None: b.yaml_set_anchor(anchor, always_dump=True) return b @property def anchor(self): # type: () -> Any if not hasattr(self, Anchor.attrib): setattr(self, Anchor.attrib, Anchor()) return getattr(self, Anchor.attrib) def yaml_anchor(self, any=False): # type: (bool) -> Any if not hasattr(self, Anchor.attrib): return None if any or self.anchor.always_dump: return self.anchor return None def yaml_set_anchor(self, value, always_dump=False): # type: (Any, bool) -> None self.anchor.value = value self.anchor.always_dump = always_dump ruamel.yaml-0.15.89/events.py0000664000175100001440000000747613373303256016476 0ustar anthonusers00000000000000# coding: utf-8 # Abstract classes. if False: # MYPY from typing import Any, Dict, Optional, List # NOQA def CommentCheck(): # type: () -> None pass class Event(object): __slots__ = 'start_mark', 'end_mark', 'comment' def __init__(self, start_mark=None, end_mark=None, comment=CommentCheck): # type: (Any, Any, Any) -> None self.start_mark = start_mark self.end_mark = end_mark # assert comment is not CommentCheck if comment is CommentCheck: comment = None self.comment = comment def __repr__(self): # type: () -> Any attributes = [ key for key in ['anchor', 'tag', 'implicit', 'value', 'flow_style', 'style'] if hasattr(self, key) ] arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) for key in attributes]) if self.comment not in [None, CommentCheck]: arguments += ', comment={!r}'.format(self.comment) return '%s(%s)' % (self.__class__.__name__, arguments) class NodeEvent(Event): __slots__ = ('anchor',) def __init__(self, anchor, start_mark=None, end_mark=None, comment=None): # type: (Any, Any, Any, Any) -> None Event.__init__(self, start_mark, end_mark, comment) self.anchor = anchor class CollectionStartEvent(NodeEvent): __slots__ = 'tag', 'implicit', 'flow_style', 'nr_items' def __init__( self, anchor, tag, implicit, start_mark=None, end_mark=None, flow_style=None, comment=None, nr_items=None, ): # type: (Any, Any, Any, Any, Any, Any, Any, Optional[int]) -> None NodeEvent.__init__(self, anchor, start_mark, end_mark, comment) self.tag = tag self.implicit = implicit self.flow_style = flow_style self.nr_items = nr_items class CollectionEndEvent(Event): __slots__ = () # Implementations. class StreamStartEvent(Event): __slots__ = ('encoding',) def __init__(self, start_mark=None, end_mark=None, encoding=None, comment=None): # type: (Any, Any, Any, Any) -> None Event.__init__(self, start_mark, end_mark, comment) self.encoding = encoding class StreamEndEvent(Event): __slots__ = () class DocumentStartEvent(Event): __slots__ = 'explicit', 'version', 'tags' def __init__( self, start_mark=None, end_mark=None, explicit=None, version=None, tags=None, comment=None, ): # type: (Any, Any, Any, Any, Any, Any) -> None Event.__init__(self, start_mark, end_mark, comment) self.explicit = explicit self.version = version self.tags = tags class DocumentEndEvent(Event): __slots__ = ('explicit',) def __init__(self, start_mark=None, end_mark=None, explicit=None, comment=None): # type: (Any, Any, Any, Any) -> None Event.__init__(self, start_mark, end_mark, comment) self.explicit = explicit class AliasEvent(NodeEvent): __slots__ = () class ScalarEvent(NodeEvent): __slots__ = 'tag', 'implicit', 'value', 'style' def __init__( self, anchor, tag, implicit, value, start_mark=None, end_mark=None, style=None, comment=None, ): # type: (Any, Any, Any, Any, Any, Any, Any, Any) -> None NodeEvent.__init__(self, anchor, start_mark, end_mark, comment) self.tag = tag self.implicit = implicit self.value = value self.style = style class SequenceStartEvent(CollectionStartEvent): __slots__ = () class SequenceEndEvent(CollectionEndEvent): __slots__ = () class MappingStartEvent(CollectionStartEvent): __slots__ = () class MappingEndEvent(CollectionEndEvent): __slots__ = () ruamel.yaml-0.15.89/setup.py0000664000175100001440000011367613435603457016337 0ustar anthonusers00000000000000# # header # coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals # # __init__.py parser import sys import os import datetime import traceback sys.path = [path for path in sys.path if path not in [os.getcwd(), ""]] import platform # NOQA from _ast import * # NOQA from ast import parse # NOQA from setuptools import setup, Extension, Distribution # NOQA from setuptools.command import install_lib # NOQA from setuptools.command.sdist import sdist as _sdist # NOQA if __name__ != '__main__': raise NotImplementedError('should never include setup.py') # # definitions full_package_name = None if __name__ != '__main__': raise NotImplementedError('should never include setup.py') if sys.version_info < (3,): string_type = basestring else: string_type = str if sys.version_info < (3, 4): class Bytes: pass class NameConstant: pass if sys.version_info >= (3, 8): from ast import Str, Num, Bytes, NameConstant # NOQA if sys.version_info < (3,): open_kw = dict() else: open_kw = dict(encoding='utf-8') if sys.version_info < (2, 7) or platform.python_implementation() == 'Jython': class Set: pass if os.environ.get('DVDEBUG', "") == "": def debug(*args, **kw): pass else: def debug(*args, **kw): with open(os.environ['DVDEBUG'], 'a') as fp: kw1 = kw.copy() kw1['file'] = fp print('{:%Y-%d-%mT%H:%M:%S}'.format(datetime.datetime.now()), file=fp, end=' ') print(*args, **kw1) def literal_eval(node_or_string): """ Safely evaluate an expression node or a string containing a Python expression. The string or node provided may only consist of the following Python literal structures: strings, bytes, numbers, tuples, lists, dicts, sets, booleans, and None. Even when passing in Unicode, the resulting Str types parsed are 'str' in Python 2. I don't now how to set 'unicode_literals' on parse -> Str is explicitly converted. """ _safe_names = {'None': None, 'True': True, 'False': False} if isinstance(node_or_string, string_type): node_or_string = parse(node_or_string, mode='eval') if isinstance(node_or_string, Expression): node_or_string = node_or_string.body else: raise TypeError('only string or AST nodes supported') def _convert(node): if isinstance(node, Str): if sys.version_info < (3,) and not isinstance(node.s, unicode): return node.s.decode('utf-8') return node.s elif isinstance(node, Bytes): return node.s elif isinstance(node, Num): return node.n elif isinstance(node, Tuple): return tuple(map(_convert, node.elts)) elif isinstance(node, List): return list(map(_convert, node.elts)) elif isinstance(node, Set): return set(map(_convert, node.elts)) elif isinstance(node, Dict): return dict((_convert(k), _convert(v)) for k, v in zip(node.keys, node.values)) elif isinstance(node, NameConstant): return node.value elif sys.version_info < (3, 4) and isinstance(node, Name): if node.id in _safe_names: return _safe_names[node.id] elif ( isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)) and isinstance(node.operand, (Num, UnaryOp, BinOp)) ): # NOQA operand = _convert(node.operand) if isinstance(node.op, UAdd): return +operand else: return -operand elif ( isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)) and isinstance(node.right, (Num, UnaryOp, BinOp)) and isinstance(node.left, (Num, UnaryOp, BinOp)) ): # NOQA left = _convert(node.left) right = _convert(node.right) if isinstance(node.op, Add): return left + right else: return left - right elif isinstance(node, Call): func_id = getattr(node.func, 'id', None) if func_id == 'dict': return dict((k.arg, _convert(k.value)) for k in node.keywords) elif func_id == 'set': return set(_convert(node.args[0])) elif func_id == 'date': return datetime.date(*[_convert(k) for k in node.args]) elif func_id == 'datetime': return datetime.datetime(*[_convert(k) for k in node.args]) err = SyntaxError('malformed node or string: ' + repr(node)) err.filename = '' err.lineno = node.lineno err.offset = node.col_offset err.text = repr(node) err.node = node raise err return _convert(node_or_string) # parses python ( "= dict( )" ) or ( "= {" ) def _package_data(fn): data = {} with open(fn, **open_kw) as fp: parsing = False lines = [] for line in fp.readlines(): if sys.version_info < (3,): line = line.decode('utf-8') if line.startswith('_package_data'): if 'dict(' in line: parsing = 'python' lines.append('dict(\n') elif line.endswith('= {\n'): parsing = 'python' lines.append('{\n') else: raise NotImplementedError continue if not parsing: continue if parsing == 'python': if line.startswith(')') or line.startswith('}'): lines.append(line) try: data = literal_eval("".join(lines)) except SyntaxError as e: context = 2 from_line = e.lineno - (context + 1) to_line = e.lineno + (context - 1) w = len(str(to_line)) for index, line in enumerate(lines): if from_line <= index <= to_line: print( '{0:{1}}: {2}'.format(index, w, line).encode('utf-8'), end="", ) if index == e.lineno - 1: print( '{0:{1}} {2}^--- {3}'.format( ' ', w, ' ' * e.offset, e.node ) ) raise break lines.append(line) else: raise NotImplementedError return data # make sure you can run "python ../some/dir/setup.py install" pkg_data = _package_data(__file__.replace('setup.py', '__init__.py')) exclude_files = ['setup.py'] # # helper def _check_convert_version(tup): """Create a PEP 386 pseudo-format conformant string from tuple tup.""" ret_val = str(tup[0]) # first is always digit next_sep = '.' # separator for next extension, can be "" or "." nr_digits = 0 # nr of adjacent digits in rest, to verify post_dev = False # are we processig post/dev for x in tup[1:]: if isinstance(x, int): nr_digits += 1 if nr_digits > 2: raise ValueError('too many consecutive digits after ' + ret_val) ret_val += next_sep + str(x) next_sep = '.' continue first_letter = x[0].lower() next_sep = "" if first_letter in 'abcr': if post_dev: raise ValueError('release level specified after ' 'post/dev: ' + x) nr_digits = 0 ret_val += 'rc' if first_letter == 'r' else first_letter elif first_letter in 'pd': nr_digits = 1 # only one can follow post_dev = True ret_val += '.post' if first_letter == 'p' else '.dev' else: raise ValueError('First letter of "' + x + '" not recognised') # .dev and .post need a number otherwise setuptools normalizes and complains if nr_digits == 1 and post_dev: ret_val += '0' return ret_val version_info = pkg_data['version_info'] version_str = _check_convert_version(version_info) class MyInstallLib(install_lib.install_lib): def install(self): fpp = pkg_data['full_package_name'].split('.') # full package path full_exclude_files = [os.path.join(*(fpp + [x])) for x in exclude_files] alt_files = [] outfiles = install_lib.install_lib.install(self) for x in outfiles: for full_exclude_file in full_exclude_files: if full_exclude_file in x: os.remove(x) break else: alt_files.append(x) return alt_files class MySdist(_sdist): def initialize_options(self): _sdist.initialize_options(self) # see pep 527, new uploads should be tar.gz or .zip # fmt = getattr(self, 'tarfmt', None) # because of unicode_literals # self.formats = fmt if fmt else [b'bztar'] if sys.version_info < (3, ) else ['bztar'] dist_base = os.environ.get('PYDISTBASE') fpn = getattr(getattr(self, 'nsp', self), 'full_package_name', None) if fpn and dist_base: print('setting distdir {}/{}'.format(dist_base, fpn)) self.dist_dir = os.path.join(dist_base, fpn) # try except so this doesn't bomb when you don't have wheel installed, implies # generation of wheels in ./dist try: from wheel.bdist_wheel import bdist_wheel as _bdist_wheel # NOQA class MyBdistWheel(_bdist_wheel): def initialize_options(self): _bdist_wheel.initialize_options(self) dist_base = os.environ.get('PYDISTBASE') fpn = getattr(getattr(self, 'nsp', self), 'full_package_name', None) if fpn and dist_base: print('setting distdir {}/{}'.format(dist_base, fpn)) self.dist_dir = os.path.join(dist_base, fpn) _bdist_wheel_available = True except ImportError: _bdist_wheel_available = False class InMemoryZipFile(object): def __init__(self, file_name=None): try: from cStringIO import StringIO except ImportError: from io import BytesIO as StringIO import zipfile self.zip_file = zipfile # Create the in-memory file-like object self._file_name = file_name self.in_memory_data = StringIO() # Create the in-memory zipfile self.in_memory_zip = self.zip_file.ZipFile( self.in_memory_data, 'w', self.zip_file.ZIP_DEFLATED, False ) self.in_memory_zip.debug = 3 def append(self, filename_in_zip, file_contents): """Appends a file with name filename_in_zip and contents of file_contents to the in-memory zip.""" self.in_memory_zip.writestr(filename_in_zip, file_contents) return self # so you can daisy-chain def write_to_file(self, filename): """Writes the in-memory zip to a file.""" # Mark the files as having been created on Windows so that # Unix permissions are not inferred as 0000 for zfile in self.in_memory_zip.filelist: zfile.create_system = 0 self.in_memory_zip.close() with open(filename, 'wb') as f: f.write(self.in_memory_data.getvalue()) def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): if self._file_name is None: return self.write_to_file(self._file_name) def delete_from_zip_file(self, pattern=None, file_names=None): """ zip_file can be a string or a zipfile.ZipFile object, the latter will be closed any name in file_names is deleted, all file_names provided have to be in the ZIP archive or else an IOError is raised """ if pattern and isinstance(pattern, string_type): import re pattern = re.compile(pattern) if file_names: if not isinstance(file_names, list): file_names = [file_names] else: file_names = [] with self.zip_file.ZipFile(self._file_name) as zf: for l in zf.infolist(): if l.filename in file_names: file_names.remove(l.filename) continue if pattern and pattern.match(l.filename): continue self.append(l.filename, zf.read(l)) if file_names: raise IOError( '[Errno 2] No such file{}: {}'.format( "" if len(file_names) == 1 else 's', ', '.join([repr(f) for f in file_names]), ) ) class NameSpacePackager(object): def __init__(self, pkg_data): assert isinstance(pkg_data, dict) self._pkg_data = pkg_data self.full_package_name = self.pn(self._pkg_data['full_package_name']) self._split = None self.depth = self.full_package_name.count('.') self.nested = self._pkg_data.get('nested', False) self.command = None self.python_version() self._pkg = [None, None] # required and pre-installable packages if ( sys.argv[0] == 'setup.py' and sys.argv[1] == 'install' and '--single-version-externally-managed' not in sys.argv ): if os.environ.get('READTHEDOCS', None) == 'True': os.system('pip install .') sys.exit(0) if not os.environ.get('RUAMEL_NO_PIP_INSTALL_CHECK', False): print('error: you have to install with "pip install ."') sys.exit(1) # If you only support an extension module on Linux, Windows thinks it # is pure. That way you would get pure python .whl files that take # precedence for downloading on Linux over source with compilable C code if self._pkg_data.get('universal'): Distribution.is_pure = lambda *args: True else: Distribution.is_pure = lambda *args: False for x in sys.argv: if x[0] == '-' or x == 'setup.py': continue self.command = x break def pn(self, s): if sys.version_info < (3,) and isinstance(s, unicode): return s.encode('utf-8') return s @property def split(self): """split the full package name in list of compontents traditionally done by setuptools.find_packages. This routine skips any directories with __init__.py, for which the name starts with "_" or ".", or contain a setup.py/tox.ini (indicating a subpackage) """ skip = [] if self._split is None: fpn = self.full_package_name.split('.') self._split = [] while fpn: self._split.insert(0, '.'.join(fpn)) fpn = fpn[:-1] for d in sorted(os.listdir('.')): if not os.path.isdir(d) or d == self._split[0] or d[0] in '._': continue # prevent sub-packages in namespace from being included x = os.path.join(d, '__init__.py') if os.path.exists(x): pd = _package_data(x) if pd.get('nested', False): skip.append(d) continue self._split.append(self.full_package_name + '.' + d) if sys.version_info < (3,): self._split = [ (y.encode('utf-8') if isinstance(y, unicode) else y) for y in self._split ] if skip: # this interferes with output checking # print('skipping sub-packages:', ', '.join(skip)) pass return self._split @property def namespace_packages(self): return self.split[: self.depth] def namespace_directories(self, depth=None): """return list of directories where the namespace should be created / can be found """ res = [] for index, d in enumerate(self.split[:depth]): # toplevel gets a dot if index > 0: d = os.path.join(*d.split('.')) res.append('.' + d) return res @property def package_dir(self): d = { # don't specify empty dir, clashes with package_data spec self.full_package_name: '.' } if 'extra_packages' in self._pkg_data: return d if len(self.split) > 1: # only if package namespace d[self.split[0]] = self.namespace_directories(1)[0] return d def create_dirs(self): """create the directories necessary for namespace packaging""" directories = self.namespace_directories(self.depth) if not directories: return if not os.path.exists(directories[0]): for d in directories: os.mkdir(d) with open(os.path.join(d, '__init__.py'), 'w') as fp: fp.write( 'import pkg_resources\n' 'pkg_resources.declare_namespace(__name__)\n' ) def python_version(self): supported = self._pkg_data.get('supported') if supported is None: return if len(supported) == 1: minimum = supported[0] else: for x in supported: if x[0] == sys.version_info[0]: minimum = x break else: return if sys.version_info < minimum: print('minimum python version(s): ' + str(supported)) sys.exit(1) def check(self): try: from pip.exceptions import InstallationError except ImportError: return # arg is either develop (pip install -e) or install if self.command not in ['install', 'develop']: return # if hgi and hgi.base are both in namespace_packages matching # against the top (hgi.) it suffices to find minus-e and non-minus-e # installed packages. As we don't know the order in namespace_packages # do some magic prefix = self.split[0] prefixes = set([prefix, prefix.replace('_', '-')]) for p in sys.path: if not p: continue # directory with setup.py if os.path.exists(os.path.join(p, 'setup.py')): continue # some linked in stuff might not be hgi based if not os.path.isdir(p): continue if p.startswith('/tmp/'): continue for fn in os.listdir(p): for pre in prefixes: if fn.startswith(pre): break else: continue full_name = os.path.join(p, fn) # not in prefixes the toplevel is never changed from _ to - if fn == prefix and os.path.isdir(full_name): # directory -> other, non-minus-e, install if self.command == 'develop': raise InstallationError( 'Cannot mix develop (pip install -e),\nwith ' 'non-develop installs for package name {0}'.format(fn) ) elif fn == prefix: raise InstallationError('non directory package {0} in {1}'.format(fn, p)) for pre in [x + '.' for x in prefixes]: if fn.startswith(pre): break else: continue # hgiabc instead of hgi. if fn.endswith('-link') and self.command == 'install': raise InstallationError( 'Cannot mix non-develop with develop\n(pip install -e)' ' installs for package name {0}'.format(fn) ) def entry_points(self, script_name=None, package_name=None): """normally called without explicit script_name and package name the default console_scripts entry depends on the existence of __main__.py: if that file exists then the function main() in there is used, otherwise the in __init__.py. the _package_data entry_points key/value pair can be explicitly specified including a "=" character. If the entry is True or 1 the scriptname is the last part of the full package path (split on '.') if the ep entry is a simple string without "=", that is assumed to be the name of the script. """ def pckg_entry_point(name): return '{0}{1}:main'.format( name, '.__main__' if os.path.exists('__main__.py') else "" ) ep = self._pkg_data.get('entry_points', True) if isinstance(ep, dict): return ep if ep is None: return None if ep not in [True, 1]: if '=' in ep: # full specification of the entry point like # entry_points=['yaml = ruamel.yaml.cmd:main'], return {'console_scripts': [ep]} # assume that it is just the script name script_name = ep if package_name is None: package_name = self.full_package_name if not script_name: script_name = package_name.split('.')[-1] return { 'console_scripts': [ '{0} = {1}'.format(script_name, pckg_entry_point(package_name)) ] } @property def url(self): if self.full_package_name.startswith('ruamel.'): sp = self.full_package_name.split('.', 1) else: sp = ['ruamel', self.full_package_name] return 'https://bitbucket.org/{0}/{1}'.format(*sp) @property def author(self): return self._pkg_data['author'] # no get needs to be there @property def author_email(self): return self._pkg_data['author_email'] # no get needs to be there @property def license(self): """return the license field from _package_data, None means MIT""" lic = self._pkg_data.get('license') if lic is None: # lic_fn = os.path.join(os.path.dirname(__file__), 'LICENSE') # assert os.path.exists(lic_fn) return 'MIT license' return lic def has_mit_lic(self): return 'MIT' in self.license @property def description(self): return self._pkg_data['description'] # no get needs to be there @property def status(self): # αβ status = self._pkg_data.get('status', 'β').lower() if status in ['α', 'alpha']: return (3, 'Alpha') elif status in ['β', 'beta']: return (4, 'Beta') elif 'stable' in status.lower(): return (5, 'Production/Stable') raise NotImplementedError @property def classifiers(self): """this needs more intelligence, probably splitting the classifiers from _pkg_data and only adding defaults when no explicit entries were provided. Add explicit Python versions in sync with tox.env generation based on python_requires? """ return sorted( set( [ 'Development Status :: {0} - {1}'.format(*self.status), 'Intended Audience :: Developers', 'License :: ' + ('OSI Approved :: MIT' if self.has_mit_lic() else 'Other/Proprietary') + ' License', 'Operating System :: OS Independent', 'Programming Language :: Python', ] + [self.pn(x) for x in self._pkg_data.get('classifiers', [])] ) ) @property def keywords(self): return self.pn(self._pkg_data.get('keywords', [])) @property def install_requires(self): """list of packages required for installation""" return self._analyse_packages[0] @property def install_pre(self): """list of packages required for installation""" return self._analyse_packages[1] @property def _analyse_packages(self): """gather from configuration, names starting with * need to be installed explicitly as they are not on PyPI install_requires should be dict, with keys 'any', 'py27' etc or a list (which is as if only 'any' was defined ToDo: update with: pep508 conditional dependencies """ if self._pkg[0] is None: self._pkg[0] = [] self._pkg[1] = [] ir = self._pkg_data.get('install_requires') if ir is None: return self._pkg # these will be both empty at this point if isinstance(ir, list): self._pkg[0] = ir return self._pkg # 'any' for all builds, 'py27' etc for specifics versions packages = ir.get('any', []) if isinstance(packages, string_type): packages = packages.split() # assume white space separated string if self.nested: # parent dir is also a package, make sure it is installed (need its .pth file) parent_pkg = self.full_package_name.rsplit('.', 1)[0] if parent_pkg not in packages: packages.append(parent_pkg) implementation = platform.python_implementation() if implementation == 'CPython': pyver = 'py{0}{1}'.format(*sys.version_info) elif implementation == 'PyPy': pyver = 'pypy' if sys.version_info < (3,) else 'pypy3' elif implementation == 'Jython': pyver = 'jython' packages.extend(ir.get(pyver, [])) for p in packages: # package name starting with * means use local source tree, non-published # to PyPi or maybe not latest version on PyPI -> pre-install if p[0] == '*': p = p[1:] self._pkg[1].append(p) self._pkg[0].append(p) return self._pkg @property def extras_require(self): """dict of conditions -> extra packages informaton required for installation as of setuptools 33 doing `package ; python_version<=2.7' in install_requires still doesn't work https://www.python.org/dev/peps/pep-0508/ https://wheel.readthedocs.io/en/latest/index.html#defining-conditional-dependencies https://hynek.me/articles/conditional-python-dependencies/ """ ep = self._pkg_data.get('extras_require') return ep @property def data_files(self): df = self._pkg_data.get('data_files', []) if self.has_mit_lic(): df.append('LICENSE') if not df: return None return [('.', df)] @property def package_data(self): df = self._pkg_data.get('data_files', []) if self.has_mit_lic(): # include the file df.append('LICENSE') # but don't install it exclude_files.append('LICENSE') pd = self._pkg_data.get('package_data', {}) if df: pd[self.full_package_name] = df if sys.version_info < (3,): # python2 doesn't seem to like unicode package names as keys # maybe only when the packages themselves are non-unicode for k in pd: if isinstance(k, unicode): pd[str(k)] = pd.pop(k) # for k in pd: # pd[k] = [e.encode('utf-8') for e in pd[k]] # de-unicode return pd @property def packages(self): s = self.split # fixed this in package_data, the keys there must be non-unicode for py27 # if sys.version_info < (3, 0): # s = [x.encode('utf-8') for x in self.split] return s + self._pkg_data.get('extra_packages', []) @property def python_requires(self): return self._pkg_data.get('python_requires', None) @property def ext_modules(self): """ Check if all modules specified in the value for 'ext_modules' can be build. That value (if not None) is a list of dicts with 'name', 'src', 'lib' Optional 'test' can be used to make sure trying to compile will work on the host creates and return the external modules as Extensions, unless that is not necessary at all for the action (like --version) test existence of compiler by using export CC=nonexistent; export CXX=nonexistent """ if hasattr(self, '_ext_modules'): return self._ext_modules if '--version' in sys.argv: return None if platform.python_implementation() == 'Jython': return None try: plat = sys.argv.index('--plat-name') if 'win' in sys.argv[plat + 1]: return None except ValueError: pass self._ext_modules = [] no_test_compile = False if '--restructuredtext' in sys.argv: no_test_compile = True elif 'sdist' in sys.argv: no_test_compile = True if no_test_compile: for target in self._pkg_data.get('ext_modules', []): ext = Extension( self.pn(target['name']), sources=[self.pn(x) for x in target['src']], libraries=[self.pn(x) for x in target.get('lib')], ) self._ext_modules.append(ext) return self._ext_modules print('sys.argv', sys.argv) import tempfile import shutil from textwrap import dedent import distutils.sysconfig import distutils.ccompiler from distutils.errors import CompileError, LinkError for target in self._pkg_data.get('ext_modules', []): # list of dicts ext = Extension( self.pn(target['name']), sources=[self.pn(x) for x in target['src']], libraries=[self.pn(x) for x in target.get('lib')], ) # debug('test1 in target', 'test' in target, target) if 'test' not in target: # no test, just hope it works self._ext_modules.append(ext) continue if sys.version_info[:2] == (3, 4) and platform.system() == 'Windows': # this is giving problems on appveyor, so skip if 'FORCE_C_BUILD_TEST' not in os.environ: self._ext_modules.append(ext) continue # write a temporary .c file to compile c_code = dedent(target['test']) try: tmp_dir = tempfile.mkdtemp(prefix='tmp_ruamel_') bin_file_name = 'test' + self.pn(target['name']) print('test compiling', bin_file_name) file_name = os.path.join(tmp_dir, bin_file_name + '.c') with open(file_name, 'w') as fp: # write source fp.write(c_code) # and try to compile it compiler = distutils.ccompiler.new_compiler() assert isinstance(compiler, distutils.ccompiler.CCompiler) # do any platform specific initialisations distutils.sysconfig.customize_compiler(compiler) # make sure you can reach header files because compile does change dir compiler.add_include_dir(os.getcwd()) if sys.version_info < (3,): tmp_dir = tmp_dir.encode('utf-8') # used to be a different directory, not necessary compile_out_dir = tmp_dir try: compiler.link_executable( compiler.compile([file_name], output_dir=compile_out_dir), bin_file_name, output_dir=tmp_dir, libraries=ext.libraries, ) except CompileError: debug('compile error:', file_name) print('compile error:', file_name) continue except LinkError: debug('link error', file_name) print('link error', file_name) continue self._ext_modules.append(ext) except Exception as e: # NOQA debug('Exception:', e) print('Exception:', e) if sys.version_info[:2] == (3, 4) and platform.system() == 'Windows': traceback.print_exc() finally: shutil.rmtree(tmp_dir) return self._ext_modules @property def test_suite(self): return self._pkg_data.get('test_suite') def wheel(self, kw, setup): """temporary add setup.cfg if creating a wheel to include LICENSE file https://bitbucket.org/pypa/wheel/issues/47 """ if 'bdist_wheel' not in sys.argv: return False file_name = 'setup.cfg' if os.path.exists(file_name): # add it if not in there? return False with open(file_name, 'w') as fp: if os.path.exists('LICENSE'): fp.write('[metadata]\nlicense-file = LICENSE\n') else: print('\n\n>>>>>> LICENSE file not found <<<<<\n\n') if self._pkg_data.get('universal'): fp.write('[bdist_wheel]\nuniversal = 1\n') try: setup(**kw) except Exception: raise finally: os.remove(file_name) return True # # call setup def main(): dump_kw = '--dump-kw' if dump_kw in sys.argv: import wheel import distutils import setuptools print('python: ', sys.version) print('setuptools:', setuptools.__version__) print('distutils: ', distutils.__version__) print('wheel: ', wheel.__version__) nsp = NameSpacePackager(pkg_data) nsp.check() nsp.create_dirs() MySdist.nsp = nsp if pkg_data.get('tarfmt'): MySdist.tarfmt = pkg_data.get('tarfmt') cmdclass = dict(install_lib=MyInstallLib, sdist=MySdist) if _bdist_wheel_available: MyBdistWheel.nsp = nsp cmdclass['bdist_wheel'] = MyBdistWheel kw = dict( name=nsp.full_package_name, namespace_packages=nsp.namespace_packages, version=version_str, packages=nsp.packages, python_requires=nsp.python_requires, url=nsp.url, author=nsp.author, author_email=nsp.author_email, cmdclass=cmdclass, package_dir=nsp.package_dir, entry_points=nsp.entry_points(), description=nsp.description, install_requires=nsp.install_requires, extras_require=nsp.extras_require, # available since setuptools 18.0 / 2015-06 license=nsp.license, classifiers=nsp.classifiers, keywords=nsp.keywords, package_data=nsp.package_data, ext_modules=nsp.ext_modules, test_suite=nsp.test_suite, ) if '--version' not in sys.argv and ('--verbose' in sys.argv or dump_kw in sys.argv): for k in sorted(kw): v = kw[k] print(' "{0}": "{1}",'.format(k, v)) # if '--record' in sys.argv: # return if dump_kw in sys.argv: sys.argv.remove(dump_kw) try: with open('README.rst') as fp: kw['long_description'] = fp.read() except Exception: pass if nsp.wheel(kw, setup): if nsp.nested and 'bdist_wheel' in sys.argv: try: d = sys.argv[sys.argv.index('-d') + 1] except ValueError: dist_base = os.environ.get('PYDISTBASE') if dist_base: d = os.path.join(dist_base, nsp.full_package_name) else: d = 'dist' for x in os.listdir(d): dashed_vs = '-' + version_str + '-' if x.endswith('.whl') and dashed_vs in x: # remove .pth file from the wheel full_name = os.path.join(d, x) print('patching .pth from', full_name) with InMemoryZipFile(full_name) as imz: imz.delete_from_zip_file(nsp.full_package_name + '.*.pth') break return for x in ['-c', 'egg_info', '--egg-base', 'pip-egg-info']: if x not in sys.argv: break else: # we're doing a tox setup install any starred package by searching up the source tree # until you match your/package/name for your.package.name for p in nsp.install_pre: import subprocess # search other source setup_path = os.path.join(*p.split('.') + ['setup.py']) try_dir = os.path.dirname(sys.executable) while len(try_dir) > 1: full_path_setup_py = os.path.join(try_dir, setup_path) if os.path.exists(full_path_setup_py): pip = sys.executable.replace('python', 'pip') cmd = [pip, 'install', os.path.dirname(full_path_setup_py)] # with open('/var/tmp/notice', 'a') as fp: # print('installing', cmd, file=fp) subprocess.check_output(cmd) break try_dir = os.path.dirname(try_dir) setup(**kw) if nsp.nested and sys.argv[:2] == ['-c', 'bdist_wheel']: d = sys.argv[sys.argv.index('-d') + 1] for x in os.listdir(d): if x.endswith('.whl'): # remove .pth file from the wheel full_name = os.path.join(d, x) print('patching .pth from', full_name) with InMemoryZipFile(full_name) as imz: imz.delete_from_zip_file(nsp.full_package_name + '.*.pth') break main() ruamel.yaml-0.15.89/representer.py0000644000175100001440000013702313435576433017526 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division from ruamel.yaml.error import * # NOQA from ruamel.yaml.nodes import * # NOQA from ruamel.yaml.compat import text_type, binary_type, to_unicode, PY2, PY3, ordereddict from ruamel.yaml.compat import nprint, nprintf # NOQA from ruamel.yaml.scalarstring import ( LiteralScalarString, FoldedScalarString, SingleQuotedScalarString, DoubleQuotedScalarString, PlainScalarString, ) from ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt from ruamel.yaml.scalarfloat import ScalarFloat from ruamel.yaml.scalarbool import ScalarBoolean from ruamel.yaml.timestamp import TimeStamp import datetime import sys import types if PY3: import copyreg import base64 else: import copy_reg as copyreg # type: ignore if False: # MYPY from typing import Dict, List, Any, Union, Text, Optional # NOQA # fmt: off __all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', 'RepresenterError', 'RoundTripRepresenter'] # fmt: on class RepresenterError(YAMLError): pass if PY2: def get_classobj_bases(cls): # type: (Any) -> Any bases = [cls] for base in cls.__bases__: bases.extend(get_classobj_bases(base)) return bases class BaseRepresenter(object): yaml_representers = {} # type: Dict[Any, Any] yaml_multi_representers = {} # type: Dict[Any, Any] def __init__(self, default_style=None, default_flow_style=None, dumper=None): # type: (Any, Any, Any, Any) -> None self.dumper = dumper if self.dumper is not None: self.dumper._representer = self self.default_style = default_style self.default_flow_style = default_flow_style self.represented_objects = {} # type: Dict[Any, Any] self.object_keeper = [] # type: List[Any] self.alias_key = None # type: Optional[int] self.sort_base_mapping_type_on_output = True @property def serializer(self): # type: () -> Any try: if hasattr(self.dumper, 'typ'): return self.dumper.serializer return self.dumper._serializer except AttributeError: return self # cyaml def represent(self, data): # type: (Any) -> None node = self.represent_data(data) self.serializer.serialize(node) self.represented_objects = {} # type: Dict[Any, Any] self.object_keeper = [] # type: List[Any] self.alias_key = None def represent_data(self, data): # type: (Any) -> Any if self.ignore_aliases(data): self.alias_key = None else: self.alias_key = id(data) if self.alias_key is not None: if self.alias_key in self.represented_objects: node = self.represented_objects[self.alias_key] # if node is None: # raise RepresenterError( # "recursive objects are not allowed: %r" % data) return node # self.represented_objects[alias_key] = None self.object_keeper.append(data) data_types = type(data).__mro__ if PY2: # if type(data) is types.InstanceType: if isinstance(data, types.InstanceType): data_types = get_classobj_bases(data.__class__) + list(data_types) if data_types[0] in self.yaml_representers: node = self.yaml_representers[data_types[0]](self, data) else: for data_type in data_types: if data_type in self.yaml_multi_representers: node = self.yaml_multi_representers[data_type](self, data) break else: if None in self.yaml_multi_representers: node = self.yaml_multi_representers[None](self, data) elif None in self.yaml_representers: node = self.yaml_representers[None](self, data) else: node = ScalarNode(None, text_type(data)) # if alias_key is not None: # self.represented_objects[alias_key] = node return node def represent_key(self, data): # type: (Any) -> Any """ David Fraser: Extract a method to represent keys in mappings, so that a subclass can choose not to quote them (for example) used in represent_mapping https://bitbucket.org/davidfraser/pyyaml/commits/d81df6eb95f20cac4a79eed95ae553b5c6f77b8c """ return self.represent_data(data) @classmethod def add_representer(cls, data_type, representer): # type: (Any, Any) -> None if 'yaml_representers' not in cls.__dict__: cls.yaml_representers = cls.yaml_representers.copy() cls.yaml_representers[data_type] = representer @classmethod def add_multi_representer(cls, data_type, representer): # type: (Any, Any) -> None if 'yaml_multi_representers' not in cls.__dict__: cls.yaml_multi_representers = cls.yaml_multi_representers.copy() cls.yaml_multi_representers[data_type] = representer def represent_scalar(self, tag, value, style=None, anchor=None): # type: (Any, Any, Any, Any) -> Any if style is None: style = self.default_style comment = None if style and style[0] in '|>': comment = getattr(value, 'comment', None) if comment: comment = [None, [comment]] node = ScalarNode(tag, value, style=style, comment=comment, anchor=anchor) if self.alias_key is not None: self.represented_objects[self.alias_key] = node return node def represent_sequence(self, tag, sequence, flow_style=None): # type: (Any, Any, Any) -> Any value = [] # type: List[Any] node = SequenceNode(tag, value, flow_style=flow_style) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True for item in sequence: node_item = self.represent_data(item) if not (isinstance(node_item, ScalarNode) and not node_item.style): best_style = False value.append(node_item) if flow_style is None: if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node def represent_omap(self, tag, omap, flow_style=None): # type: (Any, Any, Any) -> Any value = [] # type: List[Any] node = SequenceNode(tag, value, flow_style=flow_style) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True for item_key in omap: item_val = omap[item_key] node_item = self.represent_data({item_key: item_val}) # if not (isinstance(node_item, ScalarNode) \ # and not node_item.style): # best_style = False value.append(node_item) if flow_style is None: if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node def represent_mapping(self, tag, mapping, flow_style=None): # type: (Any, Any, Any) -> Any value = [] # type: List[Any] node = MappingNode(tag, value, flow_style=flow_style) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True if hasattr(mapping, 'items'): mapping = list(mapping.items()) if self.sort_base_mapping_type_on_output: try: mapping = sorted(mapping) except TypeError: pass for item_key, item_value in mapping: node_key = self.represent_key(item_key) node_value = self.represent_data(item_value) if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) if flow_style is None: if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node def ignore_aliases(self, data): # type: (Any) -> bool return False class SafeRepresenter(BaseRepresenter): def ignore_aliases(self, data): # type: (Any) -> bool # https://docs.python.org/3/reference/expressions.html#parenthesized-forms : # "i.e. two occurrences of the empty tuple may or may not yield the same object" # so "data is ()" should not be used if data is None or (isinstance(data, tuple) and data == ()): return True if isinstance(data, (binary_type, text_type, bool, int, float)): return True return False def represent_none(self, data): # type: (Any) -> Any return self.represent_scalar(u'tag:yaml.org,2002:null', u'null') if PY3: def represent_str(self, data): # type: (Any) -> Any return self.represent_scalar(u'tag:yaml.org,2002:str', data) def represent_binary(self, data): # type: (Any) -> Any if hasattr(base64, 'encodebytes'): data = base64.encodebytes(data).decode('ascii') else: data = base64.encodestring(data).decode('ascii') return self.represent_scalar(u'tag:yaml.org,2002:binary', data, style='|') else: def represent_str(self, data): # type: (Any) -> Any tag = None style = None try: data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' except UnicodeDecodeError: try: data = unicode(data, 'utf-8') tag = u'tag:yaml.org,2002:str' except UnicodeDecodeError: data = data.encode('base64') tag = u'tag:yaml.org,2002:binary' style = '|' return self.represent_scalar(tag, data, style=style) def represent_unicode(self, data): # type: (Any) -> Any return self.represent_scalar(u'tag:yaml.org,2002:str', data) def represent_bool(self, data, anchor=None): # type: (Any, Optional[Any]) -> Any try: value = self.dumper.boolean_representation[bool(data)] except AttributeError: if data: value = u'true' else: value = u'false' return self.represent_scalar(u'tag:yaml.org,2002:bool', value, anchor=anchor) def represent_int(self, data): # type: (Any) -> Any return self.represent_scalar(u'tag:yaml.org,2002:int', text_type(data)) if PY2: def represent_long(self, data): # type: (Any) -> Any return self.represent_scalar(u'tag:yaml.org,2002:int', text_type(data)) inf_value = 1e300 while repr(inf_value) != repr(inf_value * inf_value): inf_value *= inf_value def represent_float(self, data): # type: (Any) -> Any if data != data or (data == 0.0 and data == 1.0): value = u'.nan' elif data == self.inf_value: value = u'.inf' elif data == -self.inf_value: value = u'-.inf' else: value = to_unicode(repr(data)).lower() if getattr(self.serializer, 'use_version', None) == (1, 1): if u'.' not in value and u'e' in value: # Note that in some cases `repr(data)` represents a float number # without the decimal parts. For instance: # >>> repr(1e17) # '1e17' # Unfortunately, this is not a valid float representation according # to the definition of the `!!float` tag in YAML 1.1. We fix # this by adding '.0' before the 'e' symbol. value = value.replace(u'e', u'.0e', 1) return self.represent_scalar(u'tag:yaml.org,2002:float', value) def represent_list(self, data): # type: (Any) -> Any # pairs = (len(data) > 0 and isinstance(data, list)) # if pairs: # for item in data: # if not isinstance(item, tuple) or len(item) != 2: # pairs = False # break # if not pairs: return self.represent_sequence(u'tag:yaml.org,2002:seq', data) # value = [] # for item_key, item_value in data: # value.append(self.represent_mapping(u'tag:yaml.org,2002:map', # [(item_key, item_value)])) # return SequenceNode(u'tag:yaml.org,2002:pairs', value) def represent_dict(self, data): # type: (Any) -> Any return self.represent_mapping(u'tag:yaml.org,2002:map', data) def represent_ordereddict(self, data): # type: (Any) -> Any return self.represent_omap(u'tag:yaml.org,2002:omap', data) def represent_set(self, data): # type: (Any) -> Any value = {} # type: Dict[Any, None] for key in data: value[key] = None return self.represent_mapping(u'tag:yaml.org,2002:set', value) def represent_date(self, data): # type: (Any) -> Any value = to_unicode(data.isoformat()) return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) def represent_datetime(self, data): # type: (Any) -> Any value = to_unicode(data.isoformat(' ')) return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) def represent_yaml_object(self, tag, data, cls, flow_style=None): # type: (Any, Any, Any, Any) -> Any if hasattr(data, '__getstate__'): state = data.__getstate__() else: state = data.__dict__.copy() return self.represent_mapping(tag, state, flow_style=flow_style) def represent_undefined(self, data): # type: (Any) -> None raise RepresenterError('cannot represent an object: %s' % (data,)) SafeRepresenter.add_representer(type(None), SafeRepresenter.represent_none) SafeRepresenter.add_representer(str, SafeRepresenter.represent_str) if PY2: SafeRepresenter.add_representer(unicode, SafeRepresenter.represent_unicode) else: SafeRepresenter.add_representer(bytes, SafeRepresenter.represent_binary) SafeRepresenter.add_representer(bool, SafeRepresenter.represent_bool) SafeRepresenter.add_representer(int, SafeRepresenter.represent_int) if PY2: SafeRepresenter.add_representer(long, SafeRepresenter.represent_long) SafeRepresenter.add_representer(float, SafeRepresenter.represent_float) SafeRepresenter.add_representer(list, SafeRepresenter.represent_list) SafeRepresenter.add_representer(tuple, SafeRepresenter.represent_list) SafeRepresenter.add_representer(dict, SafeRepresenter.represent_dict) SafeRepresenter.add_representer(set, SafeRepresenter.represent_set) SafeRepresenter.add_representer(ordereddict, SafeRepresenter.represent_ordereddict) if sys.version_info >= (2, 7): import collections SafeRepresenter.add_representer( collections.OrderedDict, SafeRepresenter.represent_ordereddict ) SafeRepresenter.add_representer(datetime.date, SafeRepresenter.represent_date) SafeRepresenter.add_representer(datetime.datetime, SafeRepresenter.represent_datetime) SafeRepresenter.add_representer(None, SafeRepresenter.represent_undefined) class Representer(SafeRepresenter): if PY2: def represent_str(self, data): # type: (Any) -> Any tag = None style = None try: data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' except UnicodeDecodeError: try: data = unicode(data, 'utf-8') tag = u'tag:yaml.org,2002:python/str' except UnicodeDecodeError: data = data.encode('base64') tag = u'tag:yaml.org,2002:binary' style = '|' return self.represent_scalar(tag, data, style=style) def represent_unicode(self, data): # type: (Any) -> Any tag = None try: data.encode('ascii') tag = u'tag:yaml.org,2002:python/unicode' except UnicodeEncodeError: tag = u'tag:yaml.org,2002:str' return self.represent_scalar(tag, data) def represent_long(self, data): # type: (Any) -> Any tag = u'tag:yaml.org,2002:int' if int(data) is not data: tag = u'tag:yaml.org,2002:python/long' return self.represent_scalar(tag, to_unicode(data)) def represent_complex(self, data): # type: (Any) -> Any if data.imag == 0.0: data = u'%r' % data.real elif data.real == 0.0: data = u'%rj' % data.imag elif data.imag > 0: data = u'%r+%rj' % (data.real, data.imag) else: data = u'%r%rj' % (data.real, data.imag) return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data) def represent_tuple(self, data): # type: (Any) -> Any return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data) def represent_name(self, data): # type: (Any) -> Any try: name = u'%s.%s' % (data.__module__, data.__qualname__) except AttributeError: # probably PY2 name = u'%s.%s' % (data.__module__, data.__name__) return self.represent_scalar(u'tag:yaml.org,2002:python/name:' + name, "") def represent_module(self, data): # type: (Any) -> Any return self.represent_scalar(u'tag:yaml.org,2002:python/module:' + data.__name__, "") if PY2: def represent_instance(self, data): # type: (Any) -> Any # For instances of classic classes, we use __getinitargs__ and # __getstate__ to serialize the data. # If data.__getinitargs__ exists, the object must be reconstructed # by calling cls(**args), where args is a tuple returned by # __getinitargs__. Otherwise, the cls.__init__ method should never # be called and the class instance is created by instantiating a # trivial class and assigning to the instance's __class__ variable. # If data.__getstate__ exists, it returns the state of the object. # Otherwise, the state of the object is data.__dict__. # We produce either a !!python/object or !!python/object/new node. # If data.__getinitargs__ does not exist and state is a dictionary, # we produce a !!python/object node . Otherwise we produce a # !!python/object/new node. cls = data.__class__ class_name = u'%s.%s' % (cls.__module__, cls.__name__) args = None state = None if hasattr(data, '__getinitargs__'): args = list(data.__getinitargs__()) if hasattr(data, '__getstate__'): state = data.__getstate__() else: state = data.__dict__ if args is None and isinstance(state, dict): return self.represent_mapping( u'tag:yaml.org,2002:python/object:' + class_name, state ) if isinstance(state, dict) and not state: return self.represent_sequence( u'tag:yaml.org,2002:python/object/new:' + class_name, args ) value = {} if bool(args): value['args'] = args value['state'] = state # type: ignore return self.represent_mapping( u'tag:yaml.org,2002:python/object/new:' + class_name, value ) def represent_object(self, data): # type: (Any) -> Any # We use __reduce__ API to save the data. data.__reduce__ returns # a tuple of length 2-5: # (function, args, state, listitems, dictitems) # For reconstructing, we calls function(*args), then set its state, # listitems, and dictitems if they are not None. # A special case is when function.__name__ == '__newobj__'. In this # case we create the object with args[0].__new__(*args). # Another special case is when __reduce__ returns a string - we don't # support it. # We produce a !!python/object, !!python/object/new or # !!python/object/apply node. cls = type(data) if cls in copyreg.dispatch_table: reduce = copyreg.dispatch_table[cls](data) elif hasattr(data, '__reduce_ex__'): reduce = data.__reduce_ex__(2) elif hasattr(data, '__reduce__'): reduce = data.__reduce__() else: raise RepresenterError('cannot represent object: %r' % (data,)) reduce = (list(reduce) + [None] * 5)[:5] function, args, state, listitems, dictitems = reduce args = list(args) if state is None: state = {} if listitems is not None: listitems = list(listitems) if dictitems is not None: dictitems = dict(dictitems) if function.__name__ == '__newobj__': function = args[0] args = args[1:] tag = u'tag:yaml.org,2002:python/object/new:' newobj = True else: tag = u'tag:yaml.org,2002:python/object/apply:' newobj = False try: function_name = u'%s.%s' % (function.__module__, function.__qualname__) except AttributeError: # probably PY2 function_name = u'%s.%s' % (function.__module__, function.__name__) if not args and not listitems and not dictitems and isinstance(state, dict) and newobj: return self.represent_mapping( u'tag:yaml.org,2002:python/object:' + function_name, state ) if not listitems and not dictitems and isinstance(state, dict) and not state: return self.represent_sequence(tag + function_name, args) value = {} if args: value['args'] = args if state or not isinstance(state, dict): value['state'] = state if listitems: value['listitems'] = listitems if dictitems: value['dictitems'] = dictitems return self.represent_mapping(tag + function_name, value) if PY2: Representer.add_representer(str, Representer.represent_str) Representer.add_representer(unicode, Representer.represent_unicode) Representer.add_representer(long, Representer.represent_long) Representer.add_representer(complex, Representer.represent_complex) Representer.add_representer(tuple, Representer.represent_tuple) Representer.add_representer(type, Representer.represent_name) if PY2: Representer.add_representer(types.ClassType, Representer.represent_name) Representer.add_representer(types.FunctionType, Representer.represent_name) Representer.add_representer(types.BuiltinFunctionType, Representer.represent_name) Representer.add_representer(types.ModuleType, Representer.represent_module) if PY2: Representer.add_multi_representer(types.InstanceType, Representer.represent_instance) Representer.add_multi_representer(object, Representer.represent_object) Representer.add_multi_representer(type, Representer.represent_name) from ruamel.yaml.comments import ( CommentedMap, CommentedOrderedMap, CommentedSeq, CommentedKeySeq, CommentedKeyMap, CommentedSet, comment_attrib, merge_attrib, TaggedScalar, ) # NOQA class RoundTripRepresenter(SafeRepresenter): # need to add type here and write out the .comment # in serializer and emitter def __init__(self, default_style=None, default_flow_style=None, dumper=None): # type: (Any, Any, Any) -> None if not hasattr(dumper, 'typ') and default_flow_style is None: default_flow_style = False SafeRepresenter.__init__( self, default_style=default_style, default_flow_style=default_flow_style, dumper=dumper, ) def ignore_aliases(self, data): # type: (Any) -> bool try: if data.anchor is not None and data.anchor.value is not None: return False except AttributeError: pass return SafeRepresenter.ignore_aliases(self, data) def represent_none(self, data): # type: (Any) -> Any if len(self.represented_objects) == 0 and not self.serializer.use_explicit_start: # this will be open ended (although it is not yet) return self.represent_scalar(u'tag:yaml.org,2002:null', u'null') return self.represent_scalar(u'tag:yaml.org,2002:null', "") def represent_literal_scalarstring(self, data): # type: (Any) -> Any tag = None style = '|' anchor = data.yaml_anchor(any=True) if PY2 and not isinstance(data, unicode): data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' return self.represent_scalar(tag, data, style=style, anchor=anchor) represent_preserved_scalarstring = represent_literal_scalarstring def represent_folded_scalarstring(self, data): # type: (Any) -> Any tag = None style = '>' anchor = data.yaml_anchor(any=True) for fold_pos in reversed(getattr(data, 'fold_pos', [])): if ( data[fold_pos] == ' ' and (fold_pos > 0 and not data[fold_pos - 1].isspace()) and (fold_pos < len(data) and not data[fold_pos + 1].isspace()) ): data = data[:fold_pos] + '\a' + data[fold_pos:] if PY2 and not isinstance(data, unicode): data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' return self.represent_scalar(tag, data, style=style, anchor=anchor) def represent_single_quoted_scalarstring(self, data): # type: (Any) -> Any tag = None style = "'" anchor = data.yaml_anchor(any=True) if PY2 and not isinstance(data, unicode): data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' return self.represent_scalar(tag, data, style=style, anchor=anchor) def represent_double_quoted_scalarstring(self, data): # type: (Any) -> Any tag = None style = '"' anchor = data.yaml_anchor(any=True) if PY2 and not isinstance(data, unicode): data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' return self.represent_scalar(tag, data, style=style, anchor=anchor) def represent_plain_scalarstring(self, data): # type: (Any) -> Any tag = None style = '' anchor = data.yaml_anchor(any=True) if PY2 and not isinstance(data, unicode): data = unicode(data, 'ascii') tag = u'tag:yaml.org,2002:str' return self.represent_scalar(tag, data, style=style, anchor=anchor) def insert_underscore(self, prefix, s, underscore, anchor=None): # type: (Any, Any, Any, Any) -> Any if underscore is None: return self.represent_scalar(u'tag:yaml.org,2002:int', prefix + s, anchor=anchor) if underscore[0]: sl = list(s) pos = len(s) - underscore[0] while pos > 0: sl.insert(pos, '_') pos -= underscore[0] s = "".join(sl) if underscore[1]: s = '_' + s if underscore[2]: s += '_' return self.represent_scalar(u'tag:yaml.org,2002:int', prefix + s, anchor=anchor) def represent_scalar_int(self, data): # type: (Any) -> Any if data._width is not None: s = '{:0{}d}'.format(data, data._width) else: s = format(data, 'd') anchor = data.yaml_anchor(any=True) return self.insert_underscore("", s, data._underscore, anchor=anchor) def represent_binary_int(self, data): # type: (Any) -> Any if data._width is not None: # cannot use '{:#0{}b}', that strips the zeros s = '{:0{}b}'.format(data, data._width) else: s = format(data, 'b') anchor = data.yaml_anchor(any=True) return self.insert_underscore('0b', s, data._underscore, anchor=anchor) def represent_octal_int(self, data): # type: (Any) -> Any if data._width is not None: # cannot use '{:#0{}o}', that strips the zeros s = '{:0{}o}'.format(data, data._width) else: s = format(data, 'o') anchor = data.yaml_anchor(any=True) return self.insert_underscore('0o', s, data._underscore, anchor=anchor) def represent_hex_int(self, data): # type: (Any) -> Any if data._width is not None: # cannot use '{:#0{}x}', that strips the zeros s = '{:0{}x}'.format(data, data._width) else: s = format(data, 'x') anchor = data.yaml_anchor(any=True) return self.insert_underscore('0x', s, data._underscore, anchor=anchor) def represent_hex_caps_int(self, data): # type: (Any) -> Any if data._width is not None: # cannot use '{:#0{}X}', that strips the zeros s = '{:0{}X}'.format(data, data._width) else: s = format(data, 'X') anchor = data.yaml_anchor(any=True) return self.insert_underscore('0x', s, data._underscore, anchor=anchor) def represent_scalar_float(self, data): # type: (Any) -> Any """ this is way more complicated """ value = None anchor = data.yaml_anchor(any=True) if data != data or (data == 0.0 and data == 1.0): value = u'.nan' elif data == self.inf_value: value = u'.inf' elif data == -self.inf_value: value = u'-.inf' if value: return self.represent_scalar(u'tag:yaml.org,2002:float', value, anchor=anchor) if data._exp is None and data._prec > 0 and data._prec == data._width - 1: # no exponent, but trailing dot value = u'{}{:d}.'.format(data._m_sign if data._m_sign else "", abs(int(data))) elif data._exp is None: # no exponent, "normal" dot prec = data._prec ms = data._m_sign if data._m_sign else "" # -1 for the dot value = u'{}{:0{}.{}f}'.format( ms, abs(data), data._width - len(ms), data._width - prec - 1 ) if prec == 0 or (prec == 1 and ms != ""): value = value.replace(u'0.', u'.') while len(value) < data._width: value += u'0' else: # exponent m, es = u'{:{}.{}e}'.format( # data, data._width, data._width - data._prec + (1 if data._m_sign else 0) data, data._width, data._width + (1 if data._m_sign else 0), ).split('e') w = data._width if data._prec > 0 else (data._width + 1) if data < 0: w += 1 m = m[:w] e = int(es) m1, m2 = m.split('.') # always second? while len(m1) + len(m2) < data._width - (1 if data._prec >= 0 else 0): m2 += u'0' if data._m_sign and data > 0: m1 = '+' + m1 esgn = u'+' if data._e_sign else "" if data._prec < 0: # mantissa without dot if m2 != u'0': e -= len(m2) else: m2 = "" while (len(m1) + len(m2) - (1 if data._m_sign else 0)) < data._width: m2 += u'0' e -= 1 value = m1 + m2 + data._exp + u'{:{}0{}d}'.format(e, esgn, data._e_width) elif data._prec == 0: # mantissa with trailing dot e -= len(m2) value = ( m1 + m2 + u'.' + data._exp + u'{:{}0{}d}'.format(e, esgn, data._e_width) ) else: if data._m_lead0 > 0: m2 = u'0' * (data._m_lead0 - 1) + m1 + m2 m1 = u'0' m2 = m2[: -data._m_lead0] # these should be zeros e += data._m_lead0 while len(m1) < data._prec: m1 += m2[0] m2 = m2[1:] e -= 1 value = ( m1 + u'.' + m2 + data._exp + u'{:{}0{}d}'.format(e, esgn, data._e_width) ) if value is None: value = to_unicode(repr(data)).lower() return self.represent_scalar(u'tag:yaml.org,2002:float', value, anchor=anchor) def represent_sequence(self, tag, sequence, flow_style=None): # type: (Any, Any, Any) -> Any value = [] # type: List[Any] # if the flow_style is None, the flow style tacked on to the object # explicitly will be taken. If that is None as well the default flow # style rules try: flow_style = sequence.fa.flow_style(flow_style) except AttributeError: flow_style = flow_style try: anchor = sequence.yaml_anchor() except AttributeError: anchor = None node = SequenceNode(tag, value, flow_style=flow_style, anchor=anchor) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True try: comment = getattr(sequence, comment_attrib) node.comment = comment.comment # reset any comment already printed information if node.comment and node.comment[1]: for ct in node.comment[1]: ct.reset() item_comments = comment.items for v in item_comments.values(): if v and v[1]: for ct in v[1]: ct.reset() item_comments = comment.items node.comment = comment.comment try: node.comment.append(comment.end) except AttributeError: pass except AttributeError: item_comments = {} for idx, item in enumerate(sequence): node_item = self.represent_data(item) self.merge_comments(node_item, item_comments.get(idx)) if not (isinstance(node_item, ScalarNode) and not node_item.style): best_style = False value.append(node_item) if flow_style is None: if len(sequence) != 0 and self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node def merge_comments(self, node, comments): # type: (Any, Any) -> Any if comments is None: assert hasattr(node, 'comment') return node if getattr(node, 'comment', None) is not None: for idx, val in enumerate(comments): if idx >= len(node.comment): continue nc = node.comment[idx] if nc is not None: assert val is None or val == nc comments[idx] = nc node.comment = comments return node def represent_key(self, data): # type: (Any) -> Any if isinstance(data, CommentedKeySeq): self.alias_key = None return self.represent_sequence(u'tag:yaml.org,2002:seq', data, flow_style=True) if isinstance(data, CommentedKeyMap): self.alias_key = None return self.represent_mapping(u'tag:yaml.org,2002:map', data, flow_style=True) return SafeRepresenter.represent_key(self, data) def represent_mapping(self, tag, mapping, flow_style=None): # type: (Any, Any, Any) -> Any value = [] # type: List[Any] try: flow_style = mapping.fa.flow_style(flow_style) except AttributeError: flow_style = flow_style try: anchor = mapping.yaml_anchor() except AttributeError: anchor = None node = MappingNode(tag, value, flow_style=flow_style, anchor=anchor) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True # no sorting! !! try: comment = getattr(mapping, comment_attrib) node.comment = comment.comment if node.comment and node.comment[1]: for ct in node.comment[1]: ct.reset() item_comments = comment.items for v in item_comments.values(): if v and v[1]: for ct in v[1]: ct.reset() try: node.comment.append(comment.end) except AttributeError: pass except AttributeError: item_comments = {} merge_list = [m[1] for m in getattr(mapping, merge_attrib, [])] try: merge_pos = getattr(mapping, merge_attrib, [[0]])[0][0] except IndexError: merge_pos = 0 item_count = 0 if bool(merge_list): items = mapping.non_merged_items() else: items = mapping.items() for item_key, item_value in items: item_count += 1 node_key = self.represent_key(item_key) node_value = self.represent_data(item_value) item_comment = item_comments.get(item_key) if item_comment: assert getattr(node_key, 'comment', None) is None node_key.comment = item_comment[:2] nvc = getattr(node_value, 'comment', None) if nvc is not None: # end comment already there nvc[0] = item_comment[2] nvc[1] = item_comment[3] else: node_value.comment = item_comment[2:] if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) if flow_style is None: if ((item_count != 0) or bool(merge_list)) and self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style if bool(merge_list): # because of the call to represent_data here, the anchors # are marked as being used and thereby created if len(merge_list) == 1: arg = self.represent_data(merge_list[0]) else: arg = self.represent_data(merge_list) arg.flow_style = True value.insert(merge_pos, (ScalarNode(u'tag:yaml.org,2002:merge', '<<'), arg)) return node def represent_omap(self, tag, omap, flow_style=None): # type: (Any, Any, Any) -> Any value = [] # type: List[Any] try: flow_style = omap.fa.flow_style(flow_style) except AttributeError: flow_style = flow_style try: anchor = omap.yaml_anchor() except AttributeError: anchor = None node = SequenceNode(tag, value, flow_style=flow_style, anchor=anchor) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True try: comment = getattr(omap, comment_attrib) node.comment = comment.comment if node.comment and node.comment[1]: for ct in node.comment[1]: ct.reset() item_comments = comment.items for v in item_comments.values(): if v and v[1]: for ct in v[1]: ct.reset() try: node.comment.append(comment.end) except AttributeError: pass except AttributeError: item_comments = {} for item_key in omap: item_val = omap[item_key] node_item = self.represent_data({item_key: item_val}) # node_item.flow_style = False # node item has two scalars in value: node_key and node_value item_comment = item_comments.get(item_key) if item_comment: if item_comment[1]: node_item.comment = [None, item_comment[1]] assert getattr(node_item.value[0][0], 'comment', None) is None node_item.value[0][0].comment = [item_comment[0], None] nvc = getattr(node_item.value[0][1], 'comment', None) if nvc is not None: # end comment already there nvc[0] = item_comment[2] nvc[1] = item_comment[3] else: node_item.value[0][1].comment = item_comment[2:] # if not (isinstance(node_item, ScalarNode) \ # and not node_item.style): # best_style = False value.append(node_item) if flow_style is None: if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node def represent_set(self, setting): # type: (Any) -> Any flow_style = False tag = u'tag:yaml.org,2002:set' # return self.represent_mapping(tag, value) value = [] # type: List[Any] flow_style = setting.fa.flow_style(flow_style) try: anchor = setting.yaml_anchor() except AttributeError: anchor = None node = MappingNode(tag, value, flow_style=flow_style, anchor=anchor) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True # no sorting! !! try: comment = getattr(setting, comment_attrib) node.comment = comment.comment if node.comment and node.comment[1]: for ct in node.comment[1]: ct.reset() item_comments = comment.items for v in item_comments.values(): if v and v[1]: for ct in v[1]: ct.reset() try: node.comment.append(comment.end) except AttributeError: pass except AttributeError: item_comments = {} for item_key in setting.odict: node_key = self.represent_key(item_key) node_value = self.represent_data(None) item_comment = item_comments.get(item_key) if item_comment: assert getattr(node_key, 'comment', None) is None node_key.comment = item_comment[:2] node_key.style = node_value.style = '?' if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) best_style = best_style return node def represent_dict(self, data): # type: (Any) -> Any """write out tag if saved on loading""" try: t = data.tag.value except AttributeError: t = None if t: if t.startswith('!!'): tag = 'tag:yaml.org,2002:' + t[2:] else: tag = t else: tag = u'tag:yaml.org,2002:map' return self.represent_mapping(tag, data) def represent_list(self, data): # type: (Any) -> Any try: t = data.tag.value except AttributeError: t = None if t: if t.startswith('!!'): tag = 'tag:yaml.org,2002:' + t[2:] else: tag = t else: tag = u'tag:yaml.org,2002:seq' return self.represent_sequence(tag, data) def represent_datetime(self, data): # type: (Any) -> Any inter = 'T' if data._yaml['t'] else ' ' _yaml = data._yaml if _yaml['delta']: data += _yaml['delta'] value = data.isoformat(inter) else: value = data.isoformat(inter) if _yaml['tz']: value += _yaml['tz'] return self.represent_scalar(u'tag:yaml.org,2002:timestamp', to_unicode(value)) def represent_tagged_scalar(self, data): # type: (Any) -> Any try: tag = data.tag.value except AttributeError: tag = None try: anchor = data.yaml_anchor() except AttributeError: anchor = None return self.represent_scalar(tag, data.value, style=data.style, anchor=anchor) def represent_scalar_bool(self, data): # type: (Any) -> Any try: anchor = data.yaml_anchor() except AttributeError: anchor = None return SafeRepresenter.represent_bool(self, data, anchor=anchor) RoundTripRepresenter.add_representer(type(None), RoundTripRepresenter.represent_none) RoundTripRepresenter.add_representer( LiteralScalarString, RoundTripRepresenter.represent_literal_scalarstring ) RoundTripRepresenter.add_representer( FoldedScalarString, RoundTripRepresenter.represent_folded_scalarstring ) RoundTripRepresenter.add_representer( SingleQuotedScalarString, RoundTripRepresenter.represent_single_quoted_scalarstring ) RoundTripRepresenter.add_representer( DoubleQuotedScalarString, RoundTripRepresenter.represent_double_quoted_scalarstring ) RoundTripRepresenter.add_representer( PlainScalarString, RoundTripRepresenter.represent_plain_scalarstring ) RoundTripRepresenter.add_representer(ScalarInt, RoundTripRepresenter.represent_scalar_int) RoundTripRepresenter.add_representer(BinaryInt, RoundTripRepresenter.represent_binary_int) RoundTripRepresenter.add_representer(OctalInt, RoundTripRepresenter.represent_octal_int) RoundTripRepresenter.add_representer(HexInt, RoundTripRepresenter.represent_hex_int) RoundTripRepresenter.add_representer(HexCapsInt, RoundTripRepresenter.represent_hex_caps_int) RoundTripRepresenter.add_representer(ScalarFloat, RoundTripRepresenter.represent_scalar_float) RoundTripRepresenter.add_representer(ScalarBoolean, RoundTripRepresenter.represent_scalar_bool) RoundTripRepresenter.add_representer(CommentedSeq, RoundTripRepresenter.represent_list) RoundTripRepresenter.add_representer(CommentedMap, RoundTripRepresenter.represent_dict) RoundTripRepresenter.add_representer( CommentedOrderedMap, RoundTripRepresenter.represent_ordereddict ) if sys.version_info >= (2, 7): import collections RoundTripRepresenter.add_representer( collections.OrderedDict, RoundTripRepresenter.represent_ordereddict ) RoundTripRepresenter.add_representer(CommentedSet, RoundTripRepresenter.represent_set) RoundTripRepresenter.add_representer( TaggedScalar, RoundTripRepresenter.represent_tagged_scalar ) RoundTripRepresenter.add_representer(TimeStamp, RoundTripRepresenter.represent_datetime) ruamel.yaml-0.15.89/__init__.py0000664000175100001440000000543413435603534016722 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals if False: # MYPY from typing import Dict, Any # NOQA _package_data = dict( full_package_name='ruamel.yaml', version_info=(0, 15, 89), __version__='0.15.89', author='Anthon van der Neut', author_email='a.van.der.neut@ruamel.eu', description='ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order', # NOQA entry_points=None, since=2014, extras_require={ ':platform_python_implementation=="CPython" and python_version<="2.7"': [ 'ruamel.ordereddict' ], 'jinja2': ['ruamel.yaml.jinja2>=0.2'], 'docs': ['ryd'], }, ext_modules=[ dict( name='_ruamel_yaml', src=[ 'ext/_ruamel_yaml.c', 'ext/api.c', 'ext/writer.c', 'ext/dumper.c', 'ext/loader.c', 'ext/reader.c', 'ext/scanner.c', 'ext/parser.c', 'ext/emitter.c', ], lib=[], test=""" int main(int argc, char* argv[]) { /* prevent warning */ return 0; } """, ) ], # NOQA # test='#include "ext/yaml.h"\n\nint main(int argc, char* argv[])\n{\nyaml_parser_t parser;\nparser = parser; /* prevent warning */\nreturn 0;\n}\n', # NOQA classifiers=[ 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', 'Programming Language :: Python :: Implementation :: Jython', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Text Processing :: Markup', ], keywords='yaml 1.2 parser round-trip preserve quotes order config', wheels=dict(windows='appveyor', linux='libyaml-devel', macos='builder@macos'), read_the_docs='yaml', supported=[(2, 7), (3, 4)], # minimum tox=dict( env='*pn', # also test narrow Python 2.7.15 for unicode patterns deps='ruamel.std.pathlib', fl8excl='_test/lib', ), rtfd='yaml', ) # type: Dict[Any, Any] version_info = _package_data['version_info'] __version__ = _package_data['__version__'] try: from .cyaml import * # NOQA __with_libyaml__ = True except (ImportError, ValueError): # for Jython __with_libyaml__ = False from ruamel.yaml.main import * # NOQA ruamel.yaml-0.15.89/LICENSE0000664000175100001440000000214113435603751015607 0ustar anthonusers00000000000000 The MIT License (MIT) Copyright (c) 2014-2019 Anthon van der Neut, Ruamel bvba Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ruamel.yaml-0.15.89/parser.py0000644000175100001440000007711013415141073016446 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import # The following YAML grammar is LL(1) and is parsed by a recursive descent # parser. # # stream ::= STREAM-START implicit_document? explicit_document* # STREAM-END # implicit_document ::= block_node DOCUMENT-END* # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* # block_node_or_indentless_sequence ::= # ALIAS # | properties (block_content | # indentless_block_sequence)? # | block_content # | indentless_block_sequence # block_node ::= ALIAS # | properties block_content? # | block_content # flow_node ::= ALIAS # | properties flow_content? # | flow_content # properties ::= TAG ANCHOR? | ANCHOR TAG? # block_content ::= block_collection | flow_collection | SCALAR # flow_content ::= flow_collection | SCALAR # block_collection ::= block_sequence | block_mapping # flow_collection ::= flow_sequence | flow_mapping # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* # BLOCK-END # indentless_sequence ::= (BLOCK-ENTRY block_node?)+ # block_mapping ::= BLOCK-MAPPING_START # ((KEY block_node_or_indentless_sequence?)? # (VALUE block_node_or_indentless_sequence?)?)* # BLOCK-END # flow_sequence ::= FLOW-SEQUENCE-START # (flow_sequence_entry FLOW-ENTRY)* # flow_sequence_entry? # FLOW-SEQUENCE-END # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? # flow_mapping ::= FLOW-MAPPING-START # (flow_mapping_entry FLOW-ENTRY)* # flow_mapping_entry? # FLOW-MAPPING-END # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? # # FIRST sets: # # stream: { STREAM-START } # explicit_document: { DIRECTIVE DOCUMENT-START } # implicit_document: FIRST(block_node) # block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START # BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START } # flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START } # block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START # FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } # flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } # block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START } # flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } # block_sequence: { BLOCK-SEQUENCE-START } # block_mapping: { BLOCK-MAPPING-START } # block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR # BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START # FLOW-MAPPING-START BLOCK-ENTRY } # indentless_sequence: { ENTRY } # flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } # flow_sequence: { FLOW-SEQUENCE-START } # flow_mapping: { FLOW-MAPPING-START } # flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START # FLOW-MAPPING-START KEY } # flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START # FLOW-MAPPING-START KEY } # need to have full path, as pkg_resources tries to load parser.py in __init__.py # only to not do anything with the package afterwards # and for Jython too from ruamel.yaml.error import MarkedYAMLError from ruamel.yaml.tokens import * # NOQA from ruamel.yaml.events import * # NOQA from ruamel.yaml.scanner import Scanner, RoundTripScanner, ScannerError # NOQA from ruamel.yaml.compat import utf8, nprint, nprintf # NOQA if False: # MYPY from typing import Any, Dict, Optional, List # NOQA __all__ = ['Parser', 'RoundTripParser', 'ParserError'] class ParserError(MarkedYAMLError): pass class Parser(object): # Since writing a recursive-descendant parser is a straightforward task, we # do not give many comments here. DEFAULT_TAGS = {u'!': u'!', u'!!': u'tag:yaml.org,2002:'} def __init__(self, loader): # type: (Any) -> None self.loader = loader if self.loader is not None and getattr(self.loader, '_parser', None) is None: self.loader._parser = self self.reset_parser() def reset_parser(self): # type: () -> None # Reset the state attributes (to clear self-references) self.current_event = None self.yaml_version = None self.tag_handles = {} # type: Dict[Any, Any] self.states = [] # type: List[Any] self.marks = [] # type: List[Any] self.state = self.parse_stream_start # type: Any def dispose(self): # type: () -> None self.reset_parser() @property def scanner(self): # type: () -> Any if hasattr(self.loader, 'typ'): return self.loader.scanner return self.loader._scanner @property def resolver(self): # type: () -> Any if hasattr(self.loader, 'typ'): return self.loader.resolver return self.loader._resolver def check_event(self, *choices): # type: (Any) -> bool # Check the type of the next event. if self.current_event is None: if self.state: self.current_event = self.state() if self.current_event is not None: if not choices: return True for choice in choices: if isinstance(self.current_event, choice): return True return False def peek_event(self): # type: () -> Any # Get the next event. if self.current_event is None: if self.state: self.current_event = self.state() return self.current_event def get_event(self): # type: () -> Any # Get the next event and proceed further. if self.current_event is None: if self.state: self.current_event = self.state() value = self.current_event self.current_event = None return value # stream ::= STREAM-START implicit_document? explicit_document* # STREAM-END # implicit_document ::= block_node DOCUMENT-END* # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* def parse_stream_start(self): # type: () -> Any # Parse the stream start. token = self.scanner.get_token() token.move_comment(self.scanner.peek_token()) event = StreamStartEvent(token.start_mark, token.end_mark, encoding=token.encoding) # Prepare the next state. self.state = self.parse_implicit_document_start return event def parse_implicit_document_start(self): # type: () -> Any # Parse an implicit document. if not self.scanner.check_token(DirectiveToken, DocumentStartToken, StreamEndToken): self.tag_handles = self.DEFAULT_TAGS token = self.scanner.peek_token() start_mark = end_mark = token.start_mark event = DocumentStartEvent(start_mark, end_mark, explicit=False) # Prepare the next state. self.states.append(self.parse_document_end) self.state = self.parse_block_node return event else: return self.parse_document_start() def parse_document_start(self): # type: () -> Any # Parse any extra document end indicators. while self.scanner.check_token(DocumentEndToken): self.scanner.get_token() # Parse an explicit document. if not self.scanner.check_token(StreamEndToken): token = self.scanner.peek_token() start_mark = token.start_mark version, tags = self.process_directives() if not self.scanner.check_token(DocumentStartToken): raise ParserError( None, None, "expected '', but found %r" % self.scanner.peek_token().id, self.scanner.peek_token().start_mark, ) token = self.scanner.get_token() end_mark = token.end_mark event = DocumentStartEvent( start_mark, end_mark, explicit=True, version=version, tags=tags ) # type: Any self.states.append(self.parse_document_end) self.state = self.parse_document_content else: # Parse the end of the stream. token = self.scanner.get_token() event = StreamEndEvent(token.start_mark, token.end_mark, comment=token.comment) assert not self.states assert not self.marks self.state = None return event def parse_document_end(self): # type: () -> Any # Parse the document end. token = self.scanner.peek_token() start_mark = end_mark = token.start_mark explicit = False if self.scanner.check_token(DocumentEndToken): token = self.scanner.get_token() end_mark = token.end_mark explicit = True event = DocumentEndEvent(start_mark, end_mark, explicit=explicit) # Prepare the next state. if self.resolver.processing_version == (1, 1): self.state = self.parse_document_start else: self.state = self.parse_implicit_document_start return event def parse_document_content(self): # type: () -> Any if self.scanner.check_token( DirectiveToken, DocumentStartToken, DocumentEndToken, StreamEndToken ): event = self.process_empty_scalar(self.scanner.peek_token().start_mark) self.state = self.states.pop() return event else: return self.parse_block_node() def process_directives(self): # type: () -> Any self.yaml_version = None self.tag_handles = {} while self.scanner.check_token(DirectiveToken): token = self.scanner.get_token() if token.name == u'YAML': if self.yaml_version is not None: raise ParserError( None, None, 'found duplicate YAML directive', token.start_mark ) major, minor = token.value if major != 1: raise ParserError( None, None, 'found incompatible YAML document (version 1.* is ' 'required)', token.start_mark, ) self.yaml_version = token.value elif token.name == u'TAG': handle, prefix = token.value if handle in self.tag_handles: raise ParserError( None, None, 'duplicate tag handle %r' % utf8(handle), token.start_mark ) self.tag_handles[handle] = prefix if bool(self.tag_handles): value = self.yaml_version, self.tag_handles.copy() # type: Any else: value = self.yaml_version, None for key in self.DEFAULT_TAGS: if key not in self.tag_handles: self.tag_handles[key] = self.DEFAULT_TAGS[key] return value # block_node_or_indentless_sequence ::= ALIAS # | properties (block_content | indentless_block_sequence)? # | block_content # | indentless_block_sequence # block_node ::= ALIAS # | properties block_content? # | block_content # flow_node ::= ALIAS # | properties flow_content? # | flow_content # properties ::= TAG ANCHOR? | ANCHOR TAG? # block_content ::= block_collection | flow_collection | SCALAR # flow_content ::= flow_collection | SCALAR # block_collection ::= block_sequence | block_mapping # flow_collection ::= flow_sequence | flow_mapping def parse_block_node(self): # type: () -> Any return self.parse_node(block=True) def parse_flow_node(self): # type: () -> Any return self.parse_node() def parse_block_node_or_indentless_sequence(self): # type: () -> Any return self.parse_node(block=True, indentless_sequence=True) def transform_tag(self, handle, suffix): # type: (Any, Any) -> Any return self.tag_handles[handle] + suffix def parse_node(self, block=False, indentless_sequence=False): # type: (bool, bool) -> Any if self.scanner.check_token(AliasToken): token = self.scanner.get_token() event = AliasEvent(token.value, token.start_mark, token.end_mark) # type: Any self.state = self.states.pop() return event anchor = None tag = None start_mark = end_mark = tag_mark = None if self.scanner.check_token(AnchorToken): token = self.scanner.get_token() start_mark = token.start_mark end_mark = token.end_mark anchor = token.value if self.scanner.check_token(TagToken): token = self.scanner.get_token() tag_mark = token.start_mark end_mark = token.end_mark tag = token.value elif self.scanner.check_token(TagToken): token = self.scanner.get_token() start_mark = tag_mark = token.start_mark end_mark = token.end_mark tag = token.value if self.scanner.check_token(AnchorToken): token = self.scanner.get_token() start_mark = tag_mark = token.start_mark end_mark = token.end_mark anchor = token.value if tag is not None: handle, suffix = tag if handle is not None: if handle not in self.tag_handles: raise ParserError( 'while parsing a node', start_mark, 'found undefined tag handle %r' % utf8(handle), tag_mark, ) tag = self.transform_tag(handle, suffix) else: tag = suffix # if tag == u'!': # raise ParserError("while parsing a node", start_mark, # "found non-specific tag '!'", tag_mark, # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' # and share your opinion.") if start_mark is None: start_mark = end_mark = self.scanner.peek_token().start_mark event = None implicit = tag is None or tag == u'!' if indentless_sequence and self.scanner.check_token(BlockEntryToken): comment = None pt = self.scanner.peek_token() if pt.comment and pt.comment[0]: comment = [pt.comment[0], []] pt.comment[0] = None end_mark = self.scanner.peek_token().end_mark event = SequenceStartEvent( anchor, tag, implicit, start_mark, end_mark, flow_style=False, comment=comment ) self.state = self.parse_indentless_sequence_entry return event if self.scanner.check_token(ScalarToken): token = self.scanner.get_token() # self.scanner.peek_token_same_line_comment(token) end_mark = token.end_mark if (token.plain and tag is None) or tag == u'!': implicit = (True, False) elif tag is None: implicit = (False, True) else: implicit = (False, False) # nprint('se', token.value, token.comment) event = ScalarEvent( anchor, tag, implicit, token.value, start_mark, end_mark, style=token.style, comment=token.comment, ) self.state = self.states.pop() elif self.scanner.check_token(FlowSequenceStartToken): pt = self.scanner.peek_token() end_mark = pt.end_mark event = SequenceStartEvent( anchor, tag, implicit, start_mark, end_mark, flow_style=True, comment=pt.comment, ) self.state = self.parse_flow_sequence_first_entry elif self.scanner.check_token(FlowMappingStartToken): pt = self.scanner.peek_token() end_mark = self.scanner.peek_token().end_mark event = MappingStartEvent( anchor, tag, implicit, start_mark, end_mark, flow_style=True, comment=pt.comment, ) self.state = self.parse_flow_mapping_first_key elif block and self.scanner.check_token(BlockSequenceStartToken): end_mark = self.scanner.peek_token().start_mark # should inserting the comment be dependent on the # indentation? pt = self.scanner.peek_token() comment = pt.comment # nprint('pt0', type(pt)) if comment is None or comment[1] is None: comment = pt.split_comment() # nprint('pt1', comment) event = SequenceStartEvent( anchor, tag, implicit, start_mark, end_mark, flow_style=False, comment=comment ) self.state = self.parse_block_sequence_first_entry elif block and self.scanner.check_token(BlockMappingStartToken): end_mark = self.scanner.peek_token().start_mark comment = self.scanner.peek_token().comment event = MappingStartEvent( anchor, tag, implicit, start_mark, end_mark, flow_style=False, comment=comment ) self.state = self.parse_block_mapping_first_key elif anchor is not None or tag is not None: # Empty scalars are allowed even if a tag or an anchor is # specified. event = ScalarEvent(anchor, tag, (implicit, False), "", start_mark, end_mark) self.state = self.states.pop() else: if block: node = 'block' else: node = 'flow' token = self.scanner.peek_token() raise ParserError( 'while parsing a %s node' % node, start_mark, 'expected the node content, but found %r' % token.id, token.start_mark, ) return event # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* # BLOCK-END def parse_block_sequence_first_entry(self): # type: () -> Any token = self.scanner.get_token() # move any comment from start token # token.move_comment(self.scanner.peek_token()) self.marks.append(token.start_mark) return self.parse_block_sequence_entry() def parse_block_sequence_entry(self): # type: () -> Any if self.scanner.check_token(BlockEntryToken): token = self.scanner.get_token() token.move_comment(self.scanner.peek_token()) if not self.scanner.check_token(BlockEntryToken, BlockEndToken): self.states.append(self.parse_block_sequence_entry) return self.parse_block_node() else: self.state = self.parse_block_sequence_entry return self.process_empty_scalar(token.end_mark) if not self.scanner.check_token(BlockEndToken): token = self.scanner.peek_token() raise ParserError( 'while parsing a block collection', self.marks[-1], 'expected , but found %r' % token.id, token.start_mark, ) token = self.scanner.get_token() # BlockEndToken event = SequenceEndEvent(token.start_mark, token.end_mark, comment=token.comment) self.state = self.states.pop() self.marks.pop() return event # indentless_sequence ::= (BLOCK-ENTRY block_node?)+ # indentless_sequence? # sequence: # - entry # - nested def parse_indentless_sequence_entry(self): # type: () -> Any if self.scanner.check_token(BlockEntryToken): token = self.scanner.get_token() token.move_comment(self.scanner.peek_token()) if not self.scanner.check_token( BlockEntryToken, KeyToken, ValueToken, BlockEndToken ): self.states.append(self.parse_indentless_sequence_entry) return self.parse_block_node() else: self.state = self.parse_indentless_sequence_entry return self.process_empty_scalar(token.end_mark) token = self.scanner.peek_token() event = SequenceEndEvent(token.start_mark, token.start_mark, comment=token.comment) self.state = self.states.pop() return event # block_mapping ::= BLOCK-MAPPING_START # ((KEY block_node_or_indentless_sequence?)? # (VALUE block_node_or_indentless_sequence?)?)* # BLOCK-END def parse_block_mapping_first_key(self): # type: () -> Any token = self.scanner.get_token() self.marks.append(token.start_mark) return self.parse_block_mapping_key() def parse_block_mapping_key(self): # type: () -> Any if self.scanner.check_token(KeyToken): token = self.scanner.get_token() token.move_comment(self.scanner.peek_token()) if not self.scanner.check_token(KeyToken, ValueToken, BlockEndToken): self.states.append(self.parse_block_mapping_value) return self.parse_block_node_or_indentless_sequence() else: self.state = self.parse_block_mapping_value return self.process_empty_scalar(token.end_mark) if not self.scanner.check_token(BlockEndToken): token = self.scanner.peek_token() raise ParserError( 'while parsing a block mapping', self.marks[-1], 'expected , but found %r' % token.id, token.start_mark, ) token = self.scanner.get_token() token.move_comment(self.scanner.peek_token()) event = MappingEndEvent(token.start_mark, token.end_mark, comment=token.comment) self.state = self.states.pop() self.marks.pop() return event def parse_block_mapping_value(self): # type: () -> Any if self.scanner.check_token(ValueToken): token = self.scanner.get_token() # value token might have post comment move it to e.g. block if self.scanner.check_token(ValueToken): token.move_comment(self.scanner.peek_token()) else: if not self.scanner.check_token(KeyToken): token.move_comment(self.scanner.peek_token(), empty=True) # else: empty value for this key cannot move token.comment if not self.scanner.check_token(KeyToken, ValueToken, BlockEndToken): self.states.append(self.parse_block_mapping_key) return self.parse_block_node_or_indentless_sequence() else: self.state = self.parse_block_mapping_key comment = token.comment if comment is None: token = self.scanner.peek_token() comment = token.comment if comment: token._comment = [None, comment[1]] comment = [comment[0], None] return self.process_empty_scalar(token.end_mark, comment=comment) else: self.state = self.parse_block_mapping_key token = self.scanner.peek_token() return self.process_empty_scalar(token.start_mark) # flow_sequence ::= FLOW-SEQUENCE-START # (flow_sequence_entry FLOW-ENTRY)* # flow_sequence_entry? # FLOW-SEQUENCE-END # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? # # Note that while production rules for both flow_sequence_entry and # flow_mapping_entry are equal, their interpretations are different. # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?` # generate an inline mapping (set syntax). def parse_flow_sequence_first_entry(self): # type: () -> Any token = self.scanner.get_token() self.marks.append(token.start_mark) return self.parse_flow_sequence_entry(first=True) def parse_flow_sequence_entry(self, first=False): # type: (bool) -> Any if not self.scanner.check_token(FlowSequenceEndToken): if not first: if self.scanner.check_token(FlowEntryToken): self.scanner.get_token() else: token = self.scanner.peek_token() raise ParserError( 'while parsing a flow sequence', self.marks[-1], "expected ',' or ']', but got %r" % token.id, token.start_mark, ) if self.scanner.check_token(KeyToken): token = self.scanner.peek_token() event = MappingStartEvent( None, None, True, token.start_mark, token.end_mark, flow_style=True ) # type: Any self.state = self.parse_flow_sequence_entry_mapping_key return event elif not self.scanner.check_token(FlowSequenceEndToken): self.states.append(self.parse_flow_sequence_entry) return self.parse_flow_node() token = self.scanner.get_token() event = SequenceEndEvent(token.start_mark, token.end_mark, comment=token.comment) self.state = self.states.pop() self.marks.pop() return event def parse_flow_sequence_entry_mapping_key(self): # type: () -> Any token = self.scanner.get_token() if not self.scanner.check_token(ValueToken, FlowEntryToken, FlowSequenceEndToken): self.states.append(self.parse_flow_sequence_entry_mapping_value) return self.parse_flow_node() else: self.state = self.parse_flow_sequence_entry_mapping_value return self.process_empty_scalar(token.end_mark) def parse_flow_sequence_entry_mapping_value(self): # type: () -> Any if self.scanner.check_token(ValueToken): token = self.scanner.get_token() if not self.scanner.check_token(FlowEntryToken, FlowSequenceEndToken): self.states.append(self.parse_flow_sequence_entry_mapping_end) return self.parse_flow_node() else: self.state = self.parse_flow_sequence_entry_mapping_end return self.process_empty_scalar(token.end_mark) else: self.state = self.parse_flow_sequence_entry_mapping_end token = self.scanner.peek_token() return self.process_empty_scalar(token.start_mark) def parse_flow_sequence_entry_mapping_end(self): # type: () -> Any self.state = self.parse_flow_sequence_entry token = self.scanner.peek_token() return MappingEndEvent(token.start_mark, token.start_mark) # flow_mapping ::= FLOW-MAPPING-START # (flow_mapping_entry FLOW-ENTRY)* # flow_mapping_entry? # FLOW-MAPPING-END # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? def parse_flow_mapping_first_key(self): # type: () -> Any token = self.scanner.get_token() self.marks.append(token.start_mark) return self.parse_flow_mapping_key(first=True) def parse_flow_mapping_key(self, first=False): # type: (Any) -> Any if not self.scanner.check_token(FlowMappingEndToken): if not first: if self.scanner.check_token(FlowEntryToken): self.scanner.get_token() else: token = self.scanner.peek_token() raise ParserError( 'while parsing a flow mapping', self.marks[-1], "expected ',' or '}', but got %r" % token.id, token.start_mark, ) if self.scanner.check_token(KeyToken): token = self.scanner.get_token() if not self.scanner.check_token( ValueToken, FlowEntryToken, FlowMappingEndToken ): self.states.append(self.parse_flow_mapping_value) return self.parse_flow_node() else: self.state = self.parse_flow_mapping_value return self.process_empty_scalar(token.end_mark) elif not self.scanner.check_token(FlowMappingEndToken): self.states.append(self.parse_flow_mapping_empty_value) return self.parse_flow_node() token = self.scanner.get_token() event = MappingEndEvent(token.start_mark, token.end_mark, comment=token.comment) self.state = self.states.pop() self.marks.pop() return event def parse_flow_mapping_value(self): # type: () -> Any if self.scanner.check_token(ValueToken): token = self.scanner.get_token() if not self.scanner.check_token(FlowEntryToken, FlowMappingEndToken): self.states.append(self.parse_flow_mapping_key) return self.parse_flow_node() else: self.state = self.parse_flow_mapping_key return self.process_empty_scalar(token.end_mark) else: self.state = self.parse_flow_mapping_key token = self.scanner.peek_token() return self.process_empty_scalar(token.start_mark) def parse_flow_mapping_empty_value(self): # type: () -> Any self.state = self.parse_flow_mapping_key return self.process_empty_scalar(self.scanner.peek_token().start_mark) def process_empty_scalar(self, mark, comment=None): # type: (Any, Any) -> Any return ScalarEvent(None, None, (True, False), "", mark, mark, comment=comment) class RoundTripParser(Parser): """roundtrip is a safe loader, that wants to see the unmangled tag""" def transform_tag(self, handle, suffix): # type: (Any, Any) -> Any # return self.tag_handles[handle]+suffix if handle == '!!' and suffix in ( u'null', u'bool', u'int', u'float', u'binary', u'timestamp', u'omap', u'pairs', u'set', u'str', u'seq', u'map', ): return Parser.transform_tag(self, handle, suffix) return handle + suffix ruamel.yaml-0.15.89/cyaml.py0000664000175100001440000001467013411362267016271 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import from _ruamel_yaml import CParser, CEmitter # type: ignore from ruamel.yaml.constructor import Constructor, BaseConstructor, SafeConstructor from ruamel.yaml.representer import Representer, SafeRepresenter, BaseRepresenter from ruamel.yaml.resolver import Resolver, BaseResolver if False: # MYPY from typing import Any, Union, Optional # NOQA from ruamel.yaml.compat import StreamTextType, StreamType, VersionType # NOQA __all__ = ['CBaseLoader', 'CSafeLoader', 'CLoader', 'CBaseDumper', 'CSafeDumper', 'CDumper'] # this includes some hacks to solve the usage of resolver by lower level # parts of the parser class CBaseLoader(CParser, BaseConstructor, BaseResolver): # type: ignore def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None CParser.__init__(self, stream) self._parser = self._composer = self BaseConstructor.__init__(self, loader=self) BaseResolver.__init__(self, loadumper=self) # self.descend_resolver = self._resolver.descend_resolver # self.ascend_resolver = self._resolver.ascend_resolver # self.resolve = self._resolver.resolve class CSafeLoader(CParser, SafeConstructor, Resolver): # type: ignore def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None CParser.__init__(self, stream) self._parser = self._composer = self SafeConstructor.__init__(self, loader=self) Resolver.__init__(self, loadumper=self) # self.descend_resolver = self._resolver.descend_resolver # self.ascend_resolver = self._resolver.ascend_resolver # self.resolve = self._resolver.resolve class CLoader(CParser, Constructor, Resolver): # type: ignore def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None CParser.__init__(self, stream) self._parser = self._composer = self Constructor.__init__(self, loader=self) Resolver.__init__(self, loadumper=self) # self.descend_resolver = self._resolver.descend_resolver # self.ascend_resolver = self._resolver.ascend_resolver # self.resolve = self._resolver.resolve class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): # type: ignore def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA CEmitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, encoding=encoding, allow_unicode=allow_unicode, line_break=line_break, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, ) self._emitter = self._serializer = self._representer = self BaseRepresenter.__init__( self, default_style=default_style, default_flow_style=default_flow_style, dumper=self, ) BaseResolver.__init__(self, loadumper=self) class CSafeDumper(CEmitter, SafeRepresenter, Resolver): # type: ignore def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA self._emitter = self._serializer = self._representer = self CEmitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, encoding=encoding, allow_unicode=allow_unicode, line_break=line_break, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, ) self._emitter = self._serializer = self._representer = self SafeRepresenter.__init__( self, default_style=default_style, default_flow_style=default_flow_style ) Resolver.__init__(self) class CDumper(CEmitter, Representer, Resolver): # type: ignore def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA CEmitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, encoding=encoding, allow_unicode=allow_unicode, line_break=line_break, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, ) self._emitter = self._serializer = self._representer = self Representer.__init__( self, default_style=default_style, default_flow_style=default_flow_style ) Resolver.__init__(self) ruamel.yaml-0.15.89/reader.py0000664000175100001440000002517413411361314016417 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import # This module contains abstractions for the input stream. You don't have to # looks further, there are no pretty code. # # We define two classes here. # # Mark(source, line, column) # It's just a record and its only use is producing nice error messages. # Parser does not use it for any other purposes. # # Reader(source, data) # Reader determines the encoding of `data` and converts it to unicode. # Reader provides the following methods and attributes: # reader.peek(length=1) - return the next `length` characters # reader.forward(length=1) - move the current position to `length` # characters. # reader.index - the number of the current character. # reader.line, stream.column - the line and the column of the current # character. import codecs from ruamel.yaml.error import YAMLError, FileMark, StringMark, YAMLStreamError from ruamel.yaml.compat import text_type, binary_type, PY3, UNICODE_SIZE from ruamel.yaml.util import RegExp if False: # MYPY from typing import Any, Dict, Optional, List, Union, Text, Tuple, Optional # NOQA # from ruamel.yaml.compat import StreamTextType # NOQA __all__ = ['Reader', 'ReaderError'] class ReaderError(YAMLError): def __init__(self, name, position, character, encoding, reason): # type: (Any, Any, Any, Any, Any) -> None self.name = name self.character = character self.position = position self.encoding = encoding self.reason = reason def __str__(self): # type: () -> str if isinstance(self.character, binary_type): return "'%s' codec can't decode byte #x%02x: %s\n" ' in "%s", position %d' % ( self.encoding, ord(self.character), self.reason, self.name, self.position, ) else: return 'unacceptable character #x%04x: %s\n' ' in "%s", position %d' % ( self.character, self.reason, self.name, self.position, ) class Reader(object): # Reader: # - determines the data encoding and converts it to a unicode string, # - checks if characters are in allowed range, # - adds '\0' to the end. # Reader accepts # - a `str` object (PY2) / a `bytes` object (PY3), # - a `unicode` object (PY2) / a `str` object (PY3), # - a file-like object with its `read` method returning `str`, # - a file-like object with its `read` method returning `unicode`. # Yeah, it's ugly and slow. def __init__(self, stream, loader=None): # type: (Any, Any) -> None self.loader = loader if self.loader is not None and getattr(self.loader, '_reader', None) is None: self.loader._reader = self self.reset_reader() self.stream = stream # type: Any # as .read is called def reset_reader(self): # type: () -> None self.name = None # type: Any self.stream_pointer = 0 self.eof = True self.buffer = "" self.pointer = 0 self.raw_buffer = None # type: Any self.raw_decode = None self.encoding = None # type: Optional[Text] self.index = 0 self.line = 0 self.column = 0 @property def stream(self): # type: () -> Any try: return self._stream except AttributeError: raise YAMLStreamError('input stream needs to specified') @stream.setter def stream(self, val): # type: (Any) -> None if val is None: return self._stream = None if isinstance(val, text_type): self.name = '' self.check_printable(val) self.buffer = val + u'\0' # type: ignore elif isinstance(val, binary_type): self.name = '' self.raw_buffer = val self.determine_encoding() else: if not hasattr(val, 'read'): raise YAMLStreamError('stream argument needs to have a read() method') self._stream = val self.name = getattr(self.stream, 'name', '') self.eof = False self.raw_buffer = None self.determine_encoding() def peek(self, index=0): # type: (int) -> Text try: return self.buffer[self.pointer + index] except IndexError: self.update(index + 1) return self.buffer[self.pointer + index] def prefix(self, length=1): # type: (int) -> Any if self.pointer + length >= len(self.buffer): self.update(length) return self.buffer[self.pointer : self.pointer + length] def forward_1_1(self, length=1): # type: (int) -> None if self.pointer + length + 1 >= len(self.buffer): self.update(length + 1) while length != 0: ch = self.buffer[self.pointer] self.pointer += 1 self.index += 1 if ch in u'\n\x85\u2028\u2029' or ( ch == u'\r' and self.buffer[self.pointer] != u'\n' ): self.line += 1 self.column = 0 elif ch != u'\uFEFF': self.column += 1 length -= 1 def forward(self, length=1): # type: (int) -> None if self.pointer + length + 1 >= len(self.buffer): self.update(length + 1) while length != 0: ch = self.buffer[self.pointer] self.pointer += 1 self.index += 1 if ch == u'\n' or (ch == u'\r' and self.buffer[self.pointer] != u'\n'): self.line += 1 self.column = 0 elif ch != u'\uFEFF': self.column += 1 length -= 1 def get_mark(self): # type: () -> Any if self.stream is None: return StringMark( self.name, self.index, self.line, self.column, self.buffer, self.pointer ) else: return FileMark(self.name, self.index, self.line, self.column) def determine_encoding(self): # type: () -> None while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2): self.update_raw() if isinstance(self.raw_buffer, binary_type): if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): self.raw_decode = codecs.utf_16_le_decode # type: ignore self.encoding = 'utf-16-le' elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): self.raw_decode = codecs.utf_16_be_decode # type: ignore self.encoding = 'utf-16-be' else: self.raw_decode = codecs.utf_8_decode # type: ignore self.encoding = 'utf-8' self.update(1) if UNICODE_SIZE == 2: NON_PRINTABLE = RegExp( u'[^\x09\x0A\x0D\x20-\x7E\x85' u'\xA0-\uD7FF' u'\uE000-\uFFFD' u']' ) else: NON_PRINTABLE = RegExp( u'[^\x09\x0A\x0D\x20-\x7E\x85' u'\xA0-\uD7FF' u'\uE000-\uFFFD' u'\U00010000-\U0010FFFF' u']' ) _printable_ascii = ('\x09\x0A\x0D' + "".join(map(chr, range(0x20, 0x7F)))).encode('ascii') @classmethod def _get_non_printable_ascii(cls, data): # type: ignore # type: (Text, bytes) -> Optional[Tuple[int, Text]] ascii_bytes = data.encode('ascii') non_printables = ascii_bytes.translate(None, cls._printable_ascii) # type: ignore if not non_printables: return None non_printable = non_printables[:1] return ascii_bytes.index(non_printable), non_printable.decode('ascii') @classmethod def _get_non_printable_regex(cls, data): # type: (Text) -> Optional[Tuple[int, Text]] match = cls.NON_PRINTABLE.search(data) if not bool(match): return None return match.start(), match.group() @classmethod def _get_non_printable(cls, data): # type: (Text) -> Optional[Tuple[int, Text]] try: return cls._get_non_printable_ascii(data) # type: ignore except UnicodeEncodeError: return cls._get_non_printable_regex(data) def check_printable(self, data): # type: (Any) -> None non_printable_match = self._get_non_printable(data) if non_printable_match is not None: start, character = non_printable_match position = self.index + (len(self.buffer) - self.pointer) + start raise ReaderError( self.name, position, ord(character), 'unicode', 'special characters are not allowed', ) def update(self, length): # type: (int) -> None if self.raw_buffer is None: return self.buffer = self.buffer[self.pointer :] self.pointer = 0 while len(self.buffer) < length: if not self.eof: self.update_raw() if self.raw_decode is not None: try: data, converted = self.raw_decode(self.raw_buffer, 'strict', self.eof) except UnicodeDecodeError as exc: if PY3: character = self.raw_buffer[exc.start] else: character = exc.object[exc.start] if self.stream is not None: position = self.stream_pointer - len(self.raw_buffer) + exc.start elif self.stream is not None: position = self.stream_pointer - len(self.raw_buffer) + exc.start else: position = exc.start raise ReaderError(self.name, position, character, exc.encoding, exc.reason) else: data = self.raw_buffer converted = len(data) self.check_printable(data) self.buffer += data self.raw_buffer = self.raw_buffer[converted:] if self.eof: self.buffer += '\0' self.raw_buffer = None break def update_raw(self, size=None): # type: (Optional[int]) -> None if size is None: size = 4096 if PY3 else 1024 data = self.stream.read(size) if self.raw_buffer is None: self.raw_buffer = data else: self.raw_buffer += data self.stream_pointer += len(data) if not data: self.eof = True # try: # import psyco # psyco.bind(Reader) # except ImportError: # pass ruamel.yaml-0.15.89/error.py0000664000175100001440000002065313373303256016313 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import import warnings import textwrap from ruamel.yaml.compat import utf8 if False: # MYPY from typing import Any, Dict, Optional, List, Text # NOQA __all__ = [ 'FileMark', 'StringMark', 'CommentMark', 'YAMLError', 'MarkedYAMLError', 'ReusedAnchorWarning', 'UnsafeLoaderWarning', 'MarkedYAMLWarning', 'MarkedYAMLFutureWarning', ] class StreamMark(object): __slots__ = 'name', 'index', 'line', 'column' def __init__(self, name, index, line, column): # type: (Any, int, int, int) -> None self.name = name self.index = index self.line = line self.column = column def __str__(self): # type: () -> Any where = ' in "%s", line %d, column %d' % (self.name, self.line + 1, self.column + 1) return where class FileMark(StreamMark): __slots__ = () class StringMark(StreamMark): __slots__ = 'name', 'index', 'line', 'column', 'buffer', 'pointer' def __init__(self, name, index, line, column, buffer, pointer): # type: (Any, int, int, int, Any, Any) -> None StreamMark.__init__(self, name, index, line, column) self.buffer = buffer self.pointer = pointer def get_snippet(self, indent=4, max_length=75): # type: (int, int) -> Any if self.buffer is None: # always False return None head = "" start = self.pointer while start > 0 and self.buffer[start - 1] not in u'\0\r\n\x85\u2028\u2029': start -= 1 if self.pointer - start > max_length / 2 - 1: head = ' ... ' start += 5 break tail = "" end = self.pointer while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029': end += 1 if end - self.pointer > max_length / 2 - 1: tail = ' ... ' end -= 5 break snippet = utf8(self.buffer[start:end]) caret = '^' caret = '^ (line: {})'.format(self.line + 1) return ( ' ' * indent + head + snippet + tail + '\n' + ' ' * (indent + self.pointer - start + len(head)) + caret ) def __str__(self): # type: () -> Any snippet = self.get_snippet() where = ' in "%s", line %d, column %d' % (self.name, self.line + 1, self.column + 1) if snippet is not None: where += ':\n' + snippet return where class CommentMark(object): __slots__ = ('column',) def __init__(self, column): # type: (Any) -> None self.column = column class YAMLError(Exception): pass class MarkedYAMLError(YAMLError): def __init__( self, context=None, context_mark=None, problem=None, problem_mark=None, note=None, warn=None, ): # type: (Any, Any, Any, Any, Any, Any) -> None self.context = context self.context_mark = context_mark self.problem = problem self.problem_mark = problem_mark self.note = note # warn is ignored def __str__(self): # type: () -> Any lines = [] # type: List[str] if self.context is not None: lines.append(self.context) if self.context_mark is not None and ( self.problem is None or self.problem_mark is None or self.context_mark.name != self.problem_mark.name or self.context_mark.line != self.problem_mark.line or self.context_mark.column != self.problem_mark.column ): lines.append(str(self.context_mark)) if self.problem is not None: lines.append(self.problem) if self.problem_mark is not None: lines.append(str(self.problem_mark)) if self.note is not None and self.note: note = textwrap.dedent(self.note) lines.append(note) return '\n'.join(lines) class YAMLStreamError(Exception): pass class YAMLWarning(Warning): pass class MarkedYAMLWarning(YAMLWarning): def __init__( self, context=None, context_mark=None, problem=None, problem_mark=None, note=None, warn=None, ): # type: (Any, Any, Any, Any, Any, Any) -> None self.context = context self.context_mark = context_mark self.problem = problem self.problem_mark = problem_mark self.note = note self.warn = warn def __str__(self): # type: () -> Any lines = [] # type: List[str] if self.context is not None: lines.append(self.context) if self.context_mark is not None and ( self.problem is None or self.problem_mark is None or self.context_mark.name != self.problem_mark.name or self.context_mark.line != self.problem_mark.line or self.context_mark.column != self.problem_mark.column ): lines.append(str(self.context_mark)) if self.problem is not None: lines.append(self.problem) if self.problem_mark is not None: lines.append(str(self.problem_mark)) if self.note is not None and self.note: note = textwrap.dedent(self.note) lines.append(note) if self.warn is not None and self.warn: warn = textwrap.dedent(self.warn) lines.append(warn) return '\n'.join(lines) class ReusedAnchorWarning(YAMLWarning): pass class UnsafeLoaderWarning(YAMLWarning): text = """ The default 'Loader' for 'load(stream)' without further arguments can be unsafe. Use 'load(stream, Loader=ruamel.yaml.Loader)' explicitly if that is OK. Alternatively include the following in your code: import warnings warnings.simplefilter('ignore', ruamel.yaml.error.UnsafeLoaderWarning) In most other cases you should consider using 'safe_load(stream)'""" pass warnings.simplefilter('once', UnsafeLoaderWarning) class MantissaNoDotYAML1_1Warning(YAMLWarning): def __init__(self, node, flt_str): # type: (Any, Any) -> None self.node = node self.flt = flt_str def __str__(self): # type: () -> Any line = self.node.start_mark.line col = self.node.start_mark.column return """ In YAML 1.1 floating point values should have a dot ('.') in their mantissa. See the Floating-Point Language-Independent Type for YAML™ Version 1.1 specification ( http://yaml.org/type/float.html ). This dot is not required for JSON nor for YAML 1.2 Correct your float: "{}" on line: {}, column: {} or alternatively include the following in your code: import warnings warnings.simplefilter('ignore', ruamel.yaml.error.MantissaNoDotYAML1_1Warning) """.format( self.flt, line, col ) warnings.simplefilter('once', MantissaNoDotYAML1_1Warning) class YAMLFutureWarning(Warning): pass class MarkedYAMLFutureWarning(YAMLFutureWarning): def __init__( self, context=None, context_mark=None, problem=None, problem_mark=None, note=None, warn=None, ): # type: (Any, Any, Any, Any, Any, Any) -> None self.context = context self.context_mark = context_mark self.problem = problem self.problem_mark = problem_mark self.note = note self.warn = warn def __str__(self): # type: () -> Any lines = [] # type: List[str] if self.context is not None: lines.append(self.context) if self.context_mark is not None and ( self.problem is None or self.problem_mark is None or self.context_mark.name != self.problem_mark.name or self.context_mark.line != self.problem_mark.line or self.context_mark.column != self.problem_mark.column ): lines.append(str(self.context_mark)) if self.problem is not None: lines.append(self.problem) if self.problem_mark is not None: lines.append(str(self.problem_mark)) if self.note is not None and self.note: note = textwrap.dedent(self.note) lines.append(note) if self.warn is not None and self.warn: warn = textwrap.dedent(self.warn) lines.append(warn) return '\n'.join(lines) ruamel.yaml-0.15.89/timestamp.py0000664000175100001440000000165313415324417017163 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals import datetime import copy # ToDo: at least on PY3 you could probably attach the tzinfo correctly to the object # a more complete datetime might be used by safe loading as well if False: # MYPY from typing import Any, Dict, Optional, List # NOQA class TimeStamp(datetime.datetime): def __init__(self, *args, **kw): # type: (Any, Any) -> None self._yaml = dict(t=False, tz=None, delta=0) # type: Dict[Any, Any] def __new__(cls, *args, **kw): # datetime is immutable # type: (Any, Any) -> Any return datetime.datetime.__new__(cls, *args, **kw) # type: ignore def __deepcopy__(self, memo): # type: (Any) -> Any ts = TimeStamp(self.year, self.month, self.day, self.hour, self.minute, self.second) ts._yaml = copy.deepcopy(self._yaml) return ts ruamel.yaml-0.15.89/README.rst0000644000175100001440000006714113435603465016304 0ustar anthonusers00000000000000 ruamel.yaml =========== ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python. :version: 0.15.89 :updated: 2019-02-27 :documentation: http://yaml.readthedocs.io :repository: https://bitbucket.org/ruamel/ :pypi: https://pypi.org/project/ruamel.yaml/ Starting with version 0.15.0 the way YAML files are loaded and dumped is changing. See the API doc for details. Currently existing functionality will throw a warning before being changed/removed. **For production systems you should pin the version being used with ``ruamel.yaml<=0.15``**. There might be bug fixes in the 0.14 series, but new functionality is likely only to be available via the new API. If your package uses ``ruamel.yaml`` and is not listed on PyPI, drop me an email, preferably with some information on how you use the package (or a link to bitbucket/github) and I'll keep you informed when the status of the API is stable enough to make the transition. * `Overview `_ * `Installing `_ * `Basic Usage `_ * `Details `_ * `Examples `_ * `API `_ * `Differences with PyYAML `_ .. image:: https://readthedocs.org/projects/yaml/badge/?version=stable :target: https://yaml.readthedocs.org/en/stable .. image:: https://bestpractices.coreinfrastructure.org/projects/1128/badge :target: https://bestpractices.coreinfrastructure.org/projects/1128 .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/license.svg :target: https://opensource.org/licenses/MIT .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/pypi.svg :target: https://pypi.org/project/ruamel.yaml/ .. image:: https://bitbucket.org/ruamel/oitnb/raw/default/_doc/_static/oitnb.svg :target: https://pypi.org/project/oitnb/ .. image:: http://www.mypy-lang.org/static/mypy_badge.svg :target: http://mypy-lang.org/ ChangeLog ========= .. should insert NEXT: at the beginning of line for next key (with empty line) 0.15.89 (2019-02-27): - fix for items with flow-mapping in block sequence output on single line (reported by `Zahari Dim `__) - fix for safe dumping erroring in creation of representereror when dumping namedtuple (reported and solution by `Jaakko Kantojärvi `__) 0.15.88 (2019-02-12): - fix inclusing of python code from the subpackage data (containing extra tests, reported by `Florian Apolloner `__) 0.15.87 (2019-01-22): - fix problem with empty lists and the code to reinsert merge keys (reported via email by Zaloo) 0.15.86 (2019-01-16): - reinsert merge key in its old position (reported by grumbler on `__) - fix for issue with non-ASCII anchor names (reported and fix provided by Dandaleon Flux via email) - fix for issue when parsing flow mapping value starting with colon (in pure Python only) (reported by `FichteFoll `__) 0.15.85 (2019-01-08): - the types used by ``SafeConstructor`` for mappings and sequences can now by set by assigning to ``XXXConstructor.yaml_base_dict_type`` (and ``..._list_type``), preventing the need to copy two methods with 50+ lines that had ``var = {}`` hardcoded. (Implemented to help solve an feature request by `Anthony Sottile `__ in an easier way) 0.15.84 (2019-01-07): - fix for ``CommentedMap.copy()`` not returning ``CommentedMap``, let alone copying comments etc. (reported by `Anthony Sottile `__) 0.15.83 (2019-01-02): - fix for bug in roundtripping aliases used as key (reported via email by Zaloo) 0.15.82 (2018-12-28): - anchors and aliases on scalar int, float, string and bool are now preserved. Anchors do not need a referring alias for these (reported by `Alex Harvey `__) - anchors no longer lost on tagged objects when roundtripping (reported by `Zaloo `__) 0.15.81 (2018-12-06): - fix issue dumping methods of metaclass derived classes (reported and fix provided by `Douglas Raillard `__) 0.15.80 (2018-11-26): - fix issue emitting BEL character when round-tripping invalid folded input (reported by Isaac on `StackOverflow `__) 0.15.79 (2018-11-21): - fix issue with anchors nested deeper than alias (reported by gaFF on `StackOverflow `__) 0.15.78 (2018-11-15): - fix setup issue for 3.8 (reported by `Sidney Kuyateh `__) 0.15.77 (2018-11-09): - setting `yaml.sort_base_mapping_type_on_output = False`, will prevent explicit sorting by keys in the base representer of mappings. Roundtrip already did not do this. Usage only makes real sense for Python 3.6+ (feature request by `Sebastian Gerber `__). - implement Python version check in YAML metadata in ``_test/test_z_data.py`` 0.15.76 (2018-11-01): - fix issue with empty mapping and sequence loaded as flow-style (mapping reported by `Min RK `__, sequence by `Maged Ahmed `__) 0.15.75 (2018-10-27): - fix issue with single '?' scalar (reported by `Terrance `__) - fix issue with duplicate merge keys (prompted by `answering `__ a `StackOverflow question `__ by `math `__) 0.15.74 (2018-10-17): - fix dropping of comment on rt before sequence item that is sequence item (reported by `Thorsten Kampe `__) 0.15.73 (2018-10-16): - fix irregular output on pre-comment in sequence within sequence (reported by `Thorsten Kampe `__) - allow non-compact (i.e. next line) dumping sequence/mapping within sequence. 0.15.72 (2018-10-06): - fix regression on explicit 1.1 loading with the C based scanner/parser (reported by `Tomas Vavra `__) 0.15.71 (2018-09-26): - some of the tests now live in YAML files in the `yaml.data `__ repository. ``_test/test_z_data.py`` processes these. - fix regression where handcrafted CommentedMaps could not be initiated (reported by `Dan Helfman `__) - fix regression with non-root literal scalars that needed indent indicator (reported by `Clark Breyman `__) - tag:yaml.org,2002:python/object/apply now also uses __qualname__ on PY3 (reported by `Douglas RAILLARD `__) - issue with self-referring object creation (reported and fix by `Douglas RAILLARD `__) 0.15.70 (2018-09-21): - reverted CommentedMap and CommentedSeq to subclass ordereddict resp. list, reimplemented merge maps so that both ``dict(**commented_map_instance)`` and JSON dumping works. This also allows checking with ``isinstance()`` on ``dict`` resp. ``list``. (Proposed by `Stuart Berg `__, with feedback from `blhsing `__ on `StackOverflow `__) 0.15.69 (2018-09-20): - fix issue with dump_all gobbling end-of-document comments on parsing (reported by `Pierre B. `__) 0.15.68 (2018-09-20): - fix issue with parsabel, but incorrect output with nested flow-style sequences (reported by `Dougal Seeley `__) - fix issue with loading Python objects that have __setstate__ and recursion in parameters (reported by `Douglas RAILLARD `__) 0.15.67 (2018-09-19): - fix issue with extra space inserted with non-root literal strings (Issue reported and PR with fix provided by `Naomi Seyfer `__.) 0.15.66 (2018-09-07): - fix issue with fold indicating characters inserted in safe_load-ed folded strings (reported by `Maximilian Hils `__). 0.15.65 (2018-09-07): - fix issue #232 revert to throw ParserError for unexcpected ``]`` and ``}`` instead of IndexError. (Issue reported and PR with fix provided by `Naomi Seyfer `__.) - added ``key`` and ``reverse`` parameter (suggested by Jannik Klemm via email) - indent root level literal scalars that have directive or document end markers at the beginning of a line 0.15.64 (2018-08-30): - support round-trip of tagged sequences: ``!Arg [a, {b: 1}]`` - single entry mappings in flow sequences now written by default without braces, set ``yaml.brace_single_entry_mapping_in_flow_sequence=True`` to force getting ``[a, {b: 1}, {c: {d: 2}}]`` instead of the default ``[a, b: 1, c: {d: 2}]`` - fix issue when roundtripping floats starting with a dot such as ``.5`` (reported by `Harrison Gregg `__) 0.15.63 (2018-08-29): - small fix only necessary for Windows users that don't use wheels. 0.15.62 (2018-08-29): - C based reader/scanner & emitter now allow setting of 1.2 as YAML version. ** The loading/dumping is still YAML 1.1 code**, so use the common subset of YAML 1.2 and 1.1 (reported by `Ge Yang `__) 0.15.61 (2018-08-23): - support for round-tripping folded style scalars (initially requested by `Johnathan Viduchinsky `__) - update of C code - speed up of scanning (~30% depending on the input) 0.15.60 (2018-08-18): - again allow single entry map in flow sequence context (reported by `Lee Goolsbee `__) - cleanup for mypy - spurious print in library (reported by `Lele Gaifax `__), now automatically checked 0.15.59 (2018-08-17): - issue with C based loader and leading zeros (reported by `Tom Hamilton Stubber `__) 0.15.58 (2018-08-17): - simple mappings can now be used as keys when round-tripping:: {a: 1, b: 2}: hello world although using the obvious operations (del, popitem) on the key will fail, you can mutilate it by going through its attributes. If you load the above YAML in `d`, then changing the value is cumbersome: d = {CommentedKeyMap([('a', 1), ('b', 2)]): "goodbye"} and changing the key even more so: d[CommentedKeyMap([('b', 1), ('a', 2)])] = d.pop( CommentedKeyMap([('a', 1), ('b', 2)])) (you can use a `dict` instead of a list of tuples (or ordereddict), but that might result in a different order, of the keys of the key, in the output) - check integers to dump with 1.2 patterns instead of 1.1 (reported by `Lele Gaifax `__) 0.15.57 (2018-08-15): - Fix that CommentedSeq could no longer be used in adding or do a sort (reported by `Christopher Wright `__) 0.15.56 (2018-08-15): - fix issue with ``python -O`` optimizing away code (reported, and detailed cause pinpointed, by `Alex Grönholm `__) 0.15.55 (2018-08-14): - unmade ``CommentedSeq`` a subclass of ``list``. It is now indirectly a subclass of the standard ``collections.abc.MutableSequence`` (without .abc if you are still on Python2.7). If you do ``isinstance(yaml.load('[1, 2]'), list)``) anywhere in your code replace ``list`` with ``MutableSequence``. Directly, ``CommentedSeq`` is a subclass of the abstract baseclass ``ruamel.yaml.compat.MutableScliceableSequence``, with the result that *(extended) slicing is supported on ``CommentedSeq``*. (reported by `Stuart Berg `__) - duplicate keys (or their values) with non-ascii now correctly report in Python2, instead of raising a Unicode error. (Reported by `Jonathan Pyle `__) 0.15.54 (2018-08-13): - fix issue where a comment could pop-up twice in the output (reported by `Mike Kazantsev `__ and by `Nate Peterson `__) - fix issue where JSON object (mapping) without spaces was not parsed properly (reported by `Marc Schmidt `__) - fix issue where comments after empty flow-style mappings were not emitted (reported by `Qinfench Chen `__) 0.15.53 (2018-08-12): - fix issue with flow style mapping with comments gobbled newline (reported by `Christopher Lambert `__) - fix issue where single '+' under YAML 1.2 was interpreted as integer, erroring out (reported by `Jethro Yu `__) 0.15.52 (2018-08-09): - added `.copy()` mapping representation for round-tripping (``CommentedMap``) to fix incomplete copies of merged mappings (reported by `Will Richards `__) - Also unmade that class a subclass of ordereddict to solve incorrect behaviour for ``{**merged-mapping}`` and ``dict(**merged-mapping)`` (reported independently by `Tim Olsson `__ and `Filip Matzner `__) 0.15.51 (2018-08-08): - Fix method name dumps (were not dotted) and loads (reported by `Douglas Raillard `__) - Fix spurious trailing white-space caused when the comment start column was no longer reached and there was no actual EOL comment (e.g. following empty line) and doing substitutions, or when quotes around scalars got dropped. (reported by `Thomas Guillet `__) 0.15.50 (2018-08-05): - Allow ``YAML()`` as a context manager for output, thereby making it much easier to generate multi-documents in a stream. - Fix issue with incorrect type information for `load()` and `dump()` (reported by `Jimbo Jim `__) 0.15.49 (2018-08-05): - fix preservation of leading newlines in root level literal style scalar, and preserve comment after literal style indicator (``| # some comment``) Both needed for round-tripping multi-doc streams in `ryd `__. 0.15.48 (2018-08-03): - housekeeping: ``oitnb`` for formatting, mypy 0.620 upgrade and conformity 0.15.47 (2018-07-31): - fix broken 3.6 manylinux1, the result of an unclean ``build`` (reported by `Roman Sichnyi `__) 0.15.46 (2018-07-29): - fixed DeprecationWarning for importing from ``collections`` on 3.7 (issue 210, reported by `Reinoud Elhorst `__). It was `difficult to find why tox/pytest did not report `__ and as time consuming to actually `fix `__ the tests. 0.15.45 (2018-07-26): - After adding failing test for ``YAML.load_all(Path())``, remove StopIteration (PR provided by `Zachary Buhman `__, also reported by `Steven Hiscocks `__. 0.15.44 (2018-07-14): - Correct loading plain scalars consisting of numerals only and starting with `0`, when not explicitly specifying YAML version 1.1. This also fixes the issue about dumping string `'019'` as plain scalars as reported by `Min RK `__, that prompted this chance. 0.15.43 (2018-07-12): - merge PR33: Python2.7 on Windows is narrow, but has no ``sysconfig.get_config_var('Py_UNICODE_SIZE')``. (merge provided by `Marcel Bargull `__) - ``register_class()`` now returns class (proposed by `Mike Nerone `__} 0.15.42 (2018-07-01): - fix regression showing only on narrow Python 2.7 (py27mu) builds (with help from `Marcel Bargull `__ and `Colm O'Connor `__). - run pre-commit ``tox`` on Python 2.7 wide and narrow, as well as 3.4/3.5/3.6/3.7/pypy 0.15.41 (2018-06-27): - add detection of C-compile failure (investigation prompted by `StackOverlow `__ by `Emmanuel Blot `__), which was removed while no longer dependent on ``libyaml``, C-extensions compilation still needs a compiler though. 0.15.40 (2018-06-18): - added links to landing places as suggested in issue 190 by `KostisA `__ - fixes issue #201: decoding unicode escaped tags on Python2, reported by `Dan Abolafia `__ 0.15.39 (2018-06-17): - merge PR27 improving package startup time (and loading when regexp not actually used), provided by `Marcel Bargull `__ 0.15.38 (2018-06-13): - fix for losing precision when roundtripping floats by `Rolf Wojtech `__ - fix for hardcoded dir separator not working for Windows by `Nuno André `__ - typo fix by `Andrey Somov `__ 0.15.37 (2018-03-21): - again trying to create installable files for 187 0.15.36 (2018-02-07): - fix issue 187, incompatibility of C extension with 3.7 (reported by Daniel Blanchard) 0.15.35 (2017-12-03): - allow ``None`` as stream when specifying ``transform`` parameters to ``YAML.dump()``. This is useful if the transforming function doesn't return a meaningful value (inspired by `StackOverflow `__ by `rsaw `__). 0.15.34 (2017-09-17): - fix for issue 157: CDumper not dumping floats (reported by Jan Smitka) 0.15.33 (2017-08-31): - support for "undefined" round-tripping tagged scalar objects (in addition to tagged mapping object). Inspired by a use case presented by Matthew Patton on `StackOverflow `__. - fix issue 148: replace cryptic error message when using !!timestamp with an incorrectly formatted or non- scalar. Reported by FichteFoll. 0.15.32 (2017-08-21): - allow setting ``yaml.default_flow_style = None`` (default: ``False``) for for ``typ='rt'``. - fix for issue 149: multiplications on ``ScalarFloat`` now return ``float`` (reported by jan.brezina@tul.cz) 0.15.31 (2017-08-15): - fix Comment dumping 0.15.30 (2017-08-14): - fix for issue with "compact JSON" not parsing: ``{"in":{},"out":{}}`` (reported on `StackOverflow `__ by `mjalkio `_ 0.15.29 (2017-08-14): - fix issue #51: different indents for mappings and sequences (reported by Alex Harvey) - fix for flow sequence/mapping as element/value of block sequence with sequence-indent minus dash-offset not equal two. 0.15.28 (2017-08-13): - fix issue #61: merge of merge cannot be __repr__-ed (reported by Tal Liron) 0.15.27 (2017-08-13): - fix issue 62, YAML 1.2 allows ``?`` and ``:`` in plain scalars if non-ambigious (reported by nowox) - fix lists within lists which would make comments disappear 0.15.26 (2017-08-10): - fix for disappearing comment after empty flow sequence (reported by oit-tzhimmash) 0.15.25 (2017-08-09): - fix for problem with dumping (unloaded) floats (reported by eyenseo) 0.15.24 (2017-08-09): - added ScalarFloat which supports roundtripping of 23.1, 23.100, 42.00E+56, 0.0, -0.0 etc. while keeping the format. Underscores in mantissas are not preserved/supported (yet, is anybody using that?). - (finally) fixed longstanding issue 23 (reported by `Antony Sottile `__), now handling comment between block mapping key and value correctly - warn on YAML 1.1 float input that is incorrect (triggered by invalid YAML provided by Cecil Curry) - allow setting of boolean representation (`false`, `true`) by using: ``yaml.boolean_representation = [u'False', u'True']`` 0.15.23 (2017-08-01): - fix for round_tripping integers on 2.7.X > sys.maxint (reported by ccatterina) 0.15.22 (2017-07-28): - fix for round_tripping singe excl. mark tags doubling (reported and fix by Jan Brezina) 0.15.21 (2017-07-25): - fix for writing unicode in new API, (reported on `StackOverflow `__ 0.15.20 (2017-07-23): - wheels for windows including C extensions 0.15.19 (2017-07-13): - added object constructor for rt, decorator ``yaml_object`` to replace YAMLObject. - fix for problem using load_all with Path() instance - fix for load_all in combination with zero indent block style literal (``pure=True`` only!) 0.15.18 (2017-07-04): - missing ``pure`` attribute on ``YAML`` useful for implementing `!include` tag constructor for `including YAML files in a YAML file `__ - some documentation improvements - trigger of doc build on new revision 0.15.17 (2017-07-03): - support for Unicode supplementary Plane **output** (input was already supported, triggered by `this `__ Stack Overflow Q&A) 0.15.16 (2017-07-01): - minor typing issues (reported and fix provided by `Manvendra Singh `__ - small doc improvements 0.15.15 (2017-06-27): - fix for issue 135, typ='safe' not dumping in Python 2.7 (reported by Andrzej Ostrowski `__) 0.15.14 (2017-06-25): - fix for issue 133, in setup.py: change ModuleNotFoundError to ImportError (reported and fix by `Asley Drake `__) 0.15.13 (2017-06-24): - suppress duplicate key warning on mappings with merge keys (reported by Cameron Sweeney) 0.15.12 (2017-06-24): - remove fatal dependency of setup.py on wheel package (reported by Cameron Sweeney) 0.15.11 (2017-06-24): - fix for issue 130, regression in nested merge keys (reported by `David Fee `__) 0.15.10 (2017-06-23): - top level PreservedScalarString not indented if not explicitly asked to - remove Makefile (not very useful anyway) - some mypy additions 0.15.9 (2017-06-16): - fix for issue 127: tagged scalars were always quoted and seperated by a newline when in a block sequence (reported and largely fixed by `Tommy Wang `__) 0.15.8 (2017-06-15): - allow plug-in install via ``install ruamel.yaml[jinja2]`` 0.15.7 (2017-06-14): - add plug-in mechanism for load/dump pre resp. post-processing 0.15.6 (2017-06-10): - a set() with duplicate elements now throws error in rt loading - support for toplevel column zero literal/folded scalar in explicit documents 0.15.5 (2017-06-08): - repeat `load()` on a single `YAML()` instance would fail. 0.15.4 (2017-06-08): - `transform` parameter on dump that expects a function taking a string and returning a string. This allows transformation of the output before it is written to stream. This forces creation of the complete output in memory! - some updates to the docs 0.15.3 (2017-06-07): - No longer try to compile C extensions on Windows. Compilation can be forced by setting the environment variable `RUAMEL_FORCE_EXT_BUILD` to some value before starting the `pip install`. 0.15.2 (2017-06-07): - update to conform to mypy 0.511: mypy --strict 0.15.1 (2017-06-07): - `duplicate keys `__ in mappings generate an error (in the old API this change generates a warning until 0.16) - dependecy on ruamel.ordereddict for 2.7 now via extras_require 0.15.0 (2017-06-04): - it is now allowed to pass in a ``pathlib.Path`` as "stream" parameter to all load/dump functions - passing in a non-supported object (e.g. a string) as "stream" will result in a much more meaningful YAMLStreamError. - assigning a normal string value to an existing CommentedMap key or CommentedSeq element will result in a value cast to the previous value's type if possible. - added ``YAML`` class for new API 0.14.12 (2017-05-14): - fix for issue 119, deepcopy not returning subclasses (reported and PR by Constantine Evans ) 0.14.11 (2017-05-01): - fix for issue 103 allowing implicit documents after document end marker line (``...``) in YAML 1.2 0.14.10 (2017-04-26): - fix problem with emitting using cyaml 0.14.9 (2017-04-22): - remove dependency on ``typing`` while still supporting ``mypy`` (http://stackoverflow.com/a/43516781/1307905) - fix unclarity in doc that stated 2.6 is supported (reported by feetdust) 0.14.8 (2017-04-19): - fix Text not available on 3.5.0 and 3.5.1, now proactively setting version guards on all files (reported by `João Paulo Magalhães `__) 0.14.7 (2017-04-18): - round trip of integers (decimal, octal, hex, binary) now preserve leading zero(s) padding and underscores. Underscores are presumed to be at regular distances (i.e. ``0o12_345_67`` dumps back as ``0o1_23_45_67`` as the space from the last digit to the underscore before that is the determining factor). 0.14.6 (2017-04-14): - binary, octal and hex integers are now preserved by default. This was a known deficiency. Working on this was prompted by the issue report (112) from devnoname120, as well as the additional experience with `.replace()` on `scalarstring` classes. - fix issues 114: cannot install on Buildozer (reported by mixmastamyk). Setting env. var ``RUAMEL_NO_PIP_INSTALL_CHECK`` will suppress ``pip``-check. 0.14.5 (2017-04-04): - fix issue 109: None not dumping correctly at top level (reported by Andrea Censi) - fix issue 110: .replace on Preserved/DoubleQuoted/SingleQuoted ScalarString would give back "normal" string (reported by sandres23) 0.14.4 (2017-03-31): - fix readme 0.14.3 (2017-03-31): - fix for 0o52 not being a string in YAML 1.1 (reported on `StackOverflow Q&A 43138503 `__ by `Frank D `__) 0.14.2 (2017-03-23): - fix for old default pip on Ubuntu 14.04 (reported by Sébastien Maccagnoni-Munch) 0.14.1 (2017-03-22): - fix Text not available on 3.5.0 and 3.5.1 (reported by Charles Bouchard-Légaré) 0.14.0 (2017-03-21): - updates for mypy --strict - preparation for moving away from inheritance in Loader and Dumper, calls from e.g. the Representer to the Serializer.serialize() are now done via the attribute .serializer.serialize(). Usage of .serialize() outside of Serializer will be deprecated soon - some extra tests on main.py functions ---- For older changes see the file `CHANGES `_ ruamel.yaml-0.15.89/configobjwalker.py0000664000175100001440000000052613373303256020325 0ustar anthonusers00000000000000# coding: utf-8 import warnings from ruamel.yaml.util import configobj_walker as new_configobj_walker if False: # MYPY from typing import Any # NOQA def configobj_walker(cfg): # type: (Any) -> Any warnings.warn('configobj_walker has moved to ruamel.yaml.util, please update your code') return new_configobj_walker(cfg) ruamel.yaml-0.15.89/dumper.py0000664000175100001440000001474113373303256016457 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import from ruamel.yaml.emitter import Emitter from ruamel.yaml.serializer import Serializer from ruamel.yaml.representer import ( Representer, SafeRepresenter, BaseRepresenter, RoundTripRepresenter, ) from ruamel.yaml.resolver import Resolver, BaseResolver, VersionedResolver if False: # MYPY from typing import Any, Dict, List, Union, Optional # NOQA from ruamel.yaml.compat import StreamType, VersionType # NOQA __all__ = ['BaseDumper', 'SafeDumper', 'Dumper', 'RoundTripDumper'] class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (Any, StreamType, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA Emitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, block_seq_indent=block_seq_indent, dumper=self, ) Serializer.__init__( self, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, dumper=self, ) BaseRepresenter.__init__( self, default_style=default_style, default_flow_style=default_flow_style, dumper=self, ) BaseResolver.__init__(self, loadumper=self) class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA Emitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, block_seq_indent=block_seq_indent, dumper=self, ) Serializer.__init__( self, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, dumper=self, ) SafeRepresenter.__init__( self, default_style=default_style, default_flow_style=default_flow_style, dumper=self, ) Resolver.__init__(self, loadumper=self) class Dumper(Emitter, Serializer, Representer, Resolver): def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA Emitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, block_seq_indent=block_seq_indent, dumper=self, ) Serializer.__init__( self, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, dumper=self, ) Representer.__init__( self, default_style=default_style, default_flow_style=default_flow_style, dumper=self, ) Resolver.__init__(self, loadumper=self) class RoundTripDumper(Emitter, Serializer, RoundTripRepresenter, VersionedResolver): def __init__( self, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Optional[bool], Optional[int], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA Emitter.__init__( self, stream, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, block_seq_indent=block_seq_indent, top_level_colon_align=top_level_colon_align, prefix_colon=prefix_colon, dumper=self, ) Serializer.__init__( self, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, dumper=self, ) RoundTripRepresenter.__init__( self, default_style=default_style, default_flow_style=default_flow_style, dumper=self, ) VersionedResolver.__init__(self, loader=self) ruamel.yaml-0.15.89/nodes.py0000664000175100001440000000720413376725641016300 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function import sys from .compat import string_types if False: # MYPY from typing import Dict, Any, Text # NOQA class Node(object): __slots__ = 'tag', 'value', 'start_mark', 'end_mark', 'comment', 'anchor' def __init__(self, tag, value, start_mark, end_mark, comment=None, anchor=None): # type: (Any, Any, Any, Any, Any, Any) -> None self.tag = tag self.value = value self.start_mark = start_mark self.end_mark = end_mark self.comment = comment self.anchor = anchor def __repr__(self): # type: () -> str value = self.value # if isinstance(value, list): # if len(value) == 0: # value = '' # elif len(value) == 1: # value = '<1 item>' # else: # value = '<%d items>' % len(value) # else: # if len(value) > 75: # value = repr(value[:70]+u' ... ') # else: # value = repr(value) value = repr(value) return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) def dump(self, indent=0): # type: (int) -> None if isinstance(self.value, string_types): sys.stdout.write( '{}{}(tag={!r}, value={!r})\n'.format( ' ' * indent, self.__class__.__name__, self.tag, self.value ) ) if self.comment: sys.stdout.write(' {}comment: {})\n'.format(' ' * indent, self.comment)) return sys.stdout.write( '{}{}(tag={!r})\n'.format(' ' * indent, self.__class__.__name__, self.tag) ) if self.comment: sys.stdout.write(' {}comment: {})\n'.format(' ' * indent, self.comment)) for v in self.value: if isinstance(v, tuple): for v1 in v: v1.dump(indent + 1) elif isinstance(v, Node): v.dump(indent + 1) else: sys.stdout.write('Node value type? {}\n'.format(type(v))) class ScalarNode(Node): """ styles: ? -> set() ? key, no value " -> double quoted ' -> single quoted | -> literal style > -> folding style """ __slots__ = ('style',) id = 'scalar' def __init__( self, tag, value, start_mark=None, end_mark=None, style=None, comment=None, anchor=None ): # type: (Any, Any, Any, Any, Any, Any, Any) -> None Node.__init__(self, tag, value, start_mark, end_mark, comment=comment, anchor=anchor) self.style = style class CollectionNode(Node): __slots__ = ('flow_style',) def __init__( self, tag, value, start_mark=None, end_mark=None, flow_style=None, comment=None, anchor=None, ): # type: (Any, Any, Any, Any, Any, Any, Any) -> None Node.__init__(self, tag, value, start_mark, end_mark, comment=comment) self.flow_style = flow_style self.anchor = anchor class SequenceNode(CollectionNode): __slots__ = () id = 'sequence' class MappingNode(CollectionNode): __slots__ = ('merge',) id = 'mapping' def __init__( self, tag, value, start_mark=None, end_mark=None, flow_style=None, comment=None, anchor=None, ): # type: (Any, Any, Any, Any, Any, Any, Any) -> None CollectionNode.__init__( self, tag, value, start_mark, end_mark, flow_style, comment, anchor ) self.merge = None ruamel.yaml-0.15.89/ext/0000775000175100001440000000000013435603756015411 5ustar anthonusers00000000000000ruamel.yaml-0.15.89/ext/_ruamel_yaml.pxd0000664000175100001440000002165013037504357020573 0ustar anthonusers00000000000000 cdef extern from "_ruamel_yaml.h": void malloc(int l) void memcpy(char *d, char *s, int l) int strlen(char *s) int PyString_CheckExact(object o) int PyUnicode_CheckExact(object o) char *PyString_AS_STRING(object o) int PyString_GET_SIZE(object o) object PyString_FromStringAndSize(char *v, int l) object PyUnicode_FromString(char *u) object PyUnicode_DecodeUTF8(char *u, int s, char *e) object PyUnicode_AsUTF8String(object o) int PY_MAJOR_VERSION ctypedef enum: SIZEOF_VOID_P ctypedef enum yaml_encoding_t: YAML_ANY_ENCODING YAML_UTF8_ENCODING YAML_UTF16LE_ENCODING YAML_UTF16BE_ENCODING ctypedef enum yaml_break_t: YAML_ANY_BREAK YAML_CR_BREAK YAML_LN_BREAK YAML_CRLN_BREAK ctypedef enum yaml_error_type_t: YAML_NO_ERROR YAML_MEMORY_ERROR YAML_READER_ERROR YAML_SCANNER_ERROR YAML_PARSER_ERROR YAML_WRITER_ERROR YAML_EMITTER_ERROR ctypedef enum yaml_scalar_style_t: YAML_ANY_SCALAR_STYLE YAML_PLAIN_SCALAR_STYLE YAML_SINGLE_QUOTED_SCALAR_STYLE YAML_DOUBLE_QUOTED_SCALAR_STYLE YAML_LITERAL_SCALAR_STYLE YAML_FOLDED_SCALAR_STYLE ctypedef enum yaml_sequence_style_t: YAML_ANY_SEQUENCE_STYLE YAML_BLOCK_SEQUENCE_STYLE YAML_FLOW_SEQUENCE_STYLE ctypedef enum yaml_mapping_style_t: YAML_ANY_MAPPING_STYLE YAML_BLOCK_MAPPING_STYLE YAML_FLOW_MAPPING_STYLE ctypedef enum yaml_token_type_t: YAML_NO_TOKEN YAML_STREAM_START_TOKEN YAML_STREAM_END_TOKEN YAML_VERSION_DIRECTIVE_TOKEN YAML_TAG_DIRECTIVE_TOKEN YAML_DOCUMENT_START_TOKEN YAML_DOCUMENT_END_TOKEN YAML_BLOCK_SEQUENCE_START_TOKEN YAML_BLOCK_MAPPING_START_TOKEN YAML_BLOCK_END_TOKEN YAML_FLOW_SEQUENCE_START_TOKEN YAML_FLOW_SEQUENCE_END_TOKEN YAML_FLOW_MAPPING_START_TOKEN YAML_FLOW_MAPPING_END_TOKEN YAML_BLOCK_ENTRY_TOKEN YAML_FLOW_ENTRY_TOKEN YAML_KEY_TOKEN YAML_VALUE_TOKEN YAML_ALIAS_TOKEN YAML_ANCHOR_TOKEN YAML_TAG_TOKEN YAML_SCALAR_TOKEN ctypedef enum yaml_event_type_t: YAML_NO_EVENT YAML_STREAM_START_EVENT YAML_STREAM_END_EVENT YAML_DOCUMENT_START_EVENT YAML_DOCUMENT_END_EVENT YAML_ALIAS_EVENT YAML_SCALAR_EVENT YAML_SEQUENCE_START_EVENT YAML_SEQUENCE_END_EVENT YAML_MAPPING_START_EVENT YAML_MAPPING_END_EVENT ctypedef int yaml_read_handler_t(void *data, char *buffer, int size, int *size_read) except 0 ctypedef int yaml_write_handler_t(void *data, char *buffer, int size) except 0 ctypedef struct yaml_mark_t: int index int line int column ctypedef struct yaml_version_directive_t: int major int minor ctypedef struct yaml_tag_directive_t: char *handle char *prefix ctypedef struct _yaml_token_stream_start_data_t: yaml_encoding_t encoding ctypedef struct _yaml_token_alias_data_t: char *value ctypedef struct _yaml_token_anchor_data_t: char *value ctypedef struct _yaml_token_tag_data_t: char *handle char *suffix ctypedef struct _yaml_token_scalar_data_t: char *value int length yaml_scalar_style_t style ctypedef struct _yaml_token_version_directive_data_t: int major int minor ctypedef struct _yaml_token_tag_directive_data_t: char *handle char *prefix ctypedef union _yaml_token_data_t: _yaml_token_stream_start_data_t stream_start _yaml_token_alias_data_t alias _yaml_token_anchor_data_t anchor _yaml_token_tag_data_t tag _yaml_token_scalar_data_t scalar _yaml_token_version_directive_data_t version_directive _yaml_token_tag_directive_data_t tag_directive ctypedef struct yaml_token_t: yaml_token_type_t type _yaml_token_data_t data yaml_mark_t start_mark yaml_mark_t end_mark ctypedef struct _yaml_event_stream_start_data_t: yaml_encoding_t encoding ctypedef struct _yaml_event_document_start_data_tag_directives_t: yaml_tag_directive_t *start yaml_tag_directive_t *end ctypedef struct _yaml_event_document_start_data_t: yaml_version_directive_t *version_directive _yaml_event_document_start_data_tag_directives_t tag_directives int implicit ctypedef struct _yaml_event_document_end_data_t: int implicit ctypedef struct _yaml_event_alias_data_t: char *anchor ctypedef struct _yaml_event_scalar_data_t: char *anchor char *tag char *value int length int plain_implicit int quoted_implicit yaml_scalar_style_t style ctypedef struct _yaml_event_sequence_start_data_t: char *anchor char *tag int implicit yaml_sequence_style_t style ctypedef struct _yaml_event_mapping_start_data_t: char *anchor char *tag int implicit yaml_mapping_style_t style ctypedef union _yaml_event_data_t: _yaml_event_stream_start_data_t stream_start _yaml_event_document_start_data_t document_start _yaml_event_document_end_data_t document_end _yaml_event_alias_data_t alias _yaml_event_scalar_data_t scalar _yaml_event_sequence_start_data_t sequence_start _yaml_event_mapping_start_data_t mapping_start ctypedef struct yaml_event_t: yaml_event_type_t type _yaml_event_data_t data yaml_mark_t start_mark yaml_mark_t end_mark ctypedef struct yaml_parser_t: yaml_error_type_t error char *problem int problem_offset int problem_value yaml_mark_t problem_mark char *context yaml_mark_t context_mark ctypedef struct yaml_emitter_t: yaml_error_type_t error char *problem char *yaml_get_version_string() void yaml_get_version(int *major, int *minor, int *patch) void yaml_token_delete(yaml_token_t *token) int yaml_stream_start_event_initialize(yaml_event_t *event, yaml_encoding_t encoding) int yaml_stream_end_event_initialize(yaml_event_t *event) int yaml_document_start_event_initialize(yaml_event_t *event, yaml_version_directive_t *version_directive, yaml_tag_directive_t *tag_directives_start, yaml_tag_directive_t *tag_directives_end, int implicit) int yaml_document_end_event_initialize(yaml_event_t *event, int implicit) int yaml_alias_event_initialize(yaml_event_t *event, char *anchor) int yaml_scalar_event_initialize(yaml_event_t *event, char *anchor, char *tag, char *value, int length, int plain_implicit, int quoted_implicit, yaml_scalar_style_t style) int yaml_sequence_start_event_initialize(yaml_event_t *event, char *anchor, char *tag, int implicit, yaml_sequence_style_t style) int yaml_sequence_end_event_initialize(yaml_event_t *event) int yaml_mapping_start_event_initialize(yaml_event_t *event, char *anchor, char *tag, int implicit, yaml_mapping_style_t style) int yaml_mapping_end_event_initialize(yaml_event_t *event) void yaml_event_delete(yaml_event_t *event) int yaml_parser_initialize(yaml_parser_t *parser) void yaml_parser_delete(yaml_parser_t *parser) void yaml_parser_set_input_string(yaml_parser_t *parser, char *input, int size) void yaml_parser_set_input(yaml_parser_t *parser, yaml_read_handler_t *handler, void *data) void yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding) int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) except * int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) except * int yaml_emitter_initialize(yaml_emitter_t *emitter) void yaml_emitter_delete(yaml_emitter_t *emitter) void yaml_emitter_set_output_string(yaml_emitter_t *emitter, char *output, int size, int *size_written) void yaml_emitter_set_output(yaml_emitter_t *emitter, yaml_write_handler_t *handler, void *data) void yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding) void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent) void yaml_emitter_set_width(yaml_emitter_t *emitter, int width) void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) void yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break) int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) except * int yaml_emitter_flush(yaml_emitter_t *emitter) ruamel.yaml-0.15.89/ext/dumper.c0000664000175100001440000002352313351131445017042 0ustar anthonusers00000000000000 #include "yaml_private.h" /* * API functions. */ YAML_DECLARE(int) yaml_emitter_open(yaml_emitter_t *emitter); YAML_DECLARE(int) yaml_emitter_close(yaml_emitter_t *emitter); YAML_DECLARE(int) yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document); /* * Clean up functions. */ static void yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter); /* * Anchor functions. */ static void yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index); static yaml_char_t * yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id); /* * Serialize functions. */ static int yaml_emitter_dump_node(yaml_emitter_t *emitter, int index); static int yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor); static int yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node, yaml_char_t *anchor); static int yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node, yaml_char_t *anchor); static int yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node, yaml_char_t *anchor); /* * Issue a STREAM-START event. */ YAML_DECLARE(int) yaml_emitter_open(yaml_emitter_t *emitter) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; assert(emitter); /* Non-NULL emitter object is required. */ assert(!emitter->opened); /* Emitter should not be opened yet. */ STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark); if (!yaml_emitter_emit(emitter, &event)) { return 0; } emitter->opened = 1; return 1; } /* * Issue a STREAM-END event. */ YAML_DECLARE(int) yaml_emitter_close(yaml_emitter_t *emitter) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; assert(emitter); /* Non-NULL emitter object is required. */ assert(emitter->opened); /* Emitter should be opened. */ if (emitter->closed) return 1; STREAM_END_EVENT_INIT(event, mark, mark); if (!yaml_emitter_emit(emitter, &event)) { return 0; } emitter->closed = 1; return 1; } /* * Dump a YAML document. */ YAML_DECLARE(int) yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; assert(emitter); /* Non-NULL emitter object is required. */ assert(document); /* Non-NULL emitter object is expected. */ emitter->document = document; if (!emitter->opened) { if (!yaml_emitter_open(emitter)) goto error; } if (STACK_EMPTY(emitter, document->nodes)) { if (!yaml_emitter_close(emitter)) goto error; yaml_emitter_delete_document_and_anchors(emitter); return 1; } assert(emitter->opened); /* Emitter should be opened. */ emitter->anchors = (yaml_anchors_t*)yaml_malloc(sizeof(*(emitter->anchors)) * (document->nodes.top - document->nodes.start)); if (!emitter->anchors) goto error; memset(emitter->anchors, 0, sizeof(*(emitter->anchors)) * (document->nodes.top - document->nodes.start)); DOCUMENT_START_EVENT_INIT(event, document->version_directive, document->tag_directives.start, document->tag_directives.end, document->start_implicit, mark, mark); if (!yaml_emitter_emit(emitter, &event)) goto error; yaml_emitter_anchor_node(emitter, 1); if (!yaml_emitter_dump_node(emitter, 1)) goto error; DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark); if (!yaml_emitter_emit(emitter, &event)) goto error; yaml_emitter_delete_document_and_anchors(emitter); return 1; error: yaml_emitter_delete_document_and_anchors(emitter); return 0; } /* * Clean up the emitter object after a document is dumped. */ static void yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter) { int index; if (!emitter->anchors) { yaml_document_delete(emitter->document); emitter->document = NULL; return; } for (index = 0; emitter->document->nodes.start + index < emitter->document->nodes.top; index ++) { yaml_node_t node = emitter->document->nodes.start[index]; if (!emitter->anchors[index].serialized) { yaml_free(node.tag); if (node.type == YAML_SCALAR_NODE) { yaml_free(node.data.scalar.value); } } if (node.type == YAML_SEQUENCE_NODE) { STACK_DEL(emitter, node.data.sequence.items); } if (node.type == YAML_MAPPING_NODE) { STACK_DEL(emitter, node.data.mapping.pairs); } } STACK_DEL(emitter, emitter->document->nodes); yaml_free(emitter->anchors); emitter->anchors = NULL; emitter->last_anchor_id = 0; emitter->document = NULL; } /* * Check the references of a node and assign the anchor id if needed. */ static void yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index) { yaml_node_t *node = emitter->document->nodes.start + index - 1; yaml_node_item_t *item; yaml_node_pair_t *pair; emitter->anchors[index-1].references ++; if (emitter->anchors[index-1].references == 1) { switch (node->type) { case YAML_SEQUENCE_NODE: for (item = node->data.sequence.items.start; item < node->data.sequence.items.top; item ++) { yaml_emitter_anchor_node(emitter, *item); } break; case YAML_MAPPING_NODE: for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair ++) { yaml_emitter_anchor_node(emitter, pair->key); yaml_emitter_anchor_node(emitter, pair->value); } break; default: break; } } else if (emitter->anchors[index-1].references == 2) { emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id); } } /* * Generate a textual representation for an anchor. */ #define ANCHOR_TEMPLATE "id%03d" #define ANCHOR_TEMPLATE_LENGTH 16 static yaml_char_t * yaml_emitter_generate_anchor(SHIM(yaml_emitter_t *emitter), int anchor_id) { yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH); if (!anchor) return NULL; sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id); return anchor; } /* * Serialize a node. */ static int yaml_emitter_dump_node(yaml_emitter_t *emitter, int index) { yaml_node_t *node = emitter->document->nodes.start + index - 1; int anchor_id = emitter->anchors[index-1].anchor; yaml_char_t *anchor = NULL; if (anchor_id) { anchor = yaml_emitter_generate_anchor(emitter, anchor_id); if (!anchor) return 0; } if (emitter->anchors[index-1].serialized) { return yaml_emitter_dump_alias(emitter, anchor); } emitter->anchors[index-1].serialized = 1; switch (node->type) { case YAML_SCALAR_NODE: return yaml_emitter_dump_scalar(emitter, node, anchor); case YAML_SEQUENCE_NODE: return yaml_emitter_dump_sequence(emitter, node, anchor); case YAML_MAPPING_NODE: return yaml_emitter_dump_mapping(emitter, node, anchor); default: assert(0); /* Could not happen. */ break; } return 0; /* Could not happen. */ } /* * Serialize an alias. */ static int yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; ALIAS_EVENT_INIT(event, anchor, mark, mark); return yaml_emitter_emit(emitter, &event); } /* * Serialize a scalar. */ static int yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node, yaml_char_t *anchor) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; int plain_implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SCALAR_TAG) == 0); int quoted_implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SCALAR_TAG) == 0); SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value, node->data.scalar.length, plain_implicit, quoted_implicit, node->data.scalar.style, mark, mark); return yaml_emitter_emit(emitter, &event); } /* * Serialize a sequence. */ static int yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node, yaml_char_t *anchor) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0); yaml_node_item_t *item; SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit, node->data.sequence.style, mark, mark); if (!yaml_emitter_emit(emitter, &event)) return 0; for (item = node->data.sequence.items.start; item < node->data.sequence.items.top; item ++) { if (!yaml_emitter_dump_node(emitter, *item)) return 0; } SEQUENCE_END_EVENT_INIT(event, mark, mark); if (!yaml_emitter_emit(emitter, &event)) return 0; return 1; } /* * Serialize a mapping. */ static int yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node, yaml_char_t *anchor) { yaml_event_t event; yaml_mark_t mark = { 0, 0, 0 }; int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0); yaml_node_pair_t *pair; MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit, node->data.mapping.style, mark, mark); if (!yaml_emitter_emit(emitter, &event)) return 0; for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair ++) { if (!yaml_emitter_dump_node(emitter, pair->key)) return 0; if (!yaml_emitter_dump_node(emitter, pair->value)) return 0; } MAPPING_END_EVENT_INIT(event, mark, mark); if (!yaml_emitter_emit(emitter, &event)) return 0; return 1; } ruamel.yaml-0.15.89/ext/_ruamel_yaml.h0000664000175100001440000000073413037504357020227 0ustar anthonusers00000000000000 #include "yaml.h" #if PY_MAJOR_VERSION < 3 #define PyUnicode_FromString(s) PyUnicode_DecodeUTF8((s), strlen(s), "strict") #else #define PyString_CheckExact PyBytes_CheckExact #define PyString_AS_STRING PyBytes_AS_STRING #define PyString_GET_SIZE PyBytes_GET_SIZE #define PyString_FromStringAndSize PyBytes_FromStringAndSize #endif #ifdef _MSC_VER /* MS Visual C++ 6.0 */ #if _MSC_VER == 1200 #define PyLong_FromUnsignedLongLong(z) PyInt_FromLong(i) #endif #endif ruamel.yaml-0.15.89/ext/_ruamel_yaml.pyx0000664000175100001440000017643113070654661020631 0ustar anthonusers00000000000000 def get_version_string(): cdef char *value value = yaml_get_version_string() if PY_MAJOR_VERSION < 3: return value else: return PyUnicode_FromString(value) def get_version(): cdef int major, minor, patch yaml_get_version(&major, &minor, &patch) return (major, minor, patch) #Mark = yaml.error.Mark from ruamel.yaml.error import YAMLError from ruamel.yaml.reader import ReaderError from ruamel.yaml.scanner import ScannerError from ruamel.yaml.parser import ParserError from ruamel.yaml.composer import ComposerError from ruamel.yaml.constructor import ConstructorError from ruamel.yaml.emitter import EmitterError from ruamel.yaml.serializer import SerializerError from ruamel.yaml.representer import RepresenterError from ruamel.yaml.tokens import StreamStartToken from ruamel.yaml.tokens import StreamEndToken from ruamel.yaml.tokens import DirectiveToken from ruamel.yaml.tokens import DocumentStartToken from ruamel.yaml.tokens import DocumentEndToken from ruamel.yaml.tokens import BlockSequenceStartToken from ruamel.yaml.tokens import BlockMappingStartToken from ruamel.yaml.tokens import BlockEndToken from ruamel.yaml.tokens import FlowSequenceStartToken from ruamel.yaml.tokens import FlowMappingStartToken from ruamel.yaml.tokens import FlowSequenceEndToken from ruamel.yaml.tokens import FlowMappingEndToken from ruamel.yaml.tokens import KeyToken from ruamel.yaml.tokens import ValueToken from ruamel.yaml.tokens import BlockEntryToken from ruamel.yaml.tokens import FlowEntryToken from ruamel.yaml.tokens import AliasToken from ruamel.yaml.tokens import AnchorToken from ruamel.yaml.tokens import TagToken from ruamel.yaml.tokens import ScalarToken from ruamel.yaml.events import StreamStartEvent from ruamel.yaml.events import StreamEndEvent from ruamel.yaml.events import DocumentStartEvent from ruamel.yaml.events import DocumentEndEvent from ruamel.yaml.events import AliasEvent from ruamel.yaml.events import ScalarEvent from ruamel.yaml.events import SequenceStartEvent from ruamel.yaml.events import SequenceEndEvent from ruamel.yaml.events import MappingStartEvent from ruamel.yaml.events import MappingEndEvent from ruamel.yaml.nodes import ScalarNode from ruamel.yaml.nodes import SequenceNode from ruamel.yaml.nodes import MappingNode cdef class Mark: cdef readonly object name cdef readonly int index cdef readonly int line cdef readonly int column cdef readonly buffer cdef readonly pointer def __init__(self, object name, int index, int line, int column, object buffer, object pointer): self.name = name self.index = index self.line = line self.column = column self.buffer = buffer self.pointer = pointer def get_snippet(self): return None def __str__(self): where = " in \"%s\", line %d, column %d" \ % (self.name, self.line+1, self.column+1) return where #class YAMLError(Exception): # pass # #class MarkedYAMLError(YAMLError): # # def __init__(self, context=None, context_mark=None, # problem=None, problem_mark=None, note=None): # self.context = context # self.context_mark = context_mark # self.problem = problem # self.problem_mark = problem_mark # self.note = note # # def __str__(self): # lines = [] # if self.context is not None: # lines.append(self.context) # if self.context_mark is not None \ # and (self.problem is None or self.problem_mark is None # or self.context_mark.name != self.problem_mark.name # or self.context_mark.line != self.problem_mark.line # or self.context_mark.column != self.problem_mark.column): # lines.append(str(self.context_mark)) # if self.problem is not None: # lines.append(self.problem) # if self.problem_mark is not None: # lines.append(str(self.problem_mark)) # if self.note is not None: # lines.append(self.note) # return '\n'.join(lines) # #class ReaderError(YAMLError): # # def __init__(self, name, position, character, encoding, reason): # self.name = name # self.character = character # self.position = position # self.encoding = encoding # self.reason = reason # # def __str__(self): # if isinstance(self.character, str): # return "'%s' codec can't decode byte #x%02x: %s\n" \ # " in \"%s\", position %d" \ # % (self.encoding, ord(self.character), self.reason, # self.name, self.position) # else: # return "unacceptable character #x%04x: %s\n" \ # " in \"%s\", position %d" \ # % (ord(self.character), self.reason, # self.name, self.position) # #class ScannerError(MarkedYAMLError): # pass # #class ParserError(MarkedYAMLError): # pass # #class EmitterError(YAMLError): # pass # #cdef class Token: # cdef readonly Mark start_mark # cdef readonly Mark end_mark # def __init__(self, Mark start_mark, Mark end_mark): # self.start_mark = start_mark # self.end_mark = end_mark # #cdef class StreamStartToken(Token): # cdef readonly object encoding # def __init__(self, Mark start_mark, Mark end_mark, encoding): # self.start_mark = start_mark # self.end_mark = end_mark # self.encoding = encoding # #cdef class StreamEndToken(Token): # pass # #cdef class DirectiveToken(Token): # cdef readonly object name # cdef readonly object value # def __init__(self, name, value, Mark start_mark, Mark end_mark): # self.name = name # self.value = value # self.start_mark = start_mark # self.end_mark = end_mark # #cdef class DocumentStartToken(Token): # pass # #cdef class DocumentEndToken(Token): # pass # #cdef class BlockSequenceStartToken(Token): # pass # #cdef class BlockMappingStartToken(Token): # pass # #cdef class BlockEndToken(Token): # pass # #cdef class FlowSequenceStartToken(Token): # pass # #cdef class FlowMappingStartToken(Token): # pass # #cdef class FlowSequenceEndToken(Token): # pass # #cdef class FlowMappingEndToken(Token): # pass # #cdef class KeyToken(Token): # pass # #cdef class ValueToken(Token): # pass # #cdef class BlockEntryToken(Token): # pass # #cdef class FlowEntryToken(Token): # pass # #cdef class AliasToken(Token): # cdef readonly object value # def __init__(self, value, Mark start_mark, Mark end_mark): # self.value = value # self.start_mark = start_mark # self.end_mark = end_mark # #cdef class AnchorToken(Token): # cdef readonly object value # def __init__(self, value, Mark start_mark, Mark end_mark): # self.value = value # self.start_mark = start_mark # self.end_mark = end_mark # #cdef class TagToken(Token): # cdef readonly object value # def __init__(self, value, Mark start_mark, Mark end_mark): # self.value = value # self.start_mark = start_mark # self.end_mark = end_mark # #cdef class ScalarToken(Token): # cdef readonly object value # cdef readonly object plain # cdef readonly object style # def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None): # self.value = value # self.plain = plain # self.start_mark = start_mark # self.end_mark = end_mark # self.style = style cdef class CParser: cdef yaml_parser_t parser cdef yaml_event_t parsed_event cdef object stream cdef object stream_name cdef object current_token cdef object current_event cdef object anchors cdef object stream_cache cdef int stream_cache_len cdef int stream_cache_pos cdef int unicode_source def __init__(self, stream): cdef is_readable if yaml_parser_initialize(&self.parser) == 0: raise MemoryError self.parsed_event.type = YAML_NO_EVENT is_readable = 1 try: stream.read except AttributeError: is_readable = 0 self.unicode_source = 0 if is_readable: self.stream = stream try: self.stream_name = stream.name except AttributeError: if PY_MAJOR_VERSION < 3: self.stream_name = '' else: self.stream_name = u'' self.stream_cache = None self.stream_cache_len = 0 self.stream_cache_pos = 0 yaml_parser_set_input(&self.parser, input_handler, self) else: if PyUnicode_CheckExact(stream) != 0: stream = PyUnicode_AsUTF8String(stream) if PY_MAJOR_VERSION < 3: self.stream_name = '' else: self.stream_name = u'' self.unicode_source = 1 else: if PY_MAJOR_VERSION < 3: self.stream_name = '' else: self.stream_name = u'' if PyString_CheckExact(stream) == 0: if PY_MAJOR_VERSION < 3: raise TypeError("a string or stream input is required") else: raise TypeError(u"a string or stream input is required") self.stream = stream yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) self.current_token = None self.current_event = None self.anchors = {} def __dealloc__(self): yaml_parser_delete(&self.parser) yaml_event_delete(&self.parsed_event) def dispose(self): pass cdef object _parser_error(self): if self.parser.error == YAML_MEMORY_ERROR: return MemoryError elif self.parser.error == YAML_READER_ERROR: if PY_MAJOR_VERSION < 3: return ReaderError(self.stream_name, self.parser.problem_offset, self.parser.problem_value, '?', self.parser.problem) else: return ReaderError(self.stream_name, self.parser.problem_offset, self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) elif self.parser.error == YAML_SCANNER_ERROR \ or self.parser.error == YAML_PARSER_ERROR: context_mark = None problem_mark = None if self.parser.context != NULL: context_mark = Mark(self.stream_name, self.parser.context_mark.index, self.parser.context_mark.line, self.parser.context_mark.column, None, None) if self.parser.problem != NULL: problem_mark = Mark(self.stream_name, self.parser.problem_mark.index, self.parser.problem_mark.line, self.parser.problem_mark.column, None, None) context = None if self.parser.context != NULL: if PY_MAJOR_VERSION < 3: context = self.parser.context else: context = PyUnicode_FromString(self.parser.context) if PY_MAJOR_VERSION < 3: problem = self.parser.problem else: problem = PyUnicode_FromString(self.parser.problem) if self.parser.error == YAML_SCANNER_ERROR: return ScannerError(context, context_mark, problem, problem_mark) else: return ParserError(context, context_mark, problem, problem_mark) if PY_MAJOR_VERSION < 3: raise ValueError("no parser error") else: raise ValueError(u"no parser error") def raw_scan(self): cdef yaml_token_t token cdef int done cdef int count count = 0 done = 0 while done == 0: if yaml_parser_scan(&self.parser, &token) == 0: error = self._parser_error() raise error if token.type == YAML_NO_TOKEN: done = 1 else: count = count+1 yaml_token_delete(&token) return count cdef object _scan(self): cdef yaml_token_t token if yaml_parser_scan(&self.parser, &token) == 0: error = self._parser_error() raise error token_object = self._token_to_object(&token) yaml_token_delete(&token) return token_object cdef object _token_to_object(self, yaml_token_t *token): start_mark = Mark(self.stream_name, token.start_mark.index, token.start_mark.line, token.start_mark.column, None, None) end_mark = Mark(self.stream_name, token.end_mark.index, token.end_mark.line, token.end_mark.column, None, None) if token.type == YAML_NO_TOKEN: return None elif token.type == YAML_STREAM_START_TOKEN: encoding = None if token.data.stream_start.encoding == YAML_UTF8_ENCODING: if self.unicode_source == 0: encoding = u"utf-8" elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: encoding = u"utf-16-le" elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: encoding = u"utf-16-be" return StreamStartToken(start_mark, end_mark, encoding) elif token.type == YAML_STREAM_END_TOKEN: return StreamEndToken(start_mark, end_mark) elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: return DirectiveToken(u"YAML", (token.data.version_directive.major, token.data.version_directive.minor), start_mark, end_mark) elif token.type == YAML_TAG_DIRECTIVE_TOKEN: handle = PyUnicode_FromString(token.data.tag_directive.handle) prefix = PyUnicode_FromString(token.data.tag_directive.prefix) return DirectiveToken(u"TAG", (handle, prefix), start_mark, end_mark) elif token.type == YAML_DOCUMENT_START_TOKEN: return DocumentStartToken(start_mark, end_mark) elif token.type == YAML_DOCUMENT_END_TOKEN: return DocumentEndToken(start_mark, end_mark) elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: return BlockSequenceStartToken(start_mark, end_mark) elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: return BlockMappingStartToken(start_mark, end_mark) elif token.type == YAML_BLOCK_END_TOKEN: return BlockEndToken(start_mark, end_mark) elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: return FlowSequenceStartToken(start_mark, end_mark) elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: return FlowSequenceEndToken(start_mark, end_mark) elif token.type == YAML_FLOW_MAPPING_START_TOKEN: return FlowMappingStartToken(start_mark, end_mark) elif token.type == YAML_FLOW_MAPPING_END_TOKEN: return FlowMappingEndToken(start_mark, end_mark) elif token.type == YAML_BLOCK_ENTRY_TOKEN: return BlockEntryToken(start_mark, end_mark) elif token.type == YAML_FLOW_ENTRY_TOKEN: return FlowEntryToken(start_mark, end_mark) elif token.type == YAML_KEY_TOKEN: return KeyToken(start_mark, end_mark) elif token.type == YAML_VALUE_TOKEN: return ValueToken(start_mark, end_mark) elif token.type == YAML_ALIAS_TOKEN: value = PyUnicode_FromString(token.data.alias.value) return AliasToken(value, start_mark, end_mark) elif token.type == YAML_ANCHOR_TOKEN: value = PyUnicode_FromString(token.data.anchor.value) return AnchorToken(value, start_mark, end_mark) elif token.type == YAML_TAG_TOKEN: handle = PyUnicode_FromString(token.data.tag.handle) suffix = PyUnicode_FromString(token.data.tag.suffix) if not handle: handle = None return TagToken((handle, suffix), start_mark, end_mark) elif token.type == YAML_SCALAR_TOKEN: value = PyUnicode_DecodeUTF8(token.data.scalar.value, token.data.scalar.length, 'strict') plain = False style = None if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: plain = True style = u'' elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: style = u'\'' elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: style = u'"' elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: style = u'|' elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: style = u'>' return ScalarToken(value, plain, start_mark, end_mark, style) else: if PY_MAJOR_VERSION < 3: raise ValueError("unknown token type") else: raise ValueError(u"unknown token type") def get_token(self): if self.current_token is not None: value = self.current_token self.current_token = None else: value = self._scan() return value def peek_token(self): if self.current_token is None: self.current_token = self._scan() return self.current_token def check_token(self, *choices): if self.current_token is None: self.current_token = self._scan() if self.current_token is None: return False if not choices: return True token_class = self.current_token.__class__ for choice in choices: if token_class is choice: return True return False def raw_parse(self): cdef yaml_event_t event cdef int done cdef int count count = 0 done = 0 while done == 0: if yaml_parser_parse(&self.parser, &event) == 0: error = self._parser_error() raise error if event.type == YAML_NO_EVENT: done = 1 else: count = count+1 yaml_event_delete(&event) return count cdef object _parse(self): cdef yaml_event_t event if yaml_parser_parse(&self.parser, &event) == 0: error = self._parser_error() raise error event_object = self._event_to_object(&event) yaml_event_delete(&event) return event_object cdef object _event_to_object(self, yaml_event_t *event): cdef yaml_tag_directive_t *tag_directive start_mark = Mark(self.stream_name, event.start_mark.index, event.start_mark.line, event.start_mark.column, None, None) end_mark = Mark(self.stream_name, event.end_mark.index, event.end_mark.line, event.end_mark.column, None, None) if event.type == YAML_NO_EVENT: return None elif event.type == YAML_STREAM_START_EVENT: encoding = None if event.data.stream_start.encoding == YAML_UTF8_ENCODING: if self.unicode_source == 0: encoding = u"utf-8" elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: encoding = u"utf-16-le" elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: encoding = u"utf-16-be" return StreamStartEvent(start_mark, end_mark, encoding) elif event.type == YAML_STREAM_END_EVENT: return StreamEndEvent(start_mark, end_mark) elif event.type == YAML_DOCUMENT_START_EVENT: explicit = False if event.data.document_start.implicit == 0: explicit = True version = None if event.data.document_start.version_directive != NULL: version = (event.data.document_start.version_directive.major, event.data.document_start.version_directive.minor) tags = None if event.data.document_start.tag_directives.start != NULL: tags = {} tag_directive = event.data.document_start.tag_directives.start while tag_directive != event.data.document_start.tag_directives.end: handle = PyUnicode_FromString(tag_directive.handle) prefix = PyUnicode_FromString(tag_directive.prefix) tags[handle] = prefix tag_directive = tag_directive+1 return DocumentStartEvent(start_mark, end_mark, explicit, version, tags) elif event.type == YAML_DOCUMENT_END_EVENT: explicit = False if event.data.document_end.implicit == 0: explicit = True return DocumentEndEvent(start_mark, end_mark, explicit) elif event.type == YAML_ALIAS_EVENT: anchor = PyUnicode_FromString(event.data.alias.anchor) return AliasEvent(anchor, start_mark, end_mark) elif event.type == YAML_SCALAR_EVENT: anchor = None if event.data.scalar.anchor != NULL: anchor = PyUnicode_FromString(event.data.scalar.anchor) tag = None if event.data.scalar.tag != NULL: tag = PyUnicode_FromString(event.data.scalar.tag) value = PyUnicode_DecodeUTF8(event.data.scalar.value, event.data.scalar.length, 'strict') plain_implicit = False if event.data.scalar.plain_implicit == 1: plain_implicit = True quoted_implicit = False if event.data.scalar.quoted_implicit == 1: quoted_implicit = True style = None if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: style = u'' elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: style = u'\'' elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: style = u'"' elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: style = u'|' elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: style = u'>' return ScalarEvent(anchor, tag, (plain_implicit, quoted_implicit), value, start_mark, end_mark, style) elif event.type == YAML_SEQUENCE_START_EVENT: anchor = None if event.data.sequence_start.anchor != NULL: anchor = PyUnicode_FromString(event.data.sequence_start.anchor) tag = None if event.data.sequence_start.tag != NULL: tag = PyUnicode_FromString(event.data.sequence_start.tag) implicit = False if event.data.sequence_start.implicit == 1: implicit = True flow_style = None if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: flow_style = True elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: flow_style = False return SequenceStartEvent(anchor, tag, implicit, start_mark, end_mark, flow_style) elif event.type == YAML_MAPPING_START_EVENT: anchor = None if event.data.mapping_start.anchor != NULL: anchor = PyUnicode_FromString(event.data.mapping_start.anchor) tag = None if event.data.mapping_start.tag != NULL: tag = PyUnicode_FromString(event.data.mapping_start.tag) implicit = False if event.data.mapping_start.implicit == 1: implicit = True flow_style = None if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: flow_style = True elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: flow_style = False return MappingStartEvent(anchor, tag, implicit, start_mark, end_mark, flow_style) elif event.type == YAML_SEQUENCE_END_EVENT: return SequenceEndEvent(start_mark, end_mark) elif event.type == YAML_MAPPING_END_EVENT: return MappingEndEvent(start_mark, end_mark) else: if PY_MAJOR_VERSION < 3: raise ValueError("unknown event type") else: raise ValueError(u"unknown event type") def get_event(self): if self.current_event is not None: value = self.current_event self.current_event = None else: value = self._parse() return value def peek_event(self): if self.current_event is None: self.current_event = self._parse() return self.current_event def check_event(self, *choices): if self.current_event is None: self.current_event = self._parse() if self.current_event is None: return False if not choices: return True event_class = self.current_event.__class__ for choice in choices: if event_class is choice: return True return False def check_node(self): self._parse_next_event() if self.parsed_event.type == YAML_STREAM_START_EVENT: yaml_event_delete(&self.parsed_event) self._parse_next_event() if self.parsed_event.type != YAML_STREAM_END_EVENT: return True return False def get_node(self): self._parse_next_event() if self.parsed_event.type != YAML_STREAM_END_EVENT: return self._compose_document() def get_single_node(self): self._parse_next_event() yaml_event_delete(&self.parsed_event) self._parse_next_event() document = None if self.parsed_event.type != YAML_STREAM_END_EVENT: document = self._compose_document() self._parse_next_event() if self.parsed_event.type != YAML_STREAM_END_EVENT: mark = Mark(self.stream_name, self.parsed_event.start_mark.index, self.parsed_event.start_mark.line, self.parsed_event.start_mark.column, None, None) if PY_MAJOR_VERSION < 3: raise ComposerError("expected a single document in the stream", document.start_mark, "but found another document", mark) else: raise ComposerError(u"expected a single document in the stream", document.start_mark, u"but found another document", mark) return document cdef object _compose_document(self): yaml_event_delete(&self.parsed_event) node = self._compose_node(None, None) self._parse_next_event() yaml_event_delete(&self.parsed_event) self.anchors = {} return node cdef object _compose_node(self, object parent, object index): self._parse_next_event() if self.parsed_event.type == YAML_ALIAS_EVENT: anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) if anchor not in self.anchors: mark = Mark(self.stream_name, self.parsed_event.start_mark.index, self.parsed_event.start_mark.line, self.parsed_event.start_mark.column, None, None) if PY_MAJOR_VERSION < 3: raise ComposerError(None, None, "found undefined alias", mark) else: raise ComposerError(None, None, u"found undefined alias", mark) yaml_event_delete(&self.parsed_event) return self.anchors[anchor] anchor = None if self.parsed_event.type == YAML_SCALAR_EVENT \ and self.parsed_event.data.scalar.anchor != NULL: anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ and self.parsed_event.data.sequence_start.anchor != NULL: anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ and self.parsed_event.data.mapping_start.anchor != NULL: anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) if anchor is not None: if anchor in self.anchors: mark = Mark(self.stream_name, self.parsed_event.start_mark.index, self.parsed_event.start_mark.line, self.parsed_event.start_mark.column, None, None) if PY_MAJOR_VERSION < 3: raise ComposerError("found duplicate anchor; first occurrence", self.anchors[anchor].start_mark, "second occurrence", mark) else: raise ComposerError(u"found duplicate anchor; first occurrence", self.anchors[anchor].start_mark, u"second occurrence", mark) self.descend_resolver(parent, index) if self.parsed_event.type == YAML_SCALAR_EVENT: node = self._compose_scalar_node(anchor) elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: node = self._compose_sequence_node(anchor) elif self.parsed_event.type == YAML_MAPPING_START_EVENT: node = self._compose_mapping_node(anchor) self.ascend_resolver() return node cdef _compose_scalar_node(self, object anchor): start_mark = Mark(self.stream_name, self.parsed_event.start_mark.index, self.parsed_event.start_mark.line, self.parsed_event.start_mark.column, None, None) end_mark = Mark(self.stream_name, self.parsed_event.end_mark.index, self.parsed_event.end_mark.line, self.parsed_event.end_mark.column, None, None) value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value, self.parsed_event.data.scalar.length, 'strict') plain_implicit = False if self.parsed_event.data.scalar.plain_implicit == 1: plain_implicit = True quoted_implicit = False if self.parsed_event.data.scalar.quoted_implicit == 1: quoted_implicit = True if self.parsed_event.data.scalar.tag == NULL \ or (self.parsed_event.data.scalar.tag[0] == c'!' and self.parsed_event.data.scalar.tag[1] == c'\0'): tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) else: tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) style = None if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: style = u'' elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: style = u'\'' elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: style = u'"' elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: style = u'|' elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: style = u'>' node = ScalarNode(tag, value, start_mark, end_mark, style) if anchor is not None: self.anchors[anchor] = node yaml_event_delete(&self.parsed_event) return node cdef _compose_sequence_node(self, object anchor): cdef int index start_mark = Mark(self.stream_name, self.parsed_event.start_mark.index, self.parsed_event.start_mark.line, self.parsed_event.start_mark.column, None, None) implicit = False if self.parsed_event.data.sequence_start.implicit == 1: implicit = True if self.parsed_event.data.sequence_start.tag == NULL \ or (self.parsed_event.data.sequence_start.tag[0] == c'!' and self.parsed_event.data.sequence_start.tag[1] == c'\0'): tag = self.resolve(SequenceNode, None, implicit) else: tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) flow_style = None if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: flow_style = True elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: flow_style = False value = [] node = SequenceNode(tag, value, start_mark, None, flow_style) if anchor is not None: self.anchors[anchor] = node yaml_event_delete(&self.parsed_event) index = 0 self._parse_next_event() while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: value.append(self._compose_node(node, index)) index = index+1 self._parse_next_event() node.end_mark = Mark(self.stream_name, self.parsed_event.end_mark.index, self.parsed_event.end_mark.line, self.parsed_event.end_mark.column, None, None) yaml_event_delete(&self.parsed_event) return node cdef _compose_mapping_node(self, object anchor): start_mark = Mark(self.stream_name, self.parsed_event.start_mark.index, self.parsed_event.start_mark.line, self.parsed_event.start_mark.column, None, None) implicit = False if self.parsed_event.data.mapping_start.implicit == 1: implicit = True if self.parsed_event.data.mapping_start.tag == NULL \ or (self.parsed_event.data.mapping_start.tag[0] == c'!' and self.parsed_event.data.mapping_start.tag[1] == c'\0'): tag = self.resolve(MappingNode, None, implicit) else: tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) flow_style = None if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: flow_style = True elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: flow_style = False value = [] node = MappingNode(tag, value, start_mark, None, flow_style) if anchor is not None: self.anchors[anchor] = node yaml_event_delete(&self.parsed_event) self._parse_next_event() while self.parsed_event.type != YAML_MAPPING_END_EVENT: item_key = self._compose_node(node, None) item_value = self._compose_node(node, item_key) value.append((item_key, item_value)) self._parse_next_event() node.end_mark = Mark(self.stream_name, self.parsed_event.end_mark.index, self.parsed_event.end_mark.line, self.parsed_event.end_mark.column, None, None) yaml_event_delete(&self.parsed_event) return node cdef int _parse_next_event(self) except 0: if self.parsed_event.type == YAML_NO_EVENT: if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: error = self._parser_error() raise error return 1 cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: cdef CParser parser parser = data if parser.stream_cache is None: value = parser.stream.read(size) if PyUnicode_CheckExact(value) != 0: value = PyUnicode_AsUTF8String(value) parser.unicode_source = 1 if PyString_CheckExact(value) == 0: if PY_MAJOR_VERSION < 3: raise TypeError("a string value is expected") else: raise TypeError(u"a string value is expected") parser.stream_cache = value parser.stream_cache_pos = 0 parser.stream_cache_len = PyString_GET_SIZE(value) if (parser.stream_cache_len - parser.stream_cache_pos) < size: size = parser.stream_cache_len - parser.stream_cache_pos if size > 0: memcpy(buffer, PyString_AS_STRING(parser.stream_cache) + parser.stream_cache_pos, size) read[0] = size parser.stream_cache_pos += size if parser.stream_cache_pos == parser.stream_cache_len: parser.stream_cache = None return 1 cdef class CEmitter: cdef yaml_emitter_t emitter cdef object stream cdef int document_start_implicit cdef int document_end_implicit cdef object use_version cdef object use_tags cdef object serialized_nodes cdef object anchors cdef int last_alias_id cdef int closed cdef int dump_unicode cdef object use_encoding def __init__(self, stream, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None): if yaml_emitter_initialize(&self.emitter) == 0: raise MemoryError self.stream = stream self.dump_unicode = 0 if PY_MAJOR_VERSION < 3: if getattr3(stream, 'encoding', None): self.dump_unicode = 1 else: if hasattr(stream, u'encoding'): self.dump_unicode = 1 self.use_encoding = encoding yaml_emitter_set_output(&self.emitter, output_handler, self) if canonical: yaml_emitter_set_canonical(&self.emitter, 1) if indent is not None: yaml_emitter_set_indent(&self.emitter, indent) if width is not None: yaml_emitter_set_width(&self.emitter, width) if allow_unicode: yaml_emitter_set_unicode(&self.emitter, 1) if line_break is not None: if line_break == '\r': yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) elif line_break == '\n': yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) elif line_break == '\r\n': yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) self.document_start_implicit = 1 if explicit_start: self.document_start_implicit = 0 self.document_end_implicit = 1 if explicit_end: self.document_end_implicit = 0 self.use_version = version self.use_tags = tags self.serialized_nodes = {} self.anchors = {} self.last_alias_id = 0 self.closed = -1 def __dealloc__(self): yaml_emitter_delete(&self.emitter) def dispose(self): pass cdef object _emitter_error(self): if self.emitter.error == YAML_MEMORY_ERROR: return MemoryError elif self.emitter.error == YAML_EMITTER_ERROR: if PY_MAJOR_VERSION < 3: problem = self.emitter.problem else: problem = PyUnicode_FromString(self.emitter.problem) return EmitterError(problem) if PY_MAJOR_VERSION < 3: raise ValueError("no emitter error") else: raise ValueError(u"no emitter error") cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: cdef yaml_encoding_t encoding cdef yaml_version_directive_t version_directive_value cdef yaml_version_directive_t *version_directive cdef yaml_tag_directive_t tag_directives_value[128] cdef yaml_tag_directive_t *tag_directives_start cdef yaml_tag_directive_t *tag_directives_end cdef int implicit cdef int plain_implicit cdef int quoted_implicit cdef char *anchor cdef char *tag cdef char *value cdef int length cdef yaml_scalar_style_t scalar_style cdef yaml_sequence_style_t sequence_style cdef yaml_mapping_style_t mapping_style event_class = event_object.__class__ if event_class is StreamStartEvent: encoding = YAML_UTF8_ENCODING if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': encoding = YAML_UTF16LE_ENCODING elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': encoding = YAML_UTF16BE_ENCODING if event_object.encoding is None: self.dump_unicode = 1 if self.dump_unicode == 1: encoding = YAML_UTF8_ENCODING yaml_stream_start_event_initialize(event, encoding) elif event_class is StreamEndEvent: yaml_stream_end_event_initialize(event) elif event_class is DocumentStartEvent: version_directive = NULL if event_object.version: version_directive_value.major = event_object.version[0] version_directive_value.minor = event_object.version[1] version_directive = &version_directive_value tag_directives_start = NULL tag_directives_end = NULL if event_object.tags: if len(event_object.tags) > 128: if PY_MAJOR_VERSION < 3: raise ValueError("too many tags") else: raise ValueError(u"too many tags") tag_directives_start = tag_directives_value tag_directives_end = tag_directives_value cache = [] for handle in event_object.tags: prefix = event_object.tags[handle] if PyUnicode_CheckExact(handle): handle = PyUnicode_AsUTF8String(handle) cache.append(handle) if not PyString_CheckExact(handle): if PY_MAJOR_VERSION < 3: raise TypeError("tag handle must be a string") else: raise TypeError(u"tag handle must be a string") tag_directives_end.handle = PyString_AS_STRING(handle) if PyUnicode_CheckExact(prefix): prefix = PyUnicode_AsUTF8String(prefix) cache.append(prefix) if not PyString_CheckExact(prefix): if PY_MAJOR_VERSION < 3: raise TypeError("tag prefix must be a string") else: raise TypeError(u"tag prefix must be a string") tag_directives_end.prefix = PyString_AS_STRING(prefix) tag_directives_end = tag_directives_end+1 implicit = 1 if event_object.explicit: implicit = 0 if yaml_document_start_event_initialize(event, version_directive, tag_directives_start, tag_directives_end, implicit) == 0: raise MemoryError elif event_class is DocumentEndEvent: implicit = 1 if event_object.explicit: implicit = 0 yaml_document_end_event_initialize(event, implicit) elif event_class is AliasEvent: anchor = NULL anchor_object = event_object.anchor if PyUnicode_CheckExact(anchor_object): anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): if PY_MAJOR_VERSION < 3: raise TypeError("anchor must be a string") else: raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) if yaml_alias_event_initialize(event, anchor) == 0: raise MemoryError elif event_class is ScalarEvent: anchor = NULL anchor_object = event_object.anchor if anchor_object is not None: if PyUnicode_CheckExact(anchor_object): anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): if PY_MAJOR_VERSION < 3: raise TypeError("anchor must be a string") else: raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) tag = NULL tag_object = event_object.tag if tag_object is not None: if PyUnicode_CheckExact(tag_object): tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): if PY_MAJOR_VERSION < 3: raise TypeError("tag must be a string") else: raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) value_object = event_object.value if PyUnicode_CheckExact(value_object): value_object = PyUnicode_AsUTF8String(value_object) if not PyString_CheckExact(value_object): if PY_MAJOR_VERSION < 3: raise TypeError("value must be a string") else: raise TypeError(u"value must be a string") value = PyString_AS_STRING(value_object) length = PyString_GET_SIZE(value_object) plain_implicit = 0 quoted_implicit = 0 if event_object.implicit is not None: plain_implicit = event_object.implicit[0] quoted_implicit = event_object.implicit[1] style_object = event_object.style scalar_style = YAML_PLAIN_SCALAR_STYLE if style_object == "'" or style_object == u"'": scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE elif style_object == "\"" or style_object == u"\"": scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE elif style_object == "|" or style_object == u"|": scalar_style = YAML_LITERAL_SCALAR_STYLE elif style_object == ">" or style_object == u">": scalar_style = YAML_FOLDED_SCALAR_STYLE if yaml_scalar_event_initialize(event, anchor, tag, value, length, plain_implicit, quoted_implicit, scalar_style) == 0: raise MemoryError elif event_class is SequenceStartEvent: anchor = NULL anchor_object = event_object.anchor if anchor_object is not None: if PyUnicode_CheckExact(anchor_object): anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): if PY_MAJOR_VERSION < 3: raise TypeError("anchor must be a string") else: raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) tag = NULL tag_object = event_object.tag if tag_object is not None: if PyUnicode_CheckExact(tag_object): tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): if PY_MAJOR_VERSION < 3: raise TypeError("tag must be a string") else: raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) implicit = 0 if event_object.implicit: implicit = 1 sequence_style = YAML_BLOCK_SEQUENCE_STYLE if event_object.flow_style: sequence_style = YAML_FLOW_SEQUENCE_STYLE if yaml_sequence_start_event_initialize(event, anchor, tag, implicit, sequence_style) == 0: raise MemoryError elif event_class is MappingStartEvent: anchor = NULL anchor_object = event_object.anchor if anchor_object is not None: if PyUnicode_CheckExact(anchor_object): anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): if PY_MAJOR_VERSION < 3: raise TypeError("anchor must be a string") else: raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) tag = NULL tag_object = event_object.tag if tag_object is not None: if PyUnicode_CheckExact(tag_object): tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): if PY_MAJOR_VERSION < 3: raise TypeError("tag must be a string") else: raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) implicit = 0 if event_object.implicit: implicit = 1 mapping_style = YAML_BLOCK_MAPPING_STYLE if event_object.flow_style: mapping_style = YAML_FLOW_MAPPING_STYLE if yaml_mapping_start_event_initialize(event, anchor, tag, implicit, mapping_style) == 0: raise MemoryError elif event_class is SequenceEndEvent: yaml_sequence_end_event_initialize(event) elif event_class is MappingEndEvent: yaml_mapping_end_event_initialize(event) else: if PY_MAJOR_VERSION < 3: raise TypeError("invalid event %s" % event_object) else: raise TypeError(u"invalid event %s" % event_object) return 1 def emit(self, event_object): cdef yaml_event_t event self._object_to_event(event_object, &event) if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error def open(self): cdef yaml_event_t event cdef yaml_encoding_t encoding if self.closed == -1: if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': encoding = YAML_UTF16LE_ENCODING elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': encoding = YAML_UTF16BE_ENCODING else: encoding = YAML_UTF8_ENCODING if self.use_encoding is None: self.dump_unicode = 1 if self.dump_unicode == 1: encoding = YAML_UTF8_ENCODING yaml_stream_start_event_initialize(&event, encoding) if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error self.closed = 0 elif self.closed == 1: if PY_MAJOR_VERSION < 3: raise SerializerError("serializer is closed") else: raise SerializerError(u"serializer is closed") else: if PY_MAJOR_VERSION < 3: raise SerializerError("serializer is already opened") else: raise SerializerError(u"serializer is already opened") def close(self): cdef yaml_event_t event if self.closed == -1: if PY_MAJOR_VERSION < 3: raise SerializerError("serializer is not opened") else: raise SerializerError(u"serializer is not opened") elif self.closed == 0: yaml_stream_end_event_initialize(&event) if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error self.closed = 1 def serialize(self, node): cdef yaml_event_t event cdef yaml_version_directive_t version_directive_value cdef yaml_version_directive_t *version_directive cdef yaml_tag_directive_t tag_directives_value[128] cdef yaml_tag_directive_t *tag_directives_start cdef yaml_tag_directive_t *tag_directives_end if self.closed == -1: if PY_MAJOR_VERSION < 3: raise SerializerError("serializer is not opened") else: raise SerializerError(u"serializer is not opened") elif self.closed == 1: if PY_MAJOR_VERSION < 3: raise SerializerError("serializer is closed") else: raise SerializerError(u"serializer is closed") cache = [] version_directive = NULL if self.use_version: version_directive_value.major = self.use_version[0] version_directive_value.minor = self.use_version[1] version_directive = &version_directive_value tag_directives_start = NULL tag_directives_end = NULL if self.use_tags: if len(self.use_tags) > 128: if PY_MAJOR_VERSION < 3: raise ValueError("too many tags") else: raise ValueError(u"too many tags") tag_directives_start = tag_directives_value tag_directives_end = tag_directives_value for handle in self.use_tags: prefix = self.use_tags[handle] if PyUnicode_CheckExact(handle): handle = PyUnicode_AsUTF8String(handle) cache.append(handle) if not PyString_CheckExact(handle): if PY_MAJOR_VERSION < 3: raise TypeError("tag handle must be a string") else: raise TypeError(u"tag handle must be a string") tag_directives_end.handle = PyString_AS_STRING(handle) if PyUnicode_CheckExact(prefix): prefix = PyUnicode_AsUTF8String(prefix) cache.append(prefix) if not PyString_CheckExact(prefix): if PY_MAJOR_VERSION < 3: raise TypeError("tag prefix must be a string") else: raise TypeError(u"tag prefix must be a string") tag_directives_end.prefix = PyString_AS_STRING(prefix) tag_directives_end = tag_directives_end+1 if yaml_document_start_event_initialize(&event, version_directive, tag_directives_start, tag_directives_end, self.document_start_implicit) == 0: raise MemoryError if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error self._anchor_node(node) self._serialize_node(node, None, None) yaml_document_end_event_initialize(&event, self.document_end_implicit) if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error self.serialized_nodes = {} self.anchors = {} self.last_alias_id = 0 cdef int _anchor_node(self, object node) except 0: if node in self.anchors: if self.anchors[node] is None: self.last_alias_id = self.last_alias_id+1 self.anchors[node] = u"id%03d" % self.last_alias_id else: self.anchors[node] = None node_class = node.__class__ if node_class is SequenceNode: for item in node.value: self._anchor_node(item) elif node_class is MappingNode: for key, value in node.value: self._anchor_node(key) self._anchor_node(value) return 1 cdef int _serialize_node(self, object node, object parent, object index) except 0: cdef yaml_event_t event cdef int implicit cdef int plain_implicit cdef int quoted_implicit cdef char *anchor cdef char *tag cdef char *value cdef int length cdef int item_index cdef yaml_scalar_style_t scalar_style cdef yaml_sequence_style_t sequence_style cdef yaml_mapping_style_t mapping_style anchor_object = self.anchors[node] anchor = NULL if anchor_object is not None: if PyUnicode_CheckExact(anchor_object): anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): if PY_MAJOR_VERSION < 3: raise TypeError("anchor must be a string") else: raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) if node in self.serialized_nodes: if yaml_alias_event_initialize(&event, anchor) == 0: raise MemoryError if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error else: node_class = node.__class__ self.serialized_nodes[node] = True self.descend_resolver(parent, index) if node_class is ScalarNode: plain_implicit = 0 quoted_implicit = 0 tag_object = node.tag if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: plain_implicit = 1 if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: quoted_implicit = 1 tag = NULL if tag_object is not None: if PyUnicode_CheckExact(tag_object): tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): if PY_MAJOR_VERSION < 3: raise TypeError("tag must be a string") else: raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) value_object = node.value if PyUnicode_CheckExact(value_object): value_object = PyUnicode_AsUTF8String(value_object) if not PyString_CheckExact(value_object): if PY_MAJOR_VERSION < 3: raise TypeError("value must be a string") else: raise TypeError(u"value must be a string") value = PyString_AS_STRING(value_object) length = PyString_GET_SIZE(value_object) style_object = node.style scalar_style = YAML_PLAIN_SCALAR_STYLE if style_object == "'" or style_object == u"'": scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE elif style_object == "\"" or style_object == u"\"": scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE elif style_object == "|" or style_object == u"|": scalar_style = YAML_LITERAL_SCALAR_STYLE elif style_object == ">" or style_object == u">": scalar_style = YAML_FOLDED_SCALAR_STYLE if yaml_scalar_event_initialize(&event, anchor, tag, value, length, plain_implicit, quoted_implicit, scalar_style) == 0: raise MemoryError if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error elif node_class is SequenceNode: implicit = 0 tag_object = node.tag if self.resolve(SequenceNode, node.value, True) == tag_object: implicit = 1 tag = NULL if tag_object is not None: if PyUnicode_CheckExact(tag_object): tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): if PY_MAJOR_VERSION < 3: raise TypeError("tag must be a string") else: raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) sequence_style = YAML_BLOCK_SEQUENCE_STYLE if node.flow_style: sequence_style = YAML_FLOW_SEQUENCE_STYLE if yaml_sequence_start_event_initialize(&event, anchor, tag, implicit, sequence_style) == 0: raise MemoryError if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error item_index = 0 for item in node.value: self._serialize_node(item, node, item_index) item_index = item_index+1 yaml_sequence_end_event_initialize(&event) if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error elif node_class is MappingNode: implicit = 0 tag_object = node.tag if self.resolve(MappingNode, node.value, True) == tag_object: implicit = 1 tag = NULL if tag_object is not None: if PyUnicode_CheckExact(tag_object): tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): if PY_MAJOR_VERSION < 3: raise TypeError("tag must be a string") else: raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) mapping_style = YAML_BLOCK_MAPPING_STYLE if node.flow_style: mapping_style = YAML_FLOW_MAPPING_STYLE if yaml_mapping_start_event_initialize(&event, anchor, tag, implicit, mapping_style) == 0: raise MemoryError if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error for item_key, item_value in node.value: self._serialize_node(item_key, node, None) self._serialize_node(item_value, node, item_key) yaml_mapping_end_event_initialize(&event) if yaml_emitter_emit(&self.emitter, &event) == 0: error = self._emitter_error() raise error self.ascend_resolver() return 1 cdef int output_handler(void *data, char *buffer, int size) except 0: cdef CEmitter emitter emitter = data if emitter.dump_unicode == 0: value = PyString_FromStringAndSize(buffer, size) else: value = PyUnicode_DecodeUTF8(buffer, size, 'strict') emitter.stream.write(value) return 1 ruamel.yaml-0.15.89/ext/loader.c0000664000175100001440000002716113351131445017016 0ustar anthonusers00000000000000 #include "yaml_private.h" /* * API functions. */ YAML_DECLARE(int) yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document); /* * Error handling. */ static int yaml_parser_set_composer_error(yaml_parser_t *parser, const char *problem, yaml_mark_t problem_mark); static int yaml_parser_set_composer_error_context(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem, yaml_mark_t problem_mark); /* * Alias handling. */ static int yaml_parser_register_anchor(yaml_parser_t *parser, int index, yaml_char_t *anchor); /* * Clean up functions. */ static void yaml_parser_delete_aliases(yaml_parser_t *parser); /* * Composer functions. */ static int yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event); static int yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event); static int yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event); static int yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event); static int yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event); static int yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event); /* * Load the next document of the stream. */ YAML_DECLARE(int) yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document) { yaml_event_t event; assert(parser); /* Non-NULL parser object is expected. */ assert(document); /* Non-NULL document object is expected. */ memset(document, 0, sizeof(yaml_document_t)); if (!STACK_INIT(parser, document->nodes, yaml_node_t*)) goto error; if (!parser->stream_start_produced) { if (!yaml_parser_parse(parser, &event)) goto error; assert(event.type == YAML_STREAM_START_EVENT); /* STREAM-START is expected. */ } if (parser->stream_end_produced) { return 1; } if (!yaml_parser_parse(parser, &event)) goto error; if (event.type == YAML_STREAM_END_EVENT) { return 1; } if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*)) goto error; parser->document = document; if (!yaml_parser_load_document(parser, &event)) goto error; yaml_parser_delete_aliases(parser); parser->document = NULL; return 1; error: yaml_parser_delete_aliases(parser); yaml_document_delete(document); parser->document = NULL; return 0; } /* * Set composer error. */ static int yaml_parser_set_composer_error(yaml_parser_t *parser, const char *problem, yaml_mark_t problem_mark) { parser->error = YAML_COMPOSER_ERROR; parser->problem = problem; parser->problem_mark = problem_mark; return 0; } /* * Set composer error with context. */ static int yaml_parser_set_composer_error_context(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem, yaml_mark_t problem_mark) { parser->error = YAML_COMPOSER_ERROR; parser->context = context; parser->context_mark = context_mark; parser->problem = problem; parser->problem_mark = problem_mark; return 0; } /* * Delete the stack of aliases. */ static void yaml_parser_delete_aliases(yaml_parser_t *parser) { while (!STACK_EMPTY(parser, parser->aliases)) { yaml_free(POP(parser, parser->aliases).anchor); } STACK_DEL(parser, parser->aliases); } /* * Compose a document object. */ static int yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_event_t event; assert(first_event->type == YAML_DOCUMENT_START_EVENT); /* DOCUMENT-START is expected. */ parser->document->version_directive = first_event->data.document_start.version_directive; parser->document->tag_directives.start = first_event->data.document_start.tag_directives.start; parser->document->tag_directives.end = first_event->data.document_start.tag_directives.end; parser->document->start_implicit = first_event->data.document_start.implicit; parser->document->start_mark = first_event->start_mark; if (!yaml_parser_parse(parser, &event)) return 0; if (!yaml_parser_load_node(parser, &event)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; assert(event.type == YAML_DOCUMENT_END_EVENT); /* DOCUMENT-END is expected. */ parser->document->end_implicit = event.data.document_end.implicit; parser->document->end_mark = event.end_mark; return 1; } /* * Compose a node. */ static int yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event) { switch (first_event->type) { case YAML_ALIAS_EVENT: return yaml_parser_load_alias(parser, first_event); case YAML_SCALAR_EVENT: return yaml_parser_load_scalar(parser, first_event); case YAML_SEQUENCE_START_EVENT: return yaml_parser_load_sequence(parser, first_event); case YAML_MAPPING_START_EVENT: return yaml_parser_load_mapping(parser, first_event); default: assert(0); /* Could not happen. */ return 0; } return 0; } /* * Add an anchor. */ static int yaml_parser_register_anchor(yaml_parser_t *parser, int index, yaml_char_t *anchor) { yaml_alias_data_t data; yaml_alias_data_t *alias_data; if (!anchor) return 1; data.anchor = anchor; data.index = index; data.mark = parser->document->nodes.start[index-1].start_mark; for (alias_data = parser->aliases.start; alias_data != parser->aliases.top; alias_data ++) { if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) { yaml_free(anchor); return yaml_parser_set_composer_error_context(parser, "found duplicate anchor; first occurrence", alias_data->mark, "second occurrence", data.mark); } } if (!PUSH(parser, parser->aliases, data)) { yaml_free(anchor); return 0; } return 1; } /* * Compose a node corresponding to an alias. */ static int yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_char_t *anchor = first_event->data.alias.anchor; yaml_alias_data_t *alias_data; for (alias_data = parser->aliases.start; alias_data != parser->aliases.top; alias_data ++) { if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) { yaml_free(anchor); return alias_data->index; } } yaml_free(anchor); return yaml_parser_set_composer_error(parser, "found undefined alias", first_event->start_mark); } /* * Compose a scalar node. */ static int yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_node_t node; int index; yaml_char_t *tag = first_event->data.scalar.tag; if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; if (!tag || strcmp((char *)tag, "!") == 0) { yaml_free(tag); tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG); if (!tag) goto error; } SCALAR_NODE_INIT(node, tag, first_event->data.scalar.value, first_event->data.scalar.length, first_event->data.scalar.style, first_event->start_mark, first_event->end_mark); if (!PUSH(parser, parser->document->nodes, node)) goto error; index = parser->document->nodes.top - parser->document->nodes.start; if (!yaml_parser_register_anchor(parser, index, first_event->data.scalar.anchor)) return 0; return index; error: yaml_free(tag); yaml_free(first_event->data.scalar.anchor); yaml_free(first_event->data.scalar.value); return 0; } /* * Compose a sequence node. */ static int yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_event_t event; yaml_node_t node; struct { yaml_node_item_t *start; yaml_node_item_t *end; yaml_node_item_t *top; } items = { NULL, NULL, NULL }; int index, item_index; yaml_char_t *tag = first_event->data.sequence_start.tag; if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; if (!tag || strcmp((char *)tag, "!") == 0) { yaml_free(tag); tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG); if (!tag) goto error; } if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error; SEQUENCE_NODE_INIT(node, tag, items.start, items.end, first_event->data.sequence_start.style, first_event->start_mark, first_event->end_mark); if (!PUSH(parser, parser->document->nodes, node)) goto error; index = parser->document->nodes.top - parser->document->nodes.start; if (!yaml_parser_register_anchor(parser, index, first_event->data.sequence_start.anchor)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; while (event.type != YAML_SEQUENCE_END_EVENT) { if (!STACK_LIMIT(parser, parser->document->nodes.start[index-1].data.sequence.items, INT_MAX-1)) return 0; item_index = yaml_parser_load_node(parser, &event); if (!item_index) return 0; if (!PUSH(parser, parser->document->nodes.start[index-1].data.sequence.items, item_index)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; } parser->document->nodes.start[index-1].end_mark = event.end_mark; return index; error: yaml_free(tag); yaml_free(first_event->data.sequence_start.anchor); return 0; } /* * Compose a mapping node. */ static int yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_event_t event; yaml_node_t node; struct { yaml_node_pair_t *start; yaml_node_pair_t *end; yaml_node_pair_t *top; } pairs = { NULL, NULL, NULL }; int index; yaml_node_pair_t pair; yaml_char_t *tag = first_event->data.mapping_start.tag; if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; if (!tag || strcmp((char *)tag, "!") == 0) { yaml_free(tag); tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG); if (!tag) goto error; } if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error; MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end, first_event->data.mapping_start.style, first_event->start_mark, first_event->end_mark); if (!PUSH(parser, parser->document->nodes, node)) goto error; index = parser->document->nodes.top - parser->document->nodes.start; if (!yaml_parser_register_anchor(parser, index, first_event->data.mapping_start.anchor)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; while (event.type != YAML_MAPPING_END_EVENT) { if (!STACK_LIMIT(parser, parser->document->nodes.start[index-1].data.mapping.pairs, INT_MAX-1)) return 0; pair.key = yaml_parser_load_node(parser, &event); if (!pair.key) return 0; if (!yaml_parser_parse(parser, &event)) return 0; pair.value = yaml_parser_load_node(parser, &event); if (!pair.value) return 0; if (!PUSH(parser, parser->document->nodes.start[index-1].data.mapping.pairs, pair)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; } parser->document->nodes.start[index-1].end_mark = event.end_mark; return index; error: yaml_free(tag); yaml_free(first_event->data.mapping_start.anchor); return 0; } ruamel.yaml-0.15.89/ext/_ruamel_yaml.c0000664000175100001440000454447213404246006020232 0ustar anthonusers00000000000000/* Generated by Cython 0.27.3 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_27_3" #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (0 && PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #if PY_VERSION_HEX < 0x030700A0 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE___ruamel_yaml #define __PYX_HAVE_API___ruamel_yaml #include "_ruamel_yaml.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) #define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "_ruamel_yaml.pyx", "stringsource", }; /*--- Type declarations ---*/ struct __pyx_obj_12_ruamel_yaml_Mark; struct __pyx_obj_12_ruamel_yaml_CParser; struct __pyx_obj_12_ruamel_yaml_CEmitter; /* "_ruamel_yaml.pyx":63 * from ruamel.yaml.nodes import MappingNode * * cdef class Mark: # <<<<<<<<<<<<<< * cdef readonly object name * cdef readonly int index */ struct __pyx_obj_12_ruamel_yaml_Mark { PyObject_HEAD PyObject *name; int index; int line; int column; PyObject *buffer; PyObject *pointer; }; /* "_ruamel_yaml.pyx":246 * # self.style = style * * cdef class CParser: # <<<<<<<<<<<<<< * * cdef yaml_parser_t parser */ struct __pyx_obj_12_ruamel_yaml_CParser { PyObject_HEAD struct __pyx_vtabstruct_12_ruamel_yaml_CParser *__pyx_vtab; yaml_parser_t parser; yaml_event_t parsed_event; PyObject *stream; PyObject *stream_name; PyObject *current_token; PyObject *current_event; PyObject *anchors; PyObject *stream_cache; int stream_cache_len; int stream_cache_pos; int unicode_source; }; /* "_ruamel_yaml.pyx":934 * return 1 * * cdef class CEmitter: # <<<<<<<<<<<<<< * * cdef yaml_emitter_t emitter */ struct __pyx_obj_12_ruamel_yaml_CEmitter { PyObject_HEAD struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *__pyx_vtab; yaml_emitter_t emitter; PyObject *stream; int document_start_implicit; int document_end_implicit; PyObject *use_version; PyObject *use_tags; PyObject *serialized_nodes; PyObject *anchors; int last_alias_id; int closed; int dump_unicode; PyObject *use_encoding; }; /* "_ruamel_yaml.pyx":246 * # self.style = style * * cdef class CParser: # <<<<<<<<<<<<<< * * cdef yaml_parser_t parser */ struct __pyx_vtabstruct_12_ruamel_yaml_CParser { PyObject *(*_parser_error)(struct __pyx_obj_12_ruamel_yaml_CParser *); PyObject *(*_scan)(struct __pyx_obj_12_ruamel_yaml_CParser *); PyObject *(*_token_to_object)(struct __pyx_obj_12_ruamel_yaml_CParser *, yaml_token_t *); PyObject *(*_parse)(struct __pyx_obj_12_ruamel_yaml_CParser *); PyObject *(*_event_to_object)(struct __pyx_obj_12_ruamel_yaml_CParser *, yaml_event_t *); PyObject *(*_compose_document)(struct __pyx_obj_12_ruamel_yaml_CParser *); PyObject *(*_compose_node)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *, PyObject *); PyObject *(*_compose_scalar_node)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *); PyObject *(*_compose_sequence_node)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *); PyObject *(*_compose_mapping_node)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *); int (*_parse_next_event)(struct __pyx_obj_12_ruamel_yaml_CParser *); }; static struct __pyx_vtabstruct_12_ruamel_yaml_CParser *__pyx_vtabptr_12_ruamel_yaml_CParser; /* "_ruamel_yaml.pyx":934 * return 1 * * cdef class CEmitter: # <<<<<<<<<<<<<< * * cdef yaml_emitter_t emitter */ struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter { PyObject *(*_emitter_error)(struct __pyx_obj_12_ruamel_yaml_CEmitter *); int (*_object_to_event)(struct __pyx_obj_12_ruamel_yaml_CEmitter *, PyObject *, yaml_event_t *); int (*_anchor_node)(struct __pyx_obj_12_ruamel_yaml_CEmitter *, PyObject *); int (*_serialize_node)(struct __pyx_obj_12_ruamel_yaml_CEmitter *, PyObject *, PyObject *, PyObject *); }; static struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *__pyx_vtabptr_12_ruamel_yaml_CEmitter; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* GetModuleGlobalName.proto */ static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* None.proto */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* PyObjectSetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_f_12_ruamel_yaml_7CParser__parser_error(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__scan(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__token_to_object(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, yaml_token_t *__pyx_v_token); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__parse(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__event_to_object(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, yaml_event_t *__pyx_v_event); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_document(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_parent, PyObject *__pyx_v_index); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_scalar_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_anchor); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_sequence_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_anchor); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_mapping_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_anchor); /* proto*/ static int __pyx_f_12_ruamel_yaml_7CParser__parse_next_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_12_ruamel_yaml_8CEmitter__emitter_error(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self); /* proto*/ static int __pyx_f_12_ruamel_yaml_8CEmitter__object_to_event(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_event_object, yaml_event_t *__pyx_v_event); /* proto*/ static int __pyx_f_12_ruamel_yaml_8CEmitter__anchor_node(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_node); /* proto*/ static int __pyx_f_12_ruamel_yaml_8CEmitter__serialize_node(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_node, PyObject *__pyx_v_parent, PyObject *__pyx_v_index); /* proto*/ /* Module declarations from '_ruamel_yaml' */ static PyTypeObject *__pyx_ptype_12_ruamel_yaml_Mark = 0; static PyTypeObject *__pyx_ptype_12_ruamel_yaml_CParser = 0; static PyTypeObject *__pyx_ptype_12_ruamel_yaml_CEmitter = 0; static int __pyx_f_12_ruamel_yaml_input_handler(void *, char *, int, int *); /*proto*/ static int __pyx_f_12_ruamel_yaml_output_handler(void *, char *, int); /*proto*/ static PyObject *__pyx_f_12_ruamel_yaml___pyx_unpickle_Mark__set_state(struct __pyx_obj_12_ruamel_yaml_Mark *, PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "_ruamel_yaml" extern int __pyx_module_is_main__ruamel_yaml; int __pyx_module_is_main__ruamel_yaml = 0; /* Implementation of '_ruamel_yaml' */ static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_AttributeError; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ValueError; static const char __pyx_k__3[] = "?"; static const char __pyx_k__6[] = ""; static const char __pyx_k__7[] = "'"; static const char __pyx_k__8[] = "\""; static const char __pyx_k__9[] = "|"; static const char __pyx_k_TAG[] = "TAG"; static const char __pyx_k__10[] = ">"; static const char __pyx_k__19[] = "\r"; static const char __pyx_k__20[] = "\n"; static const char __pyx_k__21[] = "\r\n"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_tag[] = "tag"; static const char __pyx_k_YAML[] = "YAML"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_file[] = ""; static const char __pyx_k_line[] = "line"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_read[] = "read"; static const char __pyx_k_tags[] = "tags"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_index[] = "index"; static const char __pyx_k_major[] = "major"; static const char __pyx_k_minor[] = "minor"; static const char __pyx_k_patch[] = "patch"; static const char __pyx_k_style[] = "style"; static const char __pyx_k_utf_8[] = "utf-8"; static const char __pyx_k_value[] = "value"; static const char __pyx_k_width[] = "width"; static const char __pyx_k_write[] = "write"; static const char __pyx_k_anchor[] = "anchor"; static const char __pyx_k_buffer[] = "buffer"; static const char __pyx_k_column[] = "column"; static const char __pyx_k_id_03d[] = "id%03d"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_indent[] = "indent"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_stream[] = "stream"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_pointer[] = "pointer"; static const char __pyx_k_resolve[] = "resolve"; static const char __pyx_k_version[] = "version"; static const char __pyx_k_KeyToken[] = "KeyToken"; static const char __pyx_k_TagToken[] = "TagToken"; static const char __pyx_k_encoding[] = "encoding"; static const char __pyx_k_end_mark[] = "end_mark"; static const char __pyx_k_explicit[] = "explicit"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_implicit[] = "implicit"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_YAMLError[] = "YAMLError"; static const char __pyx_k_canonical[] = "canonical"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_utf_16_be[] = "utf-16-be"; static const char __pyx_k_utf_16_le[] = "utf-16-le"; static const char __pyx_k_AliasEvent[] = "AliasEvent"; static const char __pyx_k_AliasToken[] = "AliasToken"; static const char __pyx_k_ScalarNode[] = "ScalarNode"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ValueToken[] = "ValueToken"; static const char __pyx_k_flow_style[] = "flow_style"; static const char __pyx_k_line_break[] = "line_break"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_start_mark[] = "start_mark"; static const char __pyx_k_AnchorToken[] = "AnchorToken"; static const char __pyx_k_MappingNode[] = "MappingNode"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_ParserError[] = "ParserError"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_ReaderError[] = "ReaderError"; static const char __pyx_k_ScalarEvent[] = "ScalarEvent"; static const char __pyx_k_ScalarToken[] = "ScalarToken"; static const char __pyx_k_byte_string[] = ""; static const char __pyx_k_get_version[] = "get_version"; static const char __pyx_k_ruamel_yaml[] = "_ruamel_yaml"; static const char __pyx_k_EmitterError[] = "EmitterError"; static const char __pyx_k_ScannerError[] = "ScannerError"; static const char __pyx_k_SequenceNode[] = "SequenceNode"; static const char __pyx_k_explicit_end[] = "explicit_end"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_BlockEndToken[] = "BlockEndToken"; static const char __pyx_k_ComposerError[] = "ComposerError"; static const char __pyx_k_allow_unicode[] = "allow_unicode"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_too_many_tags[] = "too many tags"; static const char __pyx_k_AttributeError[] = "AttributeError"; static const char __pyx_k_DirectiveToken[] = "DirectiveToken"; static const char __pyx_k_FlowEntryToken[] = "FlowEntryToken"; static const char __pyx_k_StreamEndEvent[] = "StreamEndEvent"; static const char __pyx_k_StreamEndToken[] = "StreamEndToken"; static const char __pyx_k_explicit_start[] = "explicit_start"; static const char __pyx_k_unicode_string[] = ""; static const char __pyx_k_BlockEntryToken[] = "BlockEntryToken"; static const char __pyx_k_MappingEndEvent[] = "MappingEndEvent"; static const char __pyx_k_SerializerError[] = "SerializerError"; static const char __pyx_k_ascend_resolver[] = "ascend_resolver"; static const char __pyx_k_invalid_event_s[] = "invalid event %s"; static const char __pyx_k_no_parser_error[] = "no parser error"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_ruamel_yaml_pyx[] = "_ruamel_yaml.pyx"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_ConstructorError[] = "ConstructorError"; static const char __pyx_k_DocumentEndEvent[] = "DocumentEndEvent"; static const char __pyx_k_DocumentEndToken[] = "DocumentEndToken"; static const char __pyx_k_RepresenterError[] = "RepresenterError"; static const char __pyx_k_SequenceEndEvent[] = "SequenceEndEvent"; static const char __pyx_k_StreamStartEvent[] = "StreamStartEvent"; static const char __pyx_k_StreamStartToken[] = "StreamStartToken"; static const char __pyx_k_descend_resolver[] = "descend_resolver"; static const char __pyx_k_no_emitter_error[] = "no emitter error"; static const char __pyx_k_MappingStartEvent[] = "MappingStartEvent"; static const char __pyx_k_pyx_unpickle_Mark[] = "__pyx_unpickle_Mark"; static const char __pyx_k_ruamel_yaml_error[] = "ruamel.yaml.error"; static const char __pyx_k_ruamel_yaml_nodes[] = "ruamel.yaml.nodes"; static const char __pyx_k_second_occurrence[] = "second occurrence"; static const char __pyx_k_DocumentStartEvent[] = "DocumentStartEvent"; static const char __pyx_k_DocumentStartToken[] = "DocumentStartToken"; static const char __pyx_k_SequenceStartEvent[] = "SequenceStartEvent"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_get_version_string[] = "get_version_string"; static const char __pyx_k_ruamel_yaml_events[] = "ruamel.yaml.events"; static const char __pyx_k_ruamel_yaml_parser[] = "ruamel.yaml.parser"; static const char __pyx_k_ruamel_yaml_reader[] = "ruamel.yaml.reader"; static const char __pyx_k_ruamel_yaml_tokens[] = "ruamel.yaml.tokens"; static const char __pyx_k_unknown_event_type[] = "unknown event type"; static const char __pyx_k_unknown_token_type[] = "unknown token type"; static const char __pyx_k_FlowMappingEndToken[] = "FlowMappingEndToken"; static const char __pyx_k_ruamel_yaml_emitter[] = "ruamel.yaml.emitter"; static const char __pyx_k_ruamel_yaml_scanner[] = "ruamel.yaml.scanner"; static const char __pyx_k_FlowSequenceEndToken[] = "FlowSequenceEndToken"; static const char __pyx_k_in_s_line_d_column_d[] = " in \"%s\", line %d, column %d"; static const char __pyx_k_ruamel_yaml_composer[] = "ruamel.yaml.composer"; static const char __pyx_k_serializer_is_closed[] = "serializer is closed"; static const char __pyx_k_tag_must_be_a_string[] = "tag must be a string"; static const char __pyx_k_FlowMappingStartToken[] = "FlowMappingStartToken"; static const char __pyx_k_found_undefined_alias[] = "found undefined alias"; static const char __pyx_k_BlockMappingStartToken[] = "BlockMappingStartToken"; static const char __pyx_k_FlowSequenceStartToken[] = "FlowSequenceStartToken"; static const char __pyx_k_ruamel_yaml_serializer[] = "ruamel.yaml.serializer"; static const char __pyx_k_value_must_be_a_string[] = "value must be a string"; static const char __pyx_k_BlockSequenceStartToken[] = "BlockSequenceStartToken"; static const char __pyx_k_anchor_must_be_a_string[] = "anchor must be a string"; static const char __pyx_k_ruamel_yaml_constructor[] = "ruamel.yaml.constructor"; static const char __pyx_k_ruamel_yaml_representer[] = "ruamel.yaml.representer"; static const char __pyx_k_serializer_is_not_opened[] = "serializer is not opened"; static const char __pyx_k_a_string_value_is_expected[] = "a string value is expected"; static const char __pyx_k_but_found_another_document[] = "but found another document"; static const char __pyx_k_tag_handle_must_be_a_string[] = "tag handle must be a string"; static const char __pyx_k_tag_prefix_must_be_a_string[] = "tag prefix must be a string"; static const char __pyx_k_serializer_is_already_opened[] = "serializer is already opened"; static const char __pyx_k_Pickling_of_struct_members_such[] = "Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)"; static const char __pyx_k_Incompatible_checksums_s_vs_0x3f[] = "Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))"; static const char __pyx_k_a_string_or_stream_input_is_requ[] = "a string or stream input is required"; static const char __pyx_k_expected_a_single_document_in_th[] = "expected a single document in the stream"; static const char __pyx_k_found_duplicate_anchor_first_occ[] = "found duplicate anchor; first occurrence"; static const char __pyx_k_self_parsed_event_cannot_be_conv[] = "self.parsed_event cannot be converted to a Python object for pickling"; static PyObject *__pyx_n_s_AliasEvent; static PyObject *__pyx_n_s_AliasToken; static PyObject *__pyx_n_s_AnchorToken; static PyObject *__pyx_n_s_AttributeError; static PyObject *__pyx_n_s_BlockEndToken; static PyObject *__pyx_n_s_BlockEntryToken; static PyObject *__pyx_n_s_BlockMappingStartToken; static PyObject *__pyx_n_s_BlockSequenceStartToken; static PyObject *__pyx_n_s_ComposerError; static PyObject *__pyx_n_s_ConstructorError; static PyObject *__pyx_n_s_DirectiveToken; static PyObject *__pyx_n_s_DocumentEndEvent; static PyObject *__pyx_n_s_DocumentEndToken; static PyObject *__pyx_n_s_DocumentStartEvent; static PyObject *__pyx_n_s_DocumentStartToken; static PyObject *__pyx_n_s_EmitterError; static PyObject *__pyx_n_s_FlowEntryToken; static PyObject *__pyx_n_s_FlowMappingEndToken; static PyObject *__pyx_n_s_FlowMappingStartToken; static PyObject *__pyx_n_s_FlowSequenceEndToken; static PyObject *__pyx_n_s_FlowSequenceStartToken; static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x3f; static PyObject *__pyx_n_s_KeyToken; static PyObject *__pyx_n_s_MappingEndEvent; static PyObject *__pyx_n_s_MappingNode; static PyObject *__pyx_n_s_MappingStartEvent; static PyObject *__pyx_n_s_MemoryError; static PyObject *__pyx_n_s_ParserError; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_kp_s_Pickling_of_struct_members_such; static PyObject *__pyx_n_s_ReaderError; static PyObject *__pyx_n_s_RepresenterError; static PyObject *__pyx_n_s_ScalarEvent; static PyObject *__pyx_n_s_ScalarNode; static PyObject *__pyx_n_s_ScalarToken; static PyObject *__pyx_n_s_ScannerError; static PyObject *__pyx_n_s_SequenceEndEvent; static PyObject *__pyx_n_s_SequenceNode; static PyObject *__pyx_n_s_SequenceStartEvent; static PyObject *__pyx_n_s_SerializerError; static PyObject *__pyx_n_s_StreamEndEvent; static PyObject *__pyx_n_s_StreamEndToken; static PyObject *__pyx_n_s_StreamStartEvent; static PyObject *__pyx_n_s_StreamStartToken; static PyObject *__pyx_n_u_TAG; static PyObject *__pyx_n_s_TagToken; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_ValueToken; static PyObject *__pyx_n_u_YAML; static PyObject *__pyx_n_s_YAMLError; static PyObject *__pyx_kp_s__10; static PyObject *__pyx_kp_u__10; static PyObject *__pyx_kp_s__19; static PyObject *__pyx_kp_s__20; static PyObject *__pyx_kp_s__21; static PyObject *__pyx_kp_s__3; static PyObject *__pyx_kp_u__3; static PyObject *__pyx_kp_u__6; static PyObject *__pyx_kp_s__7; static PyObject *__pyx_kp_u__7; static PyObject *__pyx_kp_s__8; static PyObject *__pyx_kp_u__8; static PyObject *__pyx_kp_s__9; static PyObject *__pyx_kp_u__9; static PyObject *__pyx_kp_s_a_string_or_stream_input_is_requ; static PyObject *__pyx_kp_u_a_string_or_stream_input_is_requ; static PyObject *__pyx_kp_s_a_string_value_is_expected; static PyObject *__pyx_kp_u_a_string_value_is_expected; static PyObject *__pyx_n_s_allow_unicode; static PyObject *__pyx_n_s_anchor; static PyObject *__pyx_kp_s_anchor_must_be_a_string; static PyObject *__pyx_kp_u_anchor_must_be_a_string; static PyObject *__pyx_n_s_ascend_resolver; static PyObject *__pyx_n_s_buffer; static PyObject *__pyx_kp_s_but_found_another_document; static PyObject *__pyx_kp_u_but_found_another_document; static PyObject *__pyx_kp_s_byte_string; static PyObject *__pyx_kp_u_byte_string; static PyObject *__pyx_n_s_canonical; static PyObject *__pyx_n_s_class; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_column; static PyObject *__pyx_n_s_descend_resolver; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_encoding; static PyObject *__pyx_n_u_encoding; static PyObject *__pyx_n_s_end_mark; static PyObject *__pyx_kp_s_expected_a_single_document_in_th; static PyObject *__pyx_kp_u_expected_a_single_document_in_th; static PyObject *__pyx_n_s_explicit; static PyObject *__pyx_n_s_explicit_end; static PyObject *__pyx_n_s_explicit_start; static PyObject *__pyx_kp_s_file; static PyObject *__pyx_kp_u_file; static PyObject *__pyx_n_s_flow_style; static PyObject *__pyx_kp_s_found_duplicate_anchor_first_occ; static PyObject *__pyx_kp_u_found_duplicate_anchor_first_occ; static PyObject *__pyx_kp_s_found_undefined_alias; static PyObject *__pyx_kp_u_found_undefined_alias; static PyObject *__pyx_n_s_get_version; static PyObject *__pyx_n_s_get_version_string; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_kp_u_id_03d; static PyObject *__pyx_n_s_implicit; static PyObject *__pyx_n_s_import; static PyObject *__pyx_kp_s_in_s_line_d_column_d; static PyObject *__pyx_n_s_indent; static PyObject *__pyx_n_s_index; static PyObject *__pyx_kp_s_invalid_event_s; static PyObject *__pyx_kp_u_invalid_event_s; static PyObject *__pyx_n_s_line; static PyObject *__pyx_n_s_line_break; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_major; static PyObject *__pyx_n_s_minor; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; static PyObject *__pyx_n_s_new; static PyObject *__pyx_kp_s_no_emitter_error; static PyObject *__pyx_kp_u_no_emitter_error; static PyObject *__pyx_kp_s_no_parser_error; static PyObject *__pyx_kp_u_no_parser_error; static PyObject *__pyx_n_s_patch; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_pointer; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_Mark; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_read; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_resolve; static PyObject *__pyx_n_s_ruamel_yaml; static PyObject *__pyx_n_s_ruamel_yaml_composer; static PyObject *__pyx_n_s_ruamel_yaml_constructor; static PyObject *__pyx_n_s_ruamel_yaml_emitter; static PyObject *__pyx_n_s_ruamel_yaml_error; static PyObject *__pyx_n_s_ruamel_yaml_events; static PyObject *__pyx_n_s_ruamel_yaml_nodes; static PyObject *__pyx_n_s_ruamel_yaml_parser; static PyObject *__pyx_kp_s_ruamel_yaml_pyx; static PyObject *__pyx_n_s_ruamel_yaml_reader; static PyObject *__pyx_n_s_ruamel_yaml_representer; static PyObject *__pyx_n_s_ruamel_yaml_scanner; static PyObject *__pyx_n_s_ruamel_yaml_serializer; static PyObject *__pyx_n_s_ruamel_yaml_tokens; static PyObject *__pyx_kp_s_second_occurrence; static PyObject *__pyx_kp_u_second_occurrence; static PyObject *__pyx_kp_s_self_parsed_event_cannot_be_conv; static PyObject *__pyx_kp_s_serializer_is_already_opened; static PyObject *__pyx_kp_u_serializer_is_already_opened; static PyObject *__pyx_kp_s_serializer_is_closed; static PyObject *__pyx_kp_u_serializer_is_closed; static PyObject *__pyx_kp_s_serializer_is_not_opened; static PyObject *__pyx_kp_u_serializer_is_not_opened; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_start_mark; static PyObject *__pyx_n_s_stream; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_style; static PyObject *__pyx_n_s_tag; static PyObject *__pyx_kp_s_tag_handle_must_be_a_string; static PyObject *__pyx_kp_u_tag_handle_must_be_a_string; static PyObject *__pyx_kp_s_tag_must_be_a_string; static PyObject *__pyx_kp_u_tag_must_be_a_string; static PyObject *__pyx_kp_s_tag_prefix_must_be_a_string; static PyObject *__pyx_kp_u_tag_prefix_must_be_a_string; static PyObject *__pyx_n_s_tags; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_s_too_many_tags; static PyObject *__pyx_kp_u_too_many_tags; static PyObject *__pyx_kp_s_unicode_string; static PyObject *__pyx_kp_u_unicode_string; static PyObject *__pyx_kp_s_unknown_event_type; static PyObject *__pyx_kp_u_unknown_event_type; static PyObject *__pyx_kp_s_unknown_token_type; static PyObject *__pyx_kp_u_unknown_token_type; static PyObject *__pyx_n_s_update; static PyObject *__pyx_kp_s_utf_16_be; static PyObject *__pyx_kp_u_utf_16_be; static PyObject *__pyx_kp_s_utf_16_le; static PyObject *__pyx_kp_u_utf_16_le; static PyObject *__pyx_kp_u_utf_8; static PyObject *__pyx_n_s_value; static PyObject *__pyx_kp_s_value_must_be_a_string; static PyObject *__pyx_kp_u_value_must_be_a_string; static PyObject *__pyx_n_s_version; static PyObject *__pyx_n_s_width; static PyObject *__pyx_n_s_write; static PyObject *__pyx_pf_12_ruamel_yaml_get_version_string(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_2get_version(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static int __pyx_pf_12_ruamel_yaml_4Mark___init__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self, PyObject *__pyx_v_name, int __pyx_v_index, int __pyx_v_line, int __pyx_v_column, PyObject *__pyx_v_buffer, PyObject *__pyx_v_pointer); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_2get_snippet(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_4__str__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_4name___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_5index___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_4line___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_6column___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_6buffer___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_7pointer___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_6__reduce_cython__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_8__setstate_cython__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_12_ruamel_yaml_7CParser___init__(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_stream); /* proto */ static void __pyx_pf_12_ruamel_yaml_7CParser_2__dealloc__(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_4dispose(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_6raw_scan(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_8get_token(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_10peek_token(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_12check_token(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_choices); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_14raw_parse(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_16get_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_18peek_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_20check_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_choices); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_22check_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_24get_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_26get_single_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_12_ruamel_yaml_8CEmitter___init__(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_stream, PyObject *__pyx_v_canonical, PyObject *__pyx_v_indent, PyObject *__pyx_v_width, PyObject *__pyx_v_allow_unicode, PyObject *__pyx_v_line_break, PyObject *__pyx_v_encoding, PyObject *__pyx_v_explicit_start, PyObject *__pyx_v_explicit_end, PyObject *__pyx_v_version, PyObject *__pyx_v_tags); /* proto */ static void __pyx_pf_12_ruamel_yaml_8CEmitter_2__dealloc__(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_4dispose(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_6emit(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_event_object); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_8open(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_10close(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_12serialize(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_node); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_12_ruamel_yaml_4__pyx_unpickle_Mark(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_12_ruamel_yaml_Mark(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_12_ruamel_yaml_CParser(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_12_ruamel_yaml_CEmitter(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_66733494; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__27; static PyObject *__pyx_tuple__28; static PyObject *__pyx_tuple__29; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__31; static PyObject *__pyx_tuple__32; static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__35; static PyObject *__pyx_tuple__36; static PyObject *__pyx_tuple__37; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__39; static PyObject *__pyx_tuple__40; static PyObject *__pyx_tuple__41; static PyObject *__pyx_tuple__42; static PyObject *__pyx_tuple__43; static PyObject *__pyx_tuple__44; static PyObject *__pyx_tuple__45; static PyObject *__pyx_tuple__46; static PyObject *__pyx_tuple__47; static PyObject *__pyx_tuple__48; static PyObject *__pyx_tuple__49; static PyObject *__pyx_tuple__50; static PyObject *__pyx_tuple__51; static PyObject *__pyx_tuple__52; static PyObject *__pyx_tuple__53; static PyObject *__pyx_tuple__54; static PyObject *__pyx_tuple__55; static PyObject *__pyx_tuple__56; static PyObject *__pyx_tuple__57; static PyObject *__pyx_tuple__58; static PyObject *__pyx_tuple__59; static PyObject *__pyx_tuple__60; static PyObject *__pyx_tuple__61; static PyObject *__pyx_tuple__62; static PyObject *__pyx_tuple__63; static PyObject *__pyx_tuple__64; static PyObject *__pyx_tuple__65; static PyObject *__pyx_tuple__66; static PyObject *__pyx_tuple__67; static PyObject *__pyx_tuple__68; static PyObject *__pyx_tuple__69; static PyObject *__pyx_tuple__70; static PyObject *__pyx_tuple__71; static PyObject *__pyx_tuple__72; static PyObject *__pyx_tuple__73; static PyObject *__pyx_tuple__74; static PyObject *__pyx_tuple__75; static PyObject *__pyx_tuple__76; static PyObject *__pyx_tuple__78; static PyObject *__pyx_tuple__80; static PyObject *__pyx_codeobj__77; static PyObject *__pyx_codeobj__79; static PyObject *__pyx_codeobj__81; /* "_ruamel_yaml.pyx":3 * * * def get_version_string(): # <<<<<<<<<<<<<< * cdef char *value * value = yaml_get_version_string() */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_1get_version_string(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyMethodDef __pyx_mdef_12_ruamel_yaml_1get_version_string = {"get_version_string", (PyCFunction)__pyx_pw_12_ruamel_yaml_1get_version_string, METH_NOARGS, 0}; static PyObject *__pyx_pw_12_ruamel_yaml_1get_version_string(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_version_string (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_get_version_string(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_get_version_string(CYTHON_UNUSED PyObject *__pyx_self) { char *__pyx_v_value; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("get_version_string", 0); /* "_ruamel_yaml.pyx":5 * def get_version_string(): * cdef char *value * value = yaml_get_version_string() # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * return value */ __pyx_v_value = yaml_get_version_string(); /* "_ruamel_yaml.pyx":6 * cdef char *value * value = yaml_get_version_string() * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return value * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":7 * value = yaml_get_version_string() * if PY_MAJOR_VERSION < 3: * return value # <<<<<<<<<<<<<< * else: * return PyUnicode_FromString(value) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyBytes_FromString(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":6 * cdef char *value * value = yaml_get_version_string() * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return value * else: */ } /* "_ruamel_yaml.pyx":9 * return value * else: * return PyUnicode_FromString(value) # <<<<<<<<<<<<<< * * def get_version(): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyUnicode_FromString(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "_ruamel_yaml.pyx":3 * * * def get_version_string(): # <<<<<<<<<<<<<< * cdef char *value * value = yaml_get_version_string() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("_ruamel_yaml.get_version_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":11 * return PyUnicode_FromString(value) * * def get_version(): # <<<<<<<<<<<<<< * cdef int major, minor, patch * yaml_get_version(&major, &minor, &patch) */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_3get_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyMethodDef __pyx_mdef_12_ruamel_yaml_3get_version = {"get_version", (PyCFunction)__pyx_pw_12_ruamel_yaml_3get_version, METH_NOARGS, 0}; static PyObject *__pyx_pw_12_ruamel_yaml_3get_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_version (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_2get_version(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_2get_version(CYTHON_UNUSED PyObject *__pyx_self) { int __pyx_v_major; int __pyx_v_minor; int __pyx_v_patch; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("get_version", 0); /* "_ruamel_yaml.pyx":13 * def get_version(): * cdef int major, minor, patch * yaml_get_version(&major, &minor, &patch) # <<<<<<<<<<<<<< * return (major, minor, patch) * */ yaml_get_version((&__pyx_v_major), (&__pyx_v_minor), (&__pyx_v_patch)); /* "_ruamel_yaml.pyx":14 * cdef int major, minor, patch * yaml_get_version(&major, &minor, &patch) * return (major, minor, patch) # <<<<<<<<<<<<<< * * #Mark = yaml.error.Mark */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_major); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_minor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_patch); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":11 * return PyUnicode_FromString(value) * * def get_version(): # <<<<<<<<<<<<<< * cdef int major, minor, patch * yaml_get_version(&major, &minor, &patch) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("_ruamel_yaml.get_version", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":71 * cdef readonly pointer * * def __init__(self, object name, int index, int line, int column, # <<<<<<<<<<<<<< * object buffer, object pointer): * self.name = name */ /* Python wrapper */ static int __pyx_pw_12_ruamel_yaml_4Mark_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_12_ruamel_yaml_4Mark_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_name = 0; int __pyx_v_index; int __pyx_v_line; int __pyx_v_column; PyObject *__pyx_v_buffer = 0; PyObject *__pyx_v_pointer = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_index,&__pyx_n_s_line,&__pyx_n_s_column,&__pyx_n_s_buffer,&__pyx_n_s_pointer,0}; PyObject* values[6] = {0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_index)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 1); __PYX_ERR(0, 71, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_line)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 2); __PYX_ERR(0, 71, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_column)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 3); __PYX_ERR(0, 71, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_buffer)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 4); __PYX_ERR(0, 71, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pointer)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 5); __PYX_ERR(0, 71, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 71, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 6) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); } __pyx_v_name = values[0]; __pyx_v_index = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_index == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) __pyx_v_line = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_line == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) __pyx_v_column = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_column == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) __pyx_v_buffer = values[4]; __pyx_v_pointer = values[5]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_ruamel_yaml.Mark.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark___init__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self), __pyx_v_name, __pyx_v_index, __pyx_v_line, __pyx_v_column, __pyx_v_buffer, __pyx_v_pointer); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_12_ruamel_yaml_4Mark___init__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self, PyObject *__pyx_v_name, int __pyx_v_index, int __pyx_v_line, int __pyx_v_column, PyObject *__pyx_v_buffer, PyObject *__pyx_v_pointer) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); /* "_ruamel_yaml.pyx":73 * def __init__(self, object name, int index, int line, int column, * object buffer, object pointer): * self.name = name # <<<<<<<<<<<<<< * self.index = index * self.line = line */ __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __Pyx_GOTREF(__pyx_v_self->name); __Pyx_DECREF(__pyx_v_self->name); __pyx_v_self->name = __pyx_v_name; /* "_ruamel_yaml.pyx":74 * object buffer, object pointer): * self.name = name * self.index = index # <<<<<<<<<<<<<< * self.line = line * self.column = column */ __pyx_v_self->index = __pyx_v_index; /* "_ruamel_yaml.pyx":75 * self.name = name * self.index = index * self.line = line # <<<<<<<<<<<<<< * self.column = column * self.buffer = buffer */ __pyx_v_self->line = __pyx_v_line; /* "_ruamel_yaml.pyx":76 * self.index = index * self.line = line * self.column = column # <<<<<<<<<<<<<< * self.buffer = buffer * self.pointer = pointer */ __pyx_v_self->column = __pyx_v_column; /* "_ruamel_yaml.pyx":77 * self.line = line * self.column = column * self.buffer = buffer # <<<<<<<<<<<<<< * self.pointer = pointer * */ __Pyx_INCREF(__pyx_v_buffer); __Pyx_GIVEREF(__pyx_v_buffer); __Pyx_GOTREF(__pyx_v_self->buffer); __Pyx_DECREF(__pyx_v_self->buffer); __pyx_v_self->buffer = __pyx_v_buffer; /* "_ruamel_yaml.pyx":78 * self.column = column * self.buffer = buffer * self.pointer = pointer # <<<<<<<<<<<<<< * * def get_snippet(self): */ __Pyx_INCREF(__pyx_v_pointer); __Pyx_GIVEREF(__pyx_v_pointer); __Pyx_GOTREF(__pyx_v_self->pointer); __Pyx_DECREF(__pyx_v_self->pointer); __pyx_v_self->pointer = __pyx_v_pointer; /* "_ruamel_yaml.pyx":71 * cdef readonly pointer * * def __init__(self, object name, int index, int line, int column, # <<<<<<<<<<<<<< * object buffer, object pointer): * self.name = name */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":80 * self.pointer = pointer * * def get_snippet(self): # <<<<<<<<<<<<<< * return None * */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_3get_snippet(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_3get_snippet(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_snippet (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_2get_snippet(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_2get_snippet(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_snippet", 0); /* "_ruamel_yaml.pyx":81 * * def get_snippet(self): * return None # <<<<<<<<<<<<<< * * def __str__(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; /* "_ruamel_yaml.pyx":80 * self.pointer = pointer * * def get_snippet(self): # <<<<<<<<<<<<<< * return None * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":83 * return None * * def __str__(self): # <<<<<<<<<<<<<< * where = " in \"%s\", line %d, column %d" \ * % (self.name, self.line+1, self.column+1) */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_5__str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_5__str__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_4__str__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_4__str__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_v_where = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("__str__", 0); /* "_ruamel_yaml.pyx":85 * def __str__(self): * where = " in \"%s\", line %d, column %d" \ * % (self.name, self.line+1, self.column+1) # <<<<<<<<<<<<<< * return where * */ __pyx_t_1 = __Pyx_PyInt_From_long((__pyx_v_self->line + 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_long((__pyx_v_self->column + 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_self->name); __Pyx_GIVEREF(__pyx_v_self->name); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self->name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_in_s_line_d_column_d, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_where = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":86 * where = " in \"%s\", line %d, column %d" \ * % (self.name, self.line+1, self.column+1) * return where # <<<<<<<<<<<<<< * * #class YAMLError(Exception): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_where); __pyx_r = __pyx_v_where; goto __pyx_L0; /* "_ruamel_yaml.pyx":83 * return None * * def __str__(self): # <<<<<<<<<<<<<< * where = " in \"%s\", line %d, column %d" \ * % (self.name, self.line+1, self.column+1) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.Mark.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_where); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":64 * * cdef class Mark: * cdef readonly object name # <<<<<<<<<<<<<< * cdef readonly int index * cdef readonly int line */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_4name_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_4name___get__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_4name___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->name); __pyx_r = __pyx_v_self->name; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":65 * cdef class Mark: * cdef readonly object name * cdef readonly int index # <<<<<<<<<<<<<< * cdef readonly int line * cdef readonly int column */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_5index_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_5index_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_5index___get__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_5index___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.Mark.index.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":66 * cdef readonly object name * cdef readonly int index * cdef readonly int line # <<<<<<<<<<<<<< * cdef readonly int column * cdef readonly buffer */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_4line_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_4line_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_4line___get__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_4line___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->line); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.Mark.line.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":67 * cdef readonly int index * cdef readonly int line * cdef readonly int column # <<<<<<<<<<<<<< * cdef readonly buffer * cdef readonly pointer */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_6column_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_6column_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_6column___get__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_6column___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->column); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.Mark.column.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":68 * cdef readonly int line * cdef readonly int column * cdef readonly buffer # <<<<<<<<<<<<<< * cdef readonly pointer * */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_6buffer_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_6buffer_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_6buffer___get__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_6buffer___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->buffer); __pyx_r = __pyx_v_self->buffer; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":69 * cdef readonly int column * cdef readonly buffer * cdef readonly pointer # <<<<<<<<<<<<<< * * def __init__(self, object name, int index, int line, int column, */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_7pointer_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_7pointer_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_7pointer___get__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_7pointer___get__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->pointer); __pyx_r = __pyx_v_self->pointer; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef bint use_setstate * state = (self.buffer, self.column, self.index, self.line, self.name, self.pointer) */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_6__reduce_cython__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_6__reduce_cython__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self) { int __pyx_v_use_setstate; PyObject *__pyx_v_state = NULL; PyObject *__pyx_v__dict = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":3 * def __reduce_cython__(self): * cdef bint use_setstate * state = (self.buffer, self.column, self.index, self.line, self.name, self.pointer) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->column); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->line); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->buffer); __Pyx_GIVEREF(__pyx_v_self->buffer); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->buffer); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __Pyx_INCREF(__pyx_v_self->name); __Pyx_GIVEREF(__pyx_v_self->name); PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_v_self->name); __Pyx_INCREF(__pyx_v_self->pointer); __Pyx_GIVEREF(__pyx_v_self->pointer); PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_v_self->pointer); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_v_state = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":4 * cdef bint use_setstate * state = (self.buffer, self.column, self.index, self.line, self.name, self.pointer) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_4 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v__dict = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":5 * state = (self.buffer, self.column, self.index, self.line, self.name, self.pointer) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_5 = (__pyx_v__dict != Py_None); __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "(tree fragment)":6 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v__dict); __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "(tree fragment)":7 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.buffer is not None or self.name is not None or self.pointer is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":5 * state = (self.buffer, self.column, self.index, self.line, self.name, self.pointer) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":9 * use_setstate = True * else: * use_setstate = self.buffer is not None or self.name is not None or self.pointer is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, None), state */ /*else*/ { __pyx_t_5 = (__pyx_v_self->buffer != Py_None); __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L4_bool_binop_done; } __pyx_t_7 = (__pyx_v_self->name != Py_None); __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_6 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = (__pyx_v_self->pointer != Py_None); __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_6 = __pyx_t_7; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_6; } __pyx_L3:; /* "(tree fragment)":10 * else: * use_setstate = self.buffer is not None or self.name is not None or self.pointer is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, None), state * else: */ __pyx_t_6 = (__pyx_v_use_setstate != 0); if (__pyx_t_6) { /* "(tree fragment)":11 * use_setstate = self.buffer is not None or self.name is not None or self.pointer is not None * if use_setstate: * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, state) */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pyx_unpickle_Mark); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_66733494); __Pyx_GIVEREF(__pyx_int_66733494); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_66733494); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 2, Py_None); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "(tree fragment)":10 * else: * use_setstate = self.buffer is not None or self.name is not None or self.pointer is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, None), state * else: */ } /* "(tree fragment)":13 * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, None), state * else: * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Mark__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pyx_unpickle_Mark); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_66733494); __Pyx_GIVEREF(__pyx_int_66733494); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_66733494); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef bint use_setstate * state = (self.buffer, self.column, self.index, self.line, self.name, self.pointer) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("_ruamel_yaml.Mark.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":14 * else: * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Mark__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_4Mark_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_4Mark_8__setstate_cython__(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4Mark_8__setstate_cython__(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":15 * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Mark__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 15, __pyx_L1_error) __pyx_t_1 = __pyx_f_12_ruamel_yaml___pyx_unpickle_Mark__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":14 * else: * return __pyx_unpickle_Mark, (type(self), 0x3fa45b6, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Mark__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.Mark.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":261 * cdef int unicode_source * * def __init__(self, stream): # <<<<<<<<<<<<<< * cdef is_readable * if yaml_parser_initialize(&self.parser) == 0: */ /* Python wrapper */ static int __pyx_pw_12_ruamel_yaml_7CParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_12_ruamel_yaml_7CParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_stream = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stream,0}; PyObject* values[1] = {0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stream)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 261, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); } __pyx_v_stream = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 261, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_ruamel_yaml.CParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser___init__(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self), __pyx_v_stream); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_12_ruamel_yaml_7CParser___init__(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_stream) { PyObject *__pyx_v_is_readable = 0; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("__init__", 0); __Pyx_INCREF(__pyx_v_stream); /* "_ruamel_yaml.pyx":263 * def __init__(self, stream): * cdef is_readable * if yaml_parser_initialize(&self.parser) == 0: # <<<<<<<<<<<<<< * raise MemoryError * self.parsed_event.type = YAML_NO_EVENT */ __pyx_t_1 = ((yaml_parser_initialize((&__pyx_v_self->parser)) == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":264 * cdef is_readable * if yaml_parser_initialize(&self.parser) == 0: * raise MemoryError # <<<<<<<<<<<<<< * self.parsed_event.type = YAML_NO_EVENT * is_readable = 1 */ PyErr_NoMemory(); __PYX_ERR(0, 264, __pyx_L1_error) /* "_ruamel_yaml.pyx":263 * def __init__(self, stream): * cdef is_readable * if yaml_parser_initialize(&self.parser) == 0: # <<<<<<<<<<<<<< * raise MemoryError * self.parsed_event.type = YAML_NO_EVENT */ } /* "_ruamel_yaml.pyx":265 * if yaml_parser_initialize(&self.parser) == 0: * raise MemoryError * self.parsed_event.type = YAML_NO_EVENT # <<<<<<<<<<<<<< * is_readable = 1 * try: */ __pyx_v_self->parsed_event.type = YAML_NO_EVENT; /* "_ruamel_yaml.pyx":266 * raise MemoryError * self.parsed_event.type = YAML_NO_EVENT * is_readable = 1 # <<<<<<<<<<<<<< * try: * stream.read */ __Pyx_INCREF(__pyx_int_1); __pyx_v_is_readable = __pyx_int_1; /* "_ruamel_yaml.pyx":267 * self.parsed_event.type = YAML_NO_EVENT * is_readable = 1 * try: # <<<<<<<<<<<<<< * stream.read * except AttributeError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "_ruamel_yaml.pyx":268 * is_readable = 1 * try: * stream.read # <<<<<<<<<<<<<< * except AttributeError: * is_readable = 0 */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_stream, __pyx_n_s_read); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 268, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":267 * self.parsed_event.type = YAML_NO_EVENT * is_readable = 1 * try: # <<<<<<<<<<<<<< * stream.read * except AttributeError: */ } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":269 * try: * stream.read * except AttributeError: # <<<<<<<<<<<<<< * is_readable = 0 * self.unicode_source = 0 */ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); if (__pyx_t_6) { __Pyx_AddTraceback("_ruamel_yaml.CParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 269, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); /* "_ruamel_yaml.pyx":270 * stream.read * except AttributeError: * is_readable = 0 # <<<<<<<<<<<<<< * self.unicode_source = 0 * if is_readable: */ __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_is_readable, __pyx_int_0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "_ruamel_yaml.pyx":267 * self.parsed_event.type = YAML_NO_EVENT * is_readable = 1 * try: # <<<<<<<<<<<<<< * stream.read * except AttributeError: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "_ruamel_yaml.pyx":271 * except AttributeError: * is_readable = 0 * self.unicode_source = 0 # <<<<<<<<<<<<<< * if is_readable: * self.stream = stream */ __pyx_v_self->unicode_source = 0; /* "_ruamel_yaml.pyx":272 * is_readable = 0 * self.unicode_source = 0 * if is_readable: # <<<<<<<<<<<<<< * self.stream = stream * try: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_is_readable); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 272, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":273 * self.unicode_source = 0 * if is_readable: * self.stream = stream # <<<<<<<<<<<<<< * try: * self.stream_name = stream.name */ __Pyx_INCREF(__pyx_v_stream); __Pyx_GIVEREF(__pyx_v_stream); __Pyx_GOTREF(__pyx_v_self->stream); __Pyx_DECREF(__pyx_v_self->stream); __pyx_v_self->stream = __pyx_v_stream; /* "_ruamel_yaml.pyx":274 * if is_readable: * self.stream = stream * try: # <<<<<<<<<<<<<< * self.stream_name = stream.name * except AttributeError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); /*try:*/ { /* "_ruamel_yaml.pyx":275 * self.stream = stream * try: * self.stream_name = stream.name # <<<<<<<<<<<<<< * except AttributeError: * if PY_MAJOR_VERSION < 3: */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_stream, __pyx_n_s_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 275, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_t_8; __pyx_t_8 = 0; /* "_ruamel_yaml.pyx":274 * if is_readable: * self.stream = stream * try: # <<<<<<<<<<<<<< * self.stream_name = stream.name * except AttributeError: */ } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L18_try_end; __pyx_L13_error:; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "_ruamel_yaml.pyx":276 * try: * self.stream_name = stream.name * except AttributeError: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * self.stream_name = '' */ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); if (__pyx_t_6) { __Pyx_AddTraceback("_ruamel_yaml.CParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_5) < 0) __PYX_ERR(0, 276, __pyx_L15_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_5); /* "_ruamel_yaml.pyx":277 * self.stream_name = stream.name * except AttributeError: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * self.stream_name = '' * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":278 * except AttributeError: * if PY_MAJOR_VERSION < 3: * self.stream_name = '' # <<<<<<<<<<<<<< * else: * self.stream_name = u'' */ __Pyx_INCREF(__pyx_kp_s_file); __Pyx_GIVEREF(__pyx_kp_s_file); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_kp_s_file; /* "_ruamel_yaml.pyx":277 * self.stream_name = stream.name * except AttributeError: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * self.stream_name = '' * else: */ goto __pyx_L21; } /* "_ruamel_yaml.pyx":280 * self.stream_name = '' * else: * self.stream_name = u'' # <<<<<<<<<<<<<< * self.stream_cache = None * self.stream_cache_len = 0 */ /*else*/ { __Pyx_INCREF(__pyx_kp_u_file); __Pyx_GIVEREF(__pyx_kp_u_file); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_kp_u_file; } __pyx_L21:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L14_exception_handled; } goto __pyx_L15_except_error; __pyx_L15_except_error:; /* "_ruamel_yaml.pyx":274 * if is_readable: * self.stream = stream * try: # <<<<<<<<<<<<<< * self.stream_name = stream.name * except AttributeError: */ __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_3, __pyx_t_2); goto __pyx_L1_error; __pyx_L14_exception_handled:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_3, __pyx_t_2); __pyx_L18_try_end:; } /* "_ruamel_yaml.pyx":281 * else: * self.stream_name = u'' * self.stream_cache = None # <<<<<<<<<<<<<< * self.stream_cache_len = 0 * self.stream_cache_pos = 0 */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->stream_cache); __Pyx_DECREF(__pyx_v_self->stream_cache); __pyx_v_self->stream_cache = Py_None; /* "_ruamel_yaml.pyx":282 * self.stream_name = u'' * self.stream_cache = None * self.stream_cache_len = 0 # <<<<<<<<<<<<<< * self.stream_cache_pos = 0 * yaml_parser_set_input(&self.parser, input_handler, self) */ __pyx_v_self->stream_cache_len = 0; /* "_ruamel_yaml.pyx":283 * self.stream_cache = None * self.stream_cache_len = 0 * self.stream_cache_pos = 0 # <<<<<<<<<<<<<< * yaml_parser_set_input(&self.parser, input_handler, self) * else: */ __pyx_v_self->stream_cache_pos = 0; /* "_ruamel_yaml.pyx":284 * self.stream_cache_len = 0 * self.stream_cache_pos = 0 * yaml_parser_set_input(&self.parser, input_handler, self) # <<<<<<<<<<<<<< * else: * if PyUnicode_CheckExact(stream) != 0: */ yaml_parser_set_input((&__pyx_v_self->parser), __pyx_f_12_ruamel_yaml_input_handler, ((void *)__pyx_v_self)); /* "_ruamel_yaml.pyx":272 * is_readable = 0 * self.unicode_source = 0 * if is_readable: # <<<<<<<<<<<<<< * self.stream = stream * try: */ goto __pyx_L12; } /* "_ruamel_yaml.pyx":286 * yaml_parser_set_input(&self.parser, input_handler, self) * else: * if PyUnicode_CheckExact(stream) != 0: # <<<<<<<<<<<<<< * stream = PyUnicode_AsUTF8String(stream) * if PY_MAJOR_VERSION < 3: */ /*else*/ { __pyx_t_1 = ((PyUnicode_CheckExact(__pyx_v_stream) != 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":287 * else: * if PyUnicode_CheckExact(stream) != 0: * stream = PyUnicode_AsUTF8String(stream) # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * self.stream_name = '' */ __pyx_t_5 = PyUnicode_AsUTF8String(__pyx_v_stream); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_stream, __pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":288 * if PyUnicode_CheckExact(stream) != 0: * stream = PyUnicode_AsUTF8String(stream) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * self.stream_name = '' * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":289 * stream = PyUnicode_AsUTF8String(stream) * if PY_MAJOR_VERSION < 3: * self.stream_name = '' # <<<<<<<<<<<<<< * else: * self.stream_name = u'' */ __Pyx_INCREF(__pyx_kp_s_unicode_string); __Pyx_GIVEREF(__pyx_kp_s_unicode_string); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_kp_s_unicode_string; /* "_ruamel_yaml.pyx":288 * if PyUnicode_CheckExact(stream) != 0: * stream = PyUnicode_AsUTF8String(stream) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * self.stream_name = '' * else: */ goto __pyx_L23; } /* "_ruamel_yaml.pyx":291 * self.stream_name = '' * else: * self.stream_name = u'' # <<<<<<<<<<<<<< * self.unicode_source = 1 * else: */ /*else*/ { __Pyx_INCREF(__pyx_kp_u_unicode_string); __Pyx_GIVEREF(__pyx_kp_u_unicode_string); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_kp_u_unicode_string; } __pyx_L23:; /* "_ruamel_yaml.pyx":292 * else: * self.stream_name = u'' * self.unicode_source = 1 # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ __pyx_v_self->unicode_source = 1; /* "_ruamel_yaml.pyx":286 * yaml_parser_set_input(&self.parser, input_handler, self) * else: * if PyUnicode_CheckExact(stream) != 0: # <<<<<<<<<<<<<< * stream = PyUnicode_AsUTF8String(stream) * if PY_MAJOR_VERSION < 3: */ goto __pyx_L22; } /* "_ruamel_yaml.pyx":294 * self.unicode_source = 1 * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * self.stream_name = '' * else: */ /*else*/ { __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":295 * else: * if PY_MAJOR_VERSION < 3: * self.stream_name = '' # <<<<<<<<<<<<<< * else: * self.stream_name = u'' */ __Pyx_INCREF(__pyx_kp_s_byte_string); __Pyx_GIVEREF(__pyx_kp_s_byte_string); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_kp_s_byte_string; /* "_ruamel_yaml.pyx":294 * self.unicode_source = 1 * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * self.stream_name = '' * else: */ goto __pyx_L24; } /* "_ruamel_yaml.pyx":297 * self.stream_name = '' * else: * self.stream_name = u'' # <<<<<<<<<<<<<< * if PyString_CheckExact(stream) == 0: * if PY_MAJOR_VERSION < 3: */ /*else*/ { __Pyx_INCREF(__pyx_kp_u_byte_string); __Pyx_GIVEREF(__pyx_kp_u_byte_string); __Pyx_GOTREF(__pyx_v_self->stream_name); __Pyx_DECREF(__pyx_v_self->stream_name); __pyx_v_self->stream_name = __pyx_kp_u_byte_string; } __pyx_L24:; } __pyx_L22:; /* "_ruamel_yaml.pyx":298 * else: * self.stream_name = u'' * if PyString_CheckExact(stream) == 0: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("a string or stream input is required") */ __pyx_t_1 = ((PyString_CheckExact(__pyx_v_stream) == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":299 * self.stream_name = u'' * if PyString_CheckExact(stream) == 0: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("a string or stream input is required") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":300 * if PyString_CheckExact(stream) == 0: * if PY_MAJOR_VERSION < 3: * raise TypeError("a string or stream input is required") # <<<<<<<<<<<<<< * else: * raise TypeError(u"a string or stream input is required") */ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 300, __pyx_L1_error) /* "_ruamel_yaml.pyx":299 * self.stream_name = u'' * if PyString_CheckExact(stream) == 0: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("a string or stream input is required") * else: */ } /* "_ruamel_yaml.pyx":302 * raise TypeError("a string or stream input is required") * else: * raise TypeError(u"a string or stream input is required") # <<<<<<<<<<<<<< * self.stream = stream * yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) */ /*else*/ { __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 302, __pyx_L1_error) } /* "_ruamel_yaml.pyx":298 * else: * self.stream_name = u'' * if PyString_CheckExact(stream) == 0: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("a string or stream input is required") */ } /* "_ruamel_yaml.pyx":303 * else: * raise TypeError(u"a string or stream input is required") * self.stream = stream # <<<<<<<<<<<<<< * yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) * self.current_token = None */ __Pyx_INCREF(__pyx_v_stream); __Pyx_GIVEREF(__pyx_v_stream); __Pyx_GOTREF(__pyx_v_self->stream); __Pyx_DECREF(__pyx_v_self->stream); __pyx_v_self->stream = __pyx_v_stream; /* "_ruamel_yaml.pyx":304 * raise TypeError(u"a string or stream input is required") * self.stream = stream * yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) # <<<<<<<<<<<<<< * self.current_token = None * self.current_event = None */ yaml_parser_set_input_string((&__pyx_v_self->parser), PyString_AS_STRING(__pyx_v_stream), PyString_GET_SIZE(__pyx_v_stream)); } __pyx_L12:; /* "_ruamel_yaml.pyx":305 * self.stream = stream * yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) * self.current_token = None # <<<<<<<<<<<<<< * self.current_event = None * self.anchors = {} */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->current_token); __Pyx_DECREF(__pyx_v_self->current_token); __pyx_v_self->current_token = Py_None; /* "_ruamel_yaml.pyx":306 * yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) * self.current_token = None * self.current_event = None # <<<<<<<<<<<<<< * self.anchors = {} * */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->current_event); __Pyx_DECREF(__pyx_v_self->current_event); __pyx_v_self->current_event = Py_None; /* "_ruamel_yaml.pyx":307 * self.current_token = None * self.current_event = None * self.anchors = {} # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_GOTREF(__pyx_v_self->anchors); __Pyx_DECREF(__pyx_v_self->anchors); __pyx_v_self->anchors = __pyx_t_5; __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":261 * cdef int unicode_source * * def __init__(self, stream): # <<<<<<<<<<<<<< * cdef is_readable * if yaml_parser_initialize(&self.parser) == 0: */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_ruamel_yaml.CParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_is_readable); __Pyx_XDECREF(__pyx_v_stream); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":309 * self.anchors = {} * * def __dealloc__(self): # <<<<<<<<<<<<<< * yaml_parser_delete(&self.parser) * yaml_event_delete(&self.parsed_event) */ /* Python wrapper */ static void __pyx_pw_12_ruamel_yaml_7CParser_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_12_ruamel_yaml_7CParser_3__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_12_ruamel_yaml_7CParser_2__dealloc__(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_12_ruamel_yaml_7CParser_2__dealloc__(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); /* "_ruamel_yaml.pyx":310 * * def __dealloc__(self): * yaml_parser_delete(&self.parser) # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * */ yaml_parser_delete((&__pyx_v_self->parser)); /* "_ruamel_yaml.pyx":311 * def __dealloc__(self): * yaml_parser_delete(&self.parser) * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * * def dispose(self): */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":309 * self.anchors = {} * * def __dealloc__(self): # <<<<<<<<<<<<<< * yaml_parser_delete(&self.parser) * yaml_event_delete(&self.parsed_event) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "_ruamel_yaml.pyx":313 * yaml_event_delete(&self.parsed_event) * * def dispose(self): # <<<<<<<<<<<<<< * pass * */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_5dispose(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_5dispose(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("dispose (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_4dispose(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_4dispose(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("dispose", 0); /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":316 * pass * * cdef object _parser_error(self): # <<<<<<<<<<<<<< * if self.parser.error == YAML_MEMORY_ERROR: * return MemoryError */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__parser_error(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_v_context_mark = NULL; PyObject *__pyx_v_problem_mark = NULL; PyObject *__pyx_v_context = NULL; PyObject *__pyx_v_problem = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("_parser_error", 0); /* "_ruamel_yaml.pyx":317 * * cdef object _parser_error(self): * if self.parser.error == YAML_MEMORY_ERROR: # <<<<<<<<<<<<<< * return MemoryError * elif self.parser.error == YAML_READER_ERROR: */ switch (__pyx_v_self->parser.error) { case YAML_MEMORY_ERROR: /* "_ruamel_yaml.pyx":318 * cdef object _parser_error(self): * if self.parser.error == YAML_MEMORY_ERROR: * return MemoryError # <<<<<<<<<<<<<< * elif self.parser.error == YAML_READER_ERROR: * if PY_MAJOR_VERSION < 3: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_builtin_MemoryError); __pyx_r = __pyx_builtin_MemoryError; goto __pyx_L0; /* "_ruamel_yaml.pyx":317 * * cdef object _parser_error(self): * if self.parser.error == YAML_MEMORY_ERROR: # <<<<<<<<<<<<<< * return MemoryError * elif self.parser.error == YAML_READER_ERROR: */ break; /* "_ruamel_yaml.pyx":319 * if self.parser.error == YAML_MEMORY_ERROR: * return MemoryError * elif self.parser.error == YAML_READER_ERROR: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * return ReaderError(self.stream_name, self.parser.problem_offset, */ case YAML_READER_ERROR: /* "_ruamel_yaml.pyx":320 * return MemoryError * elif self.parser.error == YAML_READER_ERROR: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return ReaderError(self.stream_name, self.parser.problem_offset, * self.parser.problem_value, '?', self.parser.problem) */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":321 * elif self.parser.error == YAML_READER_ERROR: * if PY_MAJOR_VERSION < 3: * return ReaderError(self.stream_name, self.parser.problem_offset, # <<<<<<<<<<<<<< * self.parser.problem_value, '?', self.parser.problem) * else: */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ReaderError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_offset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":322 * if PY_MAJOR_VERSION < 3: * return ReaderError(self.stream_name, self.parser.problem_offset, * self.parser.problem_value, '?', self.parser.problem) # <<<<<<<<<<<<<< * else: * return ReaderError(self.stream_name, self.parser.problem_offset, */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->parser.problem); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_7, __pyx_v_self->stream_name, __pyx_t_4, __pyx_t_5, __pyx_kp_s__3, __pyx_t_6}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_7, __pyx_v_self->stream_name, __pyx_t_4, __pyx_t_5, __pyx_kp_s__3, __pyx_t_6}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_kp_s__3); __Pyx_GIVEREF(__pyx_kp_s__3); PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, __pyx_kp_s__3); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_8, __pyx_t_6); __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":320 * return MemoryError * elif self.parser.error == YAML_READER_ERROR: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return ReaderError(self.stream_name, self.parser.problem_offset, * self.parser.problem_value, '?', self.parser.problem) */ } /* "_ruamel_yaml.pyx":324 * self.parser.problem_value, '?', self.parser.problem) * else: * return ReaderError(self.stream_name, self.parser.problem_offset, # <<<<<<<<<<<<<< * self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) * elif self.parser.error == YAML_SCANNER_ERROR \ */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ReaderError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_offset); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); /* "_ruamel_yaml.pyx":325 * else: * return ReaderError(self.stream_name, self.parser.problem_offset, * self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) # <<<<<<<<<<<<<< * elif self.parser.error == YAML_SCANNER_ERROR \ * or self.parser.error == YAML_PARSER_ERROR: */ __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = PyUnicode_FromString(__pyx_v_self->parser.problem); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_4, __pyx_v_self->stream_name, __pyx_t_9, __pyx_t_6, __pyx_kp_u__3, __pyx_t_5}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_4, __pyx_v_self->stream_name, __pyx_t_9, __pyx_t_6, __pyx_kp_u__3, __pyx_t_5}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_kp_u__3); __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_8, __pyx_kp_u__3); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 4+__pyx_t_8, __pyx_t_5); __pyx_t_9 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "_ruamel_yaml.pyx":319 * if self.parser.error == YAML_MEMORY_ERROR: * return MemoryError * elif self.parser.error == YAML_READER_ERROR: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * return ReaderError(self.stream_name, self.parser.problem_offset, */ break; /* "_ruamel_yaml.pyx":326 * return ReaderError(self.stream_name, self.parser.problem_offset, * self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) * elif self.parser.error == YAML_SCANNER_ERROR \ # <<<<<<<<<<<<<< * or self.parser.error == YAML_PARSER_ERROR: * context_mark = None */ case YAML_SCANNER_ERROR: /* "_ruamel_yaml.pyx":327 * self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) * elif self.parser.error == YAML_SCANNER_ERROR \ * or self.parser.error == YAML_PARSER_ERROR: # <<<<<<<<<<<<<< * context_mark = None * problem_mark = None */ case YAML_PARSER_ERROR: /* "_ruamel_yaml.pyx":328 * elif self.parser.error == YAML_SCANNER_ERROR \ * or self.parser.error == YAML_PARSER_ERROR: * context_mark = None # <<<<<<<<<<<<<< * problem_mark = None * if self.parser.context != NULL: */ __Pyx_INCREF(Py_None); __pyx_v_context_mark = Py_None; /* "_ruamel_yaml.pyx":329 * or self.parser.error == YAML_PARSER_ERROR: * context_mark = None * problem_mark = None # <<<<<<<<<<<<<< * if self.parser.context != NULL: * context_mark = Mark(self.stream_name, */ __Pyx_INCREF(Py_None); __pyx_v_problem_mark = Py_None; /* "_ruamel_yaml.pyx":330 * context_mark = None * problem_mark = None * if self.parser.context != NULL: # <<<<<<<<<<<<<< * context_mark = Mark(self.stream_name, * self.parser.context_mark.index, */ __pyx_t_1 = ((__pyx_v_self->parser.context != NULL) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":332 * if self.parser.context != NULL: * context_mark = Mark(self.stream_name, * self.parser.context_mark.index, # <<<<<<<<<<<<<< * self.parser.context_mark.line, * self.parser.context_mark.column, None, None) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->parser.context_mark.index); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":333 * context_mark = Mark(self.stream_name, * self.parser.context_mark.index, * self.parser.context_mark.line, # <<<<<<<<<<<<<< * self.parser.context_mark.column, None, None) * if self.parser.problem != NULL: */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parser.context_mark.line); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":334 * self.parser.context_mark.index, * self.parser.context_mark.line, * self.parser.context_mark.column, None, None) # <<<<<<<<<<<<<< * if self.parser.problem != NULL: * problem_mark = Mark(self.stream_name, */ __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_self->parser.context_mark.column); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); /* "_ruamel_yaml.pyx":331 * problem_mark = None * if self.parser.context != NULL: * context_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parser.context_mark.index, * self.parser.context_mark.line, */ __pyx_t_5 = PyTuple_New(6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_7); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_context_mark, __pyx_t_7); __pyx_t_7 = 0; /* "_ruamel_yaml.pyx":330 * context_mark = None * problem_mark = None * if self.parser.context != NULL: # <<<<<<<<<<<<<< * context_mark = Mark(self.stream_name, * self.parser.context_mark.index, */ } /* "_ruamel_yaml.pyx":335 * self.parser.context_mark.line, * self.parser.context_mark.column, None, None) * if self.parser.problem != NULL: # <<<<<<<<<<<<<< * problem_mark = Mark(self.stream_name, * self.parser.problem_mark.index, */ __pyx_t_1 = ((__pyx_v_self->parser.problem != NULL) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":337 * if self.parser.problem != NULL: * problem_mark = Mark(self.stream_name, * self.parser.problem_mark.index, # <<<<<<<<<<<<<< * self.parser.problem_mark.line, * self.parser.problem_mark.column, None, None) */ __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_mark.index); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); /* "_ruamel_yaml.pyx":338 * problem_mark = Mark(self.stream_name, * self.parser.problem_mark.index, * self.parser.problem_mark.line, # <<<<<<<<<<<<<< * self.parser.problem_mark.column, None, None) * context = None */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_mark.line); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "_ruamel_yaml.pyx":339 * self.parser.problem_mark.index, * self.parser.problem_mark.line, * self.parser.problem_mark.column, None, None) # <<<<<<<<<<<<<< * context = None * if self.parser.context != NULL: */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parser.problem_mark.column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":336 * self.parser.context_mark.column, None, None) * if self.parser.problem != NULL: * problem_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parser.problem_mark.index, * self.parser.problem_mark.line, */ __pyx_t_2 = PyTuple_New(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_2, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_2, 5, Py_None); __pyx_t_7 = 0; __pyx_t_5 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_problem_mark, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":335 * self.parser.context_mark.line, * self.parser.context_mark.column, None, None) * if self.parser.problem != NULL: # <<<<<<<<<<<<<< * problem_mark = Mark(self.stream_name, * self.parser.problem_mark.index, */ } /* "_ruamel_yaml.pyx":340 * self.parser.problem_mark.line, * self.parser.problem_mark.column, None, None) * context = None # <<<<<<<<<<<<<< * if self.parser.context != NULL: * if PY_MAJOR_VERSION < 3: */ __Pyx_INCREF(Py_None); __pyx_v_context = Py_None; /* "_ruamel_yaml.pyx":341 * self.parser.problem_mark.column, None, None) * context = None * if self.parser.context != NULL: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * context = self.parser.context */ __pyx_t_1 = ((__pyx_v_self->parser.context != NULL) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":342 * context = None * if self.parser.context != NULL: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * context = self.parser.context * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":343 * if self.parser.context != NULL: * if PY_MAJOR_VERSION < 3: * context = self.parser.context # <<<<<<<<<<<<<< * else: * context = PyUnicode_FromString(self.parser.context) */ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->parser.context); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_context, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":342 * context = None * if self.parser.context != NULL: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * context = self.parser.context * else: */ goto __pyx_L7; } /* "_ruamel_yaml.pyx":345 * context = self.parser.context * else: * context = PyUnicode_FromString(self.parser.context) # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * problem = self.parser.problem */ /*else*/ { __pyx_t_3 = PyUnicode_FromString(__pyx_v_self->parser.context); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_context, __pyx_t_3); __pyx_t_3 = 0; } __pyx_L7:; /* "_ruamel_yaml.pyx":341 * self.parser.problem_mark.column, None, None) * context = None * if self.parser.context != NULL: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * context = self.parser.context */ } /* "_ruamel_yaml.pyx":346 * else: * context = PyUnicode_FromString(self.parser.context) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * problem = self.parser.problem * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":347 * context = PyUnicode_FromString(self.parser.context) * if PY_MAJOR_VERSION < 3: * problem = self.parser.problem # <<<<<<<<<<<<<< * else: * problem = PyUnicode_FromString(self.parser.problem) */ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->parser.problem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_problem = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":346 * else: * context = PyUnicode_FromString(self.parser.context) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * problem = self.parser.problem * else: */ goto __pyx_L8; } /* "_ruamel_yaml.pyx":349 * problem = self.parser.problem * else: * problem = PyUnicode_FromString(self.parser.problem) # <<<<<<<<<<<<<< * if self.parser.error == YAML_SCANNER_ERROR: * return ScannerError(context, context_mark, problem, problem_mark) */ /*else*/ { __pyx_t_3 = PyUnicode_FromString(__pyx_v_self->parser.problem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_problem = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L8:; /* "_ruamel_yaml.pyx":350 * else: * problem = PyUnicode_FromString(self.parser.problem) * if self.parser.error == YAML_SCANNER_ERROR: # <<<<<<<<<<<<<< * return ScannerError(context, context_mark, problem, problem_mark) * else: */ __pyx_t_1 = ((__pyx_v_self->parser.error == YAML_SCANNER_ERROR) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":351 * problem = PyUnicode_FromString(self.parser.problem) * if self.parser.error == YAML_SCANNER_ERROR: * return ScannerError(context, context_mark, problem, problem_mark) # <<<<<<<<<<<<<< * else: * return ParserError(context, context_mark, problem, problem_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScannerError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[5] = {__pyx_t_5, __pyx_v_context, __pyx_v_context_mark, __pyx_v_problem, __pyx_v_problem_mark}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[5] = {__pyx_t_5, __pyx_v_context, __pyx_v_context_mark, __pyx_v_problem, __pyx_v_problem_mark}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_7 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_v_context); __Pyx_GIVEREF(__pyx_v_context); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_v_context); __Pyx_INCREF(__pyx_v_context_mark); __Pyx_GIVEREF(__pyx_v_context_mark); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_v_context_mark); __Pyx_INCREF(__pyx_v_problem); __Pyx_GIVEREF(__pyx_v_problem); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_v_problem); __Pyx_INCREF(__pyx_v_problem_mark); __Pyx_GIVEREF(__pyx_v_problem_mark); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_8, __pyx_v_problem_mark); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":350 * else: * problem = PyUnicode_FromString(self.parser.problem) * if self.parser.error == YAML_SCANNER_ERROR: # <<<<<<<<<<<<<< * return ScannerError(context, context_mark, problem, problem_mark) * else: */ } /* "_ruamel_yaml.pyx":353 * return ScannerError(context, context_mark, problem, problem_mark) * else: * return ParserError(context, context_mark, problem, problem_mark) # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise ValueError("no parser error") */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ParserError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_context, __pyx_v_context_mark, __pyx_v_problem, __pyx_v_problem_mark}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_context, __pyx_v_context_mark, __pyx_v_problem, __pyx_v_problem_mark}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_5 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_v_context); __Pyx_GIVEREF(__pyx_v_context); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_8, __pyx_v_context); __Pyx_INCREF(__pyx_v_context_mark); __Pyx_GIVEREF(__pyx_v_context_mark); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_8, __pyx_v_context_mark); __Pyx_INCREF(__pyx_v_problem); __Pyx_GIVEREF(__pyx_v_problem); PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_8, __pyx_v_problem); __Pyx_INCREF(__pyx_v_problem_mark); __Pyx_GIVEREF(__pyx_v_problem_mark); PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_8, __pyx_v_problem_mark); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "_ruamel_yaml.pyx":326 * return ReaderError(self.stream_name, self.parser.problem_offset, * self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) * elif self.parser.error == YAML_SCANNER_ERROR \ # <<<<<<<<<<<<<< * or self.parser.error == YAML_PARSER_ERROR: * context_mark = None */ break; default: break; } /* "_ruamel_yaml.pyx":354 * else: * return ParserError(context, context_mark, problem, problem_mark) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("no parser error") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":355 * return ParserError(context, context_mark, problem, problem_mark) * if PY_MAJOR_VERSION < 3: * raise ValueError("no parser error") # <<<<<<<<<<<<<< * else: * raise ValueError(u"no parser error") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 355, __pyx_L1_error) /* "_ruamel_yaml.pyx":354 * else: * return ParserError(context, context_mark, problem, problem_mark) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("no parser error") * else: */ } /* "_ruamel_yaml.pyx":357 * raise ValueError("no parser error") * else: * raise ValueError(u"no parser error") # <<<<<<<<<<<<<< * * def raw_scan(self): */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 357, __pyx_L1_error) } /* "_ruamel_yaml.pyx":316 * pass * * cdef object _parser_error(self): # <<<<<<<<<<<<<< * if self.parser.error == YAML_MEMORY_ERROR: * return MemoryError */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_ruamel_yaml.CParser._parser_error", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_context_mark); __Pyx_XDECREF(__pyx_v_problem_mark); __Pyx_XDECREF(__pyx_v_context); __Pyx_XDECREF(__pyx_v_problem); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":359 * raise ValueError(u"no parser error") * * def raw_scan(self): # <<<<<<<<<<<<<< * cdef yaml_token_t token * cdef int done */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_7raw_scan(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_7raw_scan(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("raw_scan (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_6raw_scan(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_6raw_scan(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { yaml_token_t __pyx_v_token; int __pyx_v_done; int __pyx_v_count; PyObject *__pyx_v_error = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("raw_scan", 0); /* "_ruamel_yaml.pyx":363 * cdef int done * cdef int count * count = 0 # <<<<<<<<<<<<<< * done = 0 * while done == 0: */ __pyx_v_count = 0; /* "_ruamel_yaml.pyx":364 * cdef int count * count = 0 * done = 0 # <<<<<<<<<<<<<< * while done == 0: * if yaml_parser_scan(&self.parser, &token) == 0: */ __pyx_v_done = 0; /* "_ruamel_yaml.pyx":365 * count = 0 * done = 0 * while done == 0: # <<<<<<<<<<<<<< * if yaml_parser_scan(&self.parser, &token) == 0: * error = self._parser_error() */ while (1) { __pyx_t_1 = ((__pyx_v_done == 0) != 0); if (!__pyx_t_1) break; /* "_ruamel_yaml.pyx":366 * done = 0 * while done == 0: * if yaml_parser_scan(&self.parser, &token) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ __pyx_t_2 = yaml_parser_scan((&__pyx_v_self->parser), (&__pyx_v_token)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 366, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_2 == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":367 * while done == 0: * if yaml_parser_scan(&self.parser, &token) == 0: * error = self._parser_error() # <<<<<<<<<<<<<< * raise error * if token.type == YAML_NO_TOKEN: */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parser_error(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_error = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":368 * if yaml_parser_scan(&self.parser, &token) == 0: * error = self._parser_error() * raise error # <<<<<<<<<<<<<< * if token.type == YAML_NO_TOKEN: * done = 1 */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 368, __pyx_L1_error) /* "_ruamel_yaml.pyx":366 * done = 0 * while done == 0: * if yaml_parser_scan(&self.parser, &token) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ } /* "_ruamel_yaml.pyx":369 * error = self._parser_error() * raise error * if token.type == YAML_NO_TOKEN: # <<<<<<<<<<<<<< * done = 1 * else: */ __pyx_t_1 = ((__pyx_v_token.type == YAML_NO_TOKEN) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":370 * raise error * if token.type == YAML_NO_TOKEN: * done = 1 # <<<<<<<<<<<<<< * else: * count = count+1 */ __pyx_v_done = 1; /* "_ruamel_yaml.pyx":369 * error = self._parser_error() * raise error * if token.type == YAML_NO_TOKEN: # <<<<<<<<<<<<<< * done = 1 * else: */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":372 * done = 1 * else: * count = count+1 # <<<<<<<<<<<<<< * yaml_token_delete(&token) * return count */ /*else*/ { __pyx_v_count = (__pyx_v_count + 1); } __pyx_L6:; /* "_ruamel_yaml.pyx":373 * else: * count = count+1 * yaml_token_delete(&token) # <<<<<<<<<<<<<< * return count * */ yaml_token_delete((&__pyx_v_token)); } /* "_ruamel_yaml.pyx":374 * count = count+1 * yaml_token_delete(&token) * return count # <<<<<<<<<<<<<< * * cdef object _scan(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_count); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":359 * raise ValueError(u"no parser error") * * def raw_scan(self): # <<<<<<<<<<<<<< * cdef yaml_token_t token * cdef int done */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.raw_scan", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":376 * return count * * cdef object _scan(self): # <<<<<<<<<<<<<< * cdef yaml_token_t token * if yaml_parser_scan(&self.parser, &token) == 0: */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__scan(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { yaml_token_t __pyx_v_token; PyObject *__pyx_v_error = NULL; PyObject *__pyx_v_token_object = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("_scan", 0); /* "_ruamel_yaml.pyx":378 * cdef object _scan(self): * cdef yaml_token_t token * if yaml_parser_scan(&self.parser, &token) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ __pyx_t_1 = yaml_parser_scan((&__pyx_v_self->parser), (&__pyx_v_token)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 378, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_1 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":379 * cdef yaml_token_t token * if yaml_parser_scan(&self.parser, &token) == 0: * error = self._parser_error() # <<<<<<<<<<<<<< * raise error * token_object = self._token_to_object(&token) */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parser_error(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_error = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":380 * if yaml_parser_scan(&self.parser, &token) == 0: * error = self._parser_error() * raise error # <<<<<<<<<<<<<< * token_object = self._token_to_object(&token) * yaml_token_delete(&token) */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 380, __pyx_L1_error) /* "_ruamel_yaml.pyx":378 * cdef object _scan(self): * cdef yaml_token_t token * if yaml_parser_scan(&self.parser, &token) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ } /* "_ruamel_yaml.pyx":381 * error = self._parser_error() * raise error * token_object = self._token_to_object(&token) # <<<<<<<<<<<<<< * yaml_token_delete(&token) * return token_object */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_token_to_object(__pyx_v_self, (&__pyx_v_token)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_token_object = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":382 * raise error * token_object = self._token_to_object(&token) * yaml_token_delete(&token) # <<<<<<<<<<<<<< * return token_object * */ yaml_token_delete((&__pyx_v_token)); /* "_ruamel_yaml.pyx":383 * token_object = self._token_to_object(&token) * yaml_token_delete(&token) * return token_object # <<<<<<<<<<<<<< * * cdef object _token_to_object(self, yaml_token_t *token): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_token_object); __pyx_r = __pyx_v_token_object; goto __pyx_L0; /* "_ruamel_yaml.pyx":376 * return count * * cdef object _scan(self): # <<<<<<<<<<<<<< * cdef yaml_token_t token * if yaml_parser_scan(&self.parser, &token) == 0: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser._scan", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XDECREF(__pyx_v_token_object); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":385 * return token_object * * cdef object _token_to_object(self, yaml_token_t *token): # <<<<<<<<<<<<<< * start_mark = Mark(self.stream_name, * token.start_mark.index, */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__token_to_object(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, yaml_token_t *__pyx_v_token) { struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_start_mark = NULL; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_end_mark = NULL; PyObject *__pyx_v_encoding = NULL; PyObject *__pyx_v_handle = NULL; PyObject *__pyx_v_prefix = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_suffix = NULL; int __pyx_v_plain; PyObject *__pyx_v_style = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; __Pyx_RefNannySetupContext("_token_to_object", 0); /* "_ruamel_yaml.pyx":387 * cdef object _token_to_object(self, yaml_token_t *token): * start_mark = Mark(self.stream_name, * token.start_mark.index, # <<<<<<<<<<<<<< * token.start_mark.line, * token.start_mark.column, */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_token->start_mark.index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":388 * start_mark = Mark(self.stream_name, * token.start_mark.index, * token.start_mark.line, # <<<<<<<<<<<<<< * token.start_mark.column, * None, None) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_token->start_mark.line); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":389 * token.start_mark.index, * token.start_mark.line, * token.start_mark.column, # <<<<<<<<<<<<<< * None, None) * end_mark = Mark(self.stream_name, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_token->start_mark.column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":386 * * cdef object _token_to_object(self, yaml_token_t *token): * start_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * token.start_mark.index, * token.start_mark.line, */ __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 386, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 5, Py_None); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 386, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_start_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":392 * None, None) * end_mark = Mark(self.stream_name, * token.end_mark.index, # <<<<<<<<<<<<<< * token.end_mark.line, * token.end_mark.column, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_token->end_mark.index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":393 * end_mark = Mark(self.stream_name, * token.end_mark.index, * token.end_mark.line, # <<<<<<<<<<<<<< * token.end_mark.column, * None, None) */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_token->end_mark.line); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":394 * token.end_mark.index, * token.end_mark.line, * token.end_mark.column, # <<<<<<<<<<<<<< * None, None) * if token.type == YAML_NO_TOKEN: */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_token->end_mark.column); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":391 * token.start_mark.column, * None, None) * end_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * token.end_mark.index, * token.end_mark.line, */ __pyx_t_1 = PyTuple_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_2); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 5, Py_None); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_end_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":396 * token.end_mark.column, * None, None) * if token.type == YAML_NO_TOKEN: # <<<<<<<<<<<<<< * return None * elif token.type == YAML_STREAM_START_TOKEN: */ switch (__pyx_v_token->type) { case YAML_NO_TOKEN: /* "_ruamel_yaml.pyx":397 * None, None) * if token.type == YAML_NO_TOKEN: * return None # <<<<<<<<<<<<<< * elif token.type == YAML_STREAM_START_TOKEN: * encoding = None */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; /* "_ruamel_yaml.pyx":396 * token.end_mark.column, * None, None) * if token.type == YAML_NO_TOKEN: # <<<<<<<<<<<<<< * return None * elif token.type == YAML_STREAM_START_TOKEN: */ break; /* "_ruamel_yaml.pyx":398 * if token.type == YAML_NO_TOKEN: * return None * elif token.type == YAML_STREAM_START_TOKEN: # <<<<<<<<<<<<<< * encoding = None * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: */ case YAML_STREAM_START_TOKEN: /* "_ruamel_yaml.pyx":399 * return None * elif token.type == YAML_STREAM_START_TOKEN: * encoding = None # <<<<<<<<<<<<<< * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: */ __Pyx_INCREF(Py_None); __pyx_v_encoding = Py_None; /* "_ruamel_yaml.pyx":400 * elif token.type == YAML_STREAM_START_TOKEN: * encoding = None * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: # <<<<<<<<<<<<<< * if self.unicode_source == 0: * encoding = u"utf-8" */ __pyx_t_5 = ((__pyx_v_token->data.stream_start.encoding == YAML_UTF8_ENCODING) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":401 * encoding = None * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: # <<<<<<<<<<<<<< * encoding = u"utf-8" * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: */ __pyx_t_5 = ((__pyx_v_self->unicode_source == 0) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":402 * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: * encoding = u"utf-8" # <<<<<<<<<<<<<< * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" */ __Pyx_INCREF(__pyx_kp_u_utf_8); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_8); /* "_ruamel_yaml.pyx":401 * encoding = None * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: # <<<<<<<<<<<<<< * encoding = u"utf-8" * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: */ } /* "_ruamel_yaml.pyx":400 * elif token.type == YAML_STREAM_START_TOKEN: * encoding = None * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: # <<<<<<<<<<<<<< * if self.unicode_source == 0: * encoding = u"utf-8" */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":403 * if self.unicode_source == 0: * encoding = u"utf-8" * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-le" * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: */ __pyx_t_5 = ((__pyx_v_token->data.stream_start.encoding == YAML_UTF16LE_ENCODING) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":404 * encoding = u"utf-8" * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" # <<<<<<<<<<<<<< * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: * encoding = u"utf-16-be" */ __Pyx_INCREF(__pyx_kp_u_utf_16_le); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_16_le); /* "_ruamel_yaml.pyx":403 * if self.unicode_source == 0: * encoding = u"utf-8" * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-le" * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":405 * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-be" * return StreamStartToken(start_mark, end_mark, encoding) */ __pyx_t_5 = ((__pyx_v_token->data.stream_start.encoding == YAML_UTF16BE_ENCODING) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":406 * encoding = u"utf-16-le" * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: * encoding = u"utf-16-be" # <<<<<<<<<<<<<< * return StreamStartToken(start_mark, end_mark, encoding) * elif token.type == YAML_STREAM_END_TOKEN: */ __Pyx_INCREF(__pyx_kp_u_utf_16_be); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_16_be); /* "_ruamel_yaml.pyx":405 * elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-be" * return StreamStartToken(start_mark, end_mark, encoding) */ } __pyx_L3:; /* "_ruamel_yaml.pyx":407 * elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: * encoding = u"utf-16-be" * return StreamStartToken(start_mark, end_mark, encoding) # <<<<<<<<<<<<<< * elif token.type == YAML_STREAM_END_TOKEN: * return StreamEndToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_StreamStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_encoding}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_encoding}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_encoding); __Pyx_GIVEREF(__pyx_v_encoding); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, __pyx_v_encoding); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":398 * if token.type == YAML_NO_TOKEN: * return None * elif token.type == YAML_STREAM_START_TOKEN: # <<<<<<<<<<<<<< * encoding = None * if token.data.stream_start.encoding == YAML_UTF8_ENCODING: */ break; /* "_ruamel_yaml.pyx":408 * encoding = u"utf-16-be" * return StreamStartToken(start_mark, end_mark, encoding) * elif token.type == YAML_STREAM_END_TOKEN: # <<<<<<<<<<<<<< * return StreamEndToken(start_mark, end_mark) * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: */ case YAML_STREAM_END_TOKEN: /* "_ruamel_yaml.pyx":409 * return StreamStartToken(start_mark, end_mark, encoding) * elif token.type == YAML_STREAM_END_TOKEN: * return StreamEndToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: * return DirectiveToken(u"YAML", */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_StreamEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":408 * encoding = u"utf-16-be" * return StreamStartToken(start_mark, end_mark, encoding) * elif token.type == YAML_STREAM_END_TOKEN: # <<<<<<<<<<<<<< * return StreamEndToken(start_mark, end_mark) * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: */ break; /* "_ruamel_yaml.pyx":410 * elif token.type == YAML_STREAM_END_TOKEN: * return StreamEndToken(start_mark, end_mark) * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: # <<<<<<<<<<<<<< * return DirectiveToken(u"YAML", * (token.data.version_directive.major, */ case YAML_VERSION_DIRECTIVE_TOKEN: /* "_ruamel_yaml.pyx":411 * return StreamEndToken(start_mark, end_mark) * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: * return DirectiveToken(u"YAML", # <<<<<<<<<<<<<< * (token.data.version_directive.major, * token.data.version_directive.minor), */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DirectiveToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":412 * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: * return DirectiveToken(u"YAML", * (token.data.version_directive.major, # <<<<<<<<<<<<<< * token.data.version_directive.minor), * start_mark, end_mark) */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_token->data.version_directive.major); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":413 * return DirectiveToken(u"YAML", * (token.data.version_directive.major, * token.data.version_directive.minor), # <<<<<<<<<<<<<< * start_mark, end_mark) * elif token.type == YAML_TAG_DIRECTIVE_TOKEN: */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_token->data.version_directive.minor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":412 * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: * return DirectiveToken(u"YAML", * (token.data.version_directive.major, # <<<<<<<<<<<<<< * token.data.version_directive.minor), * start_mark, end_mark) */ __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); __pyx_t_4 = 0; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":414 * (token.data.version_directive.major, * token.data.version_directive.minor), * start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_TAG_DIRECTIVE_TOKEN: * handle = PyUnicode_FromString(token.data.tag_directive.handle) */ __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_n_u_YAML, __pyx_t_7, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_n_u_YAML, __pyx_t_7, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_4 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_n_u_YAML); __Pyx_GIVEREF(__pyx_n_u_YAML); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_n_u_YAML); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, __pyx_t_7); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_7 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":410 * elif token.type == YAML_STREAM_END_TOKEN: * return StreamEndToken(start_mark, end_mark) * elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: # <<<<<<<<<<<<<< * return DirectiveToken(u"YAML", * (token.data.version_directive.major, */ break; /* "_ruamel_yaml.pyx":415 * token.data.version_directive.minor), * start_mark, end_mark) * elif token.type == YAML_TAG_DIRECTIVE_TOKEN: # <<<<<<<<<<<<<< * handle = PyUnicode_FromString(token.data.tag_directive.handle) * prefix = PyUnicode_FromString(token.data.tag_directive.prefix) */ case YAML_TAG_DIRECTIVE_TOKEN: /* "_ruamel_yaml.pyx":416 * start_mark, end_mark) * elif token.type == YAML_TAG_DIRECTIVE_TOKEN: * handle = PyUnicode_FromString(token.data.tag_directive.handle) # <<<<<<<<<<<<<< * prefix = PyUnicode_FromString(token.data.tag_directive.prefix) * return DirectiveToken(u"TAG", (handle, prefix), */ __pyx_t_2 = PyUnicode_FromString(__pyx_v_token->data.tag_directive.handle); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_handle = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":417 * elif token.type == YAML_TAG_DIRECTIVE_TOKEN: * handle = PyUnicode_FromString(token.data.tag_directive.handle) * prefix = PyUnicode_FromString(token.data.tag_directive.prefix) # <<<<<<<<<<<<<< * return DirectiveToken(u"TAG", (handle, prefix), * start_mark, end_mark) */ __pyx_t_2 = PyUnicode_FromString(__pyx_v_token->data.tag_directive.prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_prefix = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":418 * handle = PyUnicode_FromString(token.data.tag_directive.handle) * prefix = PyUnicode_FromString(token.data.tag_directive.prefix) * return DirectiveToken(u"TAG", (handle, prefix), # <<<<<<<<<<<<<< * start_mark, end_mark) * elif token.type == YAML_DOCUMENT_START_TOKEN: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DirectiveToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_handle); __Pyx_GIVEREF(__pyx_v_handle); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_handle); __Pyx_INCREF(__pyx_v_prefix); __Pyx_GIVEREF(__pyx_v_prefix); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_prefix); /* "_ruamel_yaml.pyx":419 * prefix = PyUnicode_FromString(token.data.tag_directive.prefix) * return DirectiveToken(u"TAG", (handle, prefix), * start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_DOCUMENT_START_TOKEN: * return DocumentStartToken(start_mark, end_mark) */ __pyx_t_7 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_n_u_TAG, __pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_n_u_TAG, __pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_3 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_n_u_TAG); __Pyx_GIVEREF(__pyx_n_u_TAG); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_n_u_TAG); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 3+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":415 * token.data.version_directive.minor), * start_mark, end_mark) * elif token.type == YAML_TAG_DIRECTIVE_TOKEN: # <<<<<<<<<<<<<< * handle = PyUnicode_FromString(token.data.tag_directive.handle) * prefix = PyUnicode_FromString(token.data.tag_directive.prefix) */ break; /* "_ruamel_yaml.pyx":420 * return DirectiveToken(u"TAG", (handle, prefix), * start_mark, end_mark) * elif token.type == YAML_DOCUMENT_START_TOKEN: # <<<<<<<<<<<<<< * return DocumentStartToken(start_mark, end_mark) * elif token.type == YAML_DOCUMENT_END_TOKEN: */ case YAML_DOCUMENT_START_TOKEN: /* "_ruamel_yaml.pyx":421 * start_mark, end_mark) * elif token.type == YAML_DOCUMENT_START_TOKEN: * return DocumentStartToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_DOCUMENT_END_TOKEN: * return DocumentEndToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DocumentStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":420 * return DirectiveToken(u"TAG", (handle, prefix), * start_mark, end_mark) * elif token.type == YAML_DOCUMENT_START_TOKEN: # <<<<<<<<<<<<<< * return DocumentStartToken(start_mark, end_mark) * elif token.type == YAML_DOCUMENT_END_TOKEN: */ break; /* "_ruamel_yaml.pyx":422 * elif token.type == YAML_DOCUMENT_START_TOKEN: * return DocumentStartToken(start_mark, end_mark) * elif token.type == YAML_DOCUMENT_END_TOKEN: # <<<<<<<<<<<<<< * return DocumentEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: */ case YAML_DOCUMENT_END_TOKEN: /* "_ruamel_yaml.pyx":423 * return DocumentStartToken(start_mark, end_mark) * elif token.type == YAML_DOCUMENT_END_TOKEN: * return DocumentEndToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: * return BlockSequenceStartToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DocumentEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":422 * elif token.type == YAML_DOCUMENT_START_TOKEN: * return DocumentStartToken(start_mark, end_mark) * elif token.type == YAML_DOCUMENT_END_TOKEN: # <<<<<<<<<<<<<< * return DocumentEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: */ break; /* "_ruamel_yaml.pyx":424 * elif token.type == YAML_DOCUMENT_END_TOKEN: * return DocumentEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: # <<<<<<<<<<<<<< * return BlockSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: */ case YAML_BLOCK_SEQUENCE_START_TOKEN: /* "_ruamel_yaml.pyx":425 * return DocumentEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: * return BlockSequenceStartToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: * return BlockMappingStartToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BlockSequenceStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":424 * elif token.type == YAML_DOCUMENT_END_TOKEN: * return DocumentEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: # <<<<<<<<<<<<<< * return BlockSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: */ break; /* "_ruamel_yaml.pyx":426 * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: * return BlockSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: # <<<<<<<<<<<<<< * return BlockMappingStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_END_TOKEN: */ case YAML_BLOCK_MAPPING_START_TOKEN: /* "_ruamel_yaml.pyx":427 * return BlockSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: * return BlockMappingStartToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_BLOCK_END_TOKEN: * return BlockEndToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BlockMappingStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":426 * elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: * return BlockSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: # <<<<<<<<<<<<<< * return BlockMappingStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_END_TOKEN: */ break; /* "_ruamel_yaml.pyx":428 * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: * return BlockMappingStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_END_TOKEN: # <<<<<<<<<<<<<< * return BlockEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: */ case YAML_BLOCK_END_TOKEN: /* "_ruamel_yaml.pyx":429 * return BlockMappingStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_END_TOKEN: * return BlockEndToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: * return FlowSequenceStartToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BlockEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":428 * elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: * return BlockMappingStartToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_END_TOKEN: # <<<<<<<<<<<<<< * return BlockEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: */ break; /* "_ruamel_yaml.pyx":430 * elif token.type == YAML_BLOCK_END_TOKEN: * return BlockEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: # <<<<<<<<<<<<<< * return FlowSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: */ case YAML_FLOW_SEQUENCE_START_TOKEN: /* "_ruamel_yaml.pyx":431 * return BlockEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: * return FlowSequenceStartToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: * return FlowSequenceEndToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FlowSequenceStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":430 * elif token.type == YAML_BLOCK_END_TOKEN: * return BlockEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: # <<<<<<<<<<<<<< * return FlowSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: */ break; /* "_ruamel_yaml.pyx":432 * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: * return FlowSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: # <<<<<<<<<<<<<< * return FlowSequenceEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: */ case YAML_FLOW_SEQUENCE_END_TOKEN: /* "_ruamel_yaml.pyx":433 * return FlowSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: * return FlowSequenceEndToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: * return FlowMappingStartToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FlowSequenceEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 433, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 433, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":432 * elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: * return FlowSequenceStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: # <<<<<<<<<<<<<< * return FlowSequenceEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: */ break; /* "_ruamel_yaml.pyx":434 * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: * return FlowSequenceEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: # <<<<<<<<<<<<<< * return FlowMappingStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: */ case YAML_FLOW_MAPPING_START_TOKEN: /* "_ruamel_yaml.pyx":435 * return FlowSequenceEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: * return FlowMappingStartToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: * return FlowMappingEndToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FlowMappingStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":434 * elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: * return FlowSequenceEndToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: # <<<<<<<<<<<<<< * return FlowMappingStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: */ break; /* "_ruamel_yaml.pyx":436 * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: * return FlowMappingStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: # <<<<<<<<<<<<<< * return FlowMappingEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_ENTRY_TOKEN: */ case YAML_FLOW_MAPPING_END_TOKEN: /* "_ruamel_yaml.pyx":437 * return FlowMappingStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: * return FlowMappingEndToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_BLOCK_ENTRY_TOKEN: * return BlockEntryToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FlowMappingEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":436 * elif token.type == YAML_FLOW_MAPPING_START_TOKEN: * return FlowMappingStartToken(start_mark, end_mark) * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: # <<<<<<<<<<<<<< * return FlowMappingEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_ENTRY_TOKEN: */ break; /* "_ruamel_yaml.pyx":438 * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: * return FlowMappingEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_ENTRY_TOKEN: # <<<<<<<<<<<<<< * return BlockEntryToken(start_mark, end_mark) * elif token.type == YAML_FLOW_ENTRY_TOKEN: */ case YAML_BLOCK_ENTRY_TOKEN: /* "_ruamel_yaml.pyx":439 * return FlowMappingEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_ENTRY_TOKEN: * return BlockEntryToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_FLOW_ENTRY_TOKEN: * return FlowEntryToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_BlockEntryToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":438 * elif token.type == YAML_FLOW_MAPPING_END_TOKEN: * return FlowMappingEndToken(start_mark, end_mark) * elif token.type == YAML_BLOCK_ENTRY_TOKEN: # <<<<<<<<<<<<<< * return BlockEntryToken(start_mark, end_mark) * elif token.type == YAML_FLOW_ENTRY_TOKEN: */ break; /* "_ruamel_yaml.pyx":440 * elif token.type == YAML_BLOCK_ENTRY_TOKEN: * return BlockEntryToken(start_mark, end_mark) * elif token.type == YAML_FLOW_ENTRY_TOKEN: # <<<<<<<<<<<<<< * return FlowEntryToken(start_mark, end_mark) * elif token.type == YAML_KEY_TOKEN: */ case YAML_FLOW_ENTRY_TOKEN: /* "_ruamel_yaml.pyx":441 * return BlockEntryToken(start_mark, end_mark) * elif token.type == YAML_FLOW_ENTRY_TOKEN: * return FlowEntryToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_KEY_TOKEN: * return KeyToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FlowEntryToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":440 * elif token.type == YAML_BLOCK_ENTRY_TOKEN: * return BlockEntryToken(start_mark, end_mark) * elif token.type == YAML_FLOW_ENTRY_TOKEN: # <<<<<<<<<<<<<< * return FlowEntryToken(start_mark, end_mark) * elif token.type == YAML_KEY_TOKEN: */ break; /* "_ruamel_yaml.pyx":442 * elif token.type == YAML_FLOW_ENTRY_TOKEN: * return FlowEntryToken(start_mark, end_mark) * elif token.type == YAML_KEY_TOKEN: # <<<<<<<<<<<<<< * return KeyToken(start_mark, end_mark) * elif token.type == YAML_VALUE_TOKEN: */ case YAML_KEY_TOKEN: /* "_ruamel_yaml.pyx":443 * return FlowEntryToken(start_mark, end_mark) * elif token.type == YAML_KEY_TOKEN: * return KeyToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_VALUE_TOKEN: * return ValueToken(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_KeyToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":442 * elif token.type == YAML_FLOW_ENTRY_TOKEN: * return FlowEntryToken(start_mark, end_mark) * elif token.type == YAML_KEY_TOKEN: # <<<<<<<<<<<<<< * return KeyToken(start_mark, end_mark) * elif token.type == YAML_VALUE_TOKEN: */ break; /* "_ruamel_yaml.pyx":444 * elif token.type == YAML_KEY_TOKEN: * return KeyToken(start_mark, end_mark) * elif token.type == YAML_VALUE_TOKEN: # <<<<<<<<<<<<<< * return ValueToken(start_mark, end_mark) * elif token.type == YAML_ALIAS_TOKEN: */ case YAML_VALUE_TOKEN: /* "_ruamel_yaml.pyx":445 * return KeyToken(start_mark, end_mark) * elif token.type == YAML_VALUE_TOKEN: * return ValueToken(start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_ALIAS_TOKEN: * value = PyUnicode_FromString(token.data.alias.value) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ValueToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":444 * elif token.type == YAML_KEY_TOKEN: * return KeyToken(start_mark, end_mark) * elif token.type == YAML_VALUE_TOKEN: # <<<<<<<<<<<<<< * return ValueToken(start_mark, end_mark) * elif token.type == YAML_ALIAS_TOKEN: */ break; /* "_ruamel_yaml.pyx":446 * elif token.type == YAML_VALUE_TOKEN: * return ValueToken(start_mark, end_mark) * elif token.type == YAML_ALIAS_TOKEN: # <<<<<<<<<<<<<< * value = PyUnicode_FromString(token.data.alias.value) * return AliasToken(value, start_mark, end_mark) */ case YAML_ALIAS_TOKEN: /* "_ruamel_yaml.pyx":447 * return ValueToken(start_mark, end_mark) * elif token.type == YAML_ALIAS_TOKEN: * value = PyUnicode_FromString(token.data.alias.value) # <<<<<<<<<<<<<< * return AliasToken(value, start_mark, end_mark) * elif token.type == YAML_ANCHOR_TOKEN: */ __pyx_t_2 = PyUnicode_FromString(__pyx_v_token->data.alias.value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_value = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":448 * elif token.type == YAML_ALIAS_TOKEN: * value = PyUnicode_FromString(token.data.alias.value) * return AliasToken(value, start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_ANCHOR_TOKEN: * value = PyUnicode_FromString(token.data.anchor.value) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_AliasToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_v_value); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":446 * elif token.type == YAML_VALUE_TOKEN: * return ValueToken(start_mark, end_mark) * elif token.type == YAML_ALIAS_TOKEN: # <<<<<<<<<<<<<< * value = PyUnicode_FromString(token.data.alias.value) * return AliasToken(value, start_mark, end_mark) */ break; /* "_ruamel_yaml.pyx":449 * value = PyUnicode_FromString(token.data.alias.value) * return AliasToken(value, start_mark, end_mark) * elif token.type == YAML_ANCHOR_TOKEN: # <<<<<<<<<<<<<< * value = PyUnicode_FromString(token.data.anchor.value) * return AnchorToken(value, start_mark, end_mark) */ case YAML_ANCHOR_TOKEN: /* "_ruamel_yaml.pyx":450 * return AliasToken(value, start_mark, end_mark) * elif token.type == YAML_ANCHOR_TOKEN: * value = PyUnicode_FromString(token.data.anchor.value) # <<<<<<<<<<<<<< * return AnchorToken(value, start_mark, end_mark) * elif token.type == YAML_TAG_TOKEN: */ __pyx_t_2 = PyUnicode_FromString(__pyx_v_token->data.anchor.value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_value = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":451 * elif token.type == YAML_ANCHOR_TOKEN: * value = PyUnicode_FromString(token.data.anchor.value) * return AnchorToken(value, start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_TAG_TOKEN: * handle = PyUnicode_FromString(token.data.tag.handle) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_AnchorToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_v_value); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":449 * value = PyUnicode_FromString(token.data.alias.value) * return AliasToken(value, start_mark, end_mark) * elif token.type == YAML_ANCHOR_TOKEN: # <<<<<<<<<<<<<< * value = PyUnicode_FromString(token.data.anchor.value) * return AnchorToken(value, start_mark, end_mark) */ break; /* "_ruamel_yaml.pyx":452 * value = PyUnicode_FromString(token.data.anchor.value) * return AnchorToken(value, start_mark, end_mark) * elif token.type == YAML_TAG_TOKEN: # <<<<<<<<<<<<<< * handle = PyUnicode_FromString(token.data.tag.handle) * suffix = PyUnicode_FromString(token.data.tag.suffix) */ case YAML_TAG_TOKEN: /* "_ruamel_yaml.pyx":453 * return AnchorToken(value, start_mark, end_mark) * elif token.type == YAML_TAG_TOKEN: * handle = PyUnicode_FromString(token.data.tag.handle) # <<<<<<<<<<<<<< * suffix = PyUnicode_FromString(token.data.tag.suffix) * if not handle: */ __pyx_t_2 = PyUnicode_FromString(__pyx_v_token->data.tag.handle); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_handle = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":454 * elif token.type == YAML_TAG_TOKEN: * handle = PyUnicode_FromString(token.data.tag.handle) * suffix = PyUnicode_FromString(token.data.tag.suffix) # <<<<<<<<<<<<<< * if not handle: * handle = None */ __pyx_t_2 = PyUnicode_FromString(__pyx_v_token->data.tag.suffix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_suffix = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":455 * handle = PyUnicode_FromString(token.data.tag.handle) * suffix = PyUnicode_FromString(token.data.tag.suffix) * if not handle: # <<<<<<<<<<<<<< * handle = None * return TagToken((handle, suffix), start_mark, end_mark) */ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_handle); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 455, __pyx_L1_error) __pyx_t_8 = ((!__pyx_t_5) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":456 * suffix = PyUnicode_FromString(token.data.tag.suffix) * if not handle: * handle = None # <<<<<<<<<<<<<< * return TagToken((handle, suffix), start_mark, end_mark) * elif token.type == YAML_SCALAR_TOKEN: */ __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_handle, Py_None); /* "_ruamel_yaml.pyx":455 * handle = PyUnicode_FromString(token.data.tag.handle) * suffix = PyUnicode_FromString(token.data.tag.suffix) * if not handle: # <<<<<<<<<<<<<< * handle = None * return TagToken((handle, suffix), start_mark, end_mark) */ } /* "_ruamel_yaml.pyx":457 * if not handle: * handle = None * return TagToken((handle, suffix), start_mark, end_mark) # <<<<<<<<<<<<<< * elif token.type == YAML_SCALAR_TOKEN: * value = PyUnicode_DecodeUTF8(token.data.scalar.value, */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_TagToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_handle); __Pyx_GIVEREF(__pyx_v_handle); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_handle); __Pyx_INCREF(__pyx_v_suffix); __Pyx_GIVEREF(__pyx_v_suffix); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_suffix); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":452 * value = PyUnicode_FromString(token.data.anchor.value) * return AnchorToken(value, start_mark, end_mark) * elif token.type == YAML_TAG_TOKEN: # <<<<<<<<<<<<<< * handle = PyUnicode_FromString(token.data.tag.handle) * suffix = PyUnicode_FromString(token.data.tag.suffix) */ break; /* "_ruamel_yaml.pyx":458 * handle = None * return TagToken((handle, suffix), start_mark, end_mark) * elif token.type == YAML_SCALAR_TOKEN: # <<<<<<<<<<<<<< * value = PyUnicode_DecodeUTF8(token.data.scalar.value, * token.data.scalar.length, 'strict') */ case YAML_SCALAR_TOKEN: /* "_ruamel_yaml.pyx":459 * return TagToken((handle, suffix), start_mark, end_mark) * elif token.type == YAML_SCALAR_TOKEN: * value = PyUnicode_DecodeUTF8(token.data.scalar.value, # <<<<<<<<<<<<<< * token.data.scalar.length, 'strict') * plain = False */ __pyx_t_2 = PyUnicode_DecodeUTF8(__pyx_v_token->data.scalar.value, __pyx_v_token->data.scalar.length, ((char *)"strict")); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_value = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":461 * value = PyUnicode_DecodeUTF8(token.data.scalar.value, * token.data.scalar.length, 'strict') * plain = False # <<<<<<<<<<<<<< * style = None * if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: */ __pyx_v_plain = 0; /* "_ruamel_yaml.pyx":462 * token.data.scalar.length, 'strict') * plain = False * style = None # <<<<<<<<<<<<<< * if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * plain = True */ __Pyx_INCREF(Py_None); __pyx_v_style = Py_None; /* "_ruamel_yaml.pyx":463 * plain = False * style = None * if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: # <<<<<<<<<<<<<< * plain = True * style = u'' */ __pyx_t_8 = ((__pyx_v_token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":464 * style = None * if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * plain = True # <<<<<<<<<<<<<< * style = u'' * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: */ __pyx_v_plain = 1; /* "_ruamel_yaml.pyx":465 * if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * plain = True * style = u'' # <<<<<<<<<<<<<< * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' */ __Pyx_INCREF(__pyx_kp_u__6); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__6); /* "_ruamel_yaml.pyx":463 * plain = False * style = None * if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: # <<<<<<<<<<<<<< * plain = True * style = u'' */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":466 * plain = True * style = u'' * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'\'' * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: */ __pyx_t_8 = ((__pyx_v_token->data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":467 * style = u'' * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' # <<<<<<<<<<<<<< * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' */ __Pyx_INCREF(__pyx_kp_u__7); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__7); /* "_ruamel_yaml.pyx":466 * plain = True * style = u'' * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'\'' * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":468 * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'"' * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: */ __pyx_t_8 = ((__pyx_v_token->data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":469 * style = u'\'' * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' # <<<<<<<<<<<<<< * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' */ __Pyx_INCREF(__pyx_kp_u__8); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__8); /* "_ruamel_yaml.pyx":468 * elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'"' * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":470 * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'|' * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: */ __pyx_t_8 = ((__pyx_v_token->data.scalar.style == YAML_LITERAL_SCALAR_STYLE) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":471 * style = u'"' * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' # <<<<<<<<<<<<<< * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' */ __Pyx_INCREF(__pyx_kp_u__9); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__9); /* "_ruamel_yaml.pyx":470 * elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'|' * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":472 * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'>' * return ScalarToken(value, plain, */ __pyx_t_8 = ((__pyx_v_token->data.scalar.style == YAML_FOLDED_SCALAR_STYLE) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":473 * style = u'|' * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' # <<<<<<<<<<<<<< * return ScalarToken(value, plain, * start_mark, end_mark, style) */ __Pyx_INCREF(__pyx_kp_u__10); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__10); /* "_ruamel_yaml.pyx":472 * elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'>' * return ScalarToken(value, plain, */ } __pyx_L6:; /* "_ruamel_yaml.pyx":474 * elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' * return ScalarToken(value, plain, # <<<<<<<<<<<<<< * start_mark, end_mark, style) * else: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_plain); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); /* "_ruamel_yaml.pyx":475 * style = u'>' * return ScalarToken(value, plain, * start_mark, end_mark, style) # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[6] = {__pyx_t_4, __pyx_v_value, __pyx_t_7, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_style}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 5+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[6] = {__pyx_t_4, __pyx_v_value, __pyx_t_7, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_style}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 5+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_3 = PyTuple_New(5+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_v_value); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_t_7); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 3+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_style); __Pyx_GIVEREF(__pyx_v_style); PyTuple_SET_ITEM(__pyx_t_3, 4+__pyx_t_6, __pyx_v_style); __pyx_t_7 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":458 * handle = None * return TagToken((handle, suffix), start_mark, end_mark) * elif token.type == YAML_SCALAR_TOKEN: # <<<<<<<<<<<<<< * value = PyUnicode_DecodeUTF8(token.data.scalar.value, * token.data.scalar.length, 'strict') */ break; default: /* "_ruamel_yaml.pyx":477 * start_mark, end_mark, style) * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("unknown token type") * else: */ __pyx_t_8 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_8) { /* "_ruamel_yaml.pyx":478 * else: * if PY_MAJOR_VERSION < 3: * raise ValueError("unknown token type") # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown token type") */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 478, __pyx_L1_error) /* "_ruamel_yaml.pyx":477 * start_mark, end_mark, style) * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("unknown token type") * else: */ } /* "_ruamel_yaml.pyx":480 * raise ValueError("unknown token type") * else: * raise ValueError(u"unknown token type") # <<<<<<<<<<<<<< * * def get_token(self): */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 480, __pyx_L1_error) } break; } /* "_ruamel_yaml.pyx":385 * return token_object * * cdef object _token_to_object(self, yaml_token_t *token): # <<<<<<<<<<<<<< * start_mark = Mark(self.stream_name, * token.start_mark.index, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("_ruamel_yaml.CParser._token_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_start_mark); __Pyx_XDECREF((PyObject *)__pyx_v_end_mark); __Pyx_XDECREF(__pyx_v_encoding); __Pyx_XDECREF(__pyx_v_handle); __Pyx_XDECREF(__pyx_v_prefix); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_suffix); __Pyx_XDECREF(__pyx_v_style); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":482 * raise ValueError(u"unknown token type") * * def get_token(self): # <<<<<<<<<<<<<< * if self.current_token is not None: * value = self.current_token */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_9get_token(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_9get_token(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_token (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_8get_token(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_8get_token(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("get_token", 0); /* "_ruamel_yaml.pyx":483 * * def get_token(self): * if self.current_token is not None: # <<<<<<<<<<<<<< * value = self.current_token * self.current_token = None */ __pyx_t_1 = (__pyx_v_self->current_token != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":484 * def get_token(self): * if self.current_token is not None: * value = self.current_token # <<<<<<<<<<<<<< * self.current_token = None * else: */ __pyx_t_3 = __pyx_v_self->current_token; __Pyx_INCREF(__pyx_t_3); __pyx_v_value = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":485 * if self.current_token is not None: * value = self.current_token * self.current_token = None # <<<<<<<<<<<<<< * else: * value = self._scan() */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->current_token); __Pyx_DECREF(__pyx_v_self->current_token); __pyx_v_self->current_token = Py_None; /* "_ruamel_yaml.pyx":483 * * def get_token(self): * if self.current_token is not None: # <<<<<<<<<<<<<< * value = self.current_token * self.current_token = None */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":487 * self.current_token = None * else: * value = self._scan() # <<<<<<<<<<<<<< * return value * */ /*else*/ { __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_scan(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_value = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L3:; /* "_ruamel_yaml.pyx":488 * else: * value = self._scan() * return value # <<<<<<<<<<<<<< * * def peek_token(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_value); __pyx_r = __pyx_v_value; goto __pyx_L0; /* "_ruamel_yaml.pyx":482 * raise ValueError(u"unknown token type") * * def get_token(self): # <<<<<<<<<<<<<< * if self.current_token is not None: * value = self.current_token */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.get_token", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":490 * return value * * def peek_token(self): # <<<<<<<<<<<<<< * if self.current_token is None: * self.current_token = self._scan() */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_11peek_token(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_11peek_token(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("peek_token (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_10peek_token(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_10peek_token(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("peek_token", 0); /* "_ruamel_yaml.pyx":491 * * def peek_token(self): * if self.current_token is None: # <<<<<<<<<<<<<< * self.current_token = self._scan() * return self.current_token */ __pyx_t_1 = (__pyx_v_self->current_token == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":492 * def peek_token(self): * if self.current_token is None: * self.current_token = self._scan() # <<<<<<<<<<<<<< * return self.current_token * */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_scan(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->current_token); __Pyx_DECREF(__pyx_v_self->current_token); __pyx_v_self->current_token = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":491 * * def peek_token(self): * if self.current_token is None: # <<<<<<<<<<<<<< * self.current_token = self._scan() * return self.current_token */ } /* "_ruamel_yaml.pyx":493 * if self.current_token is None: * self.current_token = self._scan() * return self.current_token # <<<<<<<<<<<<<< * * def check_token(self, *choices): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->current_token); __pyx_r = __pyx_v_self->current_token; goto __pyx_L0; /* "_ruamel_yaml.pyx":490 * return value * * def peek_token(self): # <<<<<<<<<<<<<< * if self.current_token is None: * self.current_token = self._scan() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.peek_token", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":495 * return self.current_token * * def check_token(self, *choices): # <<<<<<<<<<<<<< * if self.current_token is None: * self.current_token = self._scan() */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_13check_token(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_13check_token(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_choices = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("check_token (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "check_token", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_choices = __pyx_args; __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_12check_token(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self), __pyx_v_choices); /* function exit code */ __Pyx_XDECREF(__pyx_v_choices); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_12check_token(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_choices) { PyObject *__pyx_v_token_class = NULL; PyObject *__pyx_v_choice = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("check_token", 0); /* "_ruamel_yaml.pyx":496 * * def check_token(self, *choices): * if self.current_token is None: # <<<<<<<<<<<<<< * self.current_token = self._scan() * if self.current_token is None: */ __pyx_t_1 = (__pyx_v_self->current_token == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":497 * def check_token(self, *choices): * if self.current_token is None: * self.current_token = self._scan() # <<<<<<<<<<<<<< * if self.current_token is None: * return False */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_scan(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->current_token); __Pyx_DECREF(__pyx_v_self->current_token); __pyx_v_self->current_token = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":496 * * def check_token(self, *choices): * if self.current_token is None: # <<<<<<<<<<<<<< * self.current_token = self._scan() * if self.current_token is None: */ } /* "_ruamel_yaml.pyx":498 * if self.current_token is None: * self.current_token = self._scan() * if self.current_token is None: # <<<<<<<<<<<<<< * return False * if not choices: */ __pyx_t_2 = (__pyx_v_self->current_token == Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":499 * self.current_token = self._scan() * if self.current_token is None: * return False # <<<<<<<<<<<<<< * if not choices: * return True */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* "_ruamel_yaml.pyx":498 * if self.current_token is None: * self.current_token = self._scan() * if self.current_token is None: # <<<<<<<<<<<<<< * return False * if not choices: */ } /* "_ruamel_yaml.pyx":500 * if self.current_token is None: * return False * if not choices: # <<<<<<<<<<<<<< * return True * token_class = self.current_token.__class__ */ __pyx_t_1 = (__pyx_v_choices != Py_None) && (PyTuple_GET_SIZE(__pyx_v_choices) != 0); __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":501 * return False * if not choices: * return True # <<<<<<<<<<<<<< * token_class = self.current_token.__class__ * for choice in choices: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; /* "_ruamel_yaml.pyx":500 * if self.current_token is None: * return False * if not choices: # <<<<<<<<<<<<<< * return True * token_class = self.current_token.__class__ */ } /* "_ruamel_yaml.pyx":502 * if not choices: * return True * token_class = self.current_token.__class__ # <<<<<<<<<<<<<< * for choice in choices: * if token_class is choice: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->current_token, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_token_class = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":503 * return True * token_class = self.current_token.__class__ * for choice in choices: # <<<<<<<<<<<<<< * if token_class is choice: * return True */ __pyx_t_3 = __pyx_v_choices; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; for (;;) { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 503, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_XDECREF_SET(__pyx_v_choice, __pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":504 * token_class = self.current_token.__class__ * for choice in choices: * if token_class is choice: # <<<<<<<<<<<<<< * return True * return False */ __pyx_t_2 = (__pyx_v_token_class == __pyx_v_choice); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":505 * for choice in choices: * if token_class is choice: * return True # <<<<<<<<<<<<<< * return False * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":504 * token_class = self.current_token.__class__ * for choice in choices: * if token_class is choice: # <<<<<<<<<<<<<< * return True * return False */ } /* "_ruamel_yaml.pyx":503 * return True * token_class = self.current_token.__class__ * for choice in choices: # <<<<<<<<<<<<<< * if token_class is choice: * return True */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":506 * if token_class is choice: * return True * return False # <<<<<<<<<<<<<< * * def raw_parse(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* "_ruamel_yaml.pyx":495 * return self.current_token * * def check_token(self, *choices): # <<<<<<<<<<<<<< * if self.current_token is None: * self.current_token = self._scan() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_ruamel_yaml.CParser.check_token", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_token_class); __Pyx_XDECREF(__pyx_v_choice); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":508 * return False * * def raw_parse(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef int done */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_15raw_parse(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_15raw_parse(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("raw_parse (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_14raw_parse(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_14raw_parse(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { yaml_event_t __pyx_v_event; int __pyx_v_done; int __pyx_v_count; PyObject *__pyx_v_error = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("raw_parse", 0); /* "_ruamel_yaml.pyx":512 * cdef int done * cdef int count * count = 0 # <<<<<<<<<<<<<< * done = 0 * while done == 0: */ __pyx_v_count = 0; /* "_ruamel_yaml.pyx":513 * cdef int count * count = 0 * done = 0 # <<<<<<<<<<<<<< * while done == 0: * if yaml_parser_parse(&self.parser, &event) == 0: */ __pyx_v_done = 0; /* "_ruamel_yaml.pyx":514 * count = 0 * done = 0 * while done == 0: # <<<<<<<<<<<<<< * if yaml_parser_parse(&self.parser, &event) == 0: * error = self._parser_error() */ while (1) { __pyx_t_1 = ((__pyx_v_done == 0) != 0); if (!__pyx_t_1) break; /* "_ruamel_yaml.pyx":515 * done = 0 * while done == 0: * if yaml_parser_parse(&self.parser, &event) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ __pyx_t_2 = yaml_parser_parse((&__pyx_v_self->parser), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 515, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_2 == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":516 * while done == 0: * if yaml_parser_parse(&self.parser, &event) == 0: * error = self._parser_error() # <<<<<<<<<<<<<< * raise error * if event.type == YAML_NO_EVENT: */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parser_error(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_error = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":517 * if yaml_parser_parse(&self.parser, &event) == 0: * error = self._parser_error() * raise error # <<<<<<<<<<<<<< * if event.type == YAML_NO_EVENT: * done = 1 */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 517, __pyx_L1_error) /* "_ruamel_yaml.pyx":515 * done = 0 * while done == 0: * if yaml_parser_parse(&self.parser, &event) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ } /* "_ruamel_yaml.pyx":518 * error = self._parser_error() * raise error * if event.type == YAML_NO_EVENT: # <<<<<<<<<<<<<< * done = 1 * else: */ __pyx_t_1 = ((__pyx_v_event.type == YAML_NO_EVENT) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":519 * raise error * if event.type == YAML_NO_EVENT: * done = 1 # <<<<<<<<<<<<<< * else: * count = count+1 */ __pyx_v_done = 1; /* "_ruamel_yaml.pyx":518 * error = self._parser_error() * raise error * if event.type == YAML_NO_EVENT: # <<<<<<<<<<<<<< * done = 1 * else: */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":521 * done = 1 * else: * count = count+1 # <<<<<<<<<<<<<< * yaml_event_delete(&event) * return count */ /*else*/ { __pyx_v_count = (__pyx_v_count + 1); } __pyx_L6:; /* "_ruamel_yaml.pyx":522 * else: * count = count+1 * yaml_event_delete(&event) # <<<<<<<<<<<<<< * return count * */ yaml_event_delete((&__pyx_v_event)); } /* "_ruamel_yaml.pyx":523 * count = count+1 * yaml_event_delete(&event) * return count # <<<<<<<<<<<<<< * * cdef object _parse(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_count); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":508 * return False * * def raw_parse(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef int done */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.raw_parse", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":525 * return count * * cdef object _parse(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * if yaml_parser_parse(&self.parser, &event) == 0: */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__parse(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { yaml_event_t __pyx_v_event; PyObject *__pyx_v_error = NULL; PyObject *__pyx_v_event_object = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("_parse", 0); /* "_ruamel_yaml.pyx":527 * cdef object _parse(self): * cdef yaml_event_t event * if yaml_parser_parse(&self.parser, &event) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ __pyx_t_1 = yaml_parser_parse((&__pyx_v_self->parser), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_1 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":528 * cdef yaml_event_t event * if yaml_parser_parse(&self.parser, &event) == 0: * error = self._parser_error() # <<<<<<<<<<<<<< * raise error * event_object = self._event_to_object(&event) */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parser_error(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_error = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":529 * if yaml_parser_parse(&self.parser, &event) == 0: * error = self._parser_error() * raise error # <<<<<<<<<<<<<< * event_object = self._event_to_object(&event) * yaml_event_delete(&event) */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 529, __pyx_L1_error) /* "_ruamel_yaml.pyx":527 * cdef object _parse(self): * cdef yaml_event_t event * if yaml_parser_parse(&self.parser, &event) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ } /* "_ruamel_yaml.pyx":530 * error = self._parser_error() * raise error * event_object = self._event_to_object(&event) # <<<<<<<<<<<<<< * yaml_event_delete(&event) * return event_object */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_event_to_object(__pyx_v_self, (&__pyx_v_event)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_event_object = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":531 * raise error * event_object = self._event_to_object(&event) * yaml_event_delete(&event) # <<<<<<<<<<<<<< * return event_object * */ yaml_event_delete((&__pyx_v_event)); /* "_ruamel_yaml.pyx":532 * event_object = self._event_to_object(&event) * yaml_event_delete(&event) * return event_object # <<<<<<<<<<<<<< * * cdef object _event_to_object(self, yaml_event_t *event): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_event_object); __pyx_r = __pyx_v_event_object; goto __pyx_L0; /* "_ruamel_yaml.pyx":525 * return count * * cdef object _parse(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * if yaml_parser_parse(&self.parser, &event) == 0: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser._parse", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XDECREF(__pyx_v_event_object); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":534 * return event_object * * cdef object _event_to_object(self, yaml_event_t *event): # <<<<<<<<<<<<<< * cdef yaml_tag_directive_t *tag_directive * start_mark = Mark(self.stream_name, */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__event_to_object(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, yaml_event_t *__pyx_v_event) { yaml_tag_directive_t *__pyx_v_tag_directive; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_start_mark = NULL; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_end_mark = NULL; PyObject *__pyx_v_encoding = NULL; int __pyx_v_explicit; PyObject *__pyx_v_version = NULL; PyObject *__pyx_v_tags = NULL; PyObject *__pyx_v_handle = NULL; PyObject *__pyx_v_prefix = NULL; PyObject *__pyx_v_anchor = NULL; PyObject *__pyx_v_tag = NULL; PyObject *__pyx_v_value = NULL; int __pyx_v_plain_implicit; int __pyx_v_quoted_implicit; PyObject *__pyx_v_style = NULL; int __pyx_v_implicit; PyObject *__pyx_v_flow_style = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; yaml_tag_directive_t *__pyx_t_7; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("_event_to_object", 0); /* "_ruamel_yaml.pyx":537 * cdef yaml_tag_directive_t *tag_directive * start_mark = Mark(self.stream_name, * event.start_mark.index, # <<<<<<<<<<<<<< * event.start_mark.line, * event.start_mark.column, */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_event->start_mark.index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":538 * start_mark = Mark(self.stream_name, * event.start_mark.index, * event.start_mark.line, # <<<<<<<<<<<<<< * event.start_mark.column, * None, None) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_event->start_mark.line); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 538, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":539 * event.start_mark.index, * event.start_mark.line, * event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * end_mark = Mark(self.stream_name, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_event->start_mark.column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":536 * cdef object _event_to_object(self, yaml_event_t *event): * cdef yaml_tag_directive_t *tag_directive * start_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * event.start_mark.index, * event.start_mark.line, */ __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 5, Py_None); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_start_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":542 * None, None) * end_mark = Mark(self.stream_name, * event.end_mark.index, # <<<<<<<<<<<<<< * event.end_mark.line, * event.end_mark.column, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_event->end_mark.index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":543 * end_mark = Mark(self.stream_name, * event.end_mark.index, * event.end_mark.line, # <<<<<<<<<<<<<< * event.end_mark.column, * None, None) */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_event->end_mark.line); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 543, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":544 * event.end_mark.index, * event.end_mark.line, * event.end_mark.column, # <<<<<<<<<<<<<< * None, None) * if event.type == YAML_NO_EVENT: */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_event->end_mark.column); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":541 * event.start_mark.column, * None, None) * end_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * event.end_mark.index, * event.end_mark.line, */ __pyx_t_1 = PyTuple_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_2); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 5, Py_None); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_end_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":546 * event.end_mark.column, * None, None) * if event.type == YAML_NO_EVENT: # <<<<<<<<<<<<<< * return None * elif event.type == YAML_STREAM_START_EVENT: */ switch (__pyx_v_event->type) { case YAML_NO_EVENT: /* "_ruamel_yaml.pyx":547 * None, None) * if event.type == YAML_NO_EVENT: * return None # <<<<<<<<<<<<<< * elif event.type == YAML_STREAM_START_EVENT: * encoding = None */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; /* "_ruamel_yaml.pyx":546 * event.end_mark.column, * None, None) * if event.type == YAML_NO_EVENT: # <<<<<<<<<<<<<< * return None * elif event.type == YAML_STREAM_START_EVENT: */ break; /* "_ruamel_yaml.pyx":548 * if event.type == YAML_NO_EVENT: * return None * elif event.type == YAML_STREAM_START_EVENT: # <<<<<<<<<<<<<< * encoding = None * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: */ case YAML_STREAM_START_EVENT: /* "_ruamel_yaml.pyx":549 * return None * elif event.type == YAML_STREAM_START_EVENT: * encoding = None # <<<<<<<<<<<<<< * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: */ __Pyx_INCREF(Py_None); __pyx_v_encoding = Py_None; /* "_ruamel_yaml.pyx":550 * elif event.type == YAML_STREAM_START_EVENT: * encoding = None * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: # <<<<<<<<<<<<<< * if self.unicode_source == 0: * encoding = u"utf-8" */ __pyx_t_5 = ((__pyx_v_event->data.stream_start.encoding == YAML_UTF8_ENCODING) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":551 * encoding = None * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: # <<<<<<<<<<<<<< * encoding = u"utf-8" * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: */ __pyx_t_5 = ((__pyx_v_self->unicode_source == 0) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":552 * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: * encoding = u"utf-8" # <<<<<<<<<<<<<< * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" */ __Pyx_INCREF(__pyx_kp_u_utf_8); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_8); /* "_ruamel_yaml.pyx":551 * encoding = None * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: * if self.unicode_source == 0: # <<<<<<<<<<<<<< * encoding = u"utf-8" * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: */ } /* "_ruamel_yaml.pyx":550 * elif event.type == YAML_STREAM_START_EVENT: * encoding = None * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: # <<<<<<<<<<<<<< * if self.unicode_source == 0: * encoding = u"utf-8" */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":553 * if self.unicode_source == 0: * encoding = u"utf-8" * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-le" * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: */ __pyx_t_5 = ((__pyx_v_event->data.stream_start.encoding == YAML_UTF16LE_ENCODING) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":554 * encoding = u"utf-8" * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" # <<<<<<<<<<<<<< * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: * encoding = u"utf-16-be" */ __Pyx_INCREF(__pyx_kp_u_utf_16_le); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_16_le); /* "_ruamel_yaml.pyx":553 * if self.unicode_source == 0: * encoding = u"utf-8" * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-le" * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":555 * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-be" * return StreamStartEvent(start_mark, end_mark, encoding) */ __pyx_t_5 = ((__pyx_v_event->data.stream_start.encoding == YAML_UTF16BE_ENCODING) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":556 * encoding = u"utf-16-le" * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: * encoding = u"utf-16-be" # <<<<<<<<<<<<<< * return StreamStartEvent(start_mark, end_mark, encoding) * elif event.type == YAML_STREAM_END_EVENT: */ __Pyx_INCREF(__pyx_kp_u_utf_16_be); __Pyx_DECREF_SET(__pyx_v_encoding, __pyx_kp_u_utf_16_be); /* "_ruamel_yaml.pyx":555 * elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: * encoding = u"utf-16-le" * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: # <<<<<<<<<<<<<< * encoding = u"utf-16-be" * return StreamStartEvent(start_mark, end_mark, encoding) */ } __pyx_L3:; /* "_ruamel_yaml.pyx":557 * elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: * encoding = u"utf-16-be" * return StreamStartEvent(start_mark, end_mark, encoding) # <<<<<<<<<<<<<< * elif event.type == YAML_STREAM_END_EVENT: * return StreamEndEvent(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_StreamStartEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_encoding}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_4, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_encoding}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_encoding); __Pyx_GIVEREF(__pyx_v_encoding); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, __pyx_v_encoding); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":548 * if event.type == YAML_NO_EVENT: * return None * elif event.type == YAML_STREAM_START_EVENT: # <<<<<<<<<<<<<< * encoding = None * if event.data.stream_start.encoding == YAML_UTF8_ENCODING: */ break; /* "_ruamel_yaml.pyx":558 * encoding = u"utf-16-be" * return StreamStartEvent(start_mark, end_mark, encoding) * elif event.type == YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * return StreamEndEvent(start_mark, end_mark) * elif event.type == YAML_DOCUMENT_START_EVENT: */ case YAML_STREAM_END_EVENT: /* "_ruamel_yaml.pyx":559 * return StreamStartEvent(start_mark, end_mark, encoding) * elif event.type == YAML_STREAM_END_EVENT: * return StreamEndEvent(start_mark, end_mark) # <<<<<<<<<<<<<< * elif event.type == YAML_DOCUMENT_START_EVENT: * explicit = False */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_StreamEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 559, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 559, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":558 * encoding = u"utf-16-be" * return StreamStartEvent(start_mark, end_mark, encoding) * elif event.type == YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * return StreamEndEvent(start_mark, end_mark) * elif event.type == YAML_DOCUMENT_START_EVENT: */ break; /* "_ruamel_yaml.pyx":560 * elif event.type == YAML_STREAM_END_EVENT: * return StreamEndEvent(start_mark, end_mark) * elif event.type == YAML_DOCUMENT_START_EVENT: # <<<<<<<<<<<<<< * explicit = False * if event.data.document_start.implicit == 0: */ case YAML_DOCUMENT_START_EVENT: /* "_ruamel_yaml.pyx":561 * return StreamEndEvent(start_mark, end_mark) * elif event.type == YAML_DOCUMENT_START_EVENT: * explicit = False # <<<<<<<<<<<<<< * if event.data.document_start.implicit == 0: * explicit = True */ __pyx_v_explicit = 0; /* "_ruamel_yaml.pyx":562 * elif event.type == YAML_DOCUMENT_START_EVENT: * explicit = False * if event.data.document_start.implicit == 0: # <<<<<<<<<<<<<< * explicit = True * version = None */ __pyx_t_5 = ((__pyx_v_event->data.document_start.implicit == 0) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":563 * explicit = False * if event.data.document_start.implicit == 0: * explicit = True # <<<<<<<<<<<<<< * version = None * if event.data.document_start.version_directive != NULL: */ __pyx_v_explicit = 1; /* "_ruamel_yaml.pyx":562 * elif event.type == YAML_DOCUMENT_START_EVENT: * explicit = False * if event.data.document_start.implicit == 0: # <<<<<<<<<<<<<< * explicit = True * version = None */ } /* "_ruamel_yaml.pyx":564 * if event.data.document_start.implicit == 0: * explicit = True * version = None # <<<<<<<<<<<<<< * if event.data.document_start.version_directive != NULL: * version = (event.data.document_start.version_directive.major, */ __Pyx_INCREF(Py_None); __pyx_v_version = Py_None; /* "_ruamel_yaml.pyx":565 * explicit = True * version = None * if event.data.document_start.version_directive != NULL: # <<<<<<<<<<<<<< * version = (event.data.document_start.version_directive.major, * event.data.document_start.version_directive.minor) */ __pyx_t_5 = ((__pyx_v_event->data.document_start.version_directive != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":566 * version = None * if event.data.document_start.version_directive != NULL: * version = (event.data.document_start.version_directive.major, # <<<<<<<<<<<<<< * event.data.document_start.version_directive.minor) * tags = None */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_event->data.document_start.version_directive->major); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":567 * if event.data.document_start.version_directive != NULL: * version = (event.data.document_start.version_directive.major, * event.data.document_start.version_directive.minor) # <<<<<<<<<<<<<< * tags = None * if event.data.document_start.tag_directives.start != NULL: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_event->data.document_start.version_directive->minor); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":566 * version = None * if event.data.document_start.version_directive != NULL: * version = (event.data.document_start.version_directive.major, # <<<<<<<<<<<<<< * event.data.document_start.version_directive.minor) * tags = None */ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __pyx_t_2 = 0; __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_version, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":565 * explicit = True * version = None * if event.data.document_start.version_directive != NULL: # <<<<<<<<<<<<<< * version = (event.data.document_start.version_directive.major, * event.data.document_start.version_directive.minor) */ } /* "_ruamel_yaml.pyx":568 * version = (event.data.document_start.version_directive.major, * event.data.document_start.version_directive.minor) * tags = None # <<<<<<<<<<<<<< * if event.data.document_start.tag_directives.start != NULL: * tags = {} */ __Pyx_INCREF(Py_None); __pyx_v_tags = Py_None; /* "_ruamel_yaml.pyx":569 * event.data.document_start.version_directive.minor) * tags = None * if event.data.document_start.tag_directives.start != NULL: # <<<<<<<<<<<<<< * tags = {} * tag_directive = event.data.document_start.tag_directives.start */ __pyx_t_5 = ((__pyx_v_event->data.document_start.tag_directives.start != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":570 * tags = None * if event.data.document_start.tag_directives.start != NULL: * tags = {} # <<<<<<<<<<<<<< * tag_directive = event.data.document_start.tag_directives.start * while tag_directive != event.data.document_start.tag_directives.end: */ __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tags, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":571 * if event.data.document_start.tag_directives.start != NULL: * tags = {} * tag_directive = event.data.document_start.tag_directives.start # <<<<<<<<<<<<<< * while tag_directive != event.data.document_start.tag_directives.end: * handle = PyUnicode_FromString(tag_directive.handle) */ __pyx_t_7 = __pyx_v_event->data.document_start.tag_directives.start; __pyx_v_tag_directive = __pyx_t_7; /* "_ruamel_yaml.pyx":572 * tags = {} * tag_directive = event.data.document_start.tag_directives.start * while tag_directive != event.data.document_start.tag_directives.end: # <<<<<<<<<<<<<< * handle = PyUnicode_FromString(tag_directive.handle) * prefix = PyUnicode_FromString(tag_directive.prefix) */ while (1) { __pyx_t_5 = ((__pyx_v_tag_directive != __pyx_v_event->data.document_start.tag_directives.end) != 0); if (!__pyx_t_5) break; /* "_ruamel_yaml.pyx":573 * tag_directive = event.data.document_start.tag_directives.start * while tag_directive != event.data.document_start.tag_directives.end: * handle = PyUnicode_FromString(tag_directive.handle) # <<<<<<<<<<<<<< * prefix = PyUnicode_FromString(tag_directive.prefix) * tags[handle] = prefix */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_tag_directive->handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_handle, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":574 * while tag_directive != event.data.document_start.tag_directives.end: * handle = PyUnicode_FromString(tag_directive.handle) * prefix = PyUnicode_FromString(tag_directive.prefix) # <<<<<<<<<<<<<< * tags[handle] = prefix * tag_directive = tag_directive+1 */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_tag_directive->prefix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":575 * handle = PyUnicode_FromString(tag_directive.handle) * prefix = PyUnicode_FromString(tag_directive.prefix) * tags[handle] = prefix # <<<<<<<<<<<<<< * tag_directive = tag_directive+1 * return DocumentStartEvent(start_mark, end_mark, */ if (unlikely(PyObject_SetItem(__pyx_v_tags, __pyx_v_handle, __pyx_v_prefix) < 0)) __PYX_ERR(0, 575, __pyx_L1_error) /* "_ruamel_yaml.pyx":576 * prefix = PyUnicode_FromString(tag_directive.prefix) * tags[handle] = prefix * tag_directive = tag_directive+1 # <<<<<<<<<<<<<< * return DocumentStartEvent(start_mark, end_mark, * explicit, version, tags) */ __pyx_v_tag_directive = (__pyx_v_tag_directive + 1); } /* "_ruamel_yaml.pyx":569 * event.data.document_start.version_directive.minor) * tags = None * if event.data.document_start.tag_directives.start != NULL: # <<<<<<<<<<<<<< * tags = {} * tag_directive = event.data.document_start.tag_directives.start */ } /* "_ruamel_yaml.pyx":577 * tags[handle] = prefix * tag_directive = tag_directive+1 * return DocumentStartEvent(start_mark, end_mark, # <<<<<<<<<<<<<< * explicit, version, tags) * elif event.type == YAML_DOCUMENT_END_EVENT: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DocumentStartEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":578 * tag_directive = tag_directive+1 * return DocumentStartEvent(start_mark, end_mark, * explicit, version, tags) # <<<<<<<<<<<<<< * elif event.type == YAML_DOCUMENT_END_EVENT: * explicit = False */ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_explicit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[6] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_t_2, __pyx_v_version, __pyx_v_tags}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 5+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[6] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_t_2, __pyx_v_version, __pyx_v_tags}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 5+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif { __pyx_t_8 = PyTuple_New(5+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_6, __pyx_t_2); __Pyx_INCREF(__pyx_v_version); __Pyx_GIVEREF(__pyx_v_version); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_6, __pyx_v_version); __Pyx_INCREF(__pyx_v_tags); __Pyx_GIVEREF(__pyx_v_tags); PyTuple_SET_ITEM(__pyx_t_8, 4+__pyx_t_6, __pyx_v_tags); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":560 * elif event.type == YAML_STREAM_END_EVENT: * return StreamEndEvent(start_mark, end_mark) * elif event.type == YAML_DOCUMENT_START_EVENT: # <<<<<<<<<<<<<< * explicit = False * if event.data.document_start.implicit == 0: */ break; /* "_ruamel_yaml.pyx":579 * return DocumentStartEvent(start_mark, end_mark, * explicit, version, tags) * elif event.type == YAML_DOCUMENT_END_EVENT: # <<<<<<<<<<<<<< * explicit = False * if event.data.document_end.implicit == 0: */ case YAML_DOCUMENT_END_EVENT: /* "_ruamel_yaml.pyx":580 * explicit, version, tags) * elif event.type == YAML_DOCUMENT_END_EVENT: * explicit = False # <<<<<<<<<<<<<< * if event.data.document_end.implicit == 0: * explicit = True */ __pyx_v_explicit = 0; /* "_ruamel_yaml.pyx":581 * elif event.type == YAML_DOCUMENT_END_EVENT: * explicit = False * if event.data.document_end.implicit == 0: # <<<<<<<<<<<<<< * explicit = True * return DocumentEndEvent(start_mark, end_mark, explicit) */ __pyx_t_5 = ((__pyx_v_event->data.document_end.implicit == 0) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":582 * explicit = False * if event.data.document_end.implicit == 0: * explicit = True # <<<<<<<<<<<<<< * return DocumentEndEvent(start_mark, end_mark, explicit) * elif event.type == YAML_ALIAS_EVENT: */ __pyx_v_explicit = 1; /* "_ruamel_yaml.pyx":581 * elif event.type == YAML_DOCUMENT_END_EVENT: * explicit = False * if event.data.document_end.implicit == 0: # <<<<<<<<<<<<<< * explicit = True * return DocumentEndEvent(start_mark, end_mark, explicit) */ } /* "_ruamel_yaml.pyx":583 * if event.data.document_end.implicit == 0: * explicit = True * return DocumentEndEvent(start_mark, end_mark, explicit) # <<<<<<<<<<<<<< * elif event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(event.data.alias.anchor) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DocumentEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_explicit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_2 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_2, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_t_8}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_2, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_t_8}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, __pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":579 * return DocumentStartEvent(start_mark, end_mark, * explicit, version, tags) * elif event.type == YAML_DOCUMENT_END_EVENT: # <<<<<<<<<<<<<< * explicit = False * if event.data.document_end.implicit == 0: */ break; /* "_ruamel_yaml.pyx":584 * explicit = True * return DocumentEndEvent(start_mark, end_mark, explicit) * elif event.type == YAML_ALIAS_EVENT: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.alias.anchor) * return AliasEvent(anchor, start_mark, end_mark) */ case YAML_ALIAS_EVENT: /* "_ruamel_yaml.pyx":585 * return DocumentEndEvent(start_mark, end_mark, explicit) * elif event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(event.data.alias.anchor) # <<<<<<<<<<<<<< * return AliasEvent(anchor, start_mark, end_mark) * elif event.type == YAML_SCALAR_EVENT: */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.alias.anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_anchor = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":586 * elif event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(event.data.alias.anchor) * return AliasEvent(anchor, start_mark, end_mark) # <<<<<<<<<<<<<< * elif event.type == YAML_SCALAR_EVENT: * anchor = None */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_AliasEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_anchor, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_anchor, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { __pyx_t_8 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_anchor); __Pyx_GIVEREF(__pyx_v_anchor); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, __pyx_v_anchor); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":584 * explicit = True * return DocumentEndEvent(start_mark, end_mark, explicit) * elif event.type == YAML_ALIAS_EVENT: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.alias.anchor) * return AliasEvent(anchor, start_mark, end_mark) */ break; /* "_ruamel_yaml.pyx":587 * anchor = PyUnicode_FromString(event.data.alias.anchor) * return AliasEvent(anchor, start_mark, end_mark) * elif event.type == YAML_SCALAR_EVENT: # <<<<<<<<<<<<<< * anchor = None * if event.data.scalar.anchor != NULL: */ case YAML_SCALAR_EVENT: /* "_ruamel_yaml.pyx":588 * return AliasEvent(anchor, start_mark, end_mark) * elif event.type == YAML_SCALAR_EVENT: * anchor = None # <<<<<<<<<<<<<< * if event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(event.data.scalar.anchor) */ __Pyx_INCREF(Py_None); __pyx_v_anchor = Py_None; /* "_ruamel_yaml.pyx":589 * elif event.type == YAML_SCALAR_EVENT: * anchor = None * if event.data.scalar.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.scalar.anchor) * tag = None */ __pyx_t_5 = ((__pyx_v_event->data.scalar.anchor != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":590 * anchor = None * if event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(event.data.scalar.anchor) # <<<<<<<<<<<<<< * tag = None * if event.data.scalar.tag != NULL: */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.scalar.anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":589 * elif event.type == YAML_SCALAR_EVENT: * anchor = None * if event.data.scalar.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.scalar.anchor) * tag = None */ } /* "_ruamel_yaml.pyx":591 * if event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(event.data.scalar.anchor) * tag = None # <<<<<<<<<<<<<< * if event.data.scalar.tag != NULL: * tag = PyUnicode_FromString(event.data.scalar.tag) */ __Pyx_INCREF(Py_None); __pyx_v_tag = Py_None; /* "_ruamel_yaml.pyx":592 * anchor = PyUnicode_FromString(event.data.scalar.anchor) * tag = None * if event.data.scalar.tag != NULL: # <<<<<<<<<<<<<< * tag = PyUnicode_FromString(event.data.scalar.tag) * value = PyUnicode_DecodeUTF8(event.data.scalar.value, */ __pyx_t_5 = ((__pyx_v_event->data.scalar.tag != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":593 * tag = None * if event.data.scalar.tag != NULL: * tag = PyUnicode_FromString(event.data.scalar.tag) # <<<<<<<<<<<<<< * value = PyUnicode_DecodeUTF8(event.data.scalar.value, * event.data.scalar.length, 'strict') */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.scalar.tag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tag, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":592 * anchor = PyUnicode_FromString(event.data.scalar.anchor) * tag = None * if event.data.scalar.tag != NULL: # <<<<<<<<<<<<<< * tag = PyUnicode_FromString(event.data.scalar.tag) * value = PyUnicode_DecodeUTF8(event.data.scalar.value, */ } /* "_ruamel_yaml.pyx":594 * if event.data.scalar.tag != NULL: * tag = PyUnicode_FromString(event.data.scalar.tag) * value = PyUnicode_DecodeUTF8(event.data.scalar.value, # <<<<<<<<<<<<<< * event.data.scalar.length, 'strict') * plain_implicit = False */ __pyx_t_4 = PyUnicode_DecodeUTF8(__pyx_v_event->data.scalar.value, __pyx_v_event->data.scalar.length, ((char *)"strict")); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_value = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":596 * value = PyUnicode_DecodeUTF8(event.data.scalar.value, * event.data.scalar.length, 'strict') * plain_implicit = False # <<<<<<<<<<<<<< * if event.data.scalar.plain_implicit == 1: * plain_implicit = True */ __pyx_v_plain_implicit = 0; /* "_ruamel_yaml.pyx":597 * event.data.scalar.length, 'strict') * plain_implicit = False * if event.data.scalar.plain_implicit == 1: # <<<<<<<<<<<<<< * plain_implicit = True * quoted_implicit = False */ __pyx_t_5 = ((__pyx_v_event->data.scalar.plain_implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":598 * plain_implicit = False * if event.data.scalar.plain_implicit == 1: * plain_implicit = True # <<<<<<<<<<<<<< * quoted_implicit = False * if event.data.scalar.quoted_implicit == 1: */ __pyx_v_plain_implicit = 1; /* "_ruamel_yaml.pyx":597 * event.data.scalar.length, 'strict') * plain_implicit = False * if event.data.scalar.plain_implicit == 1: # <<<<<<<<<<<<<< * plain_implicit = True * quoted_implicit = False */ } /* "_ruamel_yaml.pyx":599 * if event.data.scalar.plain_implicit == 1: * plain_implicit = True * quoted_implicit = False # <<<<<<<<<<<<<< * if event.data.scalar.quoted_implicit == 1: * quoted_implicit = True */ __pyx_v_quoted_implicit = 0; /* "_ruamel_yaml.pyx":600 * plain_implicit = True * quoted_implicit = False * if event.data.scalar.quoted_implicit == 1: # <<<<<<<<<<<<<< * quoted_implicit = True * style = None */ __pyx_t_5 = ((__pyx_v_event->data.scalar.quoted_implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":601 * quoted_implicit = False * if event.data.scalar.quoted_implicit == 1: * quoted_implicit = True # <<<<<<<<<<<<<< * style = None * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: */ __pyx_v_quoted_implicit = 1; /* "_ruamel_yaml.pyx":600 * plain_implicit = True * quoted_implicit = False * if event.data.scalar.quoted_implicit == 1: # <<<<<<<<<<<<<< * quoted_implicit = True * style = None */ } /* "_ruamel_yaml.pyx":602 * if event.data.scalar.quoted_implicit == 1: * quoted_implicit = True * style = None # <<<<<<<<<<<<<< * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' */ __Pyx_INCREF(Py_None); __pyx_v_style = Py_None; /* "_ruamel_yaml.pyx":603 * quoted_implicit = True * style = None * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'' * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: */ __pyx_t_5 = ((__pyx_v_event->data.scalar.style == YAML_PLAIN_SCALAR_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":604 * style = None * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' # <<<<<<<<<<<<<< * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' */ __Pyx_INCREF(__pyx_kp_u__6); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__6); /* "_ruamel_yaml.pyx":603 * quoted_implicit = True * style = None * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'' * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: */ goto __pyx_L15; } /* "_ruamel_yaml.pyx":605 * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'\'' * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: */ __pyx_t_5 = ((__pyx_v_event->data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":606 * style = u'' * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' # <<<<<<<<<<<<<< * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' */ __Pyx_INCREF(__pyx_kp_u__7); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__7); /* "_ruamel_yaml.pyx":605 * if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'\'' * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: */ goto __pyx_L15; } /* "_ruamel_yaml.pyx":607 * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'"' * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: */ __pyx_t_5 = ((__pyx_v_event->data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":608 * style = u'\'' * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' # <<<<<<<<<<<<<< * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' */ __Pyx_INCREF(__pyx_kp_u__8); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__8); /* "_ruamel_yaml.pyx":607 * elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'"' * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: */ goto __pyx_L15; } /* "_ruamel_yaml.pyx":609 * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'|' * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: */ __pyx_t_5 = ((__pyx_v_event->data.scalar.style == YAML_LITERAL_SCALAR_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":610 * style = u'"' * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' # <<<<<<<<<<<<<< * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' */ __Pyx_INCREF(__pyx_kp_u__9); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__9); /* "_ruamel_yaml.pyx":609 * elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'|' * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: */ goto __pyx_L15; } /* "_ruamel_yaml.pyx":611 * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'>' * return ScalarEvent(anchor, tag, */ __pyx_t_5 = ((__pyx_v_event->data.scalar.style == YAML_FOLDED_SCALAR_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":612 * style = u'|' * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' # <<<<<<<<<<<<<< * return ScalarEvent(anchor, tag, * (plain_implicit, quoted_implicit), */ __Pyx_INCREF(__pyx_kp_u__10); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__10); /* "_ruamel_yaml.pyx":611 * elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'>' * return ScalarEvent(anchor, tag, */ } __pyx_L15:; /* "_ruamel_yaml.pyx":613 * elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' * return ScalarEvent(anchor, tag, # <<<<<<<<<<<<<< * (plain_implicit, quoted_implicit), * value, start_mark, end_mark, style) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":614 * style = u'>' * return ScalarEvent(anchor, tag, * (plain_implicit, quoted_implicit), # <<<<<<<<<<<<<< * value, start_mark, end_mark, style) * elif event.type == YAML_SEQUENCE_START_EVENT: */ __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_plain_implicit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_quoted_implicit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); __pyx_t_8 = 0; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":615 * return ScalarEvent(anchor, tag, * (plain_implicit, quoted_implicit), * value, start_mark, end_mark, style) # <<<<<<<<<<<<<< * elif event.type == YAML_SEQUENCE_START_EVENT: * anchor = None */ __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_v_anchor, __pyx_v_tag, __pyx_t_2, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_style}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 7+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 613, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[8] = {__pyx_t_3, __pyx_v_anchor, __pyx_v_tag, __pyx_t_2, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_style}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 7+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 613, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif { __pyx_t_8 = PyTuple_New(7+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_anchor); __Pyx_GIVEREF(__pyx_v_anchor); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, __pyx_v_anchor); __Pyx_INCREF(__pyx_v_tag); __Pyx_GIVEREF(__pyx_v_tag); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, __pyx_v_tag); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_6, __pyx_t_2); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_6, __pyx_v_value); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_8, 4+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_8, 5+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_style); __Pyx_GIVEREF(__pyx_v_style); PyTuple_SET_ITEM(__pyx_t_8, 6+__pyx_t_6, __pyx_v_style); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":587 * anchor = PyUnicode_FromString(event.data.alias.anchor) * return AliasEvent(anchor, start_mark, end_mark) * elif event.type == YAML_SCALAR_EVENT: # <<<<<<<<<<<<<< * anchor = None * if event.data.scalar.anchor != NULL: */ break; /* "_ruamel_yaml.pyx":616 * (plain_implicit, quoted_implicit), * value, start_mark, end_mark, style) * elif event.type == YAML_SEQUENCE_START_EVENT: # <<<<<<<<<<<<<< * anchor = None * if event.data.sequence_start.anchor != NULL: */ case YAML_SEQUENCE_START_EVENT: /* "_ruamel_yaml.pyx":617 * value, start_mark, end_mark, style) * elif event.type == YAML_SEQUENCE_START_EVENT: * anchor = None # <<<<<<<<<<<<<< * if event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) */ __Pyx_INCREF(Py_None); __pyx_v_anchor = Py_None; /* "_ruamel_yaml.pyx":618 * elif event.type == YAML_SEQUENCE_START_EVENT: * anchor = None * if event.data.sequence_start.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) * tag = None */ __pyx_t_5 = ((__pyx_v_event->data.sequence_start.anchor != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":619 * anchor = None * if event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) # <<<<<<<<<<<<<< * tag = None * if event.data.sequence_start.tag != NULL: */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.sequence_start.anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":618 * elif event.type == YAML_SEQUENCE_START_EVENT: * anchor = None * if event.data.sequence_start.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) * tag = None */ } /* "_ruamel_yaml.pyx":620 * if event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) * tag = None # <<<<<<<<<<<<<< * if event.data.sequence_start.tag != NULL: * tag = PyUnicode_FromString(event.data.sequence_start.tag) */ __Pyx_INCREF(Py_None); __pyx_v_tag = Py_None; /* "_ruamel_yaml.pyx":621 * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) * tag = None * if event.data.sequence_start.tag != NULL: # <<<<<<<<<<<<<< * tag = PyUnicode_FromString(event.data.sequence_start.tag) * implicit = False */ __pyx_t_5 = ((__pyx_v_event->data.sequence_start.tag != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":622 * tag = None * if event.data.sequence_start.tag != NULL: * tag = PyUnicode_FromString(event.data.sequence_start.tag) # <<<<<<<<<<<<<< * implicit = False * if event.data.sequence_start.implicit == 1: */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.sequence_start.tag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 622, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tag, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":621 * anchor = PyUnicode_FromString(event.data.sequence_start.anchor) * tag = None * if event.data.sequence_start.tag != NULL: # <<<<<<<<<<<<<< * tag = PyUnicode_FromString(event.data.sequence_start.tag) * implicit = False */ } /* "_ruamel_yaml.pyx":623 * if event.data.sequence_start.tag != NULL: * tag = PyUnicode_FromString(event.data.sequence_start.tag) * implicit = False # <<<<<<<<<<<<<< * if event.data.sequence_start.implicit == 1: * implicit = True */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":624 * tag = PyUnicode_FromString(event.data.sequence_start.tag) * implicit = False * if event.data.sequence_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * flow_style = None */ __pyx_t_5 = ((__pyx_v_event->data.sequence_start.implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":625 * implicit = False * if event.data.sequence_start.implicit == 1: * implicit = True # <<<<<<<<<<<<<< * flow_style = None * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":624 * tag = PyUnicode_FromString(event.data.sequence_start.tag) * implicit = False * if event.data.sequence_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * flow_style = None */ } /* "_ruamel_yaml.pyx":626 * if event.data.sequence_start.implicit == 1: * implicit = True * flow_style = None # <<<<<<<<<<<<<< * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True */ __Pyx_INCREF(Py_None); __pyx_v_flow_style = Py_None; /* "_ruamel_yaml.pyx":627 * implicit = True * flow_style = None * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: */ __pyx_t_5 = ((__pyx_v_event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":628 * flow_style = None * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True # <<<<<<<<<<<<<< * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: * flow_style = False */ __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_True); /* "_ruamel_yaml.pyx":627 * implicit = True * flow_style = None * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: */ goto __pyx_L19; } /* "_ruamel_yaml.pyx":629 * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = False * return SequenceStartEvent(anchor, tag, implicit, */ __pyx_t_5 = ((__pyx_v_event->data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":630 * flow_style = True * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: * flow_style = False # <<<<<<<<<<<<<< * return SequenceStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) */ __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_False); /* "_ruamel_yaml.pyx":629 * if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = False * return SequenceStartEvent(anchor, tag, implicit, */ } __pyx_L19:; /* "_ruamel_yaml.pyx":631 * elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: * flow_style = False * return SequenceStartEvent(anchor, tag, implicit, # <<<<<<<<<<<<<< * start_mark, end_mark, flow_style) * elif event.type == YAML_MAPPING_START_EVENT: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceStartEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); /* "_ruamel_yaml.pyx":632 * flow_style = False * return SequenceStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) # <<<<<<<<<<<<<< * elif event.type == YAML_MAPPING_START_EVENT: * anchor = None */ __pyx_t_2 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_v_anchor, __pyx_v_tag, __pyx_t_8, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_flow_style}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 6+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_v_anchor, __pyx_v_tag, __pyx_t_8, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_flow_style}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 6+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_3 = PyTuple_New(6+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(__pyx_v_anchor); __Pyx_GIVEREF(__pyx_v_anchor); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_v_anchor); __Pyx_INCREF(__pyx_v_tag); __Pyx_GIVEREF(__pyx_v_tag); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_v_tag); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, __pyx_t_8); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 3+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 4+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_flow_style); __Pyx_GIVEREF(__pyx_v_flow_style); PyTuple_SET_ITEM(__pyx_t_3, 5+__pyx_t_6, __pyx_v_flow_style); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":616 * (plain_implicit, quoted_implicit), * value, start_mark, end_mark, style) * elif event.type == YAML_SEQUENCE_START_EVENT: # <<<<<<<<<<<<<< * anchor = None * if event.data.sequence_start.anchor != NULL: */ break; /* "_ruamel_yaml.pyx":633 * return SequenceStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) * elif event.type == YAML_MAPPING_START_EVENT: # <<<<<<<<<<<<<< * anchor = None * if event.data.mapping_start.anchor != NULL: */ case YAML_MAPPING_START_EVENT: /* "_ruamel_yaml.pyx":634 * start_mark, end_mark, flow_style) * elif event.type == YAML_MAPPING_START_EVENT: * anchor = None # <<<<<<<<<<<<<< * if event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) */ __Pyx_INCREF(Py_None); __pyx_v_anchor = Py_None; /* "_ruamel_yaml.pyx":635 * elif event.type == YAML_MAPPING_START_EVENT: * anchor = None * if event.data.mapping_start.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) * tag = None */ __pyx_t_5 = ((__pyx_v_event->data.mapping_start.anchor != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":636 * anchor = None * if event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) # <<<<<<<<<<<<<< * tag = None * if event.data.mapping_start.tag != NULL: */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.mapping_start.anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":635 * elif event.type == YAML_MAPPING_START_EVENT: * anchor = None * if event.data.mapping_start.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) * tag = None */ } /* "_ruamel_yaml.pyx":637 * if event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) * tag = None # <<<<<<<<<<<<<< * if event.data.mapping_start.tag != NULL: * tag = PyUnicode_FromString(event.data.mapping_start.tag) */ __Pyx_INCREF(Py_None); __pyx_v_tag = Py_None; /* "_ruamel_yaml.pyx":638 * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) * tag = None * if event.data.mapping_start.tag != NULL: # <<<<<<<<<<<<<< * tag = PyUnicode_FromString(event.data.mapping_start.tag) * implicit = False */ __pyx_t_5 = ((__pyx_v_event->data.mapping_start.tag != NULL) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":639 * tag = None * if event.data.mapping_start.tag != NULL: * tag = PyUnicode_FromString(event.data.mapping_start.tag) # <<<<<<<<<<<<<< * implicit = False * if event.data.mapping_start.implicit == 1: */ __pyx_t_4 = PyUnicode_FromString(__pyx_v_event->data.mapping_start.tag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 639, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tag, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":638 * anchor = PyUnicode_FromString(event.data.mapping_start.anchor) * tag = None * if event.data.mapping_start.tag != NULL: # <<<<<<<<<<<<<< * tag = PyUnicode_FromString(event.data.mapping_start.tag) * implicit = False */ } /* "_ruamel_yaml.pyx":640 * if event.data.mapping_start.tag != NULL: * tag = PyUnicode_FromString(event.data.mapping_start.tag) * implicit = False # <<<<<<<<<<<<<< * if event.data.mapping_start.implicit == 1: * implicit = True */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":641 * tag = PyUnicode_FromString(event.data.mapping_start.tag) * implicit = False * if event.data.mapping_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * flow_style = None */ __pyx_t_5 = ((__pyx_v_event->data.mapping_start.implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":642 * implicit = False * if event.data.mapping_start.implicit == 1: * implicit = True # <<<<<<<<<<<<<< * flow_style = None * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":641 * tag = PyUnicode_FromString(event.data.mapping_start.tag) * implicit = False * if event.data.mapping_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * flow_style = None */ } /* "_ruamel_yaml.pyx":643 * if event.data.mapping_start.implicit == 1: * implicit = True * flow_style = None # <<<<<<<<<<<<<< * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True */ __Pyx_INCREF(Py_None); __pyx_v_flow_style = Py_None; /* "_ruamel_yaml.pyx":644 * implicit = True * flow_style = None * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: */ __pyx_t_5 = ((__pyx_v_event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":645 * flow_style = None * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True # <<<<<<<<<<<<<< * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: * flow_style = False */ __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_True); /* "_ruamel_yaml.pyx":644 * implicit = True * flow_style = None * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: */ goto __pyx_L23; } /* "_ruamel_yaml.pyx":646 * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = False * return MappingStartEvent(anchor, tag, implicit, */ __pyx_t_5 = ((__pyx_v_event->data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":647 * flow_style = True * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: * flow_style = False # <<<<<<<<<<<<<< * return MappingStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) */ __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_False); /* "_ruamel_yaml.pyx":646 * if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = False * return MappingStartEvent(anchor, tag, implicit, */ } __pyx_L23:; /* "_ruamel_yaml.pyx":648 * elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: * flow_style = False * return MappingStartEvent(anchor, tag, implicit, # <<<<<<<<<<<<<< * start_mark, end_mark, flow_style) * elif event.type == YAML_SEQUENCE_END_EVENT: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingStartEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":649 * flow_style = False * return MappingStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) # <<<<<<<<<<<<<< * elif event.type == YAML_SEQUENCE_END_EVENT: * return SequenceEndEvent(start_mark, end_mark) */ __pyx_t_8 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[7] = {__pyx_t_8, __pyx_v_anchor, __pyx_v_tag, __pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_flow_style}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 6+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 648, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[7] = {__pyx_t_8, __pyx_v_anchor, __pyx_v_tag, __pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_flow_style}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 6+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 648, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_2 = PyTuple_New(6+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_v_anchor); __Pyx_GIVEREF(__pyx_v_anchor); PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_v_anchor); __Pyx_INCREF(__pyx_v_tag); __Pyx_GIVEREF(__pyx_v_tag); PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_v_tag); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 2+__pyx_t_6, __pyx_t_3); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_2, 3+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_2, 4+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_flow_style); __Pyx_GIVEREF(__pyx_v_flow_style); PyTuple_SET_ITEM(__pyx_t_2, 5+__pyx_t_6, __pyx_v_flow_style); __pyx_t_3 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":633 * return SequenceStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) * elif event.type == YAML_MAPPING_START_EVENT: # <<<<<<<<<<<<<< * anchor = None * if event.data.mapping_start.anchor != NULL: */ break; /* "_ruamel_yaml.pyx":650 * return MappingStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) * elif event.type == YAML_SEQUENCE_END_EVENT: # <<<<<<<<<<<<<< * return SequenceEndEvent(start_mark, end_mark) * elif event.type == YAML_MAPPING_END_EVENT: */ case YAML_SEQUENCE_END_EVENT: /* "_ruamel_yaml.pyx":651 * start_mark, end_mark, flow_style) * elif event.type == YAML_SEQUENCE_END_EVENT: * return SequenceEndEvent(start_mark, end_mark) # <<<<<<<<<<<<<< * elif event.type == YAML_MAPPING_END_EVENT: * return MappingEndEvent(start_mark, end_mark) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 651, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 651, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":650 * return MappingStartEvent(anchor, tag, implicit, * start_mark, end_mark, flow_style) * elif event.type == YAML_SEQUENCE_END_EVENT: # <<<<<<<<<<<<<< * return SequenceEndEvent(start_mark, end_mark) * elif event.type == YAML_MAPPING_END_EVENT: */ break; /* "_ruamel_yaml.pyx":652 * elif event.type == YAML_SEQUENCE_END_EVENT: * return SequenceEndEvent(start_mark, end_mark) * elif event.type == YAML_MAPPING_END_EVENT: # <<<<<<<<<<<<<< * return MappingEndEvent(start_mark, end_mark) * else: */ case YAML_MAPPING_END_EVENT: /* "_ruamel_yaml.pyx":653 * return SequenceEndEvent(start_mark, end_mark) * elif event.type == YAML_MAPPING_END_EVENT: * return MappingEndEvent(start_mark, end_mark) # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 653, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark)}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 653, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, ((PyObject *)__pyx_v_end_mark)); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":652 * elif event.type == YAML_SEQUENCE_END_EVENT: * return SequenceEndEvent(start_mark, end_mark) * elif event.type == YAML_MAPPING_END_EVENT: # <<<<<<<<<<<<<< * return MappingEndEvent(start_mark, end_mark) * else: */ break; default: /* "_ruamel_yaml.pyx":655 * return MappingEndEvent(start_mark, end_mark) * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("unknown event type") * else: */ __pyx_t_5 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":656 * else: * if PY_MAJOR_VERSION < 3: * raise ValueError("unknown event type") # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown event type") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 656, __pyx_L1_error) /* "_ruamel_yaml.pyx":655 * return MappingEndEvent(start_mark, end_mark) * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("unknown event type") * else: */ } /* "_ruamel_yaml.pyx":658 * raise ValueError("unknown event type") * else: * raise ValueError(u"unknown event type") # <<<<<<<<<<<<<< * * def get_event(self): */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 658, __pyx_L1_error) } break; } /* "_ruamel_yaml.pyx":534 * return event_object * * cdef object _event_to_object(self, yaml_event_t *event): # <<<<<<<<<<<<<< * cdef yaml_tag_directive_t *tag_directive * start_mark = Mark(self.stream_name, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_ruamel_yaml.CParser._event_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_start_mark); __Pyx_XDECREF((PyObject *)__pyx_v_end_mark); __Pyx_XDECREF(__pyx_v_encoding); __Pyx_XDECREF(__pyx_v_version); __Pyx_XDECREF(__pyx_v_tags); __Pyx_XDECREF(__pyx_v_handle); __Pyx_XDECREF(__pyx_v_prefix); __Pyx_XDECREF(__pyx_v_anchor); __Pyx_XDECREF(__pyx_v_tag); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_style); __Pyx_XDECREF(__pyx_v_flow_style); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":660 * raise ValueError(u"unknown event type") * * def get_event(self): # <<<<<<<<<<<<<< * if self.current_event is not None: * value = self.current_event */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_17get_event(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_17get_event(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_event (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_16get_event(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_16get_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("get_event", 0); /* "_ruamel_yaml.pyx":661 * * def get_event(self): * if self.current_event is not None: # <<<<<<<<<<<<<< * value = self.current_event * self.current_event = None */ __pyx_t_1 = (__pyx_v_self->current_event != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":662 * def get_event(self): * if self.current_event is not None: * value = self.current_event # <<<<<<<<<<<<<< * self.current_event = None * else: */ __pyx_t_3 = __pyx_v_self->current_event; __Pyx_INCREF(__pyx_t_3); __pyx_v_value = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":663 * if self.current_event is not None: * value = self.current_event * self.current_event = None # <<<<<<<<<<<<<< * else: * value = self._parse() */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->current_event); __Pyx_DECREF(__pyx_v_self->current_event); __pyx_v_self->current_event = Py_None; /* "_ruamel_yaml.pyx":661 * * def get_event(self): * if self.current_event is not None: # <<<<<<<<<<<<<< * value = self.current_event * self.current_event = None */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":665 * self.current_event = None * else: * value = self._parse() # <<<<<<<<<<<<<< * return value * */ /*else*/ { __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_value = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L3:; /* "_ruamel_yaml.pyx":666 * else: * value = self._parse() * return value # <<<<<<<<<<<<<< * * def peek_event(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_value); __pyx_r = __pyx_v_value; goto __pyx_L0; /* "_ruamel_yaml.pyx":660 * raise ValueError(u"unknown event type") * * def get_event(self): # <<<<<<<<<<<<<< * if self.current_event is not None: * value = self.current_event */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.get_event", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":668 * return value * * def peek_event(self): # <<<<<<<<<<<<<< * if self.current_event is None: * self.current_event = self._parse() */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_19peek_event(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_19peek_event(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("peek_event (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_18peek_event(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_18peek_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("peek_event", 0); /* "_ruamel_yaml.pyx":669 * * def peek_event(self): * if self.current_event is None: # <<<<<<<<<<<<<< * self.current_event = self._parse() * return self.current_event */ __pyx_t_1 = (__pyx_v_self->current_event == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":670 * def peek_event(self): * if self.current_event is None: * self.current_event = self._parse() # <<<<<<<<<<<<<< * return self.current_event * */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 670, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->current_event); __Pyx_DECREF(__pyx_v_self->current_event); __pyx_v_self->current_event = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":669 * * def peek_event(self): * if self.current_event is None: # <<<<<<<<<<<<<< * self.current_event = self._parse() * return self.current_event */ } /* "_ruamel_yaml.pyx":671 * if self.current_event is None: * self.current_event = self._parse() * return self.current_event # <<<<<<<<<<<<<< * * def check_event(self, *choices): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->current_event); __pyx_r = __pyx_v_self->current_event; goto __pyx_L0; /* "_ruamel_yaml.pyx":668 * return value * * def peek_event(self): # <<<<<<<<<<<<<< * if self.current_event is None: * self.current_event = self._parse() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.peek_event", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":673 * return self.current_event * * def check_event(self, *choices): # <<<<<<<<<<<<<< * if self.current_event is None: * self.current_event = self._parse() */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_21check_event(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_21check_event(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_choices = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("check_event (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "check_event", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_choices = __pyx_args; __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_20check_event(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self), __pyx_v_choices); /* function exit code */ __Pyx_XDECREF(__pyx_v_choices); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_20check_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_choices) { PyObject *__pyx_v_event_class = NULL; PyObject *__pyx_v_choice = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("check_event", 0); /* "_ruamel_yaml.pyx":674 * * def check_event(self, *choices): * if self.current_event is None: # <<<<<<<<<<<<<< * self.current_event = self._parse() * if self.current_event is None: */ __pyx_t_1 = (__pyx_v_self->current_event == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":675 * def check_event(self, *choices): * if self.current_event is None: * self.current_event = self._parse() # <<<<<<<<<<<<<< * if self.current_event is None: * return False */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->current_event); __Pyx_DECREF(__pyx_v_self->current_event); __pyx_v_self->current_event = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":674 * * def check_event(self, *choices): * if self.current_event is None: # <<<<<<<<<<<<<< * self.current_event = self._parse() * if self.current_event is None: */ } /* "_ruamel_yaml.pyx":676 * if self.current_event is None: * self.current_event = self._parse() * if self.current_event is None: # <<<<<<<<<<<<<< * return False * if not choices: */ __pyx_t_2 = (__pyx_v_self->current_event == Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":677 * self.current_event = self._parse() * if self.current_event is None: * return False # <<<<<<<<<<<<<< * if not choices: * return True */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* "_ruamel_yaml.pyx":676 * if self.current_event is None: * self.current_event = self._parse() * if self.current_event is None: # <<<<<<<<<<<<<< * return False * if not choices: */ } /* "_ruamel_yaml.pyx":678 * if self.current_event is None: * return False * if not choices: # <<<<<<<<<<<<<< * return True * event_class = self.current_event.__class__ */ __pyx_t_1 = (__pyx_v_choices != Py_None) && (PyTuple_GET_SIZE(__pyx_v_choices) != 0); __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":679 * return False * if not choices: * return True # <<<<<<<<<<<<<< * event_class = self.current_event.__class__ * for choice in choices: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; /* "_ruamel_yaml.pyx":678 * if self.current_event is None: * return False * if not choices: # <<<<<<<<<<<<<< * return True * event_class = self.current_event.__class__ */ } /* "_ruamel_yaml.pyx":680 * if not choices: * return True * event_class = self.current_event.__class__ # <<<<<<<<<<<<<< * for choice in choices: * if event_class is choice: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->current_event, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 680, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_event_class = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":681 * return True * event_class = self.current_event.__class__ * for choice in choices: # <<<<<<<<<<<<<< * if event_class is choice: * return True */ __pyx_t_3 = __pyx_v_choices; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; for (;;) { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 681, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_XDECREF_SET(__pyx_v_choice, __pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":682 * event_class = self.current_event.__class__ * for choice in choices: * if event_class is choice: # <<<<<<<<<<<<<< * return True * return False */ __pyx_t_2 = (__pyx_v_event_class == __pyx_v_choice); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":683 * for choice in choices: * if event_class is choice: * return True # <<<<<<<<<<<<<< * return False * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":682 * event_class = self.current_event.__class__ * for choice in choices: * if event_class is choice: # <<<<<<<<<<<<<< * return True * return False */ } /* "_ruamel_yaml.pyx":681 * return True * event_class = self.current_event.__class__ * for choice in choices: # <<<<<<<<<<<<<< * if event_class is choice: * return True */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":684 * if event_class is choice: * return True * return False # <<<<<<<<<<<<<< * * def check_node(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* "_ruamel_yaml.pyx":673 * return self.current_event * * def check_event(self, *choices): # <<<<<<<<<<<<<< * if self.current_event is None: * self.current_event = self._parse() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_ruamel_yaml.CParser.check_event", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_event_class); __Pyx_XDECREF(__pyx_v_choice); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":686 * return False * * def check_node(self): # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type == YAML_STREAM_START_EVENT: */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_23check_node(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_23check_node(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("check_node (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_22check_node(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_22check_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; __Pyx_RefNannySetupContext("check_node", 0); /* "_ruamel_yaml.pyx":687 * * def check_node(self): * self._parse_next_event() # <<<<<<<<<<<<<< * if self.parsed_event.type == YAML_STREAM_START_EVENT: * yaml_event_delete(&self.parsed_event) */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 687, __pyx_L1_error) /* "_ruamel_yaml.pyx":688 * def check_node(self): * self._parse_next_event() * if self.parsed_event.type == YAML_STREAM_START_EVENT: # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * self._parse_next_event() */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type == YAML_STREAM_START_EVENT) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":689 * self._parse_next_event() * if self.parsed_event.type == YAML_STREAM_START_EVENT: * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":690 * if self.parsed_event.type == YAML_STREAM_START_EVENT: * yaml_event_delete(&self.parsed_event) * self._parse_next_event() # <<<<<<<<<<<<<< * if self.parsed_event.type != YAML_STREAM_END_EVENT: * return True */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 690, __pyx_L1_error) /* "_ruamel_yaml.pyx":688 * def check_node(self): * self._parse_next_event() * if self.parsed_event.type == YAML_STREAM_START_EVENT: # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * self._parse_next_event() */ } /* "_ruamel_yaml.pyx":691 * yaml_event_delete(&self.parsed_event) * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * return True * return False */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type != YAML_STREAM_END_EVENT) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":692 * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: * return True # <<<<<<<<<<<<<< * return False * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; /* "_ruamel_yaml.pyx":691 * yaml_event_delete(&self.parsed_event) * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * return True * return False */ } /* "_ruamel_yaml.pyx":693 * if self.parsed_event.type != YAML_STREAM_END_EVENT: * return True * return False # <<<<<<<<<<<<<< * * def get_node(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* "_ruamel_yaml.pyx":686 * return False * * def check_node(self): # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type == YAML_STREAM_START_EVENT: */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("_ruamel_yaml.CParser.check_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":695 * return False * * def get_node(self): # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_25get_node(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_25get_node(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_node (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_24get_node(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_24get_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("get_node", 0); /* "_ruamel_yaml.pyx":696 * * def get_node(self): * self._parse_next_event() # <<<<<<<<<<<<<< * if self.parsed_event.type != YAML_STREAM_END_EVENT: * return self._compose_document() */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 696, __pyx_L1_error) /* "_ruamel_yaml.pyx":697 * def get_node(self): * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * return self._compose_document() * */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type != YAML_STREAM_END_EVENT) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":698 * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: * return self._compose_document() # <<<<<<<<<<<<<< * * def get_single_node(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_document(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":697 * def get_node(self): * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * return self._compose_document() * */ } /* "_ruamel_yaml.pyx":695 * return False * * def get_node(self): # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser.get_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":700 * return self._compose_document() * * def get_single_node(self): # <<<<<<<<<<<<<< * self._parse_next_event() * yaml_event_delete(&self.parsed_event) */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_27get_single_node(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_27get_single_node(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_single_node (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_26get_single_node(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_26get_single_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_v_document = NULL; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_mark = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("get_single_node", 0); /* "_ruamel_yaml.pyx":701 * * def get_single_node(self): * self._parse_next_event() # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * self._parse_next_event() */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 701, __pyx_L1_error) /* "_ruamel_yaml.pyx":702 * def get_single_node(self): * self._parse_next_event() * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * self._parse_next_event() * document = None */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":703 * self._parse_next_event() * yaml_event_delete(&self.parsed_event) * self._parse_next_event() # <<<<<<<<<<<<<< * document = None * if self.parsed_event.type != YAML_STREAM_END_EVENT: */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 703, __pyx_L1_error) /* "_ruamel_yaml.pyx":704 * yaml_event_delete(&self.parsed_event) * self._parse_next_event() * document = None # <<<<<<<<<<<<<< * if self.parsed_event.type != YAML_STREAM_END_EVENT: * document = self._compose_document() */ __Pyx_INCREF(Py_None); __pyx_v_document = Py_None; /* "_ruamel_yaml.pyx":705 * self._parse_next_event() * document = None * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * document = self._compose_document() * self._parse_next_event() */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type != YAML_STREAM_END_EVENT) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":706 * document = None * if self.parsed_event.type != YAML_STREAM_END_EVENT: * document = self._compose_document() # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_document(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_document, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":705 * self._parse_next_event() * document = None * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * document = self._compose_document() * self._parse_next_event() */ } /* "_ruamel_yaml.pyx":707 * if self.parsed_event.type != YAML_STREAM_END_EVENT: * document = self._compose_document() * self._parse_next_event() # <<<<<<<<<<<<<< * if self.parsed_event.type != YAML_STREAM_END_EVENT: * mark = Mark(self.stream_name, */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 707, __pyx_L1_error) /* "_ruamel_yaml.pyx":708 * document = self._compose_document() * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type != YAML_STREAM_END_EVENT) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":710 * if self.parsed_event.type != YAML_STREAM_END_EVENT: * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 710, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":711 * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.column, * None, None) */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.line); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":712 * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * if PY_MAJOR_VERSION < 3: */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.column); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 712, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "_ruamel_yaml.pyx":709 * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: * mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, */ __pyx_t_6 = PyTuple_New(6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 709, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_6, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_6, 5, Py_None); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 709, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":714 * self.parsed_event.start_mark.column, * None, None) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ComposerError("expected a single document in the stream", * document.start_mark, "but found another document", mark) */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":715 * None, None) * if PY_MAJOR_VERSION < 3: * raise ComposerError("expected a single document in the stream", # <<<<<<<<<<<<<< * document.start_mark, "but found another document", mark) * else: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_ComposerError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); /* "_ruamel_yaml.pyx":716 * if PY_MAJOR_VERSION < 3: * raise ComposerError("expected a single document in the stream", * document.start_mark, "but found another document", mark) # <<<<<<<<<<<<<< * else: * raise ComposerError(u"expected a single document in the stream", */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_document, __pyx_n_s_start_mark); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 716, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_kp_s_expected_a_single_document_in_th, __pyx_t_4, __pyx_kp_s_but_found_another_document, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_kp_s_expected_a_single_document_in_th, __pyx_t_4, __pyx_kp_s_but_found_another_document, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_7 = PyTuple_New(4+__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_kp_s_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_kp_s_expected_a_single_document_in_th); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_1, __pyx_kp_s_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_kp_s_but_found_another_document); __Pyx_GIVEREF(__pyx_kp_s_but_found_another_document); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_1, __pyx_kp_s_but_found_another_document); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_1, ((PyObject *)__pyx_v_mark)); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 715, __pyx_L1_error) /* "_ruamel_yaml.pyx":714 * self.parsed_event.start_mark.column, * None, None) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ComposerError("expected a single document in the stream", * document.start_mark, "but found another document", mark) */ } /* "_ruamel_yaml.pyx":718 * document.start_mark, "but found another document", mark) * else: * raise ComposerError(u"expected a single document in the stream", # <<<<<<<<<<<<<< * document.start_mark, u"but found another document", mark) * return document */ /*else*/ { __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_ComposerError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); /* "_ruamel_yaml.pyx":719 * else: * raise ComposerError(u"expected a single document in the stream", * document.start_mark, u"but found another document", mark) # <<<<<<<<<<<<<< * return document * */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_document, __pyx_n_s_start_mark); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_4 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_kp_u_expected_a_single_document_in_th, __pyx_t_7, __pyx_kp_u_but_found_another_document, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_kp_u_expected_a_single_document_in_th, __pyx_t_7, __pyx_kp_u_but_found_another_document, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_3 = PyTuple_New(4+__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(__pyx_kp_u_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_kp_u_expected_a_single_document_in_th); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_1, __pyx_kp_u_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_kp_u_but_found_another_document); __Pyx_GIVEREF(__pyx_kp_u_but_found_another_document); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_1, __pyx_kp_u_but_found_another_document); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_3, 3+__pyx_t_1, ((PyObject *)__pyx_v_mark)); __pyx_t_7 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 718, __pyx_L1_error) } /* "_ruamel_yaml.pyx":708 * document = self._compose_document() * self._parse_next_event() * if self.parsed_event.type != YAML_STREAM_END_EVENT: # <<<<<<<<<<<<<< * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ } /* "_ruamel_yaml.pyx":720 * raise ComposerError(u"expected a single document in the stream", * document.start_mark, u"but found another document", mark) * return document # <<<<<<<<<<<<<< * * cdef object _compose_document(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_document); __pyx_r = __pyx_v_document; goto __pyx_L0; /* "_ruamel_yaml.pyx":700 * return self._compose_document() * * def get_single_node(self): # <<<<<<<<<<<<<< * self._parse_next_event() * yaml_event_delete(&self.parsed_event) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("_ruamel_yaml.CParser.get_single_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_document); __Pyx_XDECREF((PyObject *)__pyx_v_mark); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":722 * return document * * cdef object _compose_document(self): # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * node = self._compose_node(None, None) */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_document(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_v_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; __Pyx_RefNannySetupContext("_compose_document", 0); /* "_ruamel_yaml.pyx":723 * * cdef object _compose_document(self): * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * node = self._compose_node(None, None) * self._parse_next_event() */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":724 * cdef object _compose_document(self): * yaml_event_delete(&self.parsed_event) * node = self._compose_node(None, None) # <<<<<<<<<<<<<< * self._parse_next_event() * yaml_event_delete(&self.parsed_event) */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_node(__pyx_v_self, Py_None, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_node = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":725 * yaml_event_delete(&self.parsed_event) * node = self._compose_node(None, None) * self._parse_next_event() # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * self.anchors = {} */ __pyx_t_2 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(0, 725, __pyx_L1_error) /* "_ruamel_yaml.pyx":726 * node = self._compose_node(None, None) * self._parse_next_event() * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * self.anchors = {} * return node */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":727 * self._parse_next_event() * yaml_event_delete(&self.parsed_event) * self.anchors = {} # <<<<<<<<<<<<<< * return node * */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->anchors); __Pyx_DECREF(__pyx_v_self->anchors); __pyx_v_self->anchors = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":728 * yaml_event_delete(&self.parsed_event) * self.anchors = {} * return node # <<<<<<<<<<<<<< * * cdef object _compose_node(self, object parent, object index): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_node); __pyx_r = __pyx_v_node; goto __pyx_L0; /* "_ruamel_yaml.pyx":722 * return document * * cdef object _compose_document(self): # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * node = self._compose_node(None, None) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.CParser._compose_document", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":730 * return node * * cdef object _compose_node(self, object parent, object index): # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type == YAML_ALIAS_EVENT: */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_parent, PyObject *__pyx_v_index) { PyObject *__pyx_v_anchor = NULL; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_mark = NULL; PyObject *__pyx_v_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("_compose_node", 0); /* "_ruamel_yaml.pyx":731 * * cdef object _compose_node(self, object parent, object index): * self._parse_next_event() # <<<<<<<<<<<<<< * if self.parsed_event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 731, __pyx_L1_error) /* "_ruamel_yaml.pyx":732 * cdef object _compose_node(self, object parent, object index): * self._parse_next_event() * if self.parsed_event.type == YAML_ALIAS_EVENT: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) * if anchor not in self.anchors: */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type == YAML_ALIAS_EVENT) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":733 * self._parse_next_event() * if self.parsed_event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) # <<<<<<<<<<<<<< * if anchor not in self.anchors: * mark = Mark(self.stream_name, */ __pyx_t_3 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.alias.anchor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_anchor = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":734 * if self.parsed_event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) * if anchor not in self.anchors: # <<<<<<<<<<<<<< * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_anchor, __pyx_v_self->anchors, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 734, __pyx_L1_error) __pyx_t_4 = (__pyx_t_2 != 0); if (__pyx_t_4) { /* "_ruamel_yaml.pyx":736 * if anchor not in self.anchors: * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":737 * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.column, * None, None) */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.line); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "_ruamel_yaml.pyx":738 * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * if PY_MAJOR_VERSION < 3: */ __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.column); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); /* "_ruamel_yaml.pyx":735 * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) * if anchor not in self.anchors: * mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, */ __pyx_t_7 = PyTuple_New(6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_7, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_7, 5, Py_None); __pyx_t_3 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_6); __pyx_t_6 = 0; /* "_ruamel_yaml.pyx":740 * self.parsed_event.start_mark.column, * None, None) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ComposerError(None, None, "found undefined alias", mark) * else: */ __pyx_t_4 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_4) { /* "_ruamel_yaml.pyx":741 * None, None) * if PY_MAJOR_VERSION < 3: * raise ComposerError(None, None, "found undefined alias", mark) # <<<<<<<<<<<<<< * else: * raise ComposerError(None, None, u"found undefined alias", mark) */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_ComposerError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[5] = {__pyx_t_5, Py_None, Py_None, __pyx_kp_s_found_undefined_alias, ((PyObject *)__pyx_v_mark)}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 741, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[5] = {__pyx_t_5, Py_None, Py_None, __pyx_kp_s_found_undefined_alias, ((PyObject *)__pyx_v_mark)}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 741, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { __pyx_t_3 = PyTuple_New(4+__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_1, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_1, Py_None); __Pyx_INCREF(__pyx_kp_s_found_undefined_alias); __Pyx_GIVEREF(__pyx_kp_s_found_undefined_alias); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_1, __pyx_kp_s_found_undefined_alias); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_3, 3+__pyx_t_1, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 741, __pyx_L1_error) /* "_ruamel_yaml.pyx":740 * self.parsed_event.start_mark.column, * None, None) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ComposerError(None, None, "found undefined alias", mark) * else: */ } /* "_ruamel_yaml.pyx":743 * raise ComposerError(None, None, "found undefined alias", mark) * else: * raise ComposerError(None, None, u"found undefined alias", mark) # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * return self.anchors[anchor] */ /*else*/ { __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_ComposerError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[5] = {__pyx_t_3, Py_None, Py_None, __pyx_kp_u_found_undefined_alias, ((PyObject *)__pyx_v_mark)}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[5] = {__pyx_t_3, Py_None, Py_None, __pyx_kp_u_found_undefined_alias, ((PyObject *)__pyx_v_mark)}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { __pyx_t_5 = PyTuple_New(4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_1, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_1, Py_None); __Pyx_INCREF(__pyx_kp_u_found_undefined_alias); __Pyx_GIVEREF(__pyx_kp_u_found_undefined_alias); PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_1, __pyx_kp_u_found_undefined_alias); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_1, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 743, __pyx_L1_error) } /* "_ruamel_yaml.pyx":734 * if self.parsed_event.type == YAML_ALIAS_EVENT: * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) * if anchor not in self.anchors: # <<<<<<<<<<<<<< * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ } /* "_ruamel_yaml.pyx":744 * else: * raise ComposerError(None, None, u"found undefined alias", mark) * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * return self.anchors[anchor] * anchor = None */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":745 * raise ComposerError(None, None, u"found undefined alias", mark) * yaml_event_delete(&self.parsed_event) * return self.anchors[anchor] # <<<<<<<<<<<<<< * anchor = None * if self.parsed_event.type == YAML_SCALAR_EVENT \ */ __Pyx_XDECREF(__pyx_r); __pyx_t_6 = PyObject_GetItem(__pyx_v_self->anchors, __pyx_v_anchor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":732 * cdef object _compose_node(self, object parent, object index): * self._parse_next_event() * if self.parsed_event.type == YAML_ALIAS_EVENT: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) * if anchor not in self.anchors: */ } /* "_ruamel_yaml.pyx":746 * yaml_event_delete(&self.parsed_event) * return self.anchors[anchor] * anchor = None # <<<<<<<<<<<<<< * if self.parsed_event.type == YAML_SCALAR_EVENT \ * and self.parsed_event.data.scalar.anchor != NULL: */ __Pyx_INCREF(Py_None); __pyx_v_anchor = Py_None; /* "_ruamel_yaml.pyx":747 * return self.anchors[anchor] * anchor = None * if self.parsed_event.type == YAML_SCALAR_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type == YAML_SCALAR_EVENT) != 0); if (__pyx_t_2) { } else { __pyx_t_4 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "_ruamel_yaml.pyx":748 * anchor = None * if self.parsed_event.type == YAML_SCALAR_EVENT \ * and self.parsed_event.data.scalar.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ */ __pyx_t_2 = ((__pyx_v_self->parsed_event.data.scalar.anchor != NULL) != 0); __pyx_t_4 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "_ruamel_yaml.pyx":747 * return self.anchors[anchor] * anchor = None * if self.parsed_event.type == YAML_SCALAR_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) */ if (__pyx_t_4) { /* "_ruamel_yaml.pyx":749 * if self.parsed_event.type == YAML_SCALAR_EVENT \ * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) # <<<<<<<<<<<<<< * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ * and self.parsed_event.data.sequence_start.anchor != NULL: */ __pyx_t_6 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.scalar.anchor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_anchor, __pyx_t_6); __pyx_t_6 = 0; /* "_ruamel_yaml.pyx":747 * return self.anchors[anchor] * anchor = None * if self.parsed_event.type == YAML_SCALAR_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":750 * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type == YAML_SEQUENCE_START_EVENT) != 0); if (__pyx_t_2) { } else { __pyx_t_4 = __pyx_t_2; goto __pyx_L9_bool_binop_done; } /* "_ruamel_yaml.pyx":751 * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ * and self.parsed_event.data.sequence_start.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ */ __pyx_t_2 = ((__pyx_v_self->parsed_event.data.sequence_start.anchor != NULL) != 0); __pyx_t_4 = __pyx_t_2; __pyx_L9_bool_binop_done:; /* "_ruamel_yaml.pyx":750 * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) */ if (__pyx_t_4) { /* "_ruamel_yaml.pyx":752 * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) # <<<<<<<<<<<<<< * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ * and self.parsed_event.data.mapping_start.anchor != NULL: */ __pyx_t_6 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.sequence_start.anchor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_anchor, __pyx_t_6); __pyx_t_6 = 0; /* "_ruamel_yaml.pyx":750 * and self.parsed_event.data.scalar.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) */ goto __pyx_L6; } /* "_ruamel_yaml.pyx":753 * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) */ __pyx_t_2 = ((__pyx_v_self->parsed_event.type == YAML_MAPPING_START_EVENT) != 0); if (__pyx_t_2) { } else { __pyx_t_4 = __pyx_t_2; goto __pyx_L11_bool_binop_done; } /* "_ruamel_yaml.pyx":754 * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ * and self.parsed_event.data.mapping_start.anchor != NULL: # <<<<<<<<<<<<<< * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) * if anchor is not None: */ __pyx_t_2 = ((__pyx_v_self->parsed_event.data.mapping_start.anchor != NULL) != 0); __pyx_t_4 = __pyx_t_2; __pyx_L11_bool_binop_done:; /* "_ruamel_yaml.pyx":753 * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) */ if (__pyx_t_4) { /* "_ruamel_yaml.pyx":755 * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ * and self.parsed_event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) # <<<<<<<<<<<<<< * if anchor is not None: * if anchor in self.anchors: */ __pyx_t_6 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.mapping_start.anchor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_anchor, __pyx_t_6); __pyx_t_6 = 0; /* "_ruamel_yaml.pyx":753 * and self.parsed_event.data.sequence_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ # <<<<<<<<<<<<<< * and self.parsed_event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) */ } __pyx_L6:; /* "_ruamel_yaml.pyx":756 * and self.parsed_event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) * if anchor is not None: # <<<<<<<<<<<<<< * if anchor in self.anchors: * mark = Mark(self.stream_name, */ __pyx_t_4 = (__pyx_v_anchor != Py_None); __pyx_t_2 = (__pyx_t_4 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":757 * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) * if anchor is not None: * if anchor in self.anchors: # <<<<<<<<<<<<<< * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_anchor, __pyx_v_self->anchors, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 757, __pyx_L1_error) __pyx_t_4 = (__pyx_t_2 != 0); if (__pyx_t_4) { /* "_ruamel_yaml.pyx":759 * if anchor in self.anchors: * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, */ __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.index); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); /* "_ruamel_yaml.pyx":760 * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.column, * None, None) */ __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.line); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); /* "_ruamel_yaml.pyx":761 * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * if PY_MAJOR_VERSION < 3: */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.column); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "_ruamel_yaml.pyx":758 * if anchor is not None: * if anchor in self.anchors: * mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, */ __pyx_t_3 = PyTuple_New(6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_5); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 5, Py_None); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":763 * self.parsed_event.start_mark.column, * None, None) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ComposerError("found duplicate anchor; first occurrence", * self.anchors[anchor].start_mark, "second occurrence", mark) */ __pyx_t_4 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_4) { /* "_ruamel_yaml.pyx":764 * None, None) * if PY_MAJOR_VERSION < 3: * raise ComposerError("found duplicate anchor; first occurrence", # <<<<<<<<<<<<<< * self.anchors[anchor].start_mark, "second occurrence", mark) * else: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ComposerError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":765 * if PY_MAJOR_VERSION < 3: * raise ComposerError("found duplicate anchor; first occurrence", * self.anchors[anchor].start_mark, "second occurrence", mark) # <<<<<<<<<<<<<< * else: * raise ComposerError(u"found duplicate anchor; first occurrence", */ __pyx_t_7 = PyObject_GetItem(__pyx_v_self->anchors, __pyx_v_anchor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_start_mark); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_kp_s_found_duplicate_anchor_first_occ, __pyx_t_6, __pyx_kp_s_second_occurrence, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_kp_s_found_duplicate_anchor_first_occ, __pyx_t_6, __pyx_kp_s_second_occurrence, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_8 = PyTuple_New(4+__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_s_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_kp_s_found_duplicate_anchor_first_occ); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_1, __pyx_kp_s_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_kp_s_second_occurrence); __Pyx_GIVEREF(__pyx_kp_s_second_occurrence); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_1, __pyx_kp_s_second_occurrence); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_1, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 764, __pyx_L1_error) /* "_ruamel_yaml.pyx":763 * self.parsed_event.start_mark.column, * None, None) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ComposerError("found duplicate anchor; first occurrence", * self.anchors[anchor].start_mark, "second occurrence", mark) */ } /* "_ruamel_yaml.pyx":767 * self.anchors[anchor].start_mark, "second occurrence", mark) * else: * raise ComposerError(u"found duplicate anchor; first occurrence", # <<<<<<<<<<<<<< * self.anchors[anchor].start_mark, u"second occurrence", mark) * self.descend_resolver(parent, index) */ /*else*/ { __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ComposerError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":768 * else: * raise ComposerError(u"found duplicate anchor; first occurrence", * self.anchors[anchor].start_mark, u"second occurrence", mark) # <<<<<<<<<<<<<< * self.descend_resolver(parent, index) * if self.parsed_event.type == YAML_SCALAR_EVENT: */ __pyx_t_8 = PyObject_GetItem(__pyx_v_self->anchors, __pyx_v_anchor); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_start_mark); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_kp_u_found_duplicate_anchor_first_occ, __pyx_t_6, __pyx_kp_u_second_occurrence, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 767, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_kp_u_found_duplicate_anchor_first_occ, __pyx_t_6, __pyx_kp_u_second_occurrence, ((PyObject *)__pyx_v_mark)}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_1, 4+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 767, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_7 = PyTuple_New(4+__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_kp_u_found_duplicate_anchor_first_occ); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_1, __pyx_kp_u_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_kp_u_second_occurrence); __Pyx_GIVEREF(__pyx_kp_u_second_occurrence); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_1, __pyx_kp_u_second_occurrence); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_1, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 767, __pyx_L1_error) } /* "_ruamel_yaml.pyx":757 * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) * if anchor is not None: * if anchor in self.anchors: # <<<<<<<<<<<<<< * mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ } /* "_ruamel_yaml.pyx":756 * and self.parsed_event.data.mapping_start.anchor != NULL: * anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) * if anchor is not None: # <<<<<<<<<<<<<< * if anchor in self.anchors: * mark = Mark(self.stream_name, */ } /* "_ruamel_yaml.pyx":769 * raise ComposerError(u"found duplicate anchor; first occurrence", * self.anchors[anchor].start_mark, u"second occurrence", mark) * self.descend_resolver(parent, index) # <<<<<<<<<<<<<< * if self.parsed_event.type == YAML_SCALAR_EVENT: * node = self._compose_scalar_node(anchor) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_descend_resolver); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_parent, __pyx_v_index}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 769, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_parent, __pyx_v_index}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 769, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_v_parent); __Pyx_GIVEREF(__pyx_v_parent); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_1, __pyx_v_parent); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_1, __pyx_v_index); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":770 * self.anchors[anchor].start_mark, u"second occurrence", mark) * self.descend_resolver(parent, index) * if self.parsed_event.type == YAML_SCALAR_EVENT: # <<<<<<<<<<<<<< * node = self._compose_scalar_node(anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: */ switch (__pyx_v_self->parsed_event.type) { case YAML_SCALAR_EVENT: /* "_ruamel_yaml.pyx":771 * self.descend_resolver(parent, index) * if self.parsed_event.type == YAML_SCALAR_EVENT: * node = self._compose_scalar_node(anchor) # <<<<<<<<<<<<<< * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: * node = self._compose_sequence_node(anchor) */ __pyx_t_5 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_scalar_node(__pyx_v_self, __pyx_v_anchor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_node = __pyx_t_5; __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":770 * self.anchors[anchor].start_mark, u"second occurrence", mark) * self.descend_resolver(parent, index) * if self.parsed_event.type == YAML_SCALAR_EVENT: # <<<<<<<<<<<<<< * node = self._compose_scalar_node(anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: */ break; /* "_ruamel_yaml.pyx":772 * if self.parsed_event.type == YAML_SCALAR_EVENT: * node = self._compose_scalar_node(anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: # <<<<<<<<<<<<<< * node = self._compose_sequence_node(anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: */ case YAML_SEQUENCE_START_EVENT: /* "_ruamel_yaml.pyx":773 * node = self._compose_scalar_node(anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: * node = self._compose_sequence_node(anchor) # <<<<<<<<<<<<<< * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: * node = self._compose_mapping_node(anchor) */ __pyx_t_5 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_sequence_node(__pyx_v_self, __pyx_v_anchor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_node = __pyx_t_5; __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":772 * if self.parsed_event.type == YAML_SCALAR_EVENT: * node = self._compose_scalar_node(anchor) * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: # <<<<<<<<<<<<<< * node = self._compose_sequence_node(anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: */ break; /* "_ruamel_yaml.pyx":774 * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: * node = self._compose_sequence_node(anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: # <<<<<<<<<<<<<< * node = self._compose_mapping_node(anchor) * self.ascend_resolver() */ case YAML_MAPPING_START_EVENT: /* "_ruamel_yaml.pyx":775 * node = self._compose_sequence_node(anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: * node = self._compose_mapping_node(anchor) # <<<<<<<<<<<<<< * self.ascend_resolver() * return node */ __pyx_t_5 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_mapping_node(__pyx_v_self, __pyx_v_anchor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 775, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_node = __pyx_t_5; __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":774 * elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: * node = self._compose_sequence_node(anchor) * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: # <<<<<<<<<<<<<< * node = self._compose_mapping_node(anchor) * self.ascend_resolver() */ break; default: break; } /* "_ruamel_yaml.pyx":776 * elif self.parsed_event.type == YAML_MAPPING_START_EVENT: * node = self._compose_mapping_node(anchor) * self.ascend_resolver() # <<<<<<<<<<<<<< * return node * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ascend_resolver); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_6) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 776, __pyx_L1_error) } __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":777 * node = self._compose_mapping_node(anchor) * self.ascend_resolver() * return node # <<<<<<<<<<<<<< * * cdef _compose_scalar_node(self, object anchor): */ __Pyx_XDECREF(__pyx_r); if (unlikely(!__pyx_v_node)) { __Pyx_RaiseUnboundLocalError("node"); __PYX_ERR(0, 777, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_node); __pyx_r = __pyx_v_node; goto __pyx_L0; /* "_ruamel_yaml.pyx":730 * return node * * cdef object _compose_node(self, object parent, object index): # <<<<<<<<<<<<<< * self._parse_next_event() * if self.parsed_event.type == YAML_ALIAS_EVENT: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_ruamel_yaml.CParser._compose_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_anchor); __Pyx_XDECREF((PyObject *)__pyx_v_mark); __Pyx_XDECREF(__pyx_v_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":779 * return node * * cdef _compose_scalar_node(self, object anchor): # <<<<<<<<<<<<<< * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_scalar_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_anchor) { struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_start_mark = NULL; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_end_mark = NULL; PyObject *__pyx_v_value = NULL; int __pyx_v_plain_implicit; int __pyx_v_quoted_implicit; PyObject *__pyx_v_tag = NULL; PyObject *__pyx_v_style = NULL; PyObject *__pyx_v_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; __Pyx_RefNannySetupContext("_compose_scalar_node", 0); /* "_ruamel_yaml.pyx":781 * cdef _compose_scalar_node(self, object anchor): * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":782 * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.column, * None, None) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.line); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":783 * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * end_mark = Mark(self.stream_name, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":780 * * cdef _compose_scalar_node(self, object anchor): * start_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, */ __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 780, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 5, Py_None); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 780, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_start_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":786 * None, None) * end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.line, * self.parsed_event.end_mark.column, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":787 * end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.column, * None, None) */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.line); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":788 * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, * self.parsed_event.end_mark.column, # <<<<<<<<<<<<<< * None, None) * value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value, */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.column); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":785 * self.parsed_event.start_mark.column, * None, None) * end_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, */ __pyx_t_1 = PyTuple_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_2); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 5, Py_None); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_end_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":790 * self.parsed_event.end_mark.column, * None, None) * value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value, # <<<<<<<<<<<<<< * self.parsed_event.data.scalar.length, 'strict') * plain_implicit = False */ __pyx_t_2 = PyUnicode_DecodeUTF8(__pyx_v_self->parsed_event.data.scalar.value, __pyx_v_self->parsed_event.data.scalar.length, ((char *)"strict")); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_value = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":792 * value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value, * self.parsed_event.data.scalar.length, 'strict') * plain_implicit = False # <<<<<<<<<<<<<< * if self.parsed_event.data.scalar.plain_implicit == 1: * plain_implicit = True */ __pyx_v_plain_implicit = 0; /* "_ruamel_yaml.pyx":793 * self.parsed_event.data.scalar.length, 'strict') * plain_implicit = False * if self.parsed_event.data.scalar.plain_implicit == 1: # <<<<<<<<<<<<<< * plain_implicit = True * quoted_implicit = False */ __pyx_t_5 = ((__pyx_v_self->parsed_event.data.scalar.plain_implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":794 * plain_implicit = False * if self.parsed_event.data.scalar.plain_implicit == 1: * plain_implicit = True # <<<<<<<<<<<<<< * quoted_implicit = False * if self.parsed_event.data.scalar.quoted_implicit == 1: */ __pyx_v_plain_implicit = 1; /* "_ruamel_yaml.pyx":793 * self.parsed_event.data.scalar.length, 'strict') * plain_implicit = False * if self.parsed_event.data.scalar.plain_implicit == 1: # <<<<<<<<<<<<<< * plain_implicit = True * quoted_implicit = False */ } /* "_ruamel_yaml.pyx":795 * if self.parsed_event.data.scalar.plain_implicit == 1: * plain_implicit = True * quoted_implicit = False # <<<<<<<<<<<<<< * if self.parsed_event.data.scalar.quoted_implicit == 1: * quoted_implicit = True */ __pyx_v_quoted_implicit = 0; /* "_ruamel_yaml.pyx":796 * plain_implicit = True * quoted_implicit = False * if self.parsed_event.data.scalar.quoted_implicit == 1: # <<<<<<<<<<<<<< * quoted_implicit = True * if self.parsed_event.data.scalar.tag == NULL \ */ __pyx_t_5 = ((__pyx_v_self->parsed_event.data.scalar.quoted_implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":797 * quoted_implicit = False * if self.parsed_event.data.scalar.quoted_implicit == 1: * quoted_implicit = True # <<<<<<<<<<<<<< * if self.parsed_event.data.scalar.tag == NULL \ * or (self.parsed_event.data.scalar.tag[0] == c'!' */ __pyx_v_quoted_implicit = 1; /* "_ruamel_yaml.pyx":796 * plain_implicit = True * quoted_implicit = False * if self.parsed_event.data.scalar.quoted_implicit == 1: # <<<<<<<<<<<<<< * quoted_implicit = True * if self.parsed_event.data.scalar.tag == NULL \ */ } /* "_ruamel_yaml.pyx":798 * if self.parsed_event.data.scalar.quoted_implicit == 1: * quoted_implicit = True * if self.parsed_event.data.scalar.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.scalar.tag[0] == c'!' * and self.parsed_event.data.scalar.tag[1] == c'\0'): */ __pyx_t_6 = ((__pyx_v_self->parsed_event.data.scalar.tag == NULL) != 0); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L6_bool_binop_done; } /* "_ruamel_yaml.pyx":799 * quoted_implicit = True * if self.parsed_event.data.scalar.tag == NULL \ * or (self.parsed_event.data.scalar.tag[0] == c'!' # <<<<<<<<<<<<<< * and self.parsed_event.data.scalar.tag[1] == c'\0'): * tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) */ __pyx_t_6 = (((__pyx_v_self->parsed_event.data.scalar.tag[0]) == '!') != 0); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L6_bool_binop_done; } /* "_ruamel_yaml.pyx":800 * if self.parsed_event.data.scalar.tag == NULL \ * or (self.parsed_event.data.scalar.tag[0] == c'!' * and self.parsed_event.data.scalar.tag[1] == c'\0'): # <<<<<<<<<<<<<< * tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) * else: */ __pyx_t_6 = (((__pyx_v_self->parsed_event.data.scalar.tag[1]) == '\x00') != 0); __pyx_t_5 = __pyx_t_6; __pyx_L6_bool_binop_done:; /* "_ruamel_yaml.pyx":798 * if self.parsed_event.data.scalar.quoted_implicit == 1: * quoted_implicit = True * if self.parsed_event.data.scalar.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.scalar.tag[0] == c'!' * and self.parsed_event.data.scalar.tag[1] == c'\0'): */ if (__pyx_t_5) { /* "_ruamel_yaml.pyx":801 * or (self.parsed_event.data.scalar.tag[0] == c'!' * and self.parsed_event.data.scalar.tag[1] == c'\0'): * tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) # <<<<<<<<<<<<<< * else: * tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_plain_implicit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_quoted_implicit); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); __pyx_t_3 = 0; __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_4, __pyx_v_value, __pyx_t_8}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_4, __pyx_v_value, __pyx_t_8}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_3 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_9, __pyx_t_4); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_9, __pyx_v_value); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_9, __pyx_t_8); __pyx_t_4 = 0; __pyx_t_8 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_tag = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":798 * if self.parsed_event.data.scalar.quoted_implicit == 1: * quoted_implicit = True * if self.parsed_event.data.scalar.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.scalar.tag[0] == c'!' * and self.parsed_event.data.scalar.tag[1] == c'\0'): */ goto __pyx_L5; } /* "_ruamel_yaml.pyx":803 * tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) * else: * tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) # <<<<<<<<<<<<<< * style = None * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: */ /*else*/ { __pyx_t_2 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.scalar.tag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 803, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_tag = __pyx_t_2; __pyx_t_2 = 0; } __pyx_L5:; /* "_ruamel_yaml.pyx":804 * else: * tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) * style = None # <<<<<<<<<<<<<< * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' */ __Pyx_INCREF(Py_None); __pyx_v_style = Py_None; /* "_ruamel_yaml.pyx":805 * tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) * style = None * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'' * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: */ switch (__pyx_v_self->parsed_event.data.scalar.style) { case YAML_PLAIN_SCALAR_STYLE: /* "_ruamel_yaml.pyx":806 * style = None * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' # <<<<<<<<<<<<<< * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' */ __Pyx_INCREF(__pyx_kp_u__6); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__6); /* "_ruamel_yaml.pyx":805 * tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) * style = None * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'' * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: */ break; /* "_ruamel_yaml.pyx":807 * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'\'' * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: */ case YAML_SINGLE_QUOTED_SCALAR_STYLE: /* "_ruamel_yaml.pyx":808 * style = u'' * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' # <<<<<<<<<<<<<< * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' */ __Pyx_INCREF(__pyx_kp_u__7); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__7); /* "_ruamel_yaml.pyx":807 * if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: * style = u'' * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'\'' * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: */ break; /* "_ruamel_yaml.pyx":809 * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'"' * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: */ case YAML_DOUBLE_QUOTED_SCALAR_STYLE: /* "_ruamel_yaml.pyx":810 * style = u'\'' * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' # <<<<<<<<<<<<<< * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' */ __Pyx_INCREF(__pyx_kp_u__8); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__8); /* "_ruamel_yaml.pyx":809 * elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: * style = u'\'' * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'"' * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: */ break; /* "_ruamel_yaml.pyx":811 * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'|' * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: */ case YAML_LITERAL_SCALAR_STYLE: /* "_ruamel_yaml.pyx":812 * style = u'"' * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' # <<<<<<<<<<<<<< * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' */ __Pyx_INCREF(__pyx_kp_u__9); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__9); /* "_ruamel_yaml.pyx":811 * elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: * style = u'"' * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'|' * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: */ break; /* "_ruamel_yaml.pyx":813 * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'>' * node = ScalarNode(tag, value, start_mark, end_mark, style) */ case YAML_FOLDED_SCALAR_STYLE: /* "_ruamel_yaml.pyx":814 * style = u'|' * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' # <<<<<<<<<<<<<< * node = ScalarNode(tag, value, start_mark, end_mark, style) * if anchor is not None: */ __Pyx_INCREF(__pyx_kp_u__10); __Pyx_DECREF_SET(__pyx_v_style, __pyx_kp_u__10); /* "_ruamel_yaml.pyx":813 * elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: * style = u'|' * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: # <<<<<<<<<<<<<< * style = u'>' * node = ScalarNode(tag, value, start_mark, end_mark, style) */ break; default: break; } /* "_ruamel_yaml.pyx":815 * elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: * style = u'>' * node = ScalarNode(tag, value, start_mark, end_mark, style) # <<<<<<<<<<<<<< * if anchor is not None: * self.anchors[anchor] = node */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[6] = {__pyx_t_3, __pyx_v_tag, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_style}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_9, 5+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 815, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[6] = {__pyx_t_3, __pyx_v_tag, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), ((PyObject *)__pyx_v_end_mark), __pyx_v_style}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_9, 5+__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 815, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_8 = PyTuple_New(5+__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_tag); __Pyx_GIVEREF(__pyx_v_tag); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_9, __pyx_v_tag); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, __pyx_v_value); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_9, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(((PyObject *)__pyx_v_end_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_end_mark)); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_9, ((PyObject *)__pyx_v_end_mark)); __Pyx_INCREF(__pyx_v_style); __Pyx_GIVEREF(__pyx_v_style); PyTuple_SET_ITEM(__pyx_t_8, 4+__pyx_t_9, __pyx_v_style); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_node = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":816 * style = u'>' * node = ScalarNode(tag, value, start_mark, end_mark, style) * if anchor is not None: # <<<<<<<<<<<<<< * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) */ __pyx_t_5 = (__pyx_v_anchor != Py_None); __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "_ruamel_yaml.pyx":817 * node = ScalarNode(tag, value, start_mark, end_mark, style) * if anchor is not None: * self.anchors[anchor] = node # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * return node */ if (unlikely(PyObject_SetItem(__pyx_v_self->anchors, __pyx_v_anchor, __pyx_v_node) < 0)) __PYX_ERR(0, 817, __pyx_L1_error) /* "_ruamel_yaml.pyx":816 * style = u'>' * node = ScalarNode(tag, value, start_mark, end_mark, style) * if anchor is not None: # <<<<<<<<<<<<<< * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) */ } /* "_ruamel_yaml.pyx":818 * if anchor is not None: * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * return node * */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":819 * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) * return node # <<<<<<<<<<<<<< * * cdef _compose_sequence_node(self, object anchor): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_node); __pyx_r = __pyx_v_node; goto __pyx_L0; /* "_ruamel_yaml.pyx":779 * return node * * cdef _compose_scalar_node(self, object anchor): # <<<<<<<<<<<<<< * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_ruamel_yaml.CParser._compose_scalar_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_start_mark); __Pyx_XDECREF((PyObject *)__pyx_v_end_mark); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_tag); __Pyx_XDECREF(__pyx_v_style); __Pyx_XDECREF(__pyx_v_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":821 * return node * * cdef _compose_sequence_node(self, object anchor): # <<<<<<<<<<<<<< * cdef int index * start_mark = Mark(self.stream_name, */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_sequence_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_anchor) { int __pyx_v_index; struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_start_mark = NULL; int __pyx_v_implicit; PyObject *__pyx_v_tag = NULL; PyObject *__pyx_v_flow_style = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; __Pyx_RefNannySetupContext("_compose_sequence_node", 0); /* "_ruamel_yaml.pyx":824 * cdef int index * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":825 * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.column, * None, None) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.line); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":826 * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * implicit = False */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":823 * cdef _compose_sequence_node(self, object anchor): * cdef int index * start_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, */ __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 823, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 5, Py_None); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 823, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_start_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":828 * self.parsed_event.start_mark.column, * None, None) * implicit = False # <<<<<<<<<<<<<< * if self.parsed_event.data.sequence_start.implicit == 1: * implicit = True */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":829 * None, None) * implicit = False * if self.parsed_event.data.sequence_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * if self.parsed_event.data.sequence_start.tag == NULL \ */ __pyx_t_5 = ((__pyx_v_self->parsed_event.data.sequence_start.implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":830 * implicit = False * if self.parsed_event.data.sequence_start.implicit == 1: * implicit = True # <<<<<<<<<<<<<< * if self.parsed_event.data.sequence_start.tag == NULL \ * or (self.parsed_event.data.sequence_start.tag[0] == c'!' */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":829 * None, None) * implicit = False * if self.parsed_event.data.sequence_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * if self.parsed_event.data.sequence_start.tag == NULL \ */ } /* "_ruamel_yaml.pyx":831 * if self.parsed_event.data.sequence_start.implicit == 1: * implicit = True * if self.parsed_event.data.sequence_start.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.sequence_start.tag[0] == c'!' * and self.parsed_event.data.sequence_start.tag[1] == c'\0'): */ __pyx_t_6 = ((__pyx_v_self->parsed_event.data.sequence_start.tag == NULL) != 0); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } /* "_ruamel_yaml.pyx":832 * implicit = True * if self.parsed_event.data.sequence_start.tag == NULL \ * or (self.parsed_event.data.sequence_start.tag[0] == c'!' # <<<<<<<<<<<<<< * and self.parsed_event.data.sequence_start.tag[1] == c'\0'): * tag = self.resolve(SequenceNode, None, implicit) */ __pyx_t_6 = (((__pyx_v_self->parsed_event.data.sequence_start.tag[0]) == '!') != 0); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } /* "_ruamel_yaml.pyx":833 * if self.parsed_event.data.sequence_start.tag == NULL \ * or (self.parsed_event.data.sequence_start.tag[0] == c'!' * and self.parsed_event.data.sequence_start.tag[1] == c'\0'): # <<<<<<<<<<<<<< * tag = self.resolve(SequenceNode, None, implicit) * else: */ __pyx_t_6 = (((__pyx_v_self->parsed_event.data.sequence_start.tag[1]) == '\x00') != 0); __pyx_t_5 = __pyx_t_6; __pyx_L5_bool_binop_done:; /* "_ruamel_yaml.pyx":831 * if self.parsed_event.data.sequence_start.implicit == 1: * implicit = True * if self.parsed_event.data.sequence_start.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.sequence_start.tag[0] == c'!' * and self.parsed_event.data.sequence_start.tag[1] == c'\0'): */ if (__pyx_t_5) { /* "_ruamel_yaml.pyx":834 * or (self.parsed_event.data.sequence_start.tag[0] == c'!' * and self.parsed_event.data.sequence_start.tag[1] == c'\0'): * tag = self.resolve(SequenceNode, None, implicit) # <<<<<<<<<<<<<< * else: * tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, Py_None, __pyx_t_1}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, Py_None, __pyx_t_1}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_2); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, Py_None); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_1); __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_tag = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":831 * if self.parsed_event.data.sequence_start.implicit == 1: * implicit = True * if self.parsed_event.data.sequence_start.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.sequence_start.tag[0] == c'!' * and self.parsed_event.data.sequence_start.tag[1] == c'\0'): */ goto __pyx_L4; } /* "_ruamel_yaml.pyx":836 * tag = self.resolve(SequenceNode, None, implicit) * else: * tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) # <<<<<<<<<<<<<< * flow_style = None * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: */ /*else*/ { __pyx_t_3 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.sequence_start.tag); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_tag = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L4:; /* "_ruamel_yaml.pyx":837 * else: * tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) * flow_style = None # <<<<<<<<<<<<<< * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True */ __Pyx_INCREF(Py_None); __pyx_v_flow_style = Py_None; /* "_ruamel_yaml.pyx":838 * tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) * flow_style = None * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: */ switch (__pyx_v_self->parsed_event.data.sequence_start.style) { case YAML_FLOW_SEQUENCE_STYLE: /* "_ruamel_yaml.pyx":839 * flow_style = None * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True # <<<<<<<<<<<<<< * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: * flow_style = False */ __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_True); /* "_ruamel_yaml.pyx":838 * tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) * flow_style = None * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: */ break; /* "_ruamel_yaml.pyx":840 * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = False * value = [] */ case YAML_BLOCK_SEQUENCE_STYLE: /* "_ruamel_yaml.pyx":841 * flow_style = True * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: * flow_style = False # <<<<<<<<<<<<<< * value = [] * node = SequenceNode(tag, value, start_mark, None, flow_style) */ __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_False); /* "_ruamel_yaml.pyx":840 * if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: * flow_style = True * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: # <<<<<<<<<<<<<< * flow_style = False * value = [] */ break; default: break; } /* "_ruamel_yaml.pyx":842 * elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: * flow_style = False * value = [] # <<<<<<<<<<<<<< * node = SequenceNode(tag, value, start_mark, None, flow_style) * if anchor is not None: */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 842, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_value = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":843 * flow_style = False * value = [] * node = SequenceNode(tag, value, start_mark, None, flow_style) # <<<<<<<<<<<<<< * if anchor is not None: * self.anchors[anchor] = node */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_v_tag, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), Py_None, __pyx_v_flow_style}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_v_tag, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), Py_None, __pyx_v_flow_style}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_1 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_INCREF(__pyx_v_tag); __Pyx_GIVEREF(__pyx_v_tag); PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_tag); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_value); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_8, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 3+__pyx_t_8, Py_None); __Pyx_INCREF(__pyx_v_flow_style); __Pyx_GIVEREF(__pyx_v_flow_style); PyTuple_SET_ITEM(__pyx_t_1, 4+__pyx_t_8, __pyx_v_flow_style); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_node = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":844 * value = [] * node = SequenceNode(tag, value, start_mark, None, flow_style) * if anchor is not None: # <<<<<<<<<<<<<< * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) */ __pyx_t_5 = (__pyx_v_anchor != Py_None); __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "_ruamel_yaml.pyx":845 * node = SequenceNode(tag, value, start_mark, None, flow_style) * if anchor is not None: * self.anchors[anchor] = node # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * index = 0 */ if (unlikely(PyObject_SetItem(__pyx_v_self->anchors, __pyx_v_anchor, __pyx_v_node) < 0)) __PYX_ERR(0, 845, __pyx_L1_error) /* "_ruamel_yaml.pyx":844 * value = [] * node = SequenceNode(tag, value, start_mark, None, flow_style) * if anchor is not None: # <<<<<<<<<<<<<< * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) */ } /* "_ruamel_yaml.pyx":846 * if anchor is not None: * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * index = 0 * self._parse_next_event() */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":847 * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) * index = 0 # <<<<<<<<<<<<<< * self._parse_next_event() * while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: */ __pyx_v_index = 0; /* "_ruamel_yaml.pyx":848 * yaml_event_delete(&self.parsed_event) * index = 0 * self._parse_next_event() # <<<<<<<<<<<<<< * while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: * value.append(self._compose_node(node, index)) */ __pyx_t_8 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_8 == ((int)0))) __PYX_ERR(0, 848, __pyx_L1_error) /* "_ruamel_yaml.pyx":849 * index = 0 * self._parse_next_event() * while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: # <<<<<<<<<<<<<< * value.append(self._compose_node(node, index)) * index = index+1 */ while (1) { __pyx_t_6 = ((__pyx_v_self->parsed_event.type != YAML_SEQUENCE_END_EVENT) != 0); if (!__pyx_t_6) break; /* "_ruamel_yaml.pyx":850 * self._parse_next_event() * while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: * value.append(self._compose_node(node, index)) # <<<<<<<<<<<<<< * index = index+1 * self._parse_next_event() */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_node(__pyx_v_self, __pyx_v_node, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 850, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":851 * while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: * value.append(self._compose_node(node, index)) * index = index+1 # <<<<<<<<<<<<<< * self._parse_next_event() * node.end_mark = Mark(self.stream_name, */ __pyx_v_index = (__pyx_v_index + 1); /* "_ruamel_yaml.pyx":852 * value.append(self._compose_node(node, index)) * index = index+1 * self._parse_next_event() # <<<<<<<<<<<<<< * node.end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, */ __pyx_t_8 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_8 == ((int)0))) __PYX_ERR(0, 852, __pyx_L1_error) } /* "_ruamel_yaml.pyx":854 * self._parse_next_event() * node.end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.line, * self.parsed_event.end_mark.column, */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.index); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":855 * node.end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.column, * None, None) */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.line); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":856 * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, * self.parsed_event.end_mark.column, # <<<<<<<<<<<<<< * None, None) * yaml_event_delete(&self.parsed_event) */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.column); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":853 * index = index+1 * self._parse_next_event() * node.end_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, */ __pyx_t_9 = PyTuple_New(6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_9, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_9, 5, Py_None); __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_node, __pyx_n_s_end_mark, __pyx_t_1) < 0) __PYX_ERR(0, 853, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":858 * self.parsed_event.end_mark.column, * None, None) * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * return node * */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":859 * None, None) * yaml_event_delete(&self.parsed_event) * return node # <<<<<<<<<<<<<< * * cdef _compose_mapping_node(self, object anchor): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_node); __pyx_r = __pyx_v_node; goto __pyx_L0; /* "_ruamel_yaml.pyx":821 * return node * * cdef _compose_sequence_node(self, object anchor): # <<<<<<<<<<<<<< * cdef int index * start_mark = Mark(self.stream_name, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_ruamel_yaml.CParser._compose_sequence_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_start_mark); __Pyx_XDECREF(__pyx_v_tag); __Pyx_XDECREF(__pyx_v_flow_style); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":861 * return node * * cdef _compose_mapping_node(self, object anchor): # <<<<<<<<<<<<<< * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ static PyObject *__pyx_f_12_ruamel_yaml_7CParser__compose_mapping_node(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, PyObject *__pyx_v_anchor) { struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v_start_mark = NULL; int __pyx_v_implicit; PyObject *__pyx_v_tag = NULL; PyObject *__pyx_v_flow_style = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_node = NULL; PyObject *__pyx_v_item_key = NULL; PyObject *__pyx_v_item_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; __Pyx_RefNannySetupContext("_compose_mapping_node", 0); /* "_ruamel_yaml.pyx":863 * cdef _compose_mapping_node(self, object anchor): * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":864 * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.column, * None, None) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.line); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 864, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "_ruamel_yaml.pyx":865 * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, * self.parsed_event.start_mark.column, # <<<<<<<<<<<<<< * None, None) * implicit = False */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.start_mark.column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":862 * * cdef _compose_mapping_node(self, object anchor): * start_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.start_mark.index, * self.parsed_event.start_mark.line, */ __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 862, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 5, Py_None); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 862, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_start_mark = ((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":867 * self.parsed_event.start_mark.column, * None, None) * implicit = False # <<<<<<<<<<<<<< * if self.parsed_event.data.mapping_start.implicit == 1: * implicit = True */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":868 * None, None) * implicit = False * if self.parsed_event.data.mapping_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * if self.parsed_event.data.mapping_start.tag == NULL \ */ __pyx_t_5 = ((__pyx_v_self->parsed_event.data.mapping_start.implicit == 1) != 0); if (__pyx_t_5) { /* "_ruamel_yaml.pyx":869 * implicit = False * if self.parsed_event.data.mapping_start.implicit == 1: * implicit = True # <<<<<<<<<<<<<< * if self.parsed_event.data.mapping_start.tag == NULL \ * or (self.parsed_event.data.mapping_start.tag[0] == c'!' */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":868 * None, None) * implicit = False * if self.parsed_event.data.mapping_start.implicit == 1: # <<<<<<<<<<<<<< * implicit = True * if self.parsed_event.data.mapping_start.tag == NULL \ */ } /* "_ruamel_yaml.pyx":870 * if self.parsed_event.data.mapping_start.implicit == 1: * implicit = True * if self.parsed_event.data.mapping_start.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.mapping_start.tag[0] == c'!' * and self.parsed_event.data.mapping_start.tag[1] == c'\0'): */ __pyx_t_6 = ((__pyx_v_self->parsed_event.data.mapping_start.tag == NULL) != 0); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } /* "_ruamel_yaml.pyx":871 * implicit = True * if self.parsed_event.data.mapping_start.tag == NULL \ * or (self.parsed_event.data.mapping_start.tag[0] == c'!' # <<<<<<<<<<<<<< * and self.parsed_event.data.mapping_start.tag[1] == c'\0'): * tag = self.resolve(MappingNode, None, implicit) */ __pyx_t_6 = (((__pyx_v_self->parsed_event.data.mapping_start.tag[0]) == '!') != 0); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L5_bool_binop_done; } /* "_ruamel_yaml.pyx":872 * if self.parsed_event.data.mapping_start.tag == NULL \ * or (self.parsed_event.data.mapping_start.tag[0] == c'!' * and self.parsed_event.data.mapping_start.tag[1] == c'\0'): # <<<<<<<<<<<<<< * tag = self.resolve(MappingNode, None, implicit) * else: */ __pyx_t_6 = (((__pyx_v_self->parsed_event.data.mapping_start.tag[1]) == '\x00') != 0); __pyx_t_5 = __pyx_t_6; __pyx_L5_bool_binop_done:; /* "_ruamel_yaml.pyx":870 * if self.parsed_event.data.mapping_start.implicit == 1: * implicit = True * if self.parsed_event.data.mapping_start.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.mapping_start.tag[0] == c'!' * and self.parsed_event.data.mapping_start.tag[1] == c'\0'): */ if (__pyx_t_5) { /* "_ruamel_yaml.pyx":873 * or (self.parsed_event.data.mapping_start.tag[0] == c'!' * and self.parsed_event.data.mapping_start.tag[1] == c'\0'): * tag = self.resolve(MappingNode, None, implicit) # <<<<<<<<<<<<<< * else: * tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, Py_None, __pyx_t_1}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, Py_None, __pyx_t_1}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_2); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, Py_None); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_1); __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_tag = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":870 * if self.parsed_event.data.mapping_start.implicit == 1: * implicit = True * if self.parsed_event.data.mapping_start.tag == NULL \ # <<<<<<<<<<<<<< * or (self.parsed_event.data.mapping_start.tag[0] == c'!' * and self.parsed_event.data.mapping_start.tag[1] == c'\0'): */ goto __pyx_L4; } /* "_ruamel_yaml.pyx":875 * tag = self.resolve(MappingNode, None, implicit) * else: * tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) # <<<<<<<<<<<<<< * flow_style = None * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: */ /*else*/ { __pyx_t_3 = PyUnicode_FromString(__pyx_v_self->parsed_event.data.mapping_start.tag); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_tag = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L4:; /* "_ruamel_yaml.pyx":876 * else: * tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) * flow_style = None # <<<<<<<<<<<<<< * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True */ __Pyx_INCREF(Py_None); __pyx_v_flow_style = Py_None; /* "_ruamel_yaml.pyx":877 * tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) * flow_style = None * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: */ switch (__pyx_v_self->parsed_event.data.mapping_start.style) { case YAML_FLOW_MAPPING_STYLE: /* "_ruamel_yaml.pyx":878 * flow_style = None * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True # <<<<<<<<<<<<<< * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: * flow_style = False */ __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_True); /* "_ruamel_yaml.pyx":877 * tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) * flow_style = None * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = True * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: */ break; /* "_ruamel_yaml.pyx":879 * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = False * value = [] */ case YAML_BLOCK_MAPPING_STYLE: /* "_ruamel_yaml.pyx":880 * flow_style = True * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: * flow_style = False # <<<<<<<<<<<<<< * value = [] * node = MappingNode(tag, value, start_mark, None, flow_style) */ __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_flow_style, Py_False); /* "_ruamel_yaml.pyx":879 * if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: * flow_style = True * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: # <<<<<<<<<<<<<< * flow_style = False * value = [] */ break; default: break; } /* "_ruamel_yaml.pyx":881 * elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: * flow_style = False * value = [] # <<<<<<<<<<<<<< * node = MappingNode(tag, value, start_mark, None, flow_style) * if anchor is not None: */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_value = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":882 * flow_style = False * value = [] * node = MappingNode(tag, value, start_mark, None, flow_style) # <<<<<<<<<<<<<< * if anchor is not None: * self.anchors[anchor] = node */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_v_tag, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), Py_None, __pyx_v_flow_style}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 882, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_v_tag, __pyx_v_value, ((PyObject *)__pyx_v_start_mark), Py_None, __pyx_v_flow_style}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 5+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 882, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_1 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_INCREF(__pyx_v_tag); __Pyx_GIVEREF(__pyx_v_tag); PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_tag); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_value); __Pyx_INCREF(((PyObject *)__pyx_v_start_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_start_mark)); PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_8, ((PyObject *)__pyx_v_start_mark)); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 3+__pyx_t_8, Py_None); __Pyx_INCREF(__pyx_v_flow_style); __Pyx_GIVEREF(__pyx_v_flow_style); PyTuple_SET_ITEM(__pyx_t_1, 4+__pyx_t_8, __pyx_v_flow_style); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_node = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":883 * value = [] * node = MappingNode(tag, value, start_mark, None, flow_style) * if anchor is not None: # <<<<<<<<<<<<<< * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) */ __pyx_t_5 = (__pyx_v_anchor != Py_None); __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "_ruamel_yaml.pyx":884 * node = MappingNode(tag, value, start_mark, None, flow_style) * if anchor is not None: * self.anchors[anchor] = node # <<<<<<<<<<<<<< * yaml_event_delete(&self.parsed_event) * self._parse_next_event() */ if (unlikely(PyObject_SetItem(__pyx_v_self->anchors, __pyx_v_anchor, __pyx_v_node) < 0)) __PYX_ERR(0, 884, __pyx_L1_error) /* "_ruamel_yaml.pyx":883 * value = [] * node = MappingNode(tag, value, start_mark, None, flow_style) * if anchor is not None: # <<<<<<<<<<<<<< * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) */ } /* "_ruamel_yaml.pyx":885 * if anchor is not None: * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * self._parse_next_event() * while self.parsed_event.type != YAML_MAPPING_END_EVENT: */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":886 * self.anchors[anchor] = node * yaml_event_delete(&self.parsed_event) * self._parse_next_event() # <<<<<<<<<<<<<< * while self.parsed_event.type != YAML_MAPPING_END_EVENT: * item_key = self._compose_node(node, None) */ __pyx_t_8 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_8 == ((int)0))) __PYX_ERR(0, 886, __pyx_L1_error) /* "_ruamel_yaml.pyx":887 * yaml_event_delete(&self.parsed_event) * self._parse_next_event() * while self.parsed_event.type != YAML_MAPPING_END_EVENT: # <<<<<<<<<<<<<< * item_key = self._compose_node(node, None) * item_value = self._compose_node(node, item_key) */ while (1) { __pyx_t_6 = ((__pyx_v_self->parsed_event.type != YAML_MAPPING_END_EVENT) != 0); if (!__pyx_t_6) break; /* "_ruamel_yaml.pyx":888 * self._parse_next_event() * while self.parsed_event.type != YAML_MAPPING_END_EVENT: * item_key = self._compose_node(node, None) # <<<<<<<<<<<<<< * item_value = self._compose_node(node, item_key) * value.append((item_key, item_value)) */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_node(__pyx_v_self, __pyx_v_node, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_item_key, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":889 * while self.parsed_event.type != YAML_MAPPING_END_EVENT: * item_key = self._compose_node(node, None) * item_value = self._compose_node(node, item_key) # <<<<<<<<<<<<<< * value.append((item_key, item_value)) * self._parse_next_event() */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_compose_node(__pyx_v_self, __pyx_v_node, __pyx_v_item_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_item_value, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":890 * item_key = self._compose_node(node, None) * item_value = self._compose_node(node, item_key) * value.append((item_key, item_value)) # <<<<<<<<<<<<<< * self._parse_next_event() * node.end_mark = Mark(self.stream_name, */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_item_key); __Pyx_GIVEREF(__pyx_v_item_key); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_item_key); __Pyx_INCREF(__pyx_v_item_value); __Pyx_GIVEREF(__pyx_v_item_value); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_item_value); __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_value, __pyx_t_3); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":891 * item_value = self._compose_node(node, item_key) * value.append((item_key, item_value)) * self._parse_next_event() # <<<<<<<<<<<<<< * node.end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, */ __pyx_t_8 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_8 == ((int)0))) __PYX_ERR(0, 891, __pyx_L1_error) } /* "_ruamel_yaml.pyx":893 * self._parse_next_event() * node.end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.line, * self.parsed_event.end_mark.column, */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_ruamel_yaml.pyx":894 * node.end_mark = Mark(self.stream_name, * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.column, * None, None) */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.line); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "_ruamel_yaml.pyx":895 * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, * self.parsed_event.end_mark.column, # <<<<<<<<<<<<<< * None, None) * yaml_event_delete(&self.parsed_event) */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->parsed_event.end_mark.column); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "_ruamel_yaml.pyx":892 * value.append((item_key, item_value)) * self._parse_next_event() * node.end_mark = Mark(self.stream_name, # <<<<<<<<<<<<<< * self.parsed_event.end_mark.index, * self.parsed_event.end_mark.line, */ __pyx_t_9 = PyTuple_New(6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_v_self->stream_name); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_self->stream_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_9, 4, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_9, 5, Py_None); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_node, __pyx_n_s_end_mark, __pyx_t_1) < 0) __PYX_ERR(0, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":897 * self.parsed_event.end_mark.column, * None, None) * yaml_event_delete(&self.parsed_event) # <<<<<<<<<<<<<< * return node * */ yaml_event_delete((&__pyx_v_self->parsed_event)); /* "_ruamel_yaml.pyx":898 * None, None) * yaml_event_delete(&self.parsed_event) * return node # <<<<<<<<<<<<<< * * cdef int _parse_next_event(self) except 0: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_node); __pyx_r = __pyx_v_node; goto __pyx_L0; /* "_ruamel_yaml.pyx":861 * return node * * cdef _compose_mapping_node(self, object anchor): # <<<<<<<<<<<<<< * start_mark = Mark(self.stream_name, * self.parsed_event.start_mark.index, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_ruamel_yaml.CParser._compose_mapping_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_start_mark); __Pyx_XDECREF(__pyx_v_tag); __Pyx_XDECREF(__pyx_v_flow_style); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_node); __Pyx_XDECREF(__pyx_v_item_key); __Pyx_XDECREF(__pyx_v_item_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":900 * return node * * cdef int _parse_next_event(self) except 0: # <<<<<<<<<<<<<< * if self.parsed_event.type == YAML_NO_EVENT: * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: */ static int __pyx_f_12_ruamel_yaml_7CParser__parse_next_event(struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_v_error = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("_parse_next_event", 0); /* "_ruamel_yaml.pyx":901 * * cdef int _parse_next_event(self) except 0: * if self.parsed_event.type == YAML_NO_EVENT: # <<<<<<<<<<<<<< * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: * error = self._parser_error() */ __pyx_t_1 = ((__pyx_v_self->parsed_event.type == YAML_NO_EVENT) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":902 * cdef int _parse_next_event(self) except 0: * if self.parsed_event.type == YAML_NO_EVENT: * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ __pyx_t_2 = yaml_parser_parse((&__pyx_v_self->parser), (&__pyx_v_self->parsed_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 902, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_2 == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":903 * if self.parsed_event.type == YAML_NO_EVENT: * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: * error = self._parser_error() # <<<<<<<<<<<<<< * raise error * return 1 */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parser_error(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 903, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_error = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":904 * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: * error = self._parser_error() * raise error # <<<<<<<<<<<<<< * return 1 * */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 904, __pyx_L1_error) /* "_ruamel_yaml.pyx":902 * cdef int _parse_next_event(self) except 0: * if self.parsed_event.type == YAML_NO_EVENT: * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: # <<<<<<<<<<<<<< * error = self._parser_error() * raise error */ } /* "_ruamel_yaml.pyx":901 * * cdef int _parse_next_event(self) except 0: * if self.parsed_event.type == YAML_NO_EVENT: # <<<<<<<<<<<<<< * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: * error = self._parser_error() */ } /* "_ruamel_yaml.pyx":905 * error = self._parser_error() * raise error * return 1 # <<<<<<<<<<<<<< * * cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: */ __pyx_r = 1; goto __pyx_L0; /* "_ruamel_yaml.pyx":900 * return node * * cdef int _parse_next_event(self) except 0: # <<<<<<<<<<<<<< * if self.parsed_event.type == YAML_NO_EVENT: * if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CParser._parse_next_event", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_29__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_29__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_28__reduce_cython__(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.CParser.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_31__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_7CParser_31__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_7CParser_30__setstate_cython__(((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_7CParser_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.CParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":907 * return 1 * * cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: # <<<<<<<<<<<<<< * cdef CParser parser * parser = data */ static int __pyx_f_12_ruamel_yaml_input_handler(void *__pyx_v_data, char *__pyx_v_buffer, int __pyx_v_size, int *__pyx_v_read) { struct __pyx_obj_12_ruamel_yaml_CParser *__pyx_v_parser = 0; PyObject *__pyx_v_value = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("input_handler", 0); /* "_ruamel_yaml.pyx":909 * cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: * cdef CParser parser * parser = data # <<<<<<<<<<<<<< * if parser.stream_cache is None: * value = parser.stream.read(size) */ __pyx_t_1 = ((PyObject *)__pyx_v_data); __Pyx_INCREF(__pyx_t_1); __pyx_v_parser = ((struct __pyx_obj_12_ruamel_yaml_CParser *)__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":910 * cdef CParser parser * parser = data * if parser.stream_cache is None: # <<<<<<<<<<<<<< * value = parser.stream.read(size) * if PyUnicode_CheckExact(value) != 0: */ __pyx_t_2 = (__pyx_v_parser->stream_cache == Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":911 * parser = data * if parser.stream_cache is None: * value = parser.stream.read(size) # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(value) != 0: * value = PyUnicode_AsUTF8String(value) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_parser->stream, __pyx_n_s_read); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_6) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 911, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":912 * if parser.stream_cache is None: * value = parser.stream.read(size) * if PyUnicode_CheckExact(value) != 0: # <<<<<<<<<<<<<< * value = PyUnicode_AsUTF8String(value) * parser.unicode_source = 1 */ __pyx_t_3 = ((PyUnicode_CheckExact(__pyx_v_value) != 0) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":913 * value = parser.stream.read(size) * if PyUnicode_CheckExact(value) != 0: * value = PyUnicode_AsUTF8String(value) # <<<<<<<<<<<<<< * parser.unicode_source = 1 * if PyString_CheckExact(value) == 0: */ __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":914 * if PyUnicode_CheckExact(value) != 0: * value = PyUnicode_AsUTF8String(value) * parser.unicode_source = 1 # <<<<<<<<<<<<<< * if PyString_CheckExact(value) == 0: * if PY_MAJOR_VERSION < 3: */ __pyx_v_parser->unicode_source = 1; /* "_ruamel_yaml.pyx":912 * if parser.stream_cache is None: * value = parser.stream.read(size) * if PyUnicode_CheckExact(value) != 0: # <<<<<<<<<<<<<< * value = PyUnicode_AsUTF8String(value) * parser.unicode_source = 1 */ } /* "_ruamel_yaml.pyx":915 * value = PyUnicode_AsUTF8String(value) * parser.unicode_source = 1 * if PyString_CheckExact(value) == 0: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("a string value is expected") */ __pyx_t_3 = ((PyString_CheckExact(__pyx_v_value) == 0) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":916 * parser.unicode_source = 1 * if PyString_CheckExact(value) == 0: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("a string value is expected") * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":917 * if PyString_CheckExact(value) == 0: * if PY_MAJOR_VERSION < 3: * raise TypeError("a string value is expected") # <<<<<<<<<<<<<< * else: * raise TypeError(u"a string value is expected") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 917, __pyx_L1_error) /* "_ruamel_yaml.pyx":916 * parser.unicode_source = 1 * if PyString_CheckExact(value) == 0: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("a string value is expected") * else: */ } /* "_ruamel_yaml.pyx":919 * raise TypeError("a string value is expected") * else: * raise TypeError(u"a string value is expected") # <<<<<<<<<<<<<< * parser.stream_cache = value * parser.stream_cache_pos = 0 */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 919, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 919, __pyx_L1_error) } /* "_ruamel_yaml.pyx":915 * value = PyUnicode_AsUTF8String(value) * parser.unicode_source = 1 * if PyString_CheckExact(value) == 0: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("a string value is expected") */ } /* "_ruamel_yaml.pyx":920 * else: * raise TypeError(u"a string value is expected") * parser.stream_cache = value # <<<<<<<<<<<<<< * parser.stream_cache_pos = 0 * parser.stream_cache_len = PyString_GET_SIZE(value) */ __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_parser->stream_cache); __Pyx_DECREF(__pyx_v_parser->stream_cache); __pyx_v_parser->stream_cache = __pyx_v_value; /* "_ruamel_yaml.pyx":921 * raise TypeError(u"a string value is expected") * parser.stream_cache = value * parser.stream_cache_pos = 0 # <<<<<<<<<<<<<< * parser.stream_cache_len = PyString_GET_SIZE(value) * if (parser.stream_cache_len - parser.stream_cache_pos) < size: */ __pyx_v_parser->stream_cache_pos = 0; /* "_ruamel_yaml.pyx":922 * parser.stream_cache = value * parser.stream_cache_pos = 0 * parser.stream_cache_len = PyString_GET_SIZE(value) # <<<<<<<<<<<<<< * if (parser.stream_cache_len - parser.stream_cache_pos) < size: * size = parser.stream_cache_len - parser.stream_cache_pos */ __pyx_v_parser->stream_cache_len = PyString_GET_SIZE(__pyx_v_value); /* "_ruamel_yaml.pyx":910 * cdef CParser parser * parser = data * if parser.stream_cache is None: # <<<<<<<<<<<<<< * value = parser.stream.read(size) * if PyUnicode_CheckExact(value) != 0: */ } /* "_ruamel_yaml.pyx":923 * parser.stream_cache_pos = 0 * parser.stream_cache_len = PyString_GET_SIZE(value) * if (parser.stream_cache_len - parser.stream_cache_pos) < size: # <<<<<<<<<<<<<< * size = parser.stream_cache_len - parser.stream_cache_pos * if size > 0: */ __pyx_t_3 = (((__pyx_v_parser->stream_cache_len - __pyx_v_parser->stream_cache_pos) < __pyx_v_size) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":924 * parser.stream_cache_len = PyString_GET_SIZE(value) * if (parser.stream_cache_len - parser.stream_cache_pos) < size: * size = parser.stream_cache_len - parser.stream_cache_pos # <<<<<<<<<<<<<< * if size > 0: * memcpy(buffer, PyString_AS_STRING(parser.stream_cache) */ __pyx_v_size = (__pyx_v_parser->stream_cache_len - __pyx_v_parser->stream_cache_pos); /* "_ruamel_yaml.pyx":923 * parser.stream_cache_pos = 0 * parser.stream_cache_len = PyString_GET_SIZE(value) * if (parser.stream_cache_len - parser.stream_cache_pos) < size: # <<<<<<<<<<<<<< * size = parser.stream_cache_len - parser.stream_cache_pos * if size > 0: */ } /* "_ruamel_yaml.pyx":925 * if (parser.stream_cache_len - parser.stream_cache_pos) < size: * size = parser.stream_cache_len - parser.stream_cache_pos * if size > 0: # <<<<<<<<<<<<<< * memcpy(buffer, PyString_AS_STRING(parser.stream_cache) * + parser.stream_cache_pos, size) */ __pyx_t_3 = ((__pyx_v_size > 0) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":926 * size = parser.stream_cache_len - parser.stream_cache_pos * if size > 0: * memcpy(buffer, PyString_AS_STRING(parser.stream_cache) # <<<<<<<<<<<<<< * + parser.stream_cache_pos, size) * read[0] = size */ __pyx_t_1 = __pyx_v_parser->stream_cache; __Pyx_INCREF(__pyx_t_1); /* "_ruamel_yaml.pyx":927 * if size > 0: * memcpy(buffer, PyString_AS_STRING(parser.stream_cache) * + parser.stream_cache_pos, size) # <<<<<<<<<<<<<< * read[0] = size * parser.stream_cache_pos += size */ memcpy(__pyx_v_buffer, (PyString_AS_STRING(__pyx_t_1) + __pyx_v_parser->stream_cache_pos), __pyx_v_size); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":925 * if (parser.stream_cache_len - parser.stream_cache_pos) < size: * size = parser.stream_cache_len - parser.stream_cache_pos * if size > 0: # <<<<<<<<<<<<<< * memcpy(buffer, PyString_AS_STRING(parser.stream_cache) * + parser.stream_cache_pos, size) */ } /* "_ruamel_yaml.pyx":928 * memcpy(buffer, PyString_AS_STRING(parser.stream_cache) * + parser.stream_cache_pos, size) * read[0] = size # <<<<<<<<<<<<<< * parser.stream_cache_pos += size * if parser.stream_cache_pos == parser.stream_cache_len: */ (__pyx_v_read[0]) = __pyx_v_size; /* "_ruamel_yaml.pyx":929 * + parser.stream_cache_pos, size) * read[0] = size * parser.stream_cache_pos += size # <<<<<<<<<<<<<< * if parser.stream_cache_pos == parser.stream_cache_len: * parser.stream_cache = None */ __pyx_v_parser->stream_cache_pos = (__pyx_v_parser->stream_cache_pos + __pyx_v_size); /* "_ruamel_yaml.pyx":930 * read[0] = size * parser.stream_cache_pos += size * if parser.stream_cache_pos == parser.stream_cache_len: # <<<<<<<<<<<<<< * parser.stream_cache = None * return 1 */ __pyx_t_3 = ((__pyx_v_parser->stream_cache_pos == __pyx_v_parser->stream_cache_len) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":931 * parser.stream_cache_pos += size * if parser.stream_cache_pos == parser.stream_cache_len: * parser.stream_cache = None # <<<<<<<<<<<<<< * return 1 * */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_parser->stream_cache); __Pyx_DECREF(__pyx_v_parser->stream_cache); __pyx_v_parser->stream_cache = Py_None; /* "_ruamel_yaml.pyx":930 * read[0] = size * parser.stream_cache_pos += size * if parser.stream_cache_pos == parser.stream_cache_len: # <<<<<<<<<<<<<< * parser.stream_cache = None * return 1 */ } /* "_ruamel_yaml.pyx":932 * if parser.stream_cache_pos == parser.stream_cache_len: * parser.stream_cache = None * return 1 # <<<<<<<<<<<<<< * * cdef class CEmitter: */ __pyx_r = 1; goto __pyx_L0; /* "_ruamel_yaml.pyx":907 * return 1 * * cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: # <<<<<<<<<<<<<< * cdef CParser parser * parser = data */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("_ruamel_yaml.input_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_parser); __Pyx_XDECREF(__pyx_v_value); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":952 * cdef object use_encoding * * def __init__(self, stream, canonical=None, indent=None, width=None, # <<<<<<<<<<<<<< * allow_unicode=None, line_break=None, encoding=None, * explicit_start=None, explicit_end=None, version=None, tags=None): */ /* Python wrapper */ static int __pyx_pw_12_ruamel_yaml_8CEmitter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_12_ruamel_yaml_8CEmitter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_stream = 0; PyObject *__pyx_v_canonical = 0; PyObject *__pyx_v_indent = 0; PyObject *__pyx_v_width = 0; PyObject *__pyx_v_allow_unicode = 0; PyObject *__pyx_v_line_break = 0; PyObject *__pyx_v_encoding = 0; PyObject *__pyx_v_explicit_start = 0; PyObject *__pyx_v_explicit_end = 0; PyObject *__pyx_v_version = 0; PyObject *__pyx_v_tags = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stream,&__pyx_n_s_canonical,&__pyx_n_s_indent,&__pyx_n_s_width,&__pyx_n_s_allow_unicode,&__pyx_n_s_line_break,&__pyx_n_s_encoding,&__pyx_n_s_explicit_start,&__pyx_n_s_explicit_end,&__pyx_n_s_version,&__pyx_n_s_tags,0}; PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0}; values[1] = ((PyObject *)Py_None); values[2] = ((PyObject *)Py_None); values[3] = ((PyObject *)Py_None); /* "_ruamel_yaml.pyx":953 * * def __init__(self, stream, canonical=None, indent=None, width=None, * allow_unicode=None, line_break=None, encoding=None, # <<<<<<<<<<<<<< * explicit_start=None, explicit_end=None, version=None, tags=None): * if yaml_emitter_initialize(&self.emitter) == 0: */ values[4] = ((PyObject *)Py_None); values[5] = ((PyObject *)Py_None); values[6] = ((PyObject *)Py_None); /* "_ruamel_yaml.pyx":954 * def __init__(self, stream, canonical=None, indent=None, width=None, * allow_unicode=None, line_break=None, encoding=None, * explicit_start=None, explicit_end=None, version=None, tags=None): # <<<<<<<<<<<<<< * if yaml_emitter_initialize(&self.emitter) == 0: * raise MemoryError */ values[7] = ((PyObject *)Py_None); values[8] = ((PyObject *)Py_None); values[9] = ((PyObject *)Py_None); values[10] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stream)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_canonical); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_indent); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_width); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_unicode); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_line_break); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encoding); if (value) { values[6] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_explicit_start); if (value) { values[7] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 8: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_explicit_end); if (value) { values[8] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 9: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_version); if (value) { values[9] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 10: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tags); if (value) { values[10] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 952, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_stream = values[0]; __pyx_v_canonical = values[1]; __pyx_v_indent = values[2]; __pyx_v_width = values[3]; __pyx_v_allow_unicode = values[4]; __pyx_v_line_break = values[5]; __pyx_v_encoding = values[6]; __pyx_v_explicit_start = values[7]; __pyx_v_explicit_end = values[8]; __pyx_v_version = values[9]; __pyx_v_tags = values[10]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 952, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_ruamel_yaml.CEmitter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter___init__(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self), __pyx_v_stream, __pyx_v_canonical, __pyx_v_indent, __pyx_v_width, __pyx_v_allow_unicode, __pyx_v_line_break, __pyx_v_encoding, __pyx_v_explicit_start, __pyx_v_explicit_end, __pyx_v_version, __pyx_v_tags); /* "_ruamel_yaml.pyx":952 * cdef object use_encoding * * def __init__(self, stream, canonical=None, indent=None, width=None, # <<<<<<<<<<<<<< * allow_unicode=None, line_break=None, encoding=None, * explicit_start=None, explicit_end=None, version=None, tags=None): */ /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_12_ruamel_yaml_8CEmitter___init__(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_stream, PyObject *__pyx_v_canonical, PyObject *__pyx_v_indent, PyObject *__pyx_v_width, PyObject *__pyx_v_allow_unicode, PyObject *__pyx_v_line_break, PyObject *__pyx_v_encoding, PyObject *__pyx_v_explicit_start, PyObject *__pyx_v_explicit_end, PyObject *__pyx_v_version, PyObject *__pyx_v_tags) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; __Pyx_RefNannySetupContext("__init__", 0); /* "_ruamel_yaml.pyx":955 * allow_unicode=None, line_break=None, encoding=None, * explicit_start=None, explicit_end=None, version=None, tags=None): * if yaml_emitter_initialize(&self.emitter) == 0: # <<<<<<<<<<<<<< * raise MemoryError * self.stream = stream */ __pyx_t_1 = ((yaml_emitter_initialize((&__pyx_v_self->emitter)) == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":956 * explicit_start=None, explicit_end=None, version=None, tags=None): * if yaml_emitter_initialize(&self.emitter) == 0: * raise MemoryError # <<<<<<<<<<<<<< * self.stream = stream * self.dump_unicode = 0 */ PyErr_NoMemory(); __PYX_ERR(0, 956, __pyx_L1_error) /* "_ruamel_yaml.pyx":955 * allow_unicode=None, line_break=None, encoding=None, * explicit_start=None, explicit_end=None, version=None, tags=None): * if yaml_emitter_initialize(&self.emitter) == 0: # <<<<<<<<<<<<<< * raise MemoryError * self.stream = stream */ } /* "_ruamel_yaml.pyx":957 * if yaml_emitter_initialize(&self.emitter) == 0: * raise MemoryError * self.stream = stream # <<<<<<<<<<<<<< * self.dump_unicode = 0 * if PY_MAJOR_VERSION < 3: */ __Pyx_INCREF(__pyx_v_stream); __Pyx_GIVEREF(__pyx_v_stream); __Pyx_GOTREF(__pyx_v_self->stream); __Pyx_DECREF(__pyx_v_self->stream); __pyx_v_self->stream = __pyx_v_stream; /* "_ruamel_yaml.pyx":958 * raise MemoryError * self.stream = stream * self.dump_unicode = 0 # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * if getattr3(stream, 'encoding', None): */ __pyx_v_self->dump_unicode = 0; /* "_ruamel_yaml.pyx":959 * self.stream = stream * self.dump_unicode = 0 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * if getattr3(stream, 'encoding', None): * self.dump_unicode = 1 */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":960 * self.dump_unicode = 0 * if PY_MAJOR_VERSION < 3: * if getattr3(stream, 'encoding', None): # <<<<<<<<<<<<<< * self.dump_unicode = 1 * else: */ __pyx_t_2 = __Pyx_GetAttr3(__pyx_v_stream, __pyx_n_s_encoding, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 960, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 960, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { /* "_ruamel_yaml.pyx":961 * if PY_MAJOR_VERSION < 3: * if getattr3(stream, 'encoding', None): * self.dump_unicode = 1 # <<<<<<<<<<<<<< * else: * if hasattr(stream, u'encoding'): */ __pyx_v_self->dump_unicode = 1; /* "_ruamel_yaml.pyx":960 * self.dump_unicode = 0 * if PY_MAJOR_VERSION < 3: * if getattr3(stream, 'encoding', None): # <<<<<<<<<<<<<< * self.dump_unicode = 1 * else: */ } /* "_ruamel_yaml.pyx":959 * self.stream = stream * self.dump_unicode = 0 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * if getattr3(stream, 'encoding', None): * self.dump_unicode = 1 */ goto __pyx_L4; } /* "_ruamel_yaml.pyx":963 * self.dump_unicode = 1 * else: * if hasattr(stream, u'encoding'): # <<<<<<<<<<<<<< * self.dump_unicode = 1 * self.use_encoding = encoding */ /*else*/ { __pyx_t_1 = __Pyx_HasAttr(__pyx_v_stream, __pyx_n_u_encoding); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 963, __pyx_L1_error) __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":964 * else: * if hasattr(stream, u'encoding'): * self.dump_unicode = 1 # <<<<<<<<<<<<<< * self.use_encoding = encoding * yaml_emitter_set_output(&self.emitter, output_handler, self) */ __pyx_v_self->dump_unicode = 1; /* "_ruamel_yaml.pyx":963 * self.dump_unicode = 1 * else: * if hasattr(stream, u'encoding'): # <<<<<<<<<<<<<< * self.dump_unicode = 1 * self.use_encoding = encoding */ } } __pyx_L4:; /* "_ruamel_yaml.pyx":965 * if hasattr(stream, u'encoding'): * self.dump_unicode = 1 * self.use_encoding = encoding # <<<<<<<<<<<<<< * yaml_emitter_set_output(&self.emitter, output_handler, self) * if canonical: */ __Pyx_INCREF(__pyx_v_encoding); __Pyx_GIVEREF(__pyx_v_encoding); __Pyx_GOTREF(__pyx_v_self->use_encoding); __Pyx_DECREF(__pyx_v_self->use_encoding); __pyx_v_self->use_encoding = __pyx_v_encoding; /* "_ruamel_yaml.pyx":966 * self.dump_unicode = 1 * self.use_encoding = encoding * yaml_emitter_set_output(&self.emitter, output_handler, self) # <<<<<<<<<<<<<< * if canonical: * yaml_emitter_set_canonical(&self.emitter, 1) */ yaml_emitter_set_output((&__pyx_v_self->emitter), __pyx_f_12_ruamel_yaml_output_handler, ((void *)__pyx_v_self)); /* "_ruamel_yaml.pyx":967 * self.use_encoding = encoding * yaml_emitter_set_output(&self.emitter, output_handler, self) * if canonical: # <<<<<<<<<<<<<< * yaml_emitter_set_canonical(&self.emitter, 1) * if indent is not None: */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_canonical); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 967, __pyx_L1_error) if (__pyx_t_3) { /* "_ruamel_yaml.pyx":968 * yaml_emitter_set_output(&self.emitter, output_handler, self) * if canonical: * yaml_emitter_set_canonical(&self.emitter, 1) # <<<<<<<<<<<<<< * if indent is not None: * yaml_emitter_set_indent(&self.emitter, indent) */ yaml_emitter_set_canonical((&__pyx_v_self->emitter), 1); /* "_ruamel_yaml.pyx":967 * self.use_encoding = encoding * yaml_emitter_set_output(&self.emitter, output_handler, self) * if canonical: # <<<<<<<<<<<<<< * yaml_emitter_set_canonical(&self.emitter, 1) * if indent is not None: */ } /* "_ruamel_yaml.pyx":969 * if canonical: * yaml_emitter_set_canonical(&self.emitter, 1) * if indent is not None: # <<<<<<<<<<<<<< * yaml_emitter_set_indent(&self.emitter, indent) * if width is not None: */ __pyx_t_3 = (__pyx_v_indent != Py_None); __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":970 * yaml_emitter_set_canonical(&self.emitter, 1) * if indent is not None: * yaml_emitter_set_indent(&self.emitter, indent) # <<<<<<<<<<<<<< * if width is not None: * yaml_emitter_set_width(&self.emitter, width) */ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_indent); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 970, __pyx_L1_error) yaml_emitter_set_indent((&__pyx_v_self->emitter), __pyx_t_4); /* "_ruamel_yaml.pyx":969 * if canonical: * yaml_emitter_set_canonical(&self.emitter, 1) * if indent is not None: # <<<<<<<<<<<<<< * yaml_emitter_set_indent(&self.emitter, indent) * if width is not None: */ } /* "_ruamel_yaml.pyx":971 * if indent is not None: * yaml_emitter_set_indent(&self.emitter, indent) * if width is not None: # <<<<<<<<<<<<<< * yaml_emitter_set_width(&self.emitter, width) * if allow_unicode: */ __pyx_t_1 = (__pyx_v_width != Py_None); __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":972 * yaml_emitter_set_indent(&self.emitter, indent) * if width is not None: * yaml_emitter_set_width(&self.emitter, width) # <<<<<<<<<<<<<< * if allow_unicode: * yaml_emitter_set_unicode(&self.emitter, 1) */ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_width); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 972, __pyx_L1_error) yaml_emitter_set_width((&__pyx_v_self->emitter), __pyx_t_4); /* "_ruamel_yaml.pyx":971 * if indent is not None: * yaml_emitter_set_indent(&self.emitter, indent) * if width is not None: # <<<<<<<<<<<<<< * yaml_emitter_set_width(&self.emitter, width) * if allow_unicode: */ } /* "_ruamel_yaml.pyx":973 * if width is not None: * yaml_emitter_set_width(&self.emitter, width) * if allow_unicode: # <<<<<<<<<<<<<< * yaml_emitter_set_unicode(&self.emitter, 1) * if line_break is not None: */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_allow_unicode); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 973, __pyx_L1_error) if (__pyx_t_3) { /* "_ruamel_yaml.pyx":974 * yaml_emitter_set_width(&self.emitter, width) * if allow_unicode: * yaml_emitter_set_unicode(&self.emitter, 1) # <<<<<<<<<<<<<< * if line_break is not None: * if line_break == '\r': */ yaml_emitter_set_unicode((&__pyx_v_self->emitter), 1); /* "_ruamel_yaml.pyx":973 * if width is not None: * yaml_emitter_set_width(&self.emitter, width) * if allow_unicode: # <<<<<<<<<<<<<< * yaml_emitter_set_unicode(&self.emitter, 1) * if line_break is not None: */ } /* "_ruamel_yaml.pyx":975 * if allow_unicode: * yaml_emitter_set_unicode(&self.emitter, 1) * if line_break is not None: # <<<<<<<<<<<<<< * if line_break == '\r': * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) */ __pyx_t_3 = (__pyx_v_line_break != Py_None); __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":976 * yaml_emitter_set_unicode(&self.emitter, 1) * if line_break is not None: * if line_break == '\r': # <<<<<<<<<<<<<< * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) * elif line_break == '\n': */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_line_break, __pyx_kp_s__19, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 976, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":977 * if line_break is not None: * if line_break == '\r': * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) # <<<<<<<<<<<<<< * elif line_break == '\n': * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) */ yaml_emitter_set_break((&__pyx_v_self->emitter), YAML_CR_BREAK); /* "_ruamel_yaml.pyx":976 * yaml_emitter_set_unicode(&self.emitter, 1) * if line_break is not None: * if line_break == '\r': # <<<<<<<<<<<<<< * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) * elif line_break == '\n': */ goto __pyx_L12; } /* "_ruamel_yaml.pyx":978 * if line_break == '\r': * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) * elif line_break == '\n': # <<<<<<<<<<<<<< * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) * elif line_break == '\r\n': */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_line_break, __pyx_kp_s__20, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 978, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":979 * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) * elif line_break == '\n': * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) # <<<<<<<<<<<<<< * elif line_break == '\r\n': * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) */ yaml_emitter_set_break((&__pyx_v_self->emitter), YAML_LN_BREAK); /* "_ruamel_yaml.pyx":978 * if line_break == '\r': * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) * elif line_break == '\n': # <<<<<<<<<<<<<< * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) * elif line_break == '\r\n': */ goto __pyx_L12; } /* "_ruamel_yaml.pyx":980 * elif line_break == '\n': * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) * elif line_break == '\r\n': # <<<<<<<<<<<<<< * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) * self.document_start_implicit = 1 */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_line_break, __pyx_kp_s__21, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 980, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":981 * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) * elif line_break == '\r\n': * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) # <<<<<<<<<<<<<< * self.document_start_implicit = 1 * if explicit_start: */ yaml_emitter_set_break((&__pyx_v_self->emitter), YAML_CRLN_BREAK); /* "_ruamel_yaml.pyx":980 * elif line_break == '\n': * yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) * elif line_break == '\r\n': # <<<<<<<<<<<<<< * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) * self.document_start_implicit = 1 */ } __pyx_L12:; /* "_ruamel_yaml.pyx":975 * if allow_unicode: * yaml_emitter_set_unicode(&self.emitter, 1) * if line_break is not None: # <<<<<<<<<<<<<< * if line_break == '\r': * yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) */ } /* "_ruamel_yaml.pyx":982 * elif line_break == '\r\n': * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) * self.document_start_implicit = 1 # <<<<<<<<<<<<<< * if explicit_start: * self.document_start_implicit = 0 */ __pyx_v_self->document_start_implicit = 1; /* "_ruamel_yaml.pyx":983 * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) * self.document_start_implicit = 1 * if explicit_start: # <<<<<<<<<<<<<< * self.document_start_implicit = 0 * self.document_end_implicit = 1 */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_explicit_start); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 983, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":984 * self.document_start_implicit = 1 * if explicit_start: * self.document_start_implicit = 0 # <<<<<<<<<<<<<< * self.document_end_implicit = 1 * if explicit_end: */ __pyx_v_self->document_start_implicit = 0; /* "_ruamel_yaml.pyx":983 * yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) * self.document_start_implicit = 1 * if explicit_start: # <<<<<<<<<<<<<< * self.document_start_implicit = 0 * self.document_end_implicit = 1 */ } /* "_ruamel_yaml.pyx":985 * if explicit_start: * self.document_start_implicit = 0 * self.document_end_implicit = 1 # <<<<<<<<<<<<<< * if explicit_end: * self.document_end_implicit = 0 */ __pyx_v_self->document_end_implicit = 1; /* "_ruamel_yaml.pyx":986 * self.document_start_implicit = 0 * self.document_end_implicit = 1 * if explicit_end: # <<<<<<<<<<<<<< * self.document_end_implicit = 0 * self.use_version = version */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_explicit_end); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 986, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":987 * self.document_end_implicit = 1 * if explicit_end: * self.document_end_implicit = 0 # <<<<<<<<<<<<<< * self.use_version = version * self.use_tags = tags */ __pyx_v_self->document_end_implicit = 0; /* "_ruamel_yaml.pyx":986 * self.document_start_implicit = 0 * self.document_end_implicit = 1 * if explicit_end: # <<<<<<<<<<<<<< * self.document_end_implicit = 0 * self.use_version = version */ } /* "_ruamel_yaml.pyx":988 * if explicit_end: * self.document_end_implicit = 0 * self.use_version = version # <<<<<<<<<<<<<< * self.use_tags = tags * self.serialized_nodes = {} */ __Pyx_INCREF(__pyx_v_version); __Pyx_GIVEREF(__pyx_v_version); __Pyx_GOTREF(__pyx_v_self->use_version); __Pyx_DECREF(__pyx_v_self->use_version); __pyx_v_self->use_version = __pyx_v_version; /* "_ruamel_yaml.pyx":989 * self.document_end_implicit = 0 * self.use_version = version * self.use_tags = tags # <<<<<<<<<<<<<< * self.serialized_nodes = {} * self.anchors = {} */ __Pyx_INCREF(__pyx_v_tags); __Pyx_GIVEREF(__pyx_v_tags); __Pyx_GOTREF(__pyx_v_self->use_tags); __Pyx_DECREF(__pyx_v_self->use_tags); __pyx_v_self->use_tags = __pyx_v_tags; /* "_ruamel_yaml.pyx":990 * self.use_version = version * self.use_tags = tags * self.serialized_nodes = {} # <<<<<<<<<<<<<< * self.anchors = {} * self.last_alias_id = 0 */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->serialized_nodes); __Pyx_DECREF(__pyx_v_self->serialized_nodes); __pyx_v_self->serialized_nodes = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":991 * self.use_tags = tags * self.serialized_nodes = {} * self.anchors = {} # <<<<<<<<<<<<<< * self.last_alias_id = 0 * self.closed = -1 */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 991, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->anchors); __Pyx_DECREF(__pyx_v_self->anchors); __pyx_v_self->anchors = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":992 * self.serialized_nodes = {} * self.anchors = {} * self.last_alias_id = 0 # <<<<<<<<<<<<<< * self.closed = -1 * */ __pyx_v_self->last_alias_id = 0; /* "_ruamel_yaml.pyx":993 * self.anchors = {} * self.last_alias_id = 0 * self.closed = -1 # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_v_self->closed = -1; /* "_ruamel_yaml.pyx":952 * cdef object use_encoding * * def __init__(self, stream, canonical=None, indent=None, width=None, # <<<<<<<<<<<<<< * allow_unicode=None, line_break=None, encoding=None, * explicit_start=None, explicit_end=None, version=None, tags=None): */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":995 * self.closed = -1 * * def __dealloc__(self): # <<<<<<<<<<<<<< * yaml_emitter_delete(&self.emitter) * */ /* Python wrapper */ static void __pyx_pw_12_ruamel_yaml_8CEmitter_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_12_ruamel_yaml_8CEmitter_3__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_12_ruamel_yaml_8CEmitter_2__dealloc__(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_12_ruamel_yaml_8CEmitter_2__dealloc__(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); /* "_ruamel_yaml.pyx":996 * * def __dealloc__(self): * yaml_emitter_delete(&self.emitter) # <<<<<<<<<<<<<< * * def dispose(self): */ yaml_emitter_delete((&__pyx_v_self->emitter)); /* "_ruamel_yaml.pyx":995 * self.closed = -1 * * def __dealloc__(self): # <<<<<<<<<<<<<< * yaml_emitter_delete(&self.emitter) * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "_ruamel_yaml.pyx":998 * yaml_emitter_delete(&self.emitter) * * def dispose(self): # <<<<<<<<<<<<<< * pass * */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_5dispose(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_5dispose(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("dispose (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_4dispose(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_4dispose(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("dispose", 0); /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1001 * pass * * cdef object _emitter_error(self): # <<<<<<<<<<<<<< * if self.emitter.error == YAML_MEMORY_ERROR: * return MemoryError */ static PyObject *__pyx_f_12_ruamel_yaml_8CEmitter__emitter_error(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self) { PyObject *__pyx_v_problem = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("_emitter_error", 0); /* "_ruamel_yaml.pyx":1002 * * cdef object _emitter_error(self): * if self.emitter.error == YAML_MEMORY_ERROR: # <<<<<<<<<<<<<< * return MemoryError * elif self.emitter.error == YAML_EMITTER_ERROR: */ switch (__pyx_v_self->emitter.error) { case YAML_MEMORY_ERROR: /* "_ruamel_yaml.pyx":1003 * cdef object _emitter_error(self): * if self.emitter.error == YAML_MEMORY_ERROR: * return MemoryError # <<<<<<<<<<<<<< * elif self.emitter.error == YAML_EMITTER_ERROR: * if PY_MAJOR_VERSION < 3: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_builtin_MemoryError); __pyx_r = __pyx_builtin_MemoryError; goto __pyx_L0; /* "_ruamel_yaml.pyx":1002 * * cdef object _emitter_error(self): * if self.emitter.error == YAML_MEMORY_ERROR: # <<<<<<<<<<<<<< * return MemoryError * elif self.emitter.error == YAML_EMITTER_ERROR: */ break; /* "_ruamel_yaml.pyx":1004 * if self.emitter.error == YAML_MEMORY_ERROR: * return MemoryError * elif self.emitter.error == YAML_EMITTER_ERROR: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * problem = self.emitter.problem */ case YAML_EMITTER_ERROR: /* "_ruamel_yaml.pyx":1005 * return MemoryError * elif self.emitter.error == YAML_EMITTER_ERROR: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * problem = self.emitter.problem * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1006 * elif self.emitter.error == YAML_EMITTER_ERROR: * if PY_MAJOR_VERSION < 3: * problem = self.emitter.problem # <<<<<<<<<<<<<< * else: * problem = PyUnicode_FromString(self.emitter.problem) */ __pyx_t_2 = __Pyx_PyBytes_FromString(__pyx_v_self->emitter.problem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_problem = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1005 * return MemoryError * elif self.emitter.error == YAML_EMITTER_ERROR: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * problem = self.emitter.problem * else: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1008 * problem = self.emitter.problem * else: * problem = PyUnicode_FromString(self.emitter.problem) # <<<<<<<<<<<<<< * return EmitterError(problem) * if PY_MAJOR_VERSION < 3: */ /*else*/ { __pyx_t_2 = PyUnicode_FromString(__pyx_v_self->emitter.problem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1008, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_problem = __pyx_t_2; __pyx_t_2 = 0; } __pyx_L3:; /* "_ruamel_yaml.pyx":1009 * else: * problem = PyUnicode_FromString(self.emitter.problem) * return EmitterError(problem) # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise ValueError("no emitter error") */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_EmitterError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_problem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_problem}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_problem}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_INCREF(__pyx_v_problem); __Pyx_GIVEREF(__pyx_v_problem); PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_problem); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "_ruamel_yaml.pyx":1004 * if self.emitter.error == YAML_MEMORY_ERROR: * return MemoryError * elif self.emitter.error == YAML_EMITTER_ERROR: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * problem = self.emitter.problem */ break; default: break; } /* "_ruamel_yaml.pyx":1010 * problem = PyUnicode_FromString(self.emitter.problem) * return EmitterError(problem) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("no emitter error") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1011 * return EmitterError(problem) * if PY_MAJOR_VERSION < 3: * raise ValueError("no emitter error") # <<<<<<<<<<<<<< * else: * raise ValueError(u"no emitter error") */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1011, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1011, __pyx_L1_error) /* "_ruamel_yaml.pyx":1010 * problem = PyUnicode_FromString(self.emitter.problem) * return EmitterError(problem) * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("no emitter error") * else: */ } /* "_ruamel_yaml.pyx":1013 * raise ValueError("no emitter error") * else: * raise ValueError(u"no emitter error") # <<<<<<<<<<<<<< * * cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1013, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1001 * pass * * cdef object _emitter_error(self): # <<<<<<<<<<<<<< * if self.emitter.error == YAML_MEMORY_ERROR: * return MemoryError */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_ruamel_yaml.CEmitter._emitter_error", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_problem); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1015 * raise ValueError(u"no emitter error") * * cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: # <<<<<<<<<<<<<< * cdef yaml_encoding_t encoding * cdef yaml_version_directive_t version_directive_value */ static int __pyx_f_12_ruamel_yaml_8CEmitter__object_to_event(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_event_object, yaml_event_t *__pyx_v_event) { yaml_encoding_t __pyx_v_encoding; yaml_version_directive_t __pyx_v_version_directive_value; yaml_version_directive_t *__pyx_v_version_directive; yaml_tag_directive_t __pyx_v_tag_directives_value[0x80]; yaml_tag_directive_t *__pyx_v_tag_directives_start; yaml_tag_directive_t *__pyx_v_tag_directives_end; int __pyx_v_implicit; int __pyx_v_plain_implicit; int __pyx_v_quoted_implicit; char *__pyx_v_anchor; char *__pyx_v_tag; char *__pyx_v_value; int __pyx_v_length; yaml_scalar_style_t __pyx_v_scalar_style; yaml_sequence_style_t __pyx_v_sequence_style; yaml_mapping_style_t __pyx_v_mapping_style; PyObject *__pyx_v_event_class = NULL; PyObject *__pyx_v_cache = NULL; PyObject *__pyx_v_handle = NULL; PyObject *__pyx_v_prefix = NULL; PyObject *__pyx_v_anchor_object = NULL; PyObject *__pyx_v_tag_object = NULL; PyObject *__pyx_v_value_object = NULL; PyObject *__pyx_v_style_object = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); PyObject *__pyx_t_8 = NULL; int __pyx_t_9; __Pyx_RefNannySetupContext("_object_to_event", 0); /* "_ruamel_yaml.pyx":1032 * cdef yaml_sequence_style_t sequence_style * cdef yaml_mapping_style_t mapping_style * event_class = event_object.__class__ # <<<<<<<<<<<<<< * if event_class is StreamStartEvent: * encoding = YAML_UTF8_ENCODING */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1032, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_event_class = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1033 * cdef yaml_mapping_style_t mapping_style * event_class = event_object.__class__ * if event_class is StreamStartEvent: # <<<<<<<<<<<<<< * encoding = YAML_UTF8_ENCODING * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_StreamStartEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__pyx_v_event_class == __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1034 * event_class = event_object.__class__ * if event_class is StreamStartEvent: * encoding = YAML_UTF8_ENCODING # <<<<<<<<<<<<<< * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING */ __pyx_v_encoding = YAML_UTF8_ENCODING; /* "_ruamel_yaml.pyx":1035 * if event_class is StreamStartEvent: * encoding = YAML_UTF8_ENCODING * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': # <<<<<<<<<<<<<< * encoding = YAML_UTF16LE_ENCODING * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_kp_u_utf_16_le, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1035, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_kp_s_utf_16_le, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1035, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_t_2; __pyx_L5_bool_binop_done:; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1036 * encoding = YAML_UTF8_ENCODING * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING # <<<<<<<<<<<<<< * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': * encoding = YAML_UTF16BE_ENCODING */ __pyx_v_encoding = YAML_UTF16LE_ENCODING; /* "_ruamel_yaml.pyx":1035 * if event_class is StreamStartEvent: * encoding = YAML_UTF8_ENCODING * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': # <<<<<<<<<<<<<< * encoding = YAML_UTF16LE_ENCODING * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': */ goto __pyx_L4; } /* "_ruamel_yaml.pyx":1037 * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': # <<<<<<<<<<<<<< * encoding = YAML_UTF16BE_ENCODING * if event_object.encoding is None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1037, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_kp_u_utf_16_be, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1037, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1037, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_kp_s_utf_16_be, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1037, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_t_2; __pyx_L7_bool_binop_done:; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1038 * encoding = YAML_UTF16LE_ENCODING * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': * encoding = YAML_UTF16BE_ENCODING # <<<<<<<<<<<<<< * if event_object.encoding is None: * self.dump_unicode = 1 */ __pyx_v_encoding = YAML_UTF16BE_ENCODING; /* "_ruamel_yaml.pyx":1037 * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': # <<<<<<<<<<<<<< * encoding = YAML_UTF16BE_ENCODING * if event_object.encoding is None: */ } __pyx_L4:; /* "_ruamel_yaml.pyx":1039 * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': * encoding = YAML_UTF16BE_ENCODING * if event_object.encoding is None: # <<<<<<<<<<<<<< * self.dump_unicode = 1 * if self.dump_unicode == 1: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1039, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_t_1 == Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1040 * encoding = YAML_UTF16BE_ENCODING * if event_object.encoding is None: * self.dump_unicode = 1 # <<<<<<<<<<<<<< * if self.dump_unicode == 1: * encoding = YAML_UTF8_ENCODING */ __pyx_v_self->dump_unicode = 1; /* "_ruamel_yaml.pyx":1039 * elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': * encoding = YAML_UTF16BE_ENCODING * if event_object.encoding is None: # <<<<<<<<<<<<<< * self.dump_unicode = 1 * if self.dump_unicode == 1: */ } /* "_ruamel_yaml.pyx":1041 * if event_object.encoding is None: * self.dump_unicode = 1 * if self.dump_unicode == 1: # <<<<<<<<<<<<<< * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(event, encoding) */ __pyx_t_2 = ((__pyx_v_self->dump_unicode == 1) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1042 * self.dump_unicode = 1 * if self.dump_unicode == 1: * encoding = YAML_UTF8_ENCODING # <<<<<<<<<<<<<< * yaml_stream_start_event_initialize(event, encoding) * elif event_class is StreamEndEvent: */ __pyx_v_encoding = YAML_UTF8_ENCODING; /* "_ruamel_yaml.pyx":1041 * if event_object.encoding is None: * self.dump_unicode = 1 * if self.dump_unicode == 1: # <<<<<<<<<<<<<< * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(event, encoding) */ } /* "_ruamel_yaml.pyx":1043 * if self.dump_unicode == 1: * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(event, encoding) # <<<<<<<<<<<<<< * elif event_class is StreamEndEvent: * yaml_stream_end_event_initialize(event) */ yaml_stream_start_event_initialize(__pyx_v_event, __pyx_v_encoding); /* "_ruamel_yaml.pyx":1033 * cdef yaml_mapping_style_t mapping_style * event_class = event_object.__class__ * if event_class is StreamStartEvent: # <<<<<<<<<<<<<< * encoding = YAML_UTF8_ENCODING * if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1044 * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(event, encoding) * elif event_class is StreamEndEvent: # <<<<<<<<<<<<<< * yaml_stream_end_event_initialize(event) * elif event_class is DocumentStartEvent: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_StreamEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__pyx_v_event_class == __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1045 * yaml_stream_start_event_initialize(event, encoding) * elif event_class is StreamEndEvent: * yaml_stream_end_event_initialize(event) # <<<<<<<<<<<<<< * elif event_class is DocumentStartEvent: * version_directive = NULL */ yaml_stream_end_event_initialize(__pyx_v_event); /* "_ruamel_yaml.pyx":1044 * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(event, encoding) * elif event_class is StreamEndEvent: # <<<<<<<<<<<<<< * yaml_stream_end_event_initialize(event) * elif event_class is DocumentStartEvent: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1046 * elif event_class is StreamEndEvent: * yaml_stream_end_event_initialize(event) * elif event_class is DocumentStartEvent: # <<<<<<<<<<<<<< * version_directive = NULL * if event_object.version: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DocumentStartEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_v_event_class == __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1047 * yaml_stream_end_event_initialize(event) * elif event_class is DocumentStartEvent: * version_directive = NULL # <<<<<<<<<<<<<< * if event_object.version: * version_directive_value.major = event_object.version[0] */ __pyx_v_version_directive = NULL; /* "_ruamel_yaml.pyx":1048 * elif event_class is DocumentStartEvent: * version_directive = NULL * if event_object.version: # <<<<<<<<<<<<<< * version_directive_value.major = event_object.version[0] * version_directive_value.minor = event_object.version[1] */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_version); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1048, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1048, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1049 * version_directive = NULL * if event_object.version: * version_directive_value.major = event_object.version[0] # <<<<<<<<<<<<<< * version_directive_value.minor = event_object.version[1] * version_directive = &version_directive_value */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_version); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1049, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_version_directive_value.major = __pyx_t_5; /* "_ruamel_yaml.pyx":1050 * if event_object.version: * version_directive_value.major = event_object.version[0] * version_directive_value.minor = event_object.version[1] # <<<<<<<<<<<<<< * version_directive = &version_directive_value * tag_directives_start = NULL */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_version); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1050, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1050, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1050, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_version_directive_value.minor = __pyx_t_5; /* "_ruamel_yaml.pyx":1051 * version_directive_value.major = event_object.version[0] * version_directive_value.minor = event_object.version[1] * version_directive = &version_directive_value # <<<<<<<<<<<<<< * tag_directives_start = NULL * tag_directives_end = NULL */ __pyx_v_version_directive = (&__pyx_v_version_directive_value); /* "_ruamel_yaml.pyx":1048 * elif event_class is DocumentStartEvent: * version_directive = NULL * if event_object.version: # <<<<<<<<<<<<<< * version_directive_value.major = event_object.version[0] * version_directive_value.minor = event_object.version[1] */ } /* "_ruamel_yaml.pyx":1052 * version_directive_value.minor = event_object.version[1] * version_directive = &version_directive_value * tag_directives_start = NULL # <<<<<<<<<<<<<< * tag_directives_end = NULL * if event_object.tags: */ __pyx_v_tag_directives_start = NULL; /* "_ruamel_yaml.pyx":1053 * version_directive = &version_directive_value * tag_directives_start = NULL * tag_directives_end = NULL # <<<<<<<<<<<<<< * if event_object.tags: * if len(event_object.tags) > 128: */ __pyx_v_tag_directives_end = NULL; /* "_ruamel_yaml.pyx":1054 * tag_directives_start = NULL * tag_directives_end = NULL * if event_object.tags: # <<<<<<<<<<<<<< * if len(event_object.tags) > 128: * if PY_MAJOR_VERSION < 3: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1054, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1054, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1055 * tag_directives_end = NULL * if event_object.tags: * if len(event_object.tags) > 128: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1055, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1055, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((__pyx_t_6 > 0x80) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1056 * if event_object.tags: * if len(event_object.tags) > 128: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("too many tags") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1057 * if len(event_object.tags) > 128: * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") # <<<<<<<<<<<<<< * else: * raise ValueError(u"too many tags") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1057, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1057, __pyx_L1_error) /* "_ruamel_yaml.pyx":1056 * if event_object.tags: * if len(event_object.tags) > 128: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("too many tags") * else: */ } /* "_ruamel_yaml.pyx":1059 * raise ValueError("too many tags") * else: * raise ValueError(u"too many tags") # <<<<<<<<<<<<<< * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1059, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1059, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1055 * tag_directives_end = NULL * if event_object.tags: * if len(event_object.tags) > 128: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") */ } /* "_ruamel_yaml.pyx":1060 * else: * raise ValueError(u"too many tags") * tag_directives_start = tag_directives_value # <<<<<<<<<<<<<< * tag_directives_end = tag_directives_value * cache = [] */ __pyx_v_tag_directives_start = __pyx_v_tag_directives_value; /* "_ruamel_yaml.pyx":1061 * raise ValueError(u"too many tags") * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value # <<<<<<<<<<<<<< * cache = [] * for handle in event_object.tags: */ __pyx_v_tag_directives_end = __pyx_v_tag_directives_value; /* "_ruamel_yaml.pyx":1062 * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value * cache = [] # <<<<<<<<<<<<<< * for handle in event_object.tags: * prefix = event_object.tags[handle] */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_cache = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1063 * tag_directives_end = tag_directives_value * cache = [] * for handle in event_object.tags: # <<<<<<<<<<<<<< * prefix = event_object.tags[handle] * if PyUnicode_CheckExact(handle): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1063, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { __pyx_t_6 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1063, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1063, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 1063, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1063, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 1063, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1063, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1063, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } __Pyx_XDECREF_SET(__pyx_v_handle, __pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1064 * cache = [] * for handle in event_object.tags: * prefix = event_object.tags[handle] # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(handle): * handle = PyUnicode_AsUTF8String(handle) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = PyObject_GetItem(__pyx_t_1, __pyx_v_handle); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_t_8); __pyx_t_8 = 0; /* "_ruamel_yaml.pyx":1065 * for handle in event_object.tags: * prefix = event_object.tags[handle] * if PyUnicode_CheckExact(handle): # <<<<<<<<<<<<<< * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_handle) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1066 * prefix = event_object.tags[handle] * if PyUnicode_CheckExact(handle): * handle = PyUnicode_AsUTF8String(handle) # <<<<<<<<<<<<<< * cache.append(handle) * if not PyString_CheckExact(handle): */ __pyx_t_8 = PyUnicode_AsUTF8String(__pyx_v_handle); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1066, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF_SET(__pyx_v_handle, __pyx_t_8); __pyx_t_8 = 0; /* "_ruamel_yaml.pyx":1067 * if PyUnicode_CheckExact(handle): * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) # <<<<<<<<<<<<<< * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: */ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_cache, __pyx_v_handle); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 1067, __pyx_L1_error) /* "_ruamel_yaml.pyx":1065 * for handle in event_object.tags: * prefix = event_object.tags[handle] * if PyUnicode_CheckExact(handle): # <<<<<<<<<<<<<< * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) */ } /* "_ruamel_yaml.pyx":1068 * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) * if not PyString_CheckExact(handle): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_handle) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1069 * cache.append(handle) * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag handle must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1070 * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag handle must be a string") */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1070, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(0, 1070, __pyx_L1_error) /* "_ruamel_yaml.pyx":1069 * cache.append(handle) * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag handle must be a string") * else: */ } /* "_ruamel_yaml.pyx":1072 * raise TypeError("tag handle must be a string") * else: * raise TypeError(u"tag handle must be a string") # <<<<<<<<<<<<<< * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): */ /*else*/ { __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(0, 1072, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1068 * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) * if not PyString_CheckExact(handle): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") */ } /* "_ruamel_yaml.pyx":1073 * else: * raise TypeError(u"tag handle must be a string") * tag_directives_end.handle = PyString_AS_STRING(handle) # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(prefix): * prefix = PyUnicode_AsUTF8String(prefix) */ __pyx_v_tag_directives_end->handle = PyString_AS_STRING(__pyx_v_handle); /* "_ruamel_yaml.pyx":1074 * raise TypeError(u"tag handle must be a string") * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): # <<<<<<<<<<<<<< * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_prefix) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1075 * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): * prefix = PyUnicode_AsUTF8String(prefix) # <<<<<<<<<<<<<< * cache.append(prefix) * if not PyString_CheckExact(prefix): */ __pyx_t_8 = PyUnicode_AsUTF8String(__pyx_v_prefix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_8); __pyx_t_8 = 0; /* "_ruamel_yaml.pyx":1076 * if PyUnicode_CheckExact(prefix): * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) # <<<<<<<<<<<<<< * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: */ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_cache, __pyx_v_prefix); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 1076, __pyx_L1_error) /* "_ruamel_yaml.pyx":1074 * raise TypeError(u"tag handle must be a string") * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): # <<<<<<<<<<<<<< * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) */ } /* "_ruamel_yaml.pyx":1077 * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) * if not PyString_CheckExact(prefix): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_prefix) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1078 * cache.append(prefix) * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag prefix must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1079 * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag prefix must be a string") */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1079, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(0, 1079, __pyx_L1_error) /* "_ruamel_yaml.pyx":1078 * cache.append(prefix) * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag prefix must be a string") * else: */ } /* "_ruamel_yaml.pyx":1081 * raise TypeError("tag prefix must be a string") * else: * raise TypeError(u"tag prefix must be a string") # <<<<<<<<<<<<<< * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 */ /*else*/ { __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(0, 1081, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1077 * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) * if not PyString_CheckExact(prefix): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") */ } /* "_ruamel_yaml.pyx":1082 * else: * raise TypeError(u"tag prefix must be a string") * tag_directives_end.prefix = PyString_AS_STRING(prefix) # <<<<<<<<<<<<<< * tag_directives_end = tag_directives_end+1 * implicit = 1 */ __pyx_v_tag_directives_end->prefix = PyString_AS_STRING(__pyx_v_prefix); /* "_ruamel_yaml.pyx":1083 * raise TypeError(u"tag prefix must be a string") * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 # <<<<<<<<<<<<<< * implicit = 1 * if event_object.explicit: */ __pyx_v_tag_directives_end = (__pyx_v_tag_directives_end + 1); /* "_ruamel_yaml.pyx":1063 * tag_directives_end = tag_directives_value * cache = [] * for handle in event_object.tags: # <<<<<<<<<<<<<< * prefix = event_object.tags[handle] * if PyUnicode_CheckExact(handle): */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1054 * tag_directives_start = NULL * tag_directives_end = NULL * if event_object.tags: # <<<<<<<<<<<<<< * if len(event_object.tags) > 128: * if PY_MAJOR_VERSION < 3: */ } /* "_ruamel_yaml.pyx":1084 * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 * implicit = 1 # <<<<<<<<<<<<<< * if event_object.explicit: * implicit = 0 */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":1085 * tag_directives_end = tag_directives_end+1 * implicit = 1 * if event_object.explicit: # <<<<<<<<<<<<<< * implicit = 0 * if yaml_document_start_event_initialize(event, version_directive, */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_explicit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1085, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1086 * implicit = 1 * if event_object.explicit: * implicit = 0 # <<<<<<<<<<<<<< * if yaml_document_start_event_initialize(event, version_directive, * tag_directives_start, tag_directives_end, implicit) == 0: */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":1085 * tag_directives_end = tag_directives_end+1 * implicit = 1 * if event_object.explicit: # <<<<<<<<<<<<<< * implicit = 0 * if yaml_document_start_event_initialize(event, version_directive, */ } /* "_ruamel_yaml.pyx":1088 * implicit = 0 * if yaml_document_start_event_initialize(event, version_directive, * tag_directives_start, tag_directives_end, implicit) == 0: # <<<<<<<<<<<<<< * raise MemoryError * elif event_class is DocumentEndEvent: */ __pyx_t_2 = ((yaml_document_start_event_initialize(__pyx_v_event, __pyx_v_version_directive, __pyx_v_tag_directives_start, __pyx_v_tag_directives_end, __pyx_v_implicit) == 0) != 0); /* "_ruamel_yaml.pyx":1087 * if event_object.explicit: * implicit = 0 * if yaml_document_start_event_initialize(event, version_directive, # <<<<<<<<<<<<<< * tag_directives_start, tag_directives_end, implicit) == 0: * raise MemoryError */ if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1089 * if yaml_document_start_event_initialize(event, version_directive, * tag_directives_start, tag_directives_end, implicit) == 0: * raise MemoryError # <<<<<<<<<<<<<< * elif event_class is DocumentEndEvent: * implicit = 1 */ PyErr_NoMemory(); __PYX_ERR(0, 1089, __pyx_L1_error) /* "_ruamel_yaml.pyx":1087 * if event_object.explicit: * implicit = 0 * if yaml_document_start_event_initialize(event, version_directive, # <<<<<<<<<<<<<< * tag_directives_start, tag_directives_end, implicit) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1046 * elif event_class is StreamEndEvent: * yaml_stream_end_event_initialize(event) * elif event_class is DocumentStartEvent: # <<<<<<<<<<<<<< * version_directive = NULL * if event_object.version: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1090 * tag_directives_start, tag_directives_end, implicit) == 0: * raise MemoryError * elif event_class is DocumentEndEvent: # <<<<<<<<<<<<<< * implicit = 1 * if event_object.explicit: */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_DocumentEndEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1091 * raise MemoryError * elif event_class is DocumentEndEvent: * implicit = 1 # <<<<<<<<<<<<<< * if event_object.explicit: * implicit = 0 */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":1092 * elif event_class is DocumentEndEvent: * implicit = 1 * if event_object.explicit: # <<<<<<<<<<<<<< * implicit = 0 * yaml_document_end_event_initialize(event, implicit) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_explicit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1092, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1092, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1093 * implicit = 1 * if event_object.explicit: * implicit = 0 # <<<<<<<<<<<<<< * yaml_document_end_event_initialize(event, implicit) * elif event_class is AliasEvent: */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":1092 * elif event_class is DocumentEndEvent: * implicit = 1 * if event_object.explicit: # <<<<<<<<<<<<<< * implicit = 0 * yaml_document_end_event_initialize(event, implicit) */ } /* "_ruamel_yaml.pyx":1094 * if event_object.explicit: * implicit = 0 * yaml_document_end_event_initialize(event, implicit) # <<<<<<<<<<<<<< * elif event_class is AliasEvent: * anchor = NULL */ yaml_document_end_event_initialize(__pyx_v_event, __pyx_v_implicit); /* "_ruamel_yaml.pyx":1090 * tag_directives_start, tag_directives_end, implicit) == 0: * raise MemoryError * elif event_class is DocumentEndEvent: # <<<<<<<<<<<<<< * implicit = 1 * if event_object.explicit: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1095 * implicit = 0 * yaml_document_end_event_initialize(event, implicit) * elif event_class is AliasEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_AliasEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1096 * yaml_document_end_event_initialize(event, implicit) * elif event_class is AliasEvent: * anchor = NULL # <<<<<<<<<<<<<< * anchor_object = event_object.anchor * if PyUnicode_CheckExact(anchor_object): */ __pyx_v_anchor = NULL; /* "_ruamel_yaml.pyx":1097 * elif event_class is AliasEvent: * anchor = NULL * anchor_object = event_object.anchor # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_anchor_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1098 * anchor = NULL * anchor_object = event_object.anchor * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_anchor_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1099 * anchor_object = event_object.anchor * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_anchor_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1099, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1098 * anchor = NULL * anchor_object = event_object.anchor * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ } /* "_ruamel_yaml.pyx":1100 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_anchor_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1101 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1102 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1102, __pyx_L1_error) /* "_ruamel_yaml.pyx":1101 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ } /* "_ruamel_yaml.pyx":1104 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * if yaml_alias_event_initialize(event, anchor) == 0: */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1104, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1100 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ } /* "_ruamel_yaml.pyx":1105 * else: * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) # <<<<<<<<<<<<<< * if yaml_alias_event_initialize(event, anchor) == 0: * raise MemoryError */ __pyx_v_anchor = PyString_AS_STRING(__pyx_v_anchor_object); /* "_ruamel_yaml.pyx":1106 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * if yaml_alias_event_initialize(event, anchor) == 0: # <<<<<<<<<<<<<< * raise MemoryError * elif event_class is ScalarEvent: */ __pyx_t_2 = ((yaml_alias_event_initialize(__pyx_v_event, __pyx_v_anchor) == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1107 * anchor = PyString_AS_STRING(anchor_object) * if yaml_alias_event_initialize(event, anchor) == 0: * raise MemoryError # <<<<<<<<<<<<<< * elif event_class is ScalarEvent: * anchor = NULL */ PyErr_NoMemory(); __PYX_ERR(0, 1107, __pyx_L1_error) /* "_ruamel_yaml.pyx":1106 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * if yaml_alias_event_initialize(event, anchor) == 0: # <<<<<<<<<<<<<< * raise MemoryError * elif event_class is ScalarEvent: */ } /* "_ruamel_yaml.pyx":1095 * implicit = 0 * yaml_document_end_event_initialize(event, implicit) * elif event_class is AliasEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1108 * if yaml_alias_event_initialize(event, anchor) == 0: * raise MemoryError * elif event_class is ScalarEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1109 * raise MemoryError * elif event_class is ScalarEvent: * anchor = NULL # <<<<<<<<<<<<<< * anchor_object = event_object.anchor * if anchor_object is not None: */ __pyx_v_anchor = NULL; /* "_ruamel_yaml.pyx":1110 * elif event_class is ScalarEvent: * anchor = NULL * anchor_object = event_object.anchor # <<<<<<<<<<<<<< * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_anchor_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1111 * anchor = NULL * anchor_object = event_object.anchor * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ __pyx_t_3 = (__pyx_v_anchor_object != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1112 * anchor_object = event_object.anchor * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_anchor_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1113 * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_anchor_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1112 * anchor_object = event_object.anchor * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ } /* "_ruamel_yaml.pyx":1114 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_anchor_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1115 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1116 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1116, __pyx_L1_error) /* "_ruamel_yaml.pyx":1115 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ } /* "_ruamel_yaml.pyx":1118 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * tag = NULL */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1118, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1114 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ } /* "_ruamel_yaml.pyx":1119 * else: * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) # <<<<<<<<<<<<<< * tag = NULL * tag_object = event_object.tag */ __pyx_v_anchor = PyString_AS_STRING(__pyx_v_anchor_object); /* "_ruamel_yaml.pyx":1111 * anchor = NULL * anchor_object = event_object.anchor * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ } /* "_ruamel_yaml.pyx":1120 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * tag = NULL # <<<<<<<<<<<<<< * tag_object = event_object.tag * if tag_object is not None: */ __pyx_v_tag = NULL; /* "_ruamel_yaml.pyx":1121 * anchor = PyString_AS_STRING(anchor_object) * tag = NULL * tag_object = event_object.tag # <<<<<<<<<<<<<< * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_tag_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1122 * tag = NULL * tag_object = event_object.tag * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ __pyx_t_2 = (__pyx_v_tag_object != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1123 * tag_object = event_object.tag * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ __pyx_t_3 = (PyUnicode_CheckExact(__pyx_v_tag_object) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1124 * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_tag_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tag_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1123 * tag_object = event_object.tag * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ } /* "_ruamel_yaml.pyx":1125 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ __pyx_t_3 = ((!(PyString_CheckExact(__pyx_v_tag_object) != 0)) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1126 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1127 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1127, __pyx_L1_error) /* "_ruamel_yaml.pyx":1126 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ } /* "_ruamel_yaml.pyx":1129 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * value_object = event_object.value */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1129, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1125 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ } /* "_ruamel_yaml.pyx":1130 * else: * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) # <<<<<<<<<<<<<< * value_object = event_object.value * if PyUnicode_CheckExact(value_object): */ __pyx_v_tag = PyString_AS_STRING(__pyx_v_tag_object); /* "_ruamel_yaml.pyx":1122 * tag = NULL * tag_object = event_object.tag * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ } /* "_ruamel_yaml.pyx":1131 * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) * value_object = event_object.value # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_value_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1132 * tag = PyString_AS_STRING(tag_object) * value_object = event_object.value * if PyUnicode_CheckExact(value_object): # <<<<<<<<<<<<<< * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): */ __pyx_t_3 = (PyUnicode_CheckExact(__pyx_v_value_object) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1133 * value_object = event_object.value * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_value_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_value_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1132 * tag = PyString_AS_STRING(tag_object) * value_object = event_object.value * if PyUnicode_CheckExact(value_object): # <<<<<<<<<<<<<< * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): */ } /* "_ruamel_yaml.pyx":1134 * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") */ __pyx_t_3 = ((!(PyString_CheckExact(__pyx_v_value_object) != 0)) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1135 * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("value must be a string") * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1136 * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"value must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1136, __pyx_L1_error) /* "_ruamel_yaml.pyx":1135 * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("value must be a string") * else: */ } /* "_ruamel_yaml.pyx":1138 * raise TypeError("value must be a string") * else: * raise TypeError(u"value must be a string") # <<<<<<<<<<<<<< * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1138, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1134 * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") */ } /* "_ruamel_yaml.pyx":1139 * else: * raise TypeError(u"value must be a string") * value = PyString_AS_STRING(value_object) # <<<<<<<<<<<<<< * length = PyString_GET_SIZE(value_object) * plain_implicit = 0 */ __pyx_v_value = PyString_AS_STRING(__pyx_v_value_object); /* "_ruamel_yaml.pyx":1140 * raise TypeError(u"value must be a string") * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) # <<<<<<<<<<<<<< * plain_implicit = 0 * quoted_implicit = 0 */ __pyx_v_length = PyString_GET_SIZE(__pyx_v_value_object); /* "_ruamel_yaml.pyx":1141 * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) * plain_implicit = 0 # <<<<<<<<<<<<<< * quoted_implicit = 0 * if event_object.implicit is not None: */ __pyx_v_plain_implicit = 0; /* "_ruamel_yaml.pyx":1142 * length = PyString_GET_SIZE(value_object) * plain_implicit = 0 * quoted_implicit = 0 # <<<<<<<<<<<<<< * if event_object.implicit is not None: * plain_implicit = event_object.implicit[0] */ __pyx_v_quoted_implicit = 0; /* "_ruamel_yaml.pyx":1143 * plain_implicit = 0 * quoted_implicit = 0 * if event_object.implicit is not None: # <<<<<<<<<<<<<< * plain_implicit = event_object.implicit[0] * quoted_implicit = event_object.implicit[1] */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_implicit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__pyx_t_4 != Py_None); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1144 * quoted_implicit = 0 * if event_object.implicit is not None: * plain_implicit = event_object.implicit[0] # <<<<<<<<<<<<<< * quoted_implicit = event_object.implicit[1] * style_object = event_object.style */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_implicit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1144, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_plain_implicit = __pyx_t_5; /* "_ruamel_yaml.pyx":1145 * if event_object.implicit is not None: * plain_implicit = event_object.implicit[0] * quoted_implicit = event_object.implicit[1] # <<<<<<<<<<<<<< * style_object = event_object.style * scalar_style = YAML_PLAIN_SCALAR_STYLE */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_implicit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1145, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_quoted_implicit = __pyx_t_5; /* "_ruamel_yaml.pyx":1143 * plain_implicit = 0 * quoted_implicit = 0 * if event_object.implicit is not None: # <<<<<<<<<<<<<< * plain_implicit = event_object.implicit[0] * quoted_implicit = event_object.implicit[1] */ } /* "_ruamel_yaml.pyx":1146 * plain_implicit = event_object.implicit[0] * quoted_implicit = event_object.implicit[1] * style_object = event_object.style # <<<<<<<<<<<<<< * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_style); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1146, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_style_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1147 * quoted_implicit = event_object.implicit[1] * style_object = event_object.style * scalar_style = YAML_PLAIN_SCALAR_STYLE # <<<<<<<<<<<<<< * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_PLAIN_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1148 * style_object = event_object.style * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": # <<<<<<<<<<<<<< * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__7, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1148, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L43_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__7, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1148, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L43_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1149 * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE # <<<<<<<<<<<<<< * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1148 * style_object = event_object.style * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": # <<<<<<<<<<<<<< * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": */ goto __pyx_L42; } /* "_ruamel_yaml.pyx":1150 * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": # <<<<<<<<<<<<<< * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1150, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L45_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1150, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L45_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1151 * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE # <<<<<<<<<<<<<< * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1150 * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": # <<<<<<<<<<<<<< * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": */ goto __pyx_L42; } /* "_ruamel_yaml.pyx":1152 * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": # <<<<<<<<<<<<<< * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__9, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1152, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L47_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__9, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1152, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L47_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1153 * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE # <<<<<<<<<<<<<< * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_LITERAL_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1152 * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": # <<<<<<<<<<<<<< * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": */ goto __pyx_L42; } /* "_ruamel_yaml.pyx":1154 * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": # <<<<<<<<<<<<<< * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(event, anchor, tag, value, length, */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__10, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1154, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L49_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__10, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1154, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L49_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1155 * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE # <<<<<<<<<<<<<< * if yaml_scalar_event_initialize(event, anchor, tag, value, length, * plain_implicit, quoted_implicit, scalar_style) == 0: */ __pyx_v_scalar_style = YAML_FOLDED_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1154 * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": # <<<<<<<<<<<<<< * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(event, anchor, tag, value, length, */ } __pyx_L42:; /* "_ruamel_yaml.pyx":1157 * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(event, anchor, tag, value, length, * plain_implicit, quoted_implicit, scalar_style) == 0: # <<<<<<<<<<<<<< * raise MemoryError * elif event_class is SequenceStartEvent: */ __pyx_t_2 = ((yaml_scalar_event_initialize(__pyx_v_event, __pyx_v_anchor, __pyx_v_tag, __pyx_v_value, __pyx_v_length, __pyx_v_plain_implicit, __pyx_v_quoted_implicit, __pyx_v_scalar_style) == 0) != 0); /* "_ruamel_yaml.pyx":1156 * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(event, anchor, tag, value, length, # <<<<<<<<<<<<<< * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError */ if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1158 * if yaml_scalar_event_initialize(event, anchor, tag, value, length, * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError # <<<<<<<<<<<<<< * elif event_class is SequenceStartEvent: * anchor = NULL */ PyErr_NoMemory(); __PYX_ERR(0, 1158, __pyx_L1_error) /* "_ruamel_yaml.pyx":1156 * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(event, anchor, tag, value, length, # <<<<<<<<<<<<<< * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1108 * if yaml_alias_event_initialize(event, anchor) == 0: * raise MemoryError * elif event_class is ScalarEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1159 * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError * elif event_class is SequenceStartEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceStartEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1160 * raise MemoryError * elif event_class is SequenceStartEvent: * anchor = NULL # <<<<<<<<<<<<<< * anchor_object = event_object.anchor * if anchor_object is not None: */ __pyx_v_anchor = NULL; /* "_ruamel_yaml.pyx":1161 * elif event_class is SequenceStartEvent: * anchor = NULL * anchor_object = event_object.anchor # <<<<<<<<<<<<<< * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_anchor_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1162 * anchor = NULL * anchor_object = event_object.anchor * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ __pyx_t_3 = (__pyx_v_anchor_object != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1163 * anchor_object = event_object.anchor * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_anchor_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1164 * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_anchor_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1163 * anchor_object = event_object.anchor * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ } /* "_ruamel_yaml.pyx":1165 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_anchor_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1166 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1167 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1167, __pyx_L1_error) /* "_ruamel_yaml.pyx":1166 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ } /* "_ruamel_yaml.pyx":1169 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * tag = NULL */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1169, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1165 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ } /* "_ruamel_yaml.pyx":1170 * else: * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) # <<<<<<<<<<<<<< * tag = NULL * tag_object = event_object.tag */ __pyx_v_anchor = PyString_AS_STRING(__pyx_v_anchor_object); /* "_ruamel_yaml.pyx":1162 * anchor = NULL * anchor_object = event_object.anchor * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ } /* "_ruamel_yaml.pyx":1171 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * tag = NULL # <<<<<<<<<<<<<< * tag_object = event_object.tag * if tag_object is not None: */ __pyx_v_tag = NULL; /* "_ruamel_yaml.pyx":1172 * anchor = PyString_AS_STRING(anchor_object) * tag = NULL * tag_object = event_object.tag # <<<<<<<<<<<<<< * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_tag_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1173 * tag = NULL * tag_object = event_object.tag * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ __pyx_t_2 = (__pyx_v_tag_object != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1174 * tag_object = event_object.tag * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ __pyx_t_3 = (PyUnicode_CheckExact(__pyx_v_tag_object) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1175 * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_tag_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tag_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1174 * tag_object = event_object.tag * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ } /* "_ruamel_yaml.pyx":1176 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ __pyx_t_3 = ((!(PyString_CheckExact(__pyx_v_tag_object) != 0)) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1177 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1178 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1178, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1178, __pyx_L1_error) /* "_ruamel_yaml.pyx":1177 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ } /* "_ruamel_yaml.pyx":1180 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * implicit = 0 */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1180, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1176 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ } /* "_ruamel_yaml.pyx":1181 * else: * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) # <<<<<<<<<<<<<< * implicit = 0 * if event_object.implicit: */ __pyx_v_tag = PyString_AS_STRING(__pyx_v_tag_object); /* "_ruamel_yaml.pyx":1173 * tag = NULL * tag_object = event_object.tag * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ } /* "_ruamel_yaml.pyx":1182 * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) * implicit = 0 # <<<<<<<<<<<<<< * if event_object.implicit: * implicit = 1 */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":1183 * tag = PyString_AS_STRING(tag_object) * implicit = 0 * if event_object.implicit: # <<<<<<<<<<<<<< * implicit = 1 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_implicit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1183, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1184 * implicit = 0 * if event_object.implicit: * implicit = 1 # <<<<<<<<<<<<<< * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if event_object.flow_style: */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":1183 * tag = PyString_AS_STRING(tag_object) * implicit = 0 * if event_object.implicit: # <<<<<<<<<<<<<< * implicit = 1 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE */ } /* "_ruamel_yaml.pyx":1185 * if event_object.implicit: * implicit = 1 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE # <<<<<<<<<<<<<< * if event_object.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE */ __pyx_v_sequence_style = YAML_BLOCK_SEQUENCE_STYLE; /* "_ruamel_yaml.pyx":1186 * implicit = 1 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if event_object.flow_style: # <<<<<<<<<<<<<< * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(event, anchor, tag, */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_flow_style); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1186, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1187 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if event_object.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE # <<<<<<<<<<<<<< * if yaml_sequence_start_event_initialize(event, anchor, tag, * implicit, sequence_style) == 0: */ __pyx_v_sequence_style = YAML_FLOW_SEQUENCE_STYLE; /* "_ruamel_yaml.pyx":1186 * implicit = 1 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if event_object.flow_style: # <<<<<<<<<<<<<< * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(event, anchor, tag, */ } /* "_ruamel_yaml.pyx":1189 * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(event, anchor, tag, * implicit, sequence_style) == 0: # <<<<<<<<<<<<<< * raise MemoryError * elif event_class is MappingStartEvent: */ __pyx_t_3 = ((yaml_sequence_start_event_initialize(__pyx_v_event, __pyx_v_anchor, __pyx_v_tag, __pyx_v_implicit, __pyx_v_sequence_style) == 0) != 0); /* "_ruamel_yaml.pyx":1188 * if event_object.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(event, anchor, tag, # <<<<<<<<<<<<<< * implicit, sequence_style) == 0: * raise MemoryError */ if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1190 * if yaml_sequence_start_event_initialize(event, anchor, tag, * implicit, sequence_style) == 0: * raise MemoryError # <<<<<<<<<<<<<< * elif event_class is MappingStartEvent: * anchor = NULL */ PyErr_NoMemory(); __PYX_ERR(0, 1190, __pyx_L1_error) /* "_ruamel_yaml.pyx":1188 * if event_object.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(event, anchor, tag, # <<<<<<<<<<<<<< * implicit, sequence_style) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1159 * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError * elif event_class is SequenceStartEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1191 * implicit, sequence_style) == 0: * raise MemoryError * elif event_class is MappingStartEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingStartEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1192 * raise MemoryError * elif event_class is MappingStartEvent: * anchor = NULL # <<<<<<<<<<<<<< * anchor_object = event_object.anchor * if anchor_object is not None: */ __pyx_v_anchor = NULL; /* "_ruamel_yaml.pyx":1193 * elif event_class is MappingStartEvent: * anchor = NULL * anchor_object = event_object.anchor # <<<<<<<<<<<<<< * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_anchor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_anchor_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1194 * anchor = NULL * anchor_object = event_object.anchor * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ __pyx_t_2 = (__pyx_v_anchor_object != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1195 * anchor_object = event_object.anchor * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ __pyx_t_3 = (PyUnicode_CheckExact(__pyx_v_anchor_object) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1196 * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_anchor_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_anchor_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1195 * anchor_object = event_object.anchor * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ } /* "_ruamel_yaml.pyx":1197 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ __pyx_t_3 = ((!(PyString_CheckExact(__pyx_v_anchor_object) != 0)) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1198 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1199 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1199, __pyx_L1_error) /* "_ruamel_yaml.pyx":1198 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ } /* "_ruamel_yaml.pyx":1201 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * tag = NULL */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1201, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1197 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ } /* "_ruamel_yaml.pyx":1202 * else: * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) # <<<<<<<<<<<<<< * tag = NULL * tag_object = event_object.tag */ __pyx_v_anchor = PyString_AS_STRING(__pyx_v_anchor_object); /* "_ruamel_yaml.pyx":1194 * anchor = NULL * anchor_object = event_object.anchor * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ } /* "_ruamel_yaml.pyx":1203 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * tag = NULL # <<<<<<<<<<<<<< * tag_object = event_object.tag * if tag_object is not None: */ __pyx_v_tag = NULL; /* "_ruamel_yaml.pyx":1204 * anchor = PyString_AS_STRING(anchor_object) * tag = NULL * tag_object = event_object.tag # <<<<<<<<<<<<<< * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_tag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_tag_object = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1205 * tag = NULL * tag_object = event_object.tag * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ __pyx_t_3 = (__pyx_v_tag_object != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1206 * tag_object = event_object.tag * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_tag_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1207 * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_4 = PyUnicode_AsUTF8String(__pyx_v_tag_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_tag_object, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1206 * tag_object = event_object.tag * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ } /* "_ruamel_yaml.pyx":1208 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_tag_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1209 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1210 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1210, __pyx_L1_error) /* "_ruamel_yaml.pyx":1209 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ } /* "_ruamel_yaml.pyx":1212 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * implicit = 0 */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1212, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1208 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ } /* "_ruamel_yaml.pyx":1213 * else: * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) # <<<<<<<<<<<<<< * implicit = 0 * if event_object.implicit: */ __pyx_v_tag = PyString_AS_STRING(__pyx_v_tag_object); /* "_ruamel_yaml.pyx":1205 * tag = NULL * tag_object = event_object.tag * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ } /* "_ruamel_yaml.pyx":1214 * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) * implicit = 0 # <<<<<<<<<<<<<< * if event_object.implicit: * implicit = 1 */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":1215 * tag = PyString_AS_STRING(tag_object) * implicit = 0 * if event_object.implicit: # <<<<<<<<<<<<<< * implicit = 1 * mapping_style = YAML_BLOCK_MAPPING_STYLE */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_implicit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1215, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1216 * implicit = 0 * if event_object.implicit: * implicit = 1 # <<<<<<<<<<<<<< * mapping_style = YAML_BLOCK_MAPPING_STYLE * if event_object.flow_style: */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":1215 * tag = PyString_AS_STRING(tag_object) * implicit = 0 * if event_object.implicit: # <<<<<<<<<<<<<< * implicit = 1 * mapping_style = YAML_BLOCK_MAPPING_STYLE */ } /* "_ruamel_yaml.pyx":1217 * if event_object.implicit: * implicit = 1 * mapping_style = YAML_BLOCK_MAPPING_STYLE # <<<<<<<<<<<<<< * if event_object.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE */ __pyx_v_mapping_style = YAML_BLOCK_MAPPING_STYLE; /* "_ruamel_yaml.pyx":1218 * implicit = 1 * mapping_style = YAML_BLOCK_MAPPING_STYLE * if event_object.flow_style: # <<<<<<<<<<<<<< * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(event, anchor, tag, */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_event_object, __pyx_n_s_flow_style); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1219 * mapping_style = YAML_BLOCK_MAPPING_STYLE * if event_object.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE # <<<<<<<<<<<<<< * if yaml_mapping_start_event_initialize(event, anchor, tag, * implicit, mapping_style) == 0: */ __pyx_v_mapping_style = YAML_FLOW_MAPPING_STYLE; /* "_ruamel_yaml.pyx":1218 * implicit = 1 * mapping_style = YAML_BLOCK_MAPPING_STYLE * if event_object.flow_style: # <<<<<<<<<<<<<< * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(event, anchor, tag, */ } /* "_ruamel_yaml.pyx":1221 * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(event, anchor, tag, * implicit, mapping_style) == 0: # <<<<<<<<<<<<<< * raise MemoryError * elif event_class is SequenceEndEvent: */ __pyx_t_2 = ((yaml_mapping_start_event_initialize(__pyx_v_event, __pyx_v_anchor, __pyx_v_tag, __pyx_v_implicit, __pyx_v_mapping_style) == 0) != 0); /* "_ruamel_yaml.pyx":1220 * if event_object.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(event, anchor, tag, # <<<<<<<<<<<<<< * implicit, mapping_style) == 0: * raise MemoryError */ if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1222 * if yaml_mapping_start_event_initialize(event, anchor, tag, * implicit, mapping_style) == 0: * raise MemoryError # <<<<<<<<<<<<<< * elif event_class is SequenceEndEvent: * yaml_sequence_end_event_initialize(event) */ PyErr_NoMemory(); __PYX_ERR(0, 1222, __pyx_L1_error) /* "_ruamel_yaml.pyx":1220 * if event_object.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(event, anchor, tag, # <<<<<<<<<<<<<< * implicit, mapping_style) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1191 * implicit, sequence_style) == 0: * raise MemoryError * elif event_class is MappingStartEvent: # <<<<<<<<<<<<<< * anchor = NULL * anchor_object = event_object.anchor */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1223 * implicit, mapping_style) == 0: * raise MemoryError * elif event_class is SequenceEndEvent: # <<<<<<<<<<<<<< * yaml_sequence_end_event_initialize(event) * elif event_class is MappingEndEvent: */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceEndEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1224 * raise MemoryError * elif event_class is SequenceEndEvent: * yaml_sequence_end_event_initialize(event) # <<<<<<<<<<<<<< * elif event_class is MappingEndEvent: * yaml_mapping_end_event_initialize(event) */ yaml_sequence_end_event_initialize(__pyx_v_event); /* "_ruamel_yaml.pyx":1223 * implicit, mapping_style) == 0: * raise MemoryError * elif event_class is SequenceEndEvent: # <<<<<<<<<<<<<< * yaml_sequence_end_event_initialize(event) * elif event_class is MappingEndEvent: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1225 * elif event_class is SequenceEndEvent: * yaml_sequence_end_event_initialize(event) * elif event_class is MappingEndEvent: # <<<<<<<<<<<<<< * yaml_mapping_end_event_initialize(event) * else: */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingEndEvent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__pyx_v_event_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1226 * yaml_sequence_end_event_initialize(event) * elif event_class is MappingEndEvent: * yaml_mapping_end_event_initialize(event) # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ yaml_mapping_end_event_initialize(__pyx_v_event); /* "_ruamel_yaml.pyx":1225 * elif event_class is SequenceEndEvent: * yaml_sequence_end_event_initialize(event) * elif event_class is MappingEndEvent: # <<<<<<<<<<<<<< * yaml_mapping_end_event_initialize(event) * else: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1228 * yaml_mapping_end_event_initialize(event) * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("invalid event %s" % event_object) * else: */ /*else*/ { __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1229 * else: * if PY_MAJOR_VERSION < 3: * raise TypeError("invalid event %s" % event_object) # <<<<<<<<<<<<<< * else: * raise TypeError(u"invalid event %s" % event_object) */ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_invalid_event_s, __pyx_v_event_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1229, __pyx_L1_error) /* "_ruamel_yaml.pyx":1228 * yaml_mapping_end_event_initialize(event) * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("invalid event %s" % event_object) * else: */ } /* "_ruamel_yaml.pyx":1231 * raise TypeError("invalid event %s" % event_object) * else: * raise TypeError(u"invalid event %s" % event_object) # <<<<<<<<<<<<<< * return 1 * */ /*else*/ { __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_invalid_event_s, __pyx_v_event_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1231, __pyx_L1_error) } } __pyx_L3:; /* "_ruamel_yaml.pyx":1232 * else: * raise TypeError(u"invalid event %s" % event_object) * return 1 # <<<<<<<<<<<<<< * * def emit(self, event_object): */ __pyx_r = 1; goto __pyx_L0; /* "_ruamel_yaml.pyx":1015 * raise ValueError(u"no emitter error") * * cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: # <<<<<<<<<<<<<< * cdef yaml_encoding_t encoding * cdef yaml_version_directive_t version_directive_value */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_ruamel_yaml.CEmitter._object_to_event", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_event_class); __Pyx_XDECREF(__pyx_v_cache); __Pyx_XDECREF(__pyx_v_handle); __Pyx_XDECREF(__pyx_v_prefix); __Pyx_XDECREF(__pyx_v_anchor_object); __Pyx_XDECREF(__pyx_v_tag_object); __Pyx_XDECREF(__pyx_v_value_object); __Pyx_XDECREF(__pyx_v_style_object); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1234 * return 1 * * def emit(self, event_object): # <<<<<<<<<<<<<< * cdef yaml_event_t event * self._object_to_event(event_object, &event) */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_7emit(PyObject *__pyx_v_self, PyObject *__pyx_v_event_object); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_7emit(PyObject *__pyx_v_self, PyObject *__pyx_v_event_object) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("emit (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_6emit(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self), ((PyObject *)__pyx_v_event_object)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_6emit(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_event_object) { yaml_event_t __pyx_v_event; PyObject *__pyx_v_error = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("emit", 0); /* "_ruamel_yaml.pyx":1236 * def emit(self, event_object): * cdef yaml_event_t event * self._object_to_event(event_object, &event) # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_object_to_event(__pyx_v_self, __pyx_v_event_object, (&__pyx_v_event)); if (unlikely(__pyx_t_1 == ((int)0))) __PYX_ERR(0, 1236, __pyx_L1_error) /* "_ruamel_yaml.pyx":1237 * cdef yaml_event_t event * self._object_to_event(event_object, &event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_1 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1237, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_1 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1238 * self._object_to_event(event_object, &event) * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * */ __pyx_t_3 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_error = __pyx_t_3; __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":1239 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * * def open(self): */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1239, __pyx_L1_error) /* "_ruamel_yaml.pyx":1237 * cdef yaml_event_t event * self._object_to_event(event_object, &event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1234 * return 1 * * def emit(self, event_object): # <<<<<<<<<<<<<< * cdef yaml_event_t event * self._object_to_event(event_object, &event) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.emit", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1241 * raise error * * def open(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef yaml_encoding_t encoding */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_9open(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_9open(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("open (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_8open(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_8open(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self) { yaml_event_t __pyx_v_event; yaml_encoding_t __pyx_v_encoding; PyObject *__pyx_v_error = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("open", 0); /* "_ruamel_yaml.pyx":1244 * cdef yaml_event_t event * cdef yaml_encoding_t encoding * if self.closed == -1: # <<<<<<<<<<<<<< * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING */ switch (__pyx_v_self->closed) { case -1L: /* "_ruamel_yaml.pyx":1245 * cdef yaml_encoding_t encoding * if self.closed == -1: * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': # <<<<<<<<<<<<<< * encoding = YAML_UTF16LE_ENCODING * elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': */ __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->use_encoding, __pyx_kp_u_utf_16_le, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1245, __pyx_L1_error) if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_self->use_encoding, __pyx_kp_s_utf_16_le, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1245, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1246 * if self.closed == -1: * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING # <<<<<<<<<<<<<< * elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': * encoding = YAML_UTF16BE_ENCODING */ __pyx_v_encoding = YAML_UTF16LE_ENCODING; /* "_ruamel_yaml.pyx":1245 * cdef yaml_encoding_t encoding * if self.closed == -1: * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': # <<<<<<<<<<<<<< * encoding = YAML_UTF16LE_ENCODING * elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1247 * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING * elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': # <<<<<<<<<<<<<< * encoding = YAML_UTF16BE_ENCODING * else: */ __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->use_encoding, __pyx_kp_u_utf_16_be, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1247, __pyx_L1_error) if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L6_bool_binop_done; } __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_self->use_encoding, __pyx_kp_s_utf_16_be, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1247, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; __pyx_L6_bool_binop_done:; if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1248 * encoding = YAML_UTF16LE_ENCODING * elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': * encoding = YAML_UTF16BE_ENCODING # <<<<<<<<<<<<<< * else: * encoding = YAML_UTF8_ENCODING */ __pyx_v_encoding = YAML_UTF16BE_ENCODING; /* "_ruamel_yaml.pyx":1247 * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING * elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': # <<<<<<<<<<<<<< * encoding = YAML_UTF16BE_ENCODING * else: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1250 * encoding = YAML_UTF16BE_ENCODING * else: * encoding = YAML_UTF8_ENCODING # <<<<<<<<<<<<<< * if self.use_encoding is None: * self.dump_unicode = 1 */ /*else*/ { __pyx_v_encoding = YAML_UTF8_ENCODING; } __pyx_L3:; /* "_ruamel_yaml.pyx":1251 * else: * encoding = YAML_UTF8_ENCODING * if self.use_encoding is None: # <<<<<<<<<<<<<< * self.dump_unicode = 1 * if self.dump_unicode == 1: */ __pyx_t_1 = (__pyx_v_self->use_encoding == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1252 * encoding = YAML_UTF8_ENCODING * if self.use_encoding is None: * self.dump_unicode = 1 # <<<<<<<<<<<<<< * if self.dump_unicode == 1: * encoding = YAML_UTF8_ENCODING */ __pyx_v_self->dump_unicode = 1; /* "_ruamel_yaml.pyx":1251 * else: * encoding = YAML_UTF8_ENCODING * if self.use_encoding is None: # <<<<<<<<<<<<<< * self.dump_unicode = 1 * if self.dump_unicode == 1: */ } /* "_ruamel_yaml.pyx":1253 * if self.use_encoding is None: * self.dump_unicode = 1 * if self.dump_unicode == 1: # <<<<<<<<<<<<<< * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(&event, encoding) */ __pyx_t_2 = ((__pyx_v_self->dump_unicode == 1) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1254 * self.dump_unicode = 1 * if self.dump_unicode == 1: * encoding = YAML_UTF8_ENCODING # <<<<<<<<<<<<<< * yaml_stream_start_event_initialize(&event, encoding) * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_v_encoding = YAML_UTF8_ENCODING; /* "_ruamel_yaml.pyx":1253 * if self.use_encoding is None: * self.dump_unicode = 1 * if self.dump_unicode == 1: # <<<<<<<<<<<<<< * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(&event, encoding) */ } /* "_ruamel_yaml.pyx":1255 * if self.dump_unicode == 1: * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(&event, encoding) # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ yaml_stream_start_event_initialize((&__pyx_v_event), __pyx_v_encoding); /* "_ruamel_yaml.pyx":1256 * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(&event, encoding) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_3 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1256, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_3 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1257 * yaml_stream_start_event_initialize(&event, encoding) * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * self.closed = 0 */ __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_error = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1258 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * self.closed = 0 * elif self.closed == 1: */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1258, __pyx_L1_error) /* "_ruamel_yaml.pyx":1256 * encoding = YAML_UTF8_ENCODING * yaml_stream_start_event_initialize(&event, encoding) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1259 * error = self._emitter_error() * raise error * self.closed = 0 # <<<<<<<<<<<<<< * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: */ __pyx_v_self->closed = 0; /* "_ruamel_yaml.pyx":1244 * cdef yaml_event_t event * cdef yaml_encoding_t encoding * if self.closed == -1: # <<<<<<<<<<<<<< * if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': * encoding = YAML_UTF16LE_ENCODING */ break; /* "_ruamel_yaml.pyx":1260 * raise error * self.closed = 0 * elif self.closed == 1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") */ case 1: /* "_ruamel_yaml.pyx":1261 * self.closed = 0 * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is closed") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1262 * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is closed") */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1262, __pyx_L1_error) /* "_ruamel_yaml.pyx":1261 * self.closed = 0 * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is closed") * else: */ } /* "_ruamel_yaml.pyx":1264 * raise SerializerError("serializer is closed") * else: * raise SerializerError(u"serializer is closed") # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ /*else*/ { __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1264, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1260 * raise error * self.closed = 0 * elif self.closed == 1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") */ break; default: /* "_ruamel_yaml.pyx":1266 * raise SerializerError(u"serializer is closed") * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is already opened") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1267 * else: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is already opened") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is already opened") */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1267, __pyx_L1_error) /* "_ruamel_yaml.pyx":1266 * raise SerializerError(u"serializer is closed") * else: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is already opened") * else: */ } /* "_ruamel_yaml.pyx":1269 * raise SerializerError("serializer is already opened") * else: * raise SerializerError(u"serializer is already opened") # <<<<<<<<<<<<<< * * def close(self): */ /*else*/ { __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 1269, __pyx_L1_error) } break; } /* "_ruamel_yaml.pyx":1241 * raise error * * def open(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef yaml_encoding_t encoding */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.open", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1271 * raise SerializerError(u"serializer is already opened") * * def close(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * if self.closed == -1: */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_11close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_11close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_10close(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_10close(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self) { yaml_event_t __pyx_v_event; PyObject *__pyx_v_error = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; __Pyx_RefNannySetupContext("close", 0); /* "_ruamel_yaml.pyx":1273 * def close(self): * cdef yaml_event_t event * if self.closed == -1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") */ switch (__pyx_v_self->closed) { case -1L: /* "_ruamel_yaml.pyx":1274 * cdef yaml_event_t event * if self.closed == -1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is not opened") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1275 * if self.closed == -1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is not opened") */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1275, __pyx_L1_error) /* "_ruamel_yaml.pyx":1274 * cdef yaml_event_t event * if self.closed == -1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is not opened") * else: */ } /* "_ruamel_yaml.pyx":1277 * raise SerializerError("serializer is not opened") * else: * raise SerializerError(u"serializer is not opened") # <<<<<<<<<<<<<< * elif self.closed == 0: * yaml_stream_end_event_initialize(&event) */ /*else*/ { __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1277, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1273 * def close(self): * cdef yaml_event_t event * if self.closed == -1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") */ break; /* "_ruamel_yaml.pyx":1278 * else: * raise SerializerError(u"serializer is not opened") * elif self.closed == 0: # <<<<<<<<<<<<<< * yaml_stream_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: */ case 0: /* "_ruamel_yaml.pyx":1279 * raise SerializerError(u"serializer is not opened") * elif self.closed == 0: * yaml_stream_end_event_initialize(&event) # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ yaml_stream_end_event_initialize((&__pyx_v_event)); /* "_ruamel_yaml.pyx":1280 * elif self.closed == 0: * yaml_stream_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1280, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1281 * yaml_stream_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * self.closed = 1 */ __pyx_t_2 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_error = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1282 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * self.closed = 1 * */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1282, __pyx_L1_error) /* "_ruamel_yaml.pyx":1280 * elif self.closed == 0: * yaml_stream_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1283 * error = self._emitter_error() * raise error * self.closed = 1 # <<<<<<<<<<<<<< * * def serialize(self, node): */ __pyx_v_self->closed = 1; /* "_ruamel_yaml.pyx":1278 * else: * raise SerializerError(u"serializer is not opened") * elif self.closed == 0: # <<<<<<<<<<<<<< * yaml_stream_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: */ break; default: break; } /* "_ruamel_yaml.pyx":1271 * raise SerializerError(u"serializer is already opened") * * def close(self): # <<<<<<<<<<<<<< * cdef yaml_event_t event * if self.closed == -1: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_error); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1285 * self.closed = 1 * * def serialize(self, node): # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef yaml_version_directive_t version_directive_value */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_13serialize(PyObject *__pyx_v_self, PyObject *__pyx_v_node); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_13serialize(PyObject *__pyx_v_self, PyObject *__pyx_v_node) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("serialize (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_12serialize(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self), ((PyObject *)__pyx_v_node)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_12serialize(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_node) { yaml_event_t __pyx_v_event; yaml_version_directive_t __pyx_v_version_directive_value; yaml_version_directive_t *__pyx_v_version_directive; yaml_tag_directive_t __pyx_v_tag_directives_value[0x80]; yaml_tag_directive_t *__pyx_v_tag_directives_start; yaml_tag_directive_t *__pyx_v_tag_directives_end; PyObject *__pyx_v_cache = NULL; PyObject *__pyx_v_handle = NULL; PyObject *__pyx_v_prefix = NULL; PyObject *__pyx_v_error = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); int __pyx_t_7; __Pyx_RefNannySetupContext("serialize", 0); /* "_ruamel_yaml.pyx":1292 * cdef yaml_tag_directive_t *tag_directives_start * cdef yaml_tag_directive_t *tag_directives_end * if self.closed == -1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") */ switch (__pyx_v_self->closed) { case -1L: /* "_ruamel_yaml.pyx":1293 * cdef yaml_tag_directive_t *tag_directives_end * if self.closed == -1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is not opened") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1294 * if self.closed == -1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is not opened") */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1294, __pyx_L1_error) /* "_ruamel_yaml.pyx":1293 * cdef yaml_tag_directive_t *tag_directives_end * if self.closed == -1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is not opened") * else: */ } /* "_ruamel_yaml.pyx":1296 * raise SerializerError("serializer is not opened") * else: * raise SerializerError(u"serializer is not opened") # <<<<<<<<<<<<<< * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: */ /*else*/ { __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1296, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1292 * cdef yaml_tag_directive_t *tag_directives_start * cdef yaml_tag_directive_t *tag_directives_end * if self.closed == -1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") */ break; /* "_ruamel_yaml.pyx":1297 * else: * raise SerializerError(u"serializer is not opened") * elif self.closed == 1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") */ case 1: /* "_ruamel_yaml.pyx":1298 * raise SerializerError(u"serializer is not opened") * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is closed") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1299 * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is closed") */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1299, __pyx_L1_error) /* "_ruamel_yaml.pyx":1298 * raise SerializerError(u"serializer is not opened") * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise SerializerError("serializer is closed") * else: */ } /* "_ruamel_yaml.pyx":1301 * raise SerializerError("serializer is closed") * else: * raise SerializerError(u"serializer is closed") # <<<<<<<<<<<<<< * cache = [] * version_directive = NULL */ /*else*/ { __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_SerializerError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1301, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1297 * else: * raise SerializerError(u"serializer is not opened") * elif self.closed == 1: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") */ break; default: break; } /* "_ruamel_yaml.pyx":1302 * else: * raise SerializerError(u"serializer is closed") * cache = [] # <<<<<<<<<<<<<< * version_directive = NULL * if self.use_version: */ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_cache = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1303 * raise SerializerError(u"serializer is closed") * cache = [] * version_directive = NULL # <<<<<<<<<<<<<< * if self.use_version: * version_directive_value.major = self.use_version[0] */ __pyx_v_version_directive = NULL; /* "_ruamel_yaml.pyx":1304 * cache = [] * version_directive = NULL * if self.use_version: # <<<<<<<<<<<<<< * version_directive_value.major = self.use_version[0] * version_directive_value.minor = self.use_version[1] */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->use_version); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1304, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1305 * version_directive = NULL * if self.use_version: * version_directive_value.major = self.use_version[0] # <<<<<<<<<<<<<< * version_directive_value.minor = self.use_version[1] * version_directive = &version_directive_value */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_self->use_version, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1305, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_version_directive_value.major = __pyx_t_4; /* "_ruamel_yaml.pyx":1306 * if self.use_version: * version_directive_value.major = self.use_version[0] * version_directive_value.minor = self.use_version[1] # <<<<<<<<<<<<<< * version_directive = &version_directive_value * tag_directives_start = NULL */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_self->use_version, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1306, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_version_directive_value.minor = __pyx_t_4; /* "_ruamel_yaml.pyx":1307 * version_directive_value.major = self.use_version[0] * version_directive_value.minor = self.use_version[1] * version_directive = &version_directive_value # <<<<<<<<<<<<<< * tag_directives_start = NULL * tag_directives_end = NULL */ __pyx_v_version_directive = (&__pyx_v_version_directive_value); /* "_ruamel_yaml.pyx":1304 * cache = [] * version_directive = NULL * if self.use_version: # <<<<<<<<<<<<<< * version_directive_value.major = self.use_version[0] * version_directive_value.minor = self.use_version[1] */ } /* "_ruamel_yaml.pyx":1308 * version_directive_value.minor = self.use_version[1] * version_directive = &version_directive_value * tag_directives_start = NULL # <<<<<<<<<<<<<< * tag_directives_end = NULL * if self.use_tags: */ __pyx_v_tag_directives_start = NULL; /* "_ruamel_yaml.pyx":1309 * version_directive = &version_directive_value * tag_directives_start = NULL * tag_directives_end = NULL # <<<<<<<<<<<<<< * if self.use_tags: * if len(self.use_tags) > 128: */ __pyx_v_tag_directives_end = NULL; /* "_ruamel_yaml.pyx":1310 * tag_directives_start = NULL * tag_directives_end = NULL * if self.use_tags: # <<<<<<<<<<<<<< * if len(self.use_tags) > 128: * if PY_MAJOR_VERSION < 3: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->use_tags); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1310, __pyx_L1_error) if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1311 * tag_directives_end = NULL * if self.use_tags: * if len(self.use_tags) > 128: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") */ __pyx_t_2 = __pyx_v_self->use_tags; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1311, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = ((__pyx_t_5 > 0x80) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1312 * if self.use_tags: * if len(self.use_tags) > 128: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("too many tags") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1313 * if len(self.use_tags) > 128: * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") # <<<<<<<<<<<<<< * else: * raise ValueError(u"too many tags") */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1313, __pyx_L1_error) /* "_ruamel_yaml.pyx":1312 * if self.use_tags: * if len(self.use_tags) > 128: * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise ValueError("too many tags") * else: */ } /* "_ruamel_yaml.pyx":1315 * raise ValueError("too many tags") * else: * raise ValueError(u"too many tags") # <<<<<<<<<<<<<< * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1315, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1311 * tag_directives_end = NULL * if self.use_tags: * if len(self.use_tags) > 128: # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") */ } /* "_ruamel_yaml.pyx":1316 * else: * raise ValueError(u"too many tags") * tag_directives_start = tag_directives_value # <<<<<<<<<<<<<< * tag_directives_end = tag_directives_value * for handle in self.use_tags: */ __pyx_v_tag_directives_start = __pyx_v_tag_directives_value; /* "_ruamel_yaml.pyx":1317 * raise ValueError(u"too many tags") * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value # <<<<<<<<<<<<<< * for handle in self.use_tags: * prefix = self.use_tags[handle] */ __pyx_v_tag_directives_end = __pyx_v_tag_directives_value; /* "_ruamel_yaml.pyx":1318 * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value * for handle in self.use_tags: # <<<<<<<<<<<<<< * prefix = self.use_tags[handle] * if PyUnicode_CheckExact(handle): */ if (likely(PyList_CheckExact(__pyx_v_self->use_tags)) || PyTuple_CheckExact(__pyx_v_self->use_tags)) { __pyx_t_2 = __pyx_v_self->use_tags; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_self->use_tags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1318, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1318, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1318, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_6(__pyx_t_2); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1318, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_v_handle, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":1319 * tag_directives_end = tag_directives_value * for handle in self.use_tags: * prefix = self.use_tags[handle] # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(handle): * handle = PyUnicode_AsUTF8String(handle) */ __pyx_t_3 = PyObject_GetItem(__pyx_v_self->use_tags, __pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_prefix, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":1320 * for handle in self.use_tags: * prefix = self.use_tags[handle] * if PyUnicode_CheckExact(handle): # <<<<<<<<<<<<<< * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) */ __pyx_t_1 = (PyUnicode_CheckExact(__pyx_v_handle) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1321 * prefix = self.use_tags[handle] * if PyUnicode_CheckExact(handle): * handle = PyUnicode_AsUTF8String(handle) # <<<<<<<<<<<<<< * cache.append(handle) * if not PyString_CheckExact(handle): */ __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_handle, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":1322 * if PyUnicode_CheckExact(handle): * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) # <<<<<<<<<<<<<< * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: */ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_cache, __pyx_v_handle); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 1322, __pyx_L1_error) /* "_ruamel_yaml.pyx":1320 * for handle in self.use_tags: * prefix = self.use_tags[handle] * if PyUnicode_CheckExact(handle): # <<<<<<<<<<<<<< * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) */ } /* "_ruamel_yaml.pyx":1323 * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) * if not PyString_CheckExact(handle): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") */ __pyx_t_1 = ((!(PyString_CheckExact(__pyx_v_handle) != 0)) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1324 * cache.append(handle) * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag handle must be a string") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1325 * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag handle must be a string") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1325, __pyx_L1_error) /* "_ruamel_yaml.pyx":1324 * cache.append(handle) * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag handle must be a string") * else: */ } /* "_ruamel_yaml.pyx":1327 * raise TypeError("tag handle must be a string") * else: * raise TypeError(u"tag handle must be a string") # <<<<<<<<<<<<<< * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1327, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1323 * handle = PyUnicode_AsUTF8String(handle) * cache.append(handle) * if not PyString_CheckExact(handle): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") */ } /* "_ruamel_yaml.pyx":1328 * else: * raise TypeError(u"tag handle must be a string") * tag_directives_end.handle = PyString_AS_STRING(handle) # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(prefix): * prefix = PyUnicode_AsUTF8String(prefix) */ __pyx_v_tag_directives_end->handle = PyString_AS_STRING(__pyx_v_handle); /* "_ruamel_yaml.pyx":1329 * raise TypeError(u"tag handle must be a string") * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): # <<<<<<<<<<<<<< * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) */ __pyx_t_1 = (PyUnicode_CheckExact(__pyx_v_prefix) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1330 * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): * prefix = PyUnicode_AsUTF8String(prefix) # <<<<<<<<<<<<<< * cache.append(prefix) * if not PyString_CheckExact(prefix): */ __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_prefix); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":1331 * if PyUnicode_CheckExact(prefix): * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) # <<<<<<<<<<<<<< * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: */ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_cache, __pyx_v_prefix); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 1331, __pyx_L1_error) /* "_ruamel_yaml.pyx":1329 * raise TypeError(u"tag handle must be a string") * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): # <<<<<<<<<<<<<< * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) */ } /* "_ruamel_yaml.pyx":1332 * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) * if not PyString_CheckExact(prefix): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") */ __pyx_t_1 = ((!(PyString_CheckExact(__pyx_v_prefix) != 0)) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1333 * cache.append(prefix) * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag prefix must be a string") * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1334 * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag prefix must be a string") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1334, __pyx_L1_error) /* "_ruamel_yaml.pyx":1333 * cache.append(prefix) * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag prefix must be a string") * else: */ } /* "_ruamel_yaml.pyx":1336 * raise TypeError("tag prefix must be a string") * else: * raise TypeError(u"tag prefix must be a string") # <<<<<<<<<<<<<< * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 1336, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1332 * prefix = PyUnicode_AsUTF8String(prefix) * cache.append(prefix) * if not PyString_CheckExact(prefix): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") */ } /* "_ruamel_yaml.pyx":1337 * else: * raise TypeError(u"tag prefix must be a string") * tag_directives_end.prefix = PyString_AS_STRING(prefix) # <<<<<<<<<<<<<< * tag_directives_end = tag_directives_end+1 * if yaml_document_start_event_initialize(&event, version_directive, */ __pyx_v_tag_directives_end->prefix = PyString_AS_STRING(__pyx_v_prefix); /* "_ruamel_yaml.pyx":1338 * raise TypeError(u"tag prefix must be a string") * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 # <<<<<<<<<<<<<< * if yaml_document_start_event_initialize(&event, version_directive, * tag_directives_start, tag_directives_end, */ __pyx_v_tag_directives_end = (__pyx_v_tag_directives_end + 1); /* "_ruamel_yaml.pyx":1318 * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value * for handle in self.use_tags: # <<<<<<<<<<<<<< * prefix = self.use_tags[handle] * if PyUnicode_CheckExact(handle): */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1310 * tag_directives_start = NULL * tag_directives_end = NULL * if self.use_tags: # <<<<<<<<<<<<<< * if len(self.use_tags) > 128: * if PY_MAJOR_VERSION < 3: */ } /* "_ruamel_yaml.pyx":1341 * if yaml_document_start_event_initialize(&event, version_directive, * tag_directives_start, tag_directives_end, * self.document_start_implicit) == 0: # <<<<<<<<<<<<<< * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_1 = ((yaml_document_start_event_initialize((&__pyx_v_event), __pyx_v_version_directive, __pyx_v_tag_directives_start, __pyx_v_tag_directives_end, __pyx_v_self->document_start_implicit) == 0) != 0); /* "_ruamel_yaml.pyx":1339 * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 * if yaml_document_start_event_initialize(&event, version_directive, # <<<<<<<<<<<<<< * tag_directives_start, tag_directives_end, * self.document_start_implicit) == 0: */ if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1342 * tag_directives_start, tag_directives_end, * self.document_start_implicit) == 0: * raise MemoryError # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ PyErr_NoMemory(); __PYX_ERR(0, 1342, __pyx_L1_error) /* "_ruamel_yaml.pyx":1339 * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 * if yaml_document_start_event_initialize(&event, version_directive, # <<<<<<<<<<<<<< * tag_directives_start, tag_directives_end, * self.document_start_implicit) == 0: */ } /* "_ruamel_yaml.pyx":1343 * self.document_start_implicit) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1343, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1344 * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * self._anchor_node(node) */ __pyx_t_2 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_error = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1345 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * self._anchor_node(node) * self._serialize_node(node, None, None) */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1345, __pyx_L1_error) /* "_ruamel_yaml.pyx":1343 * self.document_start_implicit) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1346 * error = self._emitter_error() * raise error * self._anchor_node(node) # <<<<<<<<<<<<<< * self._serialize_node(node, None, None) * yaml_document_end_event_initialize(&event, self.document_end_implicit) */ __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_anchor_node(__pyx_v_self, __pyx_v_node); if (unlikely(__pyx_t_4 == ((int)0))) __PYX_ERR(0, 1346, __pyx_L1_error) /* "_ruamel_yaml.pyx":1347 * raise error * self._anchor_node(node) * self._serialize_node(node, None, None) # <<<<<<<<<<<<<< * yaml_document_end_event_initialize(&event, self.document_end_implicit) * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_serialize_node(__pyx_v_self, __pyx_v_node, Py_None, Py_None); if (unlikely(__pyx_t_4 == ((int)0))) __PYX_ERR(0, 1347, __pyx_L1_error) /* "_ruamel_yaml.pyx":1348 * self._anchor_node(node) * self._serialize_node(node, None, None) * yaml_document_end_event_initialize(&event, self.document_end_implicit) # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ yaml_document_end_event_initialize((&__pyx_v_event), __pyx_v_self->document_end_implicit); /* "_ruamel_yaml.pyx":1349 * self._serialize_node(node, None, None) * yaml_document_end_event_initialize(&event, self.document_end_implicit) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1349, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1350 * yaml_document_end_event_initialize(&event, self.document_end_implicit) * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * self.serialized_nodes = {} */ __pyx_t_2 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_error = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1351 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * self.serialized_nodes = {} * self.anchors = {} */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1351, __pyx_L1_error) /* "_ruamel_yaml.pyx":1349 * self._serialize_node(node, None, None) * yaml_document_end_event_initialize(&event, self.document_end_implicit) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1352 * error = self._emitter_error() * raise error * self.serialized_nodes = {} # <<<<<<<<<<<<<< * self.anchors = {} * self.last_alias_id = 0 */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->serialized_nodes); __Pyx_DECREF(__pyx_v_self->serialized_nodes); __pyx_v_self->serialized_nodes = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1353 * raise error * self.serialized_nodes = {} * self.anchors = {} # <<<<<<<<<<<<<< * self.last_alias_id = 0 * */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->anchors); __Pyx_DECREF(__pyx_v_self->anchors); __pyx_v_self->anchors = __pyx_t_2; __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":1354 * self.serialized_nodes = {} * self.anchors = {} * self.last_alias_id = 0 # <<<<<<<<<<<<<< * * cdef int _anchor_node(self, object node) except 0: */ __pyx_v_self->last_alias_id = 0; /* "_ruamel_yaml.pyx":1285 * self.closed = 1 * * def serialize(self, node): # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef yaml_version_directive_t version_directive_value */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.serialize", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_cache); __Pyx_XDECREF(__pyx_v_handle); __Pyx_XDECREF(__pyx_v_prefix); __Pyx_XDECREF(__pyx_v_error); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1356 * self.last_alias_id = 0 * * cdef int _anchor_node(self, object node) except 0: # <<<<<<<<<<<<<< * if node in self.anchors: * if self.anchors[node] is None: */ static int __pyx_f_12_ruamel_yaml_8CEmitter__anchor_node(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_node) { PyObject *__pyx_v_node_class = NULL; PyObject *__pyx_v_item = NULL; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *(*__pyx_t_11)(PyObject *); __Pyx_RefNannySetupContext("_anchor_node", 0); /* "_ruamel_yaml.pyx":1357 * * cdef int _anchor_node(self, object node) except 0: * if node in self.anchors: # <<<<<<<<<<<<<< * if self.anchors[node] is None: * self.last_alias_id = self.last_alias_id+1 */ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_node, __pyx_v_self->anchors, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1357, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1358 * cdef int _anchor_node(self, object node) except 0: * if node in self.anchors: * if self.anchors[node] is None: # <<<<<<<<<<<<<< * self.last_alias_id = self.last_alias_id+1 * self.anchors[node] = u"id%03d" % self.last_alias_id */ __pyx_t_3 = PyObject_GetItem(__pyx_v_self->anchors, __pyx_v_node); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = (__pyx_t_3 == Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1359 * if node in self.anchors: * if self.anchors[node] is None: * self.last_alias_id = self.last_alias_id+1 # <<<<<<<<<<<<<< * self.anchors[node] = u"id%03d" % self.last_alias_id * else: */ __pyx_v_self->last_alias_id = (__pyx_v_self->last_alias_id + 1); /* "_ruamel_yaml.pyx":1360 * if self.anchors[node] is None: * self.last_alias_id = self.last_alias_id+1 * self.anchors[node] = u"id%03d" % self.last_alias_id # <<<<<<<<<<<<<< * else: * self.anchors[node] = None */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->last_alias_id); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_id_03d, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(PyObject_SetItem(__pyx_v_self->anchors, __pyx_v_node, __pyx_t_4) < 0)) __PYX_ERR(0, 1360, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1358 * cdef int _anchor_node(self, object node) except 0: * if node in self.anchors: * if self.anchors[node] is None: # <<<<<<<<<<<<<< * self.last_alias_id = self.last_alias_id+1 * self.anchors[node] = u"id%03d" % self.last_alias_id */ } /* "_ruamel_yaml.pyx":1357 * * cdef int _anchor_node(self, object node) except 0: * if node in self.anchors: # <<<<<<<<<<<<<< * if self.anchors[node] is None: * self.last_alias_id = self.last_alias_id+1 */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1362 * self.anchors[node] = u"id%03d" % self.last_alias_id * else: * self.anchors[node] = None # <<<<<<<<<<<<<< * node_class = node.__class__ * if node_class is SequenceNode: */ /*else*/ { if (unlikely(PyObject_SetItem(__pyx_v_self->anchors, __pyx_v_node, Py_None) < 0)) __PYX_ERR(0, 1362, __pyx_L1_error) /* "_ruamel_yaml.pyx":1363 * else: * self.anchors[node] = None * node_class = node.__class__ # <<<<<<<<<<<<<< * if node_class is SequenceNode: * for item in node.value: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_node_class = __pyx_t_4; __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1364 * self.anchors[node] = None * node_class = node.__class__ * if node_class is SequenceNode: # <<<<<<<<<<<<<< * for item in node.value: * self._anchor_node(item) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = (__pyx_v_node_class == __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1365 * node_class = node.__class__ * if node_class is SequenceNode: * for item in node.value: # <<<<<<<<<<<<<< * self._anchor_node(item) * elif node_class is MappingNode: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1365, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1365, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1365, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } } else { __pyx_t_4 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1365, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1366 * if node_class is SequenceNode: * for item in node.value: * self._anchor_node(item) # <<<<<<<<<<<<<< * elif node_class is MappingNode: * for key, value in node.value: */ __pyx_t_7 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_anchor_node(__pyx_v_self, __pyx_v_item); if (unlikely(__pyx_t_7 == ((int)0))) __PYX_ERR(0, 1366, __pyx_L1_error) /* "_ruamel_yaml.pyx":1365 * node_class = node.__class__ * if node_class is SequenceNode: * for item in node.value: # <<<<<<<<<<<<<< * self._anchor_node(item) * elif node_class is MappingNode: */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_ruamel_yaml.pyx":1364 * self.anchors[node] = None * node_class = node.__class__ * if node_class is SequenceNode: # <<<<<<<<<<<<<< * for item in node.value: * self._anchor_node(item) */ goto __pyx_L5; } /* "_ruamel_yaml.pyx":1367 * for item in node.value: * self._anchor_node(item) * elif node_class is MappingNode: # <<<<<<<<<<<<<< * for key, value in node.value: * self._anchor_node(key) */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = (__pyx_v_node_class == __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_ruamel_yaml.pyx":1368 * self._anchor_node(item) * elif node_class is MappingNode: * for key, value in node.value: # <<<<<<<<<<<<<< * self._anchor_node(key) * self._anchor_node(value) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1368, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1368, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1368, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1368, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_3); } if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { PyObject* sequence = __pyx_t_3; #if !CYTHON_COMPILING_IN_PYPY Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 1368, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_8 = PyList_GET_ITEM(sequence, 0); __pyx_t_9 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); #else __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext; index = 0; __pyx_t_8 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_8)) goto __pyx_L10_unpacking_failed; __Pyx_GOTREF(__pyx_t_8); index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_9)) goto __pyx_L10_unpacking_failed; __Pyx_GOTREF(__pyx_t_9); if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 2) < 0) __PYX_ERR(0, 1368, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L11_unpacking_done; __pyx_L10_unpacking_failed:; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 1368, __pyx_L1_error) __pyx_L11_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_9); __pyx_t_9 = 0; /* "_ruamel_yaml.pyx":1369 * elif node_class is MappingNode: * for key, value in node.value: * self._anchor_node(key) # <<<<<<<<<<<<<< * self._anchor_node(value) * return 1 */ __pyx_t_7 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_anchor_node(__pyx_v_self, __pyx_v_key); if (unlikely(__pyx_t_7 == ((int)0))) __PYX_ERR(0, 1369, __pyx_L1_error) /* "_ruamel_yaml.pyx":1370 * for key, value in node.value: * self._anchor_node(key) * self._anchor_node(value) # <<<<<<<<<<<<<< * return 1 * */ __pyx_t_7 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_anchor_node(__pyx_v_self, __pyx_v_value); if (unlikely(__pyx_t_7 == ((int)0))) __PYX_ERR(0, 1370, __pyx_L1_error) /* "_ruamel_yaml.pyx":1368 * self._anchor_node(item) * elif node_class is MappingNode: * for key, value in node.value: # <<<<<<<<<<<<<< * self._anchor_node(key) * self._anchor_node(value) */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_ruamel_yaml.pyx":1367 * for item in node.value: * self._anchor_node(item) * elif node_class is MappingNode: # <<<<<<<<<<<<<< * for key, value in node.value: * self._anchor_node(key) */ } __pyx_L5:; } __pyx_L3:; /* "_ruamel_yaml.pyx":1371 * self._anchor_node(key) * self._anchor_node(value) * return 1 # <<<<<<<<<<<<<< * * cdef int _serialize_node(self, object node, object parent, object index) except 0: */ __pyx_r = 1; goto __pyx_L0; /* "_ruamel_yaml.pyx":1356 * self.last_alias_id = 0 * * cdef int _anchor_node(self, object node) except 0: # <<<<<<<<<<<<<< * if node in self.anchors: * if self.anchors[node] is None: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("_ruamel_yaml.CEmitter._anchor_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_node_class); __Pyx_XDECREF(__pyx_v_item); __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1373 * return 1 * * cdef int _serialize_node(self, object node, object parent, object index) except 0: # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef int implicit */ static int __pyx_f_12_ruamel_yaml_8CEmitter__serialize_node(struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, PyObject *__pyx_v_node, PyObject *__pyx_v_parent, PyObject *__pyx_v_index) { yaml_event_t __pyx_v_event; int __pyx_v_implicit; int __pyx_v_plain_implicit; int __pyx_v_quoted_implicit; char *__pyx_v_anchor; char *__pyx_v_tag; char *__pyx_v_value; int __pyx_v_length; int __pyx_v_item_index; yaml_scalar_style_t __pyx_v_scalar_style; yaml_sequence_style_t __pyx_v_sequence_style; yaml_mapping_style_t __pyx_v_mapping_style; PyObject *__pyx_v_anchor_object = NULL; PyObject *__pyx_v_error = NULL; PyObject *__pyx_v_node_class = NULL; PyObject *__pyx_v_tag_object = NULL; PyObject *__pyx_v_value_object = NULL; PyObject *__pyx_v_style_object = NULL; PyObject *__pyx_v_item = NULL; PyObject *__pyx_v_item_key = NULL; PyObject *__pyx_v_item_value = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; Py_ssize_t __pyx_t_10; PyObject *(*__pyx_t_11)(PyObject *); PyObject *(*__pyx_t_12)(PyObject *); __Pyx_RefNannySetupContext("_serialize_node", 0); /* "_ruamel_yaml.pyx":1386 * cdef yaml_sequence_style_t sequence_style * cdef yaml_mapping_style_t mapping_style * anchor_object = self.anchors[node] # <<<<<<<<<<<<<< * anchor = NULL * if anchor_object is not None: */ __pyx_t_1 = PyObject_GetItem(__pyx_v_self->anchors, __pyx_v_node); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1386, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_anchor_object = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1387 * cdef yaml_mapping_style_t mapping_style * anchor_object = self.anchors[node] * anchor = NULL # <<<<<<<<<<<<<< * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): */ __pyx_v_anchor = NULL; /* "_ruamel_yaml.pyx":1388 * anchor_object = self.anchors[node] * anchor = NULL * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ __pyx_t_2 = (__pyx_v_anchor_object != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1389 * anchor = NULL * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ __pyx_t_3 = (PyUnicode_CheckExact(__pyx_v_anchor_object) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1390 * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_anchor_object); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_anchor_object, __pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1389 * anchor = NULL * if anchor_object is not None: * if PyUnicode_CheckExact(anchor_object): # <<<<<<<<<<<<<< * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): */ } /* "_ruamel_yaml.pyx":1391 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ __pyx_t_3 = ((!(PyString_CheckExact(__pyx_v_anchor_object) != 0)) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1392 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1393 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1393, __pyx_L1_error) /* "_ruamel_yaml.pyx":1392 * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("anchor must be a string") * else: */ } /* "_ruamel_yaml.pyx":1395 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * if node in self.serialized_nodes: */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1395, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1391 * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) * if not PyString_CheckExact(anchor_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") */ } /* "_ruamel_yaml.pyx":1396 * else: * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) # <<<<<<<<<<<<<< * if node in self.serialized_nodes: * if yaml_alias_event_initialize(&event, anchor) == 0: */ __pyx_v_anchor = PyString_AS_STRING(__pyx_v_anchor_object); /* "_ruamel_yaml.pyx":1388 * anchor_object = self.anchors[node] * anchor = NULL * if anchor_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(anchor_object): * anchor_object = PyUnicode_AsUTF8String(anchor_object) */ } /* "_ruamel_yaml.pyx":1397 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * if node in self.serialized_nodes: # <<<<<<<<<<<<<< * if yaml_alias_event_initialize(&event, anchor) == 0: * raise MemoryError */ __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_node, __pyx_v_self->serialized_nodes, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1397, __pyx_L1_error) __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1398 * anchor = PyString_AS_STRING(anchor_object) * if node in self.serialized_nodes: * if yaml_alias_event_initialize(&event, anchor) == 0: # <<<<<<<<<<<<<< * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_2 = ((yaml_alias_event_initialize((&__pyx_v_event), __pyx_v_anchor) == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1399 * if node in self.serialized_nodes: * if yaml_alias_event_initialize(&event, anchor) == 0: * raise MemoryError # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ PyErr_NoMemory(); __PYX_ERR(0, 1399, __pyx_L1_error) /* "_ruamel_yaml.pyx":1398 * anchor = PyString_AS_STRING(anchor_object) * if node in self.serialized_nodes: * if yaml_alias_event_initialize(&event, anchor) == 0: # <<<<<<<<<<<<<< * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: */ } /* "_ruamel_yaml.pyx":1400 * if yaml_alias_event_initialize(&event, anchor) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1400, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1401 * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * else: */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_error = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1402 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * else: * node_class = node.__class__ */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1402, __pyx_L1_error) /* "_ruamel_yaml.pyx":1400 * if yaml_alias_event_initialize(&event, anchor) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1397 * raise TypeError(u"anchor must be a string") * anchor = PyString_AS_STRING(anchor_object) * if node in self.serialized_nodes: # <<<<<<<<<<<<<< * if yaml_alias_event_initialize(&event, anchor) == 0: * raise MemoryError */ goto __pyx_L7; } /* "_ruamel_yaml.pyx":1404 * raise error * else: * node_class = node.__class__ # <<<<<<<<<<<<<< * self.serialized_nodes[node] = True * self.descend_resolver(parent, index) */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_node_class = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1405 * else: * node_class = node.__class__ * self.serialized_nodes[node] = True # <<<<<<<<<<<<<< * self.descend_resolver(parent, index) * if node_class is ScalarNode: */ if (unlikely(PyObject_SetItem(__pyx_v_self->serialized_nodes, __pyx_v_node, Py_True) < 0)) __PYX_ERR(0, 1405, __pyx_L1_error) /* "_ruamel_yaml.pyx":1406 * node_class = node.__class__ * self.serialized_nodes[node] = True * self.descend_resolver(parent, index) # <<<<<<<<<<<<<< * if node_class is ScalarNode: * plain_implicit = 0 */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_descend_resolver); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_4 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_4 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_parent, __pyx_v_index}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_parent, __pyx_v_index}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_v_parent); __Pyx_GIVEREF(__pyx_v_parent); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_4, __pyx_v_parent); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_4, __pyx_v_index); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1407 * self.serialized_nodes[node] = True * self.descend_resolver(parent, index) * if node_class is ScalarNode: # <<<<<<<<<<<<<< * plain_implicit = 0 * quoted_implicit = 0 */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__pyx_v_node_class == __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1408 * self.descend_resolver(parent, index) * if node_class is ScalarNode: * plain_implicit = 0 # <<<<<<<<<<<<<< * quoted_implicit = 0 * tag_object = node.tag */ __pyx_v_plain_implicit = 0; /* "_ruamel_yaml.pyx":1409 * if node_class is ScalarNode: * plain_implicit = 0 * quoted_implicit = 0 # <<<<<<<<<<<<<< * tag_object = node.tag * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: */ __pyx_v_quoted_implicit = 0; /* "_ruamel_yaml.pyx":1410 * plain_implicit = 0 * quoted_implicit = 0 * tag_object = node.tag # <<<<<<<<<<<<<< * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: * plain_implicit = 1 */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_tag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_tag_object = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1411 * quoted_implicit = 0 * tag_object = node.tag * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: # <<<<<<<<<<<<<< * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_4 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_4 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_7, __pyx_t_6, __pyx_tuple__64}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_7, __pyx_t_6, __pyx_tuple__64}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_4, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_4, __pyx_tuple__64); __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_v_tag_object, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1412 * tag_object = node.tag * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: * plain_implicit = 1 # <<<<<<<<<<<<<< * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: * quoted_implicit = 1 */ __pyx_v_plain_implicit = 1; /* "_ruamel_yaml.pyx":1411 * quoted_implicit = 0 * tag_object = node.tag * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: # <<<<<<<<<<<<<< * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: */ } /* "_ruamel_yaml.pyx":1413 * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: # <<<<<<<<<<<<<< * quoted_implicit = 1 * tag = NULL */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_4 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_4 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_9, __pyx_t_6, __pyx_tuple__65}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_9, __pyx_t_6, __pyx_tuple__65}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_8 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_4, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_4, __pyx_tuple__65); __pyx_t_9 = 0; __pyx_t_6 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_tag_object, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1414 * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: * quoted_implicit = 1 # <<<<<<<<<<<<<< * tag = NULL * if tag_object is not None: */ __pyx_v_quoted_implicit = 1; /* "_ruamel_yaml.pyx":1413 * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: # <<<<<<<<<<<<<< * quoted_implicit = 1 * tag = NULL */ } /* "_ruamel_yaml.pyx":1415 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: * quoted_implicit = 1 * tag = NULL # <<<<<<<<<<<<<< * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): */ __pyx_v_tag = NULL; /* "_ruamel_yaml.pyx":1416 * quoted_implicit = 1 * tag = NULL * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ __pyx_t_3 = (__pyx_v_tag_object != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1417 * tag = NULL * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_tag_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1418 * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_tag_object); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_tag_object, __pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1417 * tag = NULL * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ } /* "_ruamel_yaml.pyx":1419 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_tag_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1420 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1421 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1421, __pyx_L1_error) /* "_ruamel_yaml.pyx":1420 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ } /* "_ruamel_yaml.pyx":1423 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * value_object = node.value */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1423, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1419 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ } /* "_ruamel_yaml.pyx":1424 * else: * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) # <<<<<<<<<<<<<< * value_object = node.value * if PyUnicode_CheckExact(value_object): */ __pyx_v_tag = PyString_AS_STRING(__pyx_v_tag_object); /* "_ruamel_yaml.pyx":1416 * quoted_implicit = 1 * tag = NULL * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ } /* "_ruamel_yaml.pyx":1425 * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) * value_object = node.value # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value_object = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1426 * tag = PyString_AS_STRING(tag_object) * value_object = node.value * if PyUnicode_CheckExact(value_object): # <<<<<<<<<<<<<< * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_value_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1427 * value_object = node.value * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_value_object); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_value_object, __pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1426 * tag = PyString_AS_STRING(tag_object) * value_object = node.value * if PyUnicode_CheckExact(value_object): # <<<<<<<<<<<<<< * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): */ } /* "_ruamel_yaml.pyx":1428 * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_value_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1429 * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("value must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1430 * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"value must be a string") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1430, __pyx_L1_error) /* "_ruamel_yaml.pyx":1429 * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("value must be a string") * else: */ } /* "_ruamel_yaml.pyx":1432 * raise TypeError("value must be a string") * else: * raise TypeError(u"value must be a string") # <<<<<<<<<<<<<< * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 1432, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1428 * if PyUnicode_CheckExact(value_object): * value_object = PyUnicode_AsUTF8String(value_object) * if not PyString_CheckExact(value_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") */ } /* "_ruamel_yaml.pyx":1433 * else: * raise TypeError(u"value must be a string") * value = PyString_AS_STRING(value_object) # <<<<<<<<<<<<<< * length = PyString_GET_SIZE(value_object) * style_object = node.style */ __pyx_v_value = PyString_AS_STRING(__pyx_v_value_object); /* "_ruamel_yaml.pyx":1434 * raise TypeError(u"value must be a string") * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) # <<<<<<<<<<<<<< * style_object = node.style * scalar_style = YAML_PLAIN_SCALAR_STYLE */ __pyx_v_length = PyString_GET_SIZE(__pyx_v_value_object); /* "_ruamel_yaml.pyx":1435 * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) * style_object = node.style # <<<<<<<<<<<<<< * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_style); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_style_object = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1436 * length = PyString_GET_SIZE(value_object) * style_object = node.style * scalar_style = YAML_PLAIN_SCALAR_STYLE # <<<<<<<<<<<<<< * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_PLAIN_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1437 * style_object = node.style * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": # <<<<<<<<<<<<<< * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__7, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1437, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L21_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__7, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1437, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L21_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1438 * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE # <<<<<<<<<<<<<< * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1437 * style_object = node.style * scalar_style = YAML_PLAIN_SCALAR_STYLE * if style_object == "'" or style_object == u"'": # <<<<<<<<<<<<<< * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": */ goto __pyx_L20; } /* "_ruamel_yaml.pyx":1439 * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": # <<<<<<<<<<<<<< * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1439, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L23_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1439, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L23_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1440 * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE # <<<<<<<<<<<<<< * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1439 * if style_object == "'" or style_object == u"'": * scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE * elif style_object == "\"" or style_object == u"\"": # <<<<<<<<<<<<<< * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": */ goto __pyx_L20; } /* "_ruamel_yaml.pyx":1441 * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": # <<<<<<<<<<<<<< * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__9, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1441, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L25_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__9, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1441, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L25_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1442 * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE # <<<<<<<<<<<<<< * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE */ __pyx_v_scalar_style = YAML_LITERAL_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1441 * elif style_object == "\"" or style_object == u"\"": * scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE * elif style_object == "|" or style_object == u"|": # <<<<<<<<<<<<<< * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": */ goto __pyx_L20; } /* "_ruamel_yaml.pyx":1443 * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": # <<<<<<<<<<<<<< * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_style_object, __pyx_kp_s__10, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1443, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L27_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_style_object, __pyx_kp_u__10, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1443, __pyx_L1_error) __pyx_t_2 = __pyx_t_3; __pyx_L27_bool_binop_done:; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1444 * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE # <<<<<<<<<<<<<< * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, * plain_implicit, quoted_implicit, scalar_style) == 0: */ __pyx_v_scalar_style = YAML_FOLDED_SCALAR_STYLE; /* "_ruamel_yaml.pyx":1443 * elif style_object == "|" or style_object == u"|": * scalar_style = YAML_LITERAL_SCALAR_STYLE * elif style_object == ">" or style_object == u">": # <<<<<<<<<<<<<< * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, */ } __pyx_L20:; /* "_ruamel_yaml.pyx":1446 * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, * plain_implicit, quoted_implicit, scalar_style) == 0: # <<<<<<<<<<<<<< * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_2 = ((yaml_scalar_event_initialize((&__pyx_v_event), __pyx_v_anchor, __pyx_v_tag, __pyx_v_value, __pyx_v_length, __pyx_v_plain_implicit, __pyx_v_quoted_implicit, __pyx_v_scalar_style) == 0) != 0); /* "_ruamel_yaml.pyx":1445 * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, # <<<<<<<<<<<<<< * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError */ if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1447 * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ PyErr_NoMemory(); __PYX_ERR(0, 1447, __pyx_L1_error) /* "_ruamel_yaml.pyx":1445 * elif style_object == ">" or style_object == u">": * scalar_style = YAML_FOLDED_SCALAR_STYLE * if yaml_scalar_event_initialize(&event, anchor, tag, value, length, # <<<<<<<<<<<<<< * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1448 * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1448, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1449 * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * elif node_class is SequenceNode: */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_error = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1450 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * elif node_class is SequenceNode: * implicit = 0 */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1450, __pyx_L1_error) /* "_ruamel_yaml.pyx":1448 * plain_implicit, quoted_implicit, scalar_style) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1407 * self.serialized_nodes[node] = True * self.descend_resolver(parent, index) * if node_class is ScalarNode: # <<<<<<<<<<<<<< * plain_implicit = 0 * quoted_implicit = 0 */ goto __pyx_L10; } /* "_ruamel_yaml.pyx":1451 * error = self._emitter_error() * raise error * elif node_class is SequenceNode: # <<<<<<<<<<<<<< * implicit = 0 * tag_object = node.tag */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__pyx_v_node_class == __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1452 * raise error * elif node_class is SequenceNode: * implicit = 0 # <<<<<<<<<<<<<< * tag_object = node.tag * if self.resolve(SequenceNode, node.value, True) == tag_object: */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":1453 * elif node_class is SequenceNode: * implicit = 0 * tag_object = node.tag # <<<<<<<<<<<<<< * if self.resolve(SequenceNode, node.value, True) == tag_object: * implicit = 1 */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_tag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_tag_object = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1454 * implicit = 0 * tag_object = node.tag * if self.resolve(SequenceNode, node.value, True) == tag_object: # <<<<<<<<<<<<<< * implicit = 1 * tag = NULL */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_4 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_4 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_t_8, __pyx_t_6, Py_True}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_t_8, __pyx_t_6, Py_True}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_4, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_4, __pyx_t_6); __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_4, Py_True); __pyx_t_8 = 0; __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_v_tag_object, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1455 * tag_object = node.tag * if self.resolve(SequenceNode, node.value, True) == tag_object: * implicit = 1 # <<<<<<<<<<<<<< * tag = NULL * if tag_object is not None: */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":1454 * implicit = 0 * tag_object = node.tag * if self.resolve(SequenceNode, node.value, True) == tag_object: # <<<<<<<<<<<<<< * implicit = 1 * tag = NULL */ } /* "_ruamel_yaml.pyx":1456 * if self.resolve(SequenceNode, node.value, True) == tag_object: * implicit = 1 * tag = NULL # <<<<<<<<<<<<<< * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): */ __pyx_v_tag = NULL; /* "_ruamel_yaml.pyx":1457 * implicit = 1 * tag = NULL * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ __pyx_t_3 = (__pyx_v_tag_object != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1458 * tag = NULL * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_tag_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1459 * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_5 = PyUnicode_AsUTF8String(__pyx_v_tag_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_tag_object, __pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":1458 * tag = NULL * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ } /* "_ruamel_yaml.pyx":1460 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_tag_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1461 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1462 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1462, __pyx_L1_error) /* "_ruamel_yaml.pyx":1461 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ } /* "_ruamel_yaml.pyx":1464 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * sequence_style = YAML_BLOCK_SEQUENCE_STYLE */ /*else*/ { __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1464, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1460 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ } /* "_ruamel_yaml.pyx":1465 * else: * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) # <<<<<<<<<<<<<< * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if node.flow_style: */ __pyx_v_tag = PyString_AS_STRING(__pyx_v_tag_object); /* "_ruamel_yaml.pyx":1457 * implicit = 1 * tag = NULL * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ } /* "_ruamel_yaml.pyx":1466 * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) * sequence_style = YAML_BLOCK_SEQUENCE_STYLE # <<<<<<<<<<<<<< * if node.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE */ __pyx_v_sequence_style = YAML_BLOCK_SEQUENCE_STYLE; /* "_ruamel_yaml.pyx":1467 * tag = PyString_AS_STRING(tag_object) * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if node.flow_style: # <<<<<<<<<<<<<< * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(&event, anchor, tag, */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_flow_style); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1467, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1468 * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if node.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE # <<<<<<<<<<<<<< * if yaml_sequence_start_event_initialize(&event, anchor, tag, * implicit, sequence_style) == 0: */ __pyx_v_sequence_style = YAML_FLOW_SEQUENCE_STYLE; /* "_ruamel_yaml.pyx":1467 * tag = PyString_AS_STRING(tag_object) * sequence_style = YAML_BLOCK_SEQUENCE_STYLE * if node.flow_style: # <<<<<<<<<<<<<< * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(&event, anchor, tag, */ } /* "_ruamel_yaml.pyx":1470 * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(&event, anchor, tag, * implicit, sequence_style) == 0: # <<<<<<<<<<<<<< * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_2 = ((yaml_sequence_start_event_initialize((&__pyx_v_event), __pyx_v_anchor, __pyx_v_tag, __pyx_v_implicit, __pyx_v_sequence_style) == 0) != 0); /* "_ruamel_yaml.pyx":1469 * if node.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(&event, anchor, tag, # <<<<<<<<<<<<<< * implicit, sequence_style) == 0: * raise MemoryError */ if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1471 * if yaml_sequence_start_event_initialize(&event, anchor, tag, * implicit, sequence_style) == 0: * raise MemoryError # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ PyErr_NoMemory(); __PYX_ERR(0, 1471, __pyx_L1_error) /* "_ruamel_yaml.pyx":1469 * if node.flow_style: * sequence_style = YAML_FLOW_SEQUENCE_STYLE * if yaml_sequence_start_event_initialize(&event, anchor, tag, # <<<<<<<<<<<<<< * implicit, sequence_style) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1472 * implicit, sequence_style) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1472, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1473 * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * item_index = 0 */ __pyx_t_5 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_error = __pyx_t_5; __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":1474 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * item_index = 0 * for item in node.value: */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1474, __pyx_L1_error) /* "_ruamel_yaml.pyx":1472 * implicit, sequence_style) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1475 * error = self._emitter_error() * raise error * item_index = 0 # <<<<<<<<<<<<<< * for item in node.value: * self._serialize_node(item, node, item_index) */ __pyx_v_item_index = 0; /* "_ruamel_yaml.pyx":1476 * raise error * item_index = 0 * for item in node.value: # <<<<<<<<<<<<<< * self._serialize_node(item, node, item_index) * item_index = item_index+1 */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { __pyx_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1); __pyx_t_10 = 0; __pyx_t_11 = NULL; } else { __pyx_t_10 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1476, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; for (;;) { if (likely(!__pyx_t_11)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 1476, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 1476, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } } else { __pyx_t_5 = __pyx_t_11(__pyx_t_1); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1476, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":1477 * item_index = 0 * for item in node.value: * self._serialize_node(item, node, item_index) # <<<<<<<<<<<<<< * item_index = item_index+1 * yaml_sequence_end_event_initialize(&event) */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_item_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_serialize_node(__pyx_v_self, __pyx_v_item, __pyx_v_node, __pyx_t_5); if (unlikely(__pyx_t_4 == ((int)0))) __PYX_ERR(0, 1477, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":1478 * for item in node.value: * self._serialize_node(item, node, item_index) * item_index = item_index+1 # <<<<<<<<<<<<<< * yaml_sequence_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_v_item_index = (__pyx_v_item_index + 1); /* "_ruamel_yaml.pyx":1476 * raise error * item_index = 0 * for item in node.value: # <<<<<<<<<<<<<< * self._serialize_node(item, node, item_index) * item_index = item_index+1 */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1479 * self._serialize_node(item, node, item_index) * item_index = item_index+1 * yaml_sequence_end_event_initialize(&event) # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ yaml_sequence_end_event_initialize((&__pyx_v_event)); /* "_ruamel_yaml.pyx":1480 * item_index = item_index+1 * yaml_sequence_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1480, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1481 * yaml_sequence_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * elif node_class is MappingNode: */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_error = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1482 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * elif node_class is MappingNode: * implicit = 0 */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1482, __pyx_L1_error) /* "_ruamel_yaml.pyx":1480 * item_index = item_index+1 * yaml_sequence_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1451 * error = self._emitter_error() * raise error * elif node_class is SequenceNode: # <<<<<<<<<<<<<< * implicit = 0 * tag_object = node.tag */ goto __pyx_L10; } /* "_ruamel_yaml.pyx":1483 * error = self._emitter_error() * raise error * elif node_class is MappingNode: # <<<<<<<<<<<<<< * implicit = 0 * tag_object = node.tag */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__pyx_v_node_class == __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1484 * raise error * elif node_class is MappingNode: * implicit = 0 # <<<<<<<<<<<<<< * tag_object = node.tag * if self.resolve(MappingNode, node.value, True) == tag_object: */ __pyx_v_implicit = 0; /* "_ruamel_yaml.pyx":1485 * elif node_class is MappingNode: * implicit = 0 * tag_object = node.tag # <<<<<<<<<<<<<< * if self.resolve(MappingNode, node.value, True) == tag_object: * implicit = 1 */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_tag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_tag_object = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1486 * implicit = 0 * tag_object = node.tag * if self.resolve(MappingNode, node.value, True) == tag_object: # <<<<<<<<<<<<<< * implicit = 1 * tag = NULL */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resolve); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_4 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_4 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_7, __pyx_t_6, Py_True}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_7, __pyx_t_6, Py_True}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_4, 3+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_4, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_4, __pyx_t_6); __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_4, Py_True); __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_v_tag_object, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1486, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_3) { /* "_ruamel_yaml.pyx":1487 * tag_object = node.tag * if self.resolve(MappingNode, node.value, True) == tag_object: * implicit = 1 # <<<<<<<<<<<<<< * tag = NULL * if tag_object is not None: */ __pyx_v_implicit = 1; /* "_ruamel_yaml.pyx":1486 * implicit = 0 * tag_object = node.tag * if self.resolve(MappingNode, node.value, True) == tag_object: # <<<<<<<<<<<<<< * implicit = 1 * tag = NULL */ } /* "_ruamel_yaml.pyx":1488 * if self.resolve(MappingNode, node.value, True) == tag_object: * implicit = 1 * tag = NULL # <<<<<<<<<<<<<< * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): */ __pyx_v_tag = NULL; /* "_ruamel_yaml.pyx":1489 * implicit = 1 * tag = NULL * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ __pyx_t_3 = (__pyx_v_tag_object != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1490 * tag = NULL * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ __pyx_t_2 = (PyUnicode_CheckExact(__pyx_v_tag_object) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1491 * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) # <<<<<<<<<<<<<< * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: */ __pyx_t_5 = PyUnicode_AsUTF8String(__pyx_v_tag_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_tag_object, __pyx_t_5); __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":1490 * tag = NULL * if tag_object is not None: * if PyUnicode_CheckExact(tag_object): # <<<<<<<<<<<<<< * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): */ } /* "_ruamel_yaml.pyx":1492 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ __pyx_t_2 = ((!(PyString_CheckExact(__pyx_v_tag_object) != 0)) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1493 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1494 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1494, __pyx_L1_error) /* "_ruamel_yaml.pyx":1493 * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise TypeError("tag must be a string") * else: */ } /* "_ruamel_yaml.pyx":1496 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * mapping_style = YAML_BLOCK_MAPPING_STYLE */ /*else*/ { __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(0, 1496, __pyx_L1_error) } /* "_ruamel_yaml.pyx":1492 * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) * if not PyString_CheckExact(tag_object): # <<<<<<<<<<<<<< * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") */ } /* "_ruamel_yaml.pyx":1497 * else: * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) # <<<<<<<<<<<<<< * mapping_style = YAML_BLOCK_MAPPING_STYLE * if node.flow_style: */ __pyx_v_tag = PyString_AS_STRING(__pyx_v_tag_object); /* "_ruamel_yaml.pyx":1489 * implicit = 1 * tag = NULL * if tag_object is not None: # <<<<<<<<<<<<<< * if PyUnicode_CheckExact(tag_object): * tag_object = PyUnicode_AsUTF8String(tag_object) */ } /* "_ruamel_yaml.pyx":1498 * raise TypeError(u"tag must be a string") * tag = PyString_AS_STRING(tag_object) * mapping_style = YAML_BLOCK_MAPPING_STYLE # <<<<<<<<<<<<<< * if node.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE */ __pyx_v_mapping_style = YAML_BLOCK_MAPPING_STYLE; /* "_ruamel_yaml.pyx":1499 * tag = PyString_AS_STRING(tag_object) * mapping_style = YAML_BLOCK_MAPPING_STYLE * if node.flow_style: # <<<<<<<<<<<<<< * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(&event, anchor, tag, */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_flow_style); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1499, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1500 * mapping_style = YAML_BLOCK_MAPPING_STYLE * if node.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE # <<<<<<<<<<<<<< * if yaml_mapping_start_event_initialize(&event, anchor, tag, * implicit, mapping_style) == 0: */ __pyx_v_mapping_style = YAML_FLOW_MAPPING_STYLE; /* "_ruamel_yaml.pyx":1499 * tag = PyString_AS_STRING(tag_object) * mapping_style = YAML_BLOCK_MAPPING_STYLE * if node.flow_style: # <<<<<<<<<<<<<< * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(&event, anchor, tag, */ } /* "_ruamel_yaml.pyx":1502 * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(&event, anchor, tag, * implicit, mapping_style) == 0: # <<<<<<<<<<<<<< * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_2 = ((yaml_mapping_start_event_initialize((&__pyx_v_event), __pyx_v_anchor, __pyx_v_tag, __pyx_v_implicit, __pyx_v_mapping_style) == 0) != 0); /* "_ruamel_yaml.pyx":1501 * if node.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(&event, anchor, tag, # <<<<<<<<<<<<<< * implicit, mapping_style) == 0: * raise MemoryError */ if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1503 * if yaml_mapping_start_event_initialize(&event, anchor, tag, * implicit, mapping_style) == 0: * raise MemoryError # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ PyErr_NoMemory(); __PYX_ERR(0, 1503, __pyx_L1_error) /* "_ruamel_yaml.pyx":1501 * if node.flow_style: * mapping_style = YAML_FLOW_MAPPING_STYLE * if yaml_mapping_start_event_initialize(&event, anchor, tag, # <<<<<<<<<<<<<< * implicit, mapping_style) == 0: * raise MemoryError */ } /* "_ruamel_yaml.pyx":1504 * implicit, mapping_style) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1504, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1505 * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * for item_key, item_value in node.value: */ __pyx_t_5 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_error = __pyx_t_5; __pyx_t_5 = 0; /* "_ruamel_yaml.pyx":1506 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * for item_key, item_value in node.value: * self._serialize_node(item_key, node, None) */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1506, __pyx_L1_error) /* "_ruamel_yaml.pyx":1504 * implicit, mapping_style) == 0: * raise MemoryError * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1507 * error = self._emitter_error() * raise error * for item_key, item_value in node.value: # <<<<<<<<<<<<<< * self._serialize_node(item_key, node, None) * self._serialize_node(item_value, node, item_key) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { __pyx_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1); __pyx_t_10 = 0; __pyx_t_11 = NULL; } else { __pyx_t_10 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1507, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; for (;;) { if (likely(!__pyx_t_11)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 1507, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 1507, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } } else { __pyx_t_5 = __pyx_t_11(__pyx_t_1); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1507, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { PyObject* sequence = __pyx_t_5; #if !CYTHON_COMPILING_IN_PYPY Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 1507, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_9 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_12 = Py_TYPE(__pyx_t_7)->tp_iternext; index = 0; __pyx_t_9 = __pyx_t_12(__pyx_t_7); if (unlikely(!__pyx_t_9)) goto __pyx_L52_unpacking_failed; __Pyx_GOTREF(__pyx_t_9); index = 1; __pyx_t_6 = __pyx_t_12(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L52_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_7), 2) < 0) __PYX_ERR(0, 1507, __pyx_L1_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L53_unpacking_done; __pyx_L52_unpacking_failed:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 1507, __pyx_L1_error) __pyx_L53_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_item_key, __pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF_SET(__pyx_v_item_value, __pyx_t_6); __pyx_t_6 = 0; /* "_ruamel_yaml.pyx":1508 * raise error * for item_key, item_value in node.value: * self._serialize_node(item_key, node, None) # <<<<<<<<<<<<<< * self._serialize_node(item_value, node, item_key) * yaml_mapping_end_event_initialize(&event) */ __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_serialize_node(__pyx_v_self, __pyx_v_item_key, __pyx_v_node, Py_None); if (unlikely(__pyx_t_4 == ((int)0))) __PYX_ERR(0, 1508, __pyx_L1_error) /* "_ruamel_yaml.pyx":1509 * for item_key, item_value in node.value: * self._serialize_node(item_key, node, None) * self._serialize_node(item_value, node, item_key) # <<<<<<<<<<<<<< * yaml_mapping_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: */ __pyx_t_4 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_serialize_node(__pyx_v_self, __pyx_v_item_value, __pyx_v_node, __pyx_v_item_key); if (unlikely(__pyx_t_4 == ((int)0))) __PYX_ERR(0, 1509, __pyx_L1_error) /* "_ruamel_yaml.pyx":1507 * error = self._emitter_error() * raise error * for item_key, item_value in node.value: # <<<<<<<<<<<<<< * self._serialize_node(item_key, node, None) * self._serialize_node(item_value, node, item_key) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1510 * self._serialize_node(item_key, node, None) * self._serialize_node(item_value, node, item_key) * yaml_mapping_end_event_initialize(&event) # <<<<<<<<<<<<<< * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() */ yaml_mapping_end_event_initialize((&__pyx_v_event)); /* "_ruamel_yaml.pyx":1511 * self._serialize_node(item_value, node, item_key) * yaml_mapping_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ __pyx_t_4 = yaml_emitter_emit((&__pyx_v_self->emitter), (&__pyx_v_event)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1511, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1512 * yaml_mapping_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() # <<<<<<<<<<<<<< * raise error * self.ascend_resolver() */ __pyx_t_1 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter *)__pyx_v_self->__pyx_vtab)->_emitter_error(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_error = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1513 * if yaml_emitter_emit(&self.emitter, &event) == 0: * error = self._emitter_error() * raise error # <<<<<<<<<<<<<< * self.ascend_resolver() * return 1 */ __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(0, 1513, __pyx_L1_error) /* "_ruamel_yaml.pyx":1511 * self._serialize_node(item_value, node, item_key) * yaml_mapping_end_event_initialize(&event) * if yaml_emitter_emit(&self.emitter, &event) == 0: # <<<<<<<<<<<<<< * error = self._emitter_error() * raise error */ } /* "_ruamel_yaml.pyx":1483 * error = self._emitter_error() * raise error * elif node_class is MappingNode: # <<<<<<<<<<<<<< * implicit = 0 * tag_object = node.tag */ } __pyx_L10:; /* "_ruamel_yaml.pyx":1514 * error = self._emitter_error() * raise error * self.ascend_resolver() # <<<<<<<<<<<<<< * return 1 * */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ascend_resolver); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1514, __pyx_L1_error) } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L7:; /* "_ruamel_yaml.pyx":1515 * raise error * self.ascend_resolver() * return 1 # <<<<<<<<<<<<<< * * cdef int output_handler(void *data, char *buffer, int size) except 0: */ __pyx_r = 1; goto __pyx_L0; /* "_ruamel_yaml.pyx":1373 * return 1 * * cdef int _serialize_node(self, object node, object parent, object index) except 0: # <<<<<<<<<<<<<< * cdef yaml_event_t event * cdef int implicit */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_ruamel_yaml.CEmitter._serialize_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_anchor_object); __Pyx_XDECREF(__pyx_v_error); __Pyx_XDECREF(__pyx_v_node_class); __Pyx_XDECREF(__pyx_v_tag_object); __Pyx_XDECREF(__pyx_v_value_object); __Pyx_XDECREF(__pyx_v_style_object); __Pyx_XDECREF(__pyx_v_item); __Pyx_XDECREF(__pyx_v_item_key); __Pyx_XDECREF(__pyx_v_item_value); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_14__reduce_cython__(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_12_ruamel_yaml_8CEmitter_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_12_ruamel_yaml_8CEmitter_16__setstate_cython__(((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_8CEmitter_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") * def __setstate_cython__(self, __pyx_state): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_ruamel_yaml.CEmitter.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_ruamel_yaml.pyx":1517 * return 1 * * cdef int output_handler(void *data, char *buffer, int size) except 0: # <<<<<<<<<<<<<< * cdef CEmitter emitter * emitter = data */ static int __pyx_f_12_ruamel_yaml_output_handler(void *__pyx_v_data, char *__pyx_v_buffer, int __pyx_v_size) { struct __pyx_obj_12_ruamel_yaml_CEmitter *__pyx_v_emitter = 0; PyObject *__pyx_v_value = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("output_handler", 0); /* "_ruamel_yaml.pyx":1519 * cdef int output_handler(void *data, char *buffer, int size) except 0: * cdef CEmitter emitter * emitter = data # <<<<<<<<<<<<<< * if emitter.dump_unicode == 0: * value = PyString_FromStringAndSize(buffer, size) */ __pyx_t_1 = ((PyObject *)__pyx_v_data); __Pyx_INCREF(__pyx_t_1); __pyx_v_emitter = ((struct __pyx_obj_12_ruamel_yaml_CEmitter *)__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1520 * cdef CEmitter emitter * emitter = data * if emitter.dump_unicode == 0: # <<<<<<<<<<<<<< * value = PyString_FromStringAndSize(buffer, size) * else: */ __pyx_t_2 = ((__pyx_v_emitter->dump_unicode == 0) != 0); if (__pyx_t_2) { /* "_ruamel_yaml.pyx":1521 * emitter = data * if emitter.dump_unicode == 0: * value = PyString_FromStringAndSize(buffer, size) # <<<<<<<<<<<<<< * else: * value = PyUnicode_DecodeUTF8(buffer, size, 'strict') */ __pyx_t_1 = PyString_FromStringAndSize(__pyx_v_buffer, __pyx_v_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1520 * cdef CEmitter emitter * emitter = data * if emitter.dump_unicode == 0: # <<<<<<<<<<<<<< * value = PyString_FromStringAndSize(buffer, size) * else: */ goto __pyx_L3; } /* "_ruamel_yaml.pyx":1523 * value = PyString_FromStringAndSize(buffer, size) * else: * value = PyUnicode_DecodeUTF8(buffer, size, 'strict') # <<<<<<<<<<<<<< * emitter.stream.write(value) * return 1 */ /*else*/ { __pyx_t_1 = PyUnicode_DecodeUTF8(__pyx_v_buffer, __pyx_v_size, ((char *)"strict")); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; } __pyx_L3:; /* "_ruamel_yaml.pyx":1524 * else: * value = PyUnicode_DecodeUTF8(buffer, size, 'strict') * emitter.stream.write(value) # <<<<<<<<<<<<<< * return 1 * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_emitter->stream, __pyx_n_s_write); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_value}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1524, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_value}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1524, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_value); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":1525 * value = PyUnicode_DecodeUTF8(buffer, size, 'strict') * emitter.stream.write(value) * return 1 # <<<<<<<<<<<<<< * */ __pyx_r = 1; goto __pyx_L0; /* "_ruamel_yaml.pyx":1517 * return 1 * * cdef int output_handler(void *data, char *buffer, int size) except 0: # <<<<<<<<<<<<<< * cdef CEmitter emitter * emitter = data */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_ruamel_yaml.output_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_emitter); __Pyx_XDECREF(__pyx_v_value); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * if __pyx_checksum != 0x3fa45b6: * from pickle import PickleError as __pyx_PickleError */ /* Python wrapper */ static PyObject *__pyx_pw_12_ruamel_yaml_5__pyx_unpickle_Mark(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_12_ruamel_yaml_5__pyx_unpickle_Mark = {"__pyx_unpickle_Mark", (PyCFunction)__pyx_pw_12_ruamel_yaml_5__pyx_unpickle_Mark, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_12_ruamel_yaml_5__pyx_unpickle_Mark(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_Mark (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Mark", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Mark", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Mark") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Mark", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_ruamel_yaml.__pyx_unpickle_Mark", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12_ruamel_yaml_4__pyx_unpickle_Mark(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12_ruamel_yaml_4__pyx_unpickle_Mark(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = NULL; PyObject *__pyx_v___pyx_result = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; __Pyx_RefNannySetupContext("__pyx_unpickle_Mark", 0); /* "(tree fragment)":2 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): * if __pyx_checksum != 0x3fa45b6: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) */ __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x3fa45b6) != 0); if (__pyx_t_1) { /* "(tree fragment)":3 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): * if __pyx_checksum != 0x3fa45b6: * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) * __pyx_result = Mark.__new__(__pyx_type) */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_2); __pyx_v___pyx_PickleError = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":4 * if __pyx_checksum != 0x3fa45b6: * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = Mark.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x3f, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_3); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":2 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): * if __pyx_checksum != 0x3fa45b6: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) */ } /* "(tree fragment)":5 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) * __pyx_result = Mark.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_12_ruamel_yaml_Mark), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_6) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v___pyx_type}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v___pyx_type}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL; __Pyx_INCREF(__pyx_v___pyx_type); __Pyx_GIVEREF(__pyx_v___pyx_type); PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v___pyx_type); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v___pyx_result = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":6 * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) * __pyx_result = Mark.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_1 = (__pyx_v___pyx_state != Py_None); __pyx_t_7 = (__pyx_t_1 != 0); if (__pyx_t_7) { /* "(tree fragment)":7 * __pyx_result = Mark.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 7, __pyx_L1_error) __pyx_t_3 = __pyx_f_12_ruamel_yaml___pyx_unpickle_Mark__set_state(((struct __pyx_obj_12_ruamel_yaml_Mark *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * raise __pyx_PickleError("Incompatible checksums (%s vs 0x3fa45b6 = (buffer, column, index, line, name, pointer))" % __pyx_checksum) * __pyx_result = Mark.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":8 * if __pyx_state is not None: * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * if __pyx_checksum != 0x3fa45b6: * from pickle import PickleError as __pyx_PickleError */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_ruamel_yaml.__pyx_unpickle_Mark", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":9 * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] * if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_12_ruamel_yaml___pyx_unpickle_Mark__set_state(struct __pyx_obj_12_ruamel_yaml_Mark *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("__pyx_unpickle_Mark__set_state", 0); /* "(tree fragment)":10 * return __pyx_result * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] # <<<<<<<<<<<<<< * if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[6]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 10, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->buffer); __Pyx_DECREF(__pyx_v___pyx_result->buffer); __pyx_v___pyx_result->buffer = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 10, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->column = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 10, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->index = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 10, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->line = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 10, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->name); __Pyx_DECREF(__pyx_v___pyx_result->name); __pyx_v___pyx_result->name = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 10, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->pointer); __Pyx_DECREF(__pyx_v___pyx_result->pointer); __pyx_v___pyx_result->pointer = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":11 * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] * if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[6]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 11, __pyx_L1_error) } __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 11, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 6) != 0); if (__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 11, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); __pyx_t_3 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_3) { /* "(tree fragment)":12 * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] * if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[6]) # <<<<<<<<<<<<<< */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_9) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_7}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_7}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_7); __pyx_t_7 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":11 * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] * if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[6]) */ } /* "(tree fragment)":9 * __pyx_unpickle_Mark__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Mark__set_state(Mark __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.buffer = __pyx_state[0]; __pyx_result.column = __pyx_state[1]; __pyx_result.index = __pyx_state[2]; __pyx_result.line = __pyx_state[3]; __pyx_result.name = __pyx_state[4]; __pyx_result.pointer = __pyx_state[5] * if len(__pyx_state) > 6 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("_ruamel_yaml.__pyx_unpickle_Mark__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_tp_new_12_ruamel_yaml_Mark(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_12_ruamel_yaml_Mark *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_12_ruamel_yaml_Mark *)o); p->name = Py_None; Py_INCREF(Py_None); p->buffer = Py_None; Py_INCREF(Py_None); p->pointer = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_12_ruamel_yaml_Mark(PyObject *o) { struct __pyx_obj_12_ruamel_yaml_Mark *p = (struct __pyx_obj_12_ruamel_yaml_Mark *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->name); Py_CLEAR(p->buffer); Py_CLEAR(p->pointer); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_12_ruamel_yaml_Mark(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_12_ruamel_yaml_Mark *p = (struct __pyx_obj_12_ruamel_yaml_Mark *)o; if (p->name) { e = (*v)(p->name, a); if (e) return e; } if (p->buffer) { e = (*v)(p->buffer, a); if (e) return e; } if (p->pointer) { e = (*v)(p->pointer, a); if (e) return e; } return 0; } static int __pyx_tp_clear_12_ruamel_yaml_Mark(PyObject *o) { PyObject* tmp; struct __pyx_obj_12_ruamel_yaml_Mark *p = (struct __pyx_obj_12_ruamel_yaml_Mark *)o; tmp = ((PyObject*)p->name); p->name = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->buffer); p->buffer = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->pointer); p->pointer = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_12_ruamel_yaml_4Mark_name(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_12_ruamel_yaml_4Mark_4name_1__get__(o); } static PyObject *__pyx_getprop_12_ruamel_yaml_4Mark_index(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_12_ruamel_yaml_4Mark_5index_1__get__(o); } static PyObject *__pyx_getprop_12_ruamel_yaml_4Mark_line(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_12_ruamel_yaml_4Mark_4line_1__get__(o); } static PyObject *__pyx_getprop_12_ruamel_yaml_4Mark_column(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_12_ruamel_yaml_4Mark_6column_1__get__(o); } static PyObject *__pyx_getprop_12_ruamel_yaml_4Mark_buffer(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_12_ruamel_yaml_4Mark_6buffer_1__get__(o); } static PyObject *__pyx_getprop_12_ruamel_yaml_4Mark_pointer(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_12_ruamel_yaml_4Mark_7pointer_1__get__(o); } static PyMethodDef __pyx_methods_12_ruamel_yaml_Mark[] = { {"get_snippet", (PyCFunction)__pyx_pw_12_ruamel_yaml_4Mark_3get_snippet, METH_NOARGS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_12_ruamel_yaml_4Mark_7__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_12_ruamel_yaml_4Mark_9__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_12_ruamel_yaml_Mark[] = { {(char *)"name", __pyx_getprop_12_ruamel_yaml_4Mark_name, 0, (char *)0, 0}, {(char *)"index", __pyx_getprop_12_ruamel_yaml_4Mark_index, 0, (char *)0, 0}, {(char *)"line", __pyx_getprop_12_ruamel_yaml_4Mark_line, 0, (char *)0, 0}, {(char *)"column", __pyx_getprop_12_ruamel_yaml_4Mark_column, 0, (char *)0, 0}, {(char *)"buffer", __pyx_getprop_12_ruamel_yaml_4Mark_buffer, 0, (char *)0, 0}, {(char *)"pointer", __pyx_getprop_12_ruamel_yaml_4Mark_pointer, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_12_ruamel_yaml_Mark = { PyVarObject_HEAD_INIT(0, 0) "_ruamel_yaml.Mark", /*tp_name*/ sizeof(struct __pyx_obj_12_ruamel_yaml_Mark), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_12_ruamel_yaml_Mark, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ __pyx_pw_12_ruamel_yaml_4Mark_5__str__, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_12_ruamel_yaml_Mark, /*tp_traverse*/ __pyx_tp_clear_12_ruamel_yaml_Mark, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_12_ruamel_yaml_Mark, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_12_ruamel_yaml_Mark, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_12_ruamel_yaml_4Mark_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_12_ruamel_yaml_Mark, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_12_ruamel_yaml_CParser __pyx_vtable_12_ruamel_yaml_CParser; static PyObject *__pyx_tp_new_12_ruamel_yaml_CParser(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_12_ruamel_yaml_CParser *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_12_ruamel_yaml_CParser *)o); p->__pyx_vtab = __pyx_vtabptr_12_ruamel_yaml_CParser; p->stream = Py_None; Py_INCREF(Py_None); p->stream_name = Py_None; Py_INCREF(Py_None); p->current_token = Py_None; Py_INCREF(Py_None); p->current_event = Py_None; Py_INCREF(Py_None); p->anchors = Py_None; Py_INCREF(Py_None); p->stream_cache = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_12_ruamel_yaml_CParser(PyObject *o) { struct __pyx_obj_12_ruamel_yaml_CParser *p = (struct __pyx_obj_12_ruamel_yaml_CParser *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); ++Py_REFCNT(o); __pyx_pw_12_ruamel_yaml_7CParser_3__dealloc__(o); --Py_REFCNT(o); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->stream); Py_CLEAR(p->stream_name); Py_CLEAR(p->current_token); Py_CLEAR(p->current_event); Py_CLEAR(p->anchors); Py_CLEAR(p->stream_cache); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_12_ruamel_yaml_CParser(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_12_ruamel_yaml_CParser *p = (struct __pyx_obj_12_ruamel_yaml_CParser *)o; if (p->stream) { e = (*v)(p->stream, a); if (e) return e; } if (p->stream_name) { e = (*v)(p->stream_name, a); if (e) return e; } if (p->current_token) { e = (*v)(p->current_token, a); if (e) return e; } if (p->current_event) { e = (*v)(p->current_event, a); if (e) return e; } if (p->anchors) { e = (*v)(p->anchors, a); if (e) return e; } if (p->stream_cache) { e = (*v)(p->stream_cache, a); if (e) return e; } return 0; } static int __pyx_tp_clear_12_ruamel_yaml_CParser(PyObject *o) { PyObject* tmp; struct __pyx_obj_12_ruamel_yaml_CParser *p = (struct __pyx_obj_12_ruamel_yaml_CParser *)o; tmp = ((PyObject*)p->stream); p->stream = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->stream_name); p->stream_name = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->current_token); p->current_token = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->current_event); p->current_event = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->anchors); p->anchors = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->stream_cache); p->stream_cache = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_12_ruamel_yaml_CParser[] = { {"dispose", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_5dispose, METH_NOARGS, 0}, {"raw_scan", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_7raw_scan, METH_NOARGS, 0}, {"get_token", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_9get_token, METH_NOARGS, 0}, {"peek_token", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_11peek_token, METH_NOARGS, 0}, {"check_token", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_13check_token, METH_VARARGS|METH_KEYWORDS, 0}, {"raw_parse", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_15raw_parse, METH_NOARGS, 0}, {"get_event", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_17get_event, METH_NOARGS, 0}, {"peek_event", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_19peek_event, METH_NOARGS, 0}, {"check_event", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_21check_event, METH_VARARGS|METH_KEYWORDS, 0}, {"check_node", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_23check_node, METH_NOARGS, 0}, {"get_node", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_25get_node, METH_NOARGS, 0}, {"get_single_node", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_27get_single_node, METH_NOARGS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_29__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_12_ruamel_yaml_7CParser_31__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_12_ruamel_yaml_CParser = { PyVarObject_HEAD_INIT(0, 0) "_ruamel_yaml.CParser", /*tp_name*/ sizeof(struct __pyx_obj_12_ruamel_yaml_CParser), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_12_ruamel_yaml_CParser, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_12_ruamel_yaml_CParser, /*tp_traverse*/ __pyx_tp_clear_12_ruamel_yaml_CParser, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_12_ruamel_yaml_CParser, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_12_ruamel_yaml_7CParser_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_12_ruamel_yaml_CParser, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_12_ruamel_yaml_CEmitter __pyx_vtable_12_ruamel_yaml_CEmitter; static PyObject *__pyx_tp_new_12_ruamel_yaml_CEmitter(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_12_ruamel_yaml_CEmitter *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_12_ruamel_yaml_CEmitter *)o); p->__pyx_vtab = __pyx_vtabptr_12_ruamel_yaml_CEmitter; p->stream = Py_None; Py_INCREF(Py_None); p->use_version = Py_None; Py_INCREF(Py_None); p->use_tags = Py_None; Py_INCREF(Py_None); p->serialized_nodes = Py_None; Py_INCREF(Py_None); p->anchors = Py_None; Py_INCREF(Py_None); p->use_encoding = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_12_ruamel_yaml_CEmitter(PyObject *o) { struct __pyx_obj_12_ruamel_yaml_CEmitter *p = (struct __pyx_obj_12_ruamel_yaml_CEmitter *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); ++Py_REFCNT(o); __pyx_pw_12_ruamel_yaml_8CEmitter_3__dealloc__(o); --Py_REFCNT(o); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->stream); Py_CLEAR(p->use_version); Py_CLEAR(p->use_tags); Py_CLEAR(p->serialized_nodes); Py_CLEAR(p->anchors); Py_CLEAR(p->use_encoding); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_12_ruamel_yaml_CEmitter(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_12_ruamel_yaml_CEmitter *p = (struct __pyx_obj_12_ruamel_yaml_CEmitter *)o; if (p->stream) { e = (*v)(p->stream, a); if (e) return e; } if (p->use_version) { e = (*v)(p->use_version, a); if (e) return e; } if (p->use_tags) { e = (*v)(p->use_tags, a); if (e) return e; } if (p->serialized_nodes) { e = (*v)(p->serialized_nodes, a); if (e) return e; } if (p->anchors) { e = (*v)(p->anchors, a); if (e) return e; } if (p->use_encoding) { e = (*v)(p->use_encoding, a); if (e) return e; } return 0; } static int __pyx_tp_clear_12_ruamel_yaml_CEmitter(PyObject *o) { PyObject* tmp; struct __pyx_obj_12_ruamel_yaml_CEmitter *p = (struct __pyx_obj_12_ruamel_yaml_CEmitter *)o; tmp = ((PyObject*)p->stream); p->stream = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->use_version); p->use_version = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->use_tags); p->use_tags = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->serialized_nodes); p->serialized_nodes = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->anchors); p->anchors = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->use_encoding); p->use_encoding = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_12_ruamel_yaml_CEmitter[] = { {"dispose", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_5dispose, METH_NOARGS, 0}, {"emit", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_7emit, METH_O, 0}, {"open", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_9open, METH_NOARGS, 0}, {"close", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_11close, METH_NOARGS, 0}, {"serialize", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_13serialize, METH_O, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_15__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_12_ruamel_yaml_8CEmitter_17__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_12_ruamel_yaml_CEmitter = { PyVarObject_HEAD_INIT(0, 0) "_ruamel_yaml.CEmitter", /*tp_name*/ sizeof(struct __pyx_obj_12_ruamel_yaml_CEmitter), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_12_ruamel_yaml_CEmitter, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_12_ruamel_yaml_CEmitter, /*tp_traverse*/ __pyx_tp_clear_12_ruamel_yaml_CEmitter, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_12_ruamel_yaml_CEmitter, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_12_ruamel_yaml_8CEmitter_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_12_ruamel_yaml_CEmitter, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__ruamel_yaml(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__ruamel_yaml}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_ruamel_yaml", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_AliasEvent, __pyx_k_AliasEvent, sizeof(__pyx_k_AliasEvent), 0, 0, 1, 1}, {&__pyx_n_s_AliasToken, __pyx_k_AliasToken, sizeof(__pyx_k_AliasToken), 0, 0, 1, 1}, {&__pyx_n_s_AnchorToken, __pyx_k_AnchorToken, sizeof(__pyx_k_AnchorToken), 0, 0, 1, 1}, {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1}, {&__pyx_n_s_BlockEndToken, __pyx_k_BlockEndToken, sizeof(__pyx_k_BlockEndToken), 0, 0, 1, 1}, {&__pyx_n_s_BlockEntryToken, __pyx_k_BlockEntryToken, sizeof(__pyx_k_BlockEntryToken), 0, 0, 1, 1}, {&__pyx_n_s_BlockMappingStartToken, __pyx_k_BlockMappingStartToken, sizeof(__pyx_k_BlockMappingStartToken), 0, 0, 1, 1}, {&__pyx_n_s_BlockSequenceStartToken, __pyx_k_BlockSequenceStartToken, sizeof(__pyx_k_BlockSequenceStartToken), 0, 0, 1, 1}, {&__pyx_n_s_ComposerError, __pyx_k_ComposerError, sizeof(__pyx_k_ComposerError), 0, 0, 1, 1}, {&__pyx_n_s_ConstructorError, __pyx_k_ConstructorError, sizeof(__pyx_k_ConstructorError), 0, 0, 1, 1}, {&__pyx_n_s_DirectiveToken, __pyx_k_DirectiveToken, sizeof(__pyx_k_DirectiveToken), 0, 0, 1, 1}, {&__pyx_n_s_DocumentEndEvent, __pyx_k_DocumentEndEvent, sizeof(__pyx_k_DocumentEndEvent), 0, 0, 1, 1}, {&__pyx_n_s_DocumentEndToken, __pyx_k_DocumentEndToken, sizeof(__pyx_k_DocumentEndToken), 0, 0, 1, 1}, {&__pyx_n_s_DocumentStartEvent, __pyx_k_DocumentStartEvent, sizeof(__pyx_k_DocumentStartEvent), 0, 0, 1, 1}, {&__pyx_n_s_DocumentStartToken, __pyx_k_DocumentStartToken, sizeof(__pyx_k_DocumentStartToken), 0, 0, 1, 1}, {&__pyx_n_s_EmitterError, __pyx_k_EmitterError, sizeof(__pyx_k_EmitterError), 0, 0, 1, 1}, {&__pyx_n_s_FlowEntryToken, __pyx_k_FlowEntryToken, sizeof(__pyx_k_FlowEntryToken), 0, 0, 1, 1}, {&__pyx_n_s_FlowMappingEndToken, __pyx_k_FlowMappingEndToken, sizeof(__pyx_k_FlowMappingEndToken), 0, 0, 1, 1}, {&__pyx_n_s_FlowMappingStartToken, __pyx_k_FlowMappingStartToken, sizeof(__pyx_k_FlowMappingStartToken), 0, 0, 1, 1}, {&__pyx_n_s_FlowSequenceEndToken, __pyx_k_FlowSequenceEndToken, sizeof(__pyx_k_FlowSequenceEndToken), 0, 0, 1, 1}, {&__pyx_n_s_FlowSequenceStartToken, __pyx_k_FlowSequenceStartToken, sizeof(__pyx_k_FlowSequenceStartToken), 0, 0, 1, 1}, {&__pyx_kp_s_Incompatible_checksums_s_vs_0x3f, __pyx_k_Incompatible_checksums_s_vs_0x3f, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x3f), 0, 0, 1, 0}, {&__pyx_n_s_KeyToken, __pyx_k_KeyToken, sizeof(__pyx_k_KeyToken), 0, 0, 1, 1}, {&__pyx_n_s_MappingEndEvent, __pyx_k_MappingEndEvent, sizeof(__pyx_k_MappingEndEvent), 0, 0, 1, 1}, {&__pyx_n_s_MappingNode, __pyx_k_MappingNode, sizeof(__pyx_k_MappingNode), 0, 0, 1, 1}, {&__pyx_n_s_MappingStartEvent, __pyx_k_MappingStartEvent, sizeof(__pyx_k_MappingStartEvent), 0, 0, 1, 1}, {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, {&__pyx_n_s_ParserError, __pyx_k_ParserError, sizeof(__pyx_k_ParserError), 0, 0, 1, 1}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_kp_s_Pickling_of_struct_members_such, __pyx_k_Pickling_of_struct_members_such, sizeof(__pyx_k_Pickling_of_struct_members_such), 0, 0, 1, 0}, {&__pyx_n_s_ReaderError, __pyx_k_ReaderError, sizeof(__pyx_k_ReaderError), 0, 0, 1, 1}, {&__pyx_n_s_RepresenterError, __pyx_k_RepresenterError, sizeof(__pyx_k_RepresenterError), 0, 0, 1, 1}, {&__pyx_n_s_ScalarEvent, __pyx_k_ScalarEvent, sizeof(__pyx_k_ScalarEvent), 0, 0, 1, 1}, {&__pyx_n_s_ScalarNode, __pyx_k_ScalarNode, sizeof(__pyx_k_ScalarNode), 0, 0, 1, 1}, {&__pyx_n_s_ScalarToken, __pyx_k_ScalarToken, sizeof(__pyx_k_ScalarToken), 0, 0, 1, 1}, {&__pyx_n_s_ScannerError, __pyx_k_ScannerError, sizeof(__pyx_k_ScannerError), 0, 0, 1, 1}, {&__pyx_n_s_SequenceEndEvent, __pyx_k_SequenceEndEvent, sizeof(__pyx_k_SequenceEndEvent), 0, 0, 1, 1}, {&__pyx_n_s_SequenceNode, __pyx_k_SequenceNode, sizeof(__pyx_k_SequenceNode), 0, 0, 1, 1}, {&__pyx_n_s_SequenceStartEvent, __pyx_k_SequenceStartEvent, sizeof(__pyx_k_SequenceStartEvent), 0, 0, 1, 1}, {&__pyx_n_s_SerializerError, __pyx_k_SerializerError, sizeof(__pyx_k_SerializerError), 0, 0, 1, 1}, {&__pyx_n_s_StreamEndEvent, __pyx_k_StreamEndEvent, sizeof(__pyx_k_StreamEndEvent), 0, 0, 1, 1}, {&__pyx_n_s_StreamEndToken, __pyx_k_StreamEndToken, sizeof(__pyx_k_StreamEndToken), 0, 0, 1, 1}, {&__pyx_n_s_StreamStartEvent, __pyx_k_StreamStartEvent, sizeof(__pyx_k_StreamStartEvent), 0, 0, 1, 1}, {&__pyx_n_s_StreamStartToken, __pyx_k_StreamStartToken, sizeof(__pyx_k_StreamStartToken), 0, 0, 1, 1}, {&__pyx_n_u_TAG, __pyx_k_TAG, sizeof(__pyx_k_TAG), 0, 1, 0, 1}, {&__pyx_n_s_TagToken, __pyx_k_TagToken, sizeof(__pyx_k_TagToken), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_ValueToken, __pyx_k_ValueToken, sizeof(__pyx_k_ValueToken), 0, 0, 1, 1}, {&__pyx_n_u_YAML, __pyx_k_YAML, sizeof(__pyx_k_YAML), 0, 1, 0, 1}, {&__pyx_n_s_YAMLError, __pyx_k_YAMLError, sizeof(__pyx_k_YAMLError), 0, 0, 1, 1}, {&__pyx_kp_s__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 0, 1, 0}, {&__pyx_kp_u__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 1, 0, 0}, {&__pyx_kp_s__19, __pyx_k__19, sizeof(__pyx_k__19), 0, 0, 1, 0}, {&__pyx_kp_s__20, __pyx_k__20, sizeof(__pyx_k__20), 0, 0, 1, 0}, {&__pyx_kp_s__21, __pyx_k__21, sizeof(__pyx_k__21), 0, 0, 1, 0}, {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, {&__pyx_kp_u__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0, 0}, {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, {&__pyx_kp_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 0}, {&__pyx_kp_u__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0, 0}, {&__pyx_kp_s__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 1, 0}, {&__pyx_kp_u__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 1, 0, 0}, {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 0}, {&__pyx_kp_u__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 1, 0, 0}, {&__pyx_kp_s_a_string_or_stream_input_is_requ, __pyx_k_a_string_or_stream_input_is_requ, sizeof(__pyx_k_a_string_or_stream_input_is_requ), 0, 0, 1, 0}, {&__pyx_kp_u_a_string_or_stream_input_is_requ, __pyx_k_a_string_or_stream_input_is_requ, sizeof(__pyx_k_a_string_or_stream_input_is_requ), 0, 1, 0, 0}, {&__pyx_kp_s_a_string_value_is_expected, __pyx_k_a_string_value_is_expected, sizeof(__pyx_k_a_string_value_is_expected), 0, 0, 1, 0}, {&__pyx_kp_u_a_string_value_is_expected, __pyx_k_a_string_value_is_expected, sizeof(__pyx_k_a_string_value_is_expected), 0, 1, 0, 0}, {&__pyx_n_s_allow_unicode, __pyx_k_allow_unicode, sizeof(__pyx_k_allow_unicode), 0, 0, 1, 1}, {&__pyx_n_s_anchor, __pyx_k_anchor, sizeof(__pyx_k_anchor), 0, 0, 1, 1}, {&__pyx_kp_s_anchor_must_be_a_string, __pyx_k_anchor_must_be_a_string, sizeof(__pyx_k_anchor_must_be_a_string), 0, 0, 1, 0}, {&__pyx_kp_u_anchor_must_be_a_string, __pyx_k_anchor_must_be_a_string, sizeof(__pyx_k_anchor_must_be_a_string), 0, 1, 0, 0}, {&__pyx_n_s_ascend_resolver, __pyx_k_ascend_resolver, sizeof(__pyx_k_ascend_resolver), 0, 0, 1, 1}, {&__pyx_n_s_buffer, __pyx_k_buffer, sizeof(__pyx_k_buffer), 0, 0, 1, 1}, {&__pyx_kp_s_but_found_another_document, __pyx_k_but_found_another_document, sizeof(__pyx_k_but_found_another_document), 0, 0, 1, 0}, {&__pyx_kp_u_but_found_another_document, __pyx_k_but_found_another_document, sizeof(__pyx_k_but_found_another_document), 0, 1, 0, 0}, {&__pyx_kp_s_byte_string, __pyx_k_byte_string, sizeof(__pyx_k_byte_string), 0, 0, 1, 0}, {&__pyx_kp_u_byte_string, __pyx_k_byte_string, sizeof(__pyx_k_byte_string), 0, 1, 0, 0}, {&__pyx_n_s_canonical, __pyx_k_canonical, sizeof(__pyx_k_canonical), 0, 0, 1, 1}, {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_column, __pyx_k_column, sizeof(__pyx_k_column), 0, 0, 1, 1}, {&__pyx_n_s_descend_resolver, __pyx_k_descend_resolver, sizeof(__pyx_k_descend_resolver), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_encoding, __pyx_k_encoding, sizeof(__pyx_k_encoding), 0, 0, 1, 1}, {&__pyx_n_u_encoding, __pyx_k_encoding, sizeof(__pyx_k_encoding), 0, 1, 0, 1}, {&__pyx_n_s_end_mark, __pyx_k_end_mark, sizeof(__pyx_k_end_mark), 0, 0, 1, 1}, {&__pyx_kp_s_expected_a_single_document_in_th, __pyx_k_expected_a_single_document_in_th, sizeof(__pyx_k_expected_a_single_document_in_th), 0, 0, 1, 0}, {&__pyx_kp_u_expected_a_single_document_in_th, __pyx_k_expected_a_single_document_in_th, sizeof(__pyx_k_expected_a_single_document_in_th), 0, 1, 0, 0}, {&__pyx_n_s_explicit, __pyx_k_explicit, sizeof(__pyx_k_explicit), 0, 0, 1, 1}, {&__pyx_n_s_explicit_end, __pyx_k_explicit_end, sizeof(__pyx_k_explicit_end), 0, 0, 1, 1}, {&__pyx_n_s_explicit_start, __pyx_k_explicit_start, sizeof(__pyx_k_explicit_start), 0, 0, 1, 1}, {&__pyx_kp_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 0}, {&__pyx_kp_u_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 1, 0, 0}, {&__pyx_n_s_flow_style, __pyx_k_flow_style, sizeof(__pyx_k_flow_style), 0, 0, 1, 1}, {&__pyx_kp_s_found_duplicate_anchor_first_occ, __pyx_k_found_duplicate_anchor_first_occ, sizeof(__pyx_k_found_duplicate_anchor_first_occ), 0, 0, 1, 0}, {&__pyx_kp_u_found_duplicate_anchor_first_occ, __pyx_k_found_duplicate_anchor_first_occ, sizeof(__pyx_k_found_duplicate_anchor_first_occ), 0, 1, 0, 0}, {&__pyx_kp_s_found_undefined_alias, __pyx_k_found_undefined_alias, sizeof(__pyx_k_found_undefined_alias), 0, 0, 1, 0}, {&__pyx_kp_u_found_undefined_alias, __pyx_k_found_undefined_alias, sizeof(__pyx_k_found_undefined_alias), 0, 1, 0, 0}, {&__pyx_n_s_get_version, __pyx_k_get_version, sizeof(__pyx_k_get_version), 0, 0, 1, 1}, {&__pyx_n_s_get_version_string, __pyx_k_get_version_string, sizeof(__pyx_k_get_version_string), 0, 0, 1, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_kp_u_id_03d, __pyx_k_id_03d, sizeof(__pyx_k_id_03d), 0, 1, 0, 0}, {&__pyx_n_s_implicit, __pyx_k_implicit, sizeof(__pyx_k_implicit), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_kp_s_in_s_line_d_column_d, __pyx_k_in_s_line_d_column_d, sizeof(__pyx_k_in_s_line_d_column_d), 0, 0, 1, 0}, {&__pyx_n_s_indent, __pyx_k_indent, sizeof(__pyx_k_indent), 0, 0, 1, 1}, {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, {&__pyx_kp_s_invalid_event_s, __pyx_k_invalid_event_s, sizeof(__pyx_k_invalid_event_s), 0, 0, 1, 0}, {&__pyx_kp_u_invalid_event_s, __pyx_k_invalid_event_s, sizeof(__pyx_k_invalid_event_s), 0, 1, 0, 0}, {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 0, 1, 1}, {&__pyx_n_s_line_break, __pyx_k_line_break, sizeof(__pyx_k_line_break), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_major, __pyx_k_major, sizeof(__pyx_k_major), 0, 0, 1, 1}, {&__pyx_n_s_minor, __pyx_k_minor, sizeof(__pyx_k_minor), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_kp_s_no_emitter_error, __pyx_k_no_emitter_error, sizeof(__pyx_k_no_emitter_error), 0, 0, 1, 0}, {&__pyx_kp_u_no_emitter_error, __pyx_k_no_emitter_error, sizeof(__pyx_k_no_emitter_error), 0, 1, 0, 0}, {&__pyx_kp_s_no_parser_error, __pyx_k_no_parser_error, sizeof(__pyx_k_no_parser_error), 0, 0, 1, 0}, {&__pyx_kp_u_no_parser_error, __pyx_k_no_parser_error, sizeof(__pyx_k_no_parser_error), 0, 1, 0, 0}, {&__pyx_n_s_patch, __pyx_k_patch, sizeof(__pyx_k_patch), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_pointer, __pyx_k_pointer, sizeof(__pyx_k_pointer), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_Mark, __pyx_k_pyx_unpickle_Mark, sizeof(__pyx_k_pyx_unpickle_Mark), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_resolve, __pyx_k_resolve, sizeof(__pyx_k_resolve), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml, __pyx_k_ruamel_yaml, sizeof(__pyx_k_ruamel_yaml), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_composer, __pyx_k_ruamel_yaml_composer, sizeof(__pyx_k_ruamel_yaml_composer), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_constructor, __pyx_k_ruamel_yaml_constructor, sizeof(__pyx_k_ruamel_yaml_constructor), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_emitter, __pyx_k_ruamel_yaml_emitter, sizeof(__pyx_k_ruamel_yaml_emitter), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_error, __pyx_k_ruamel_yaml_error, sizeof(__pyx_k_ruamel_yaml_error), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_events, __pyx_k_ruamel_yaml_events, sizeof(__pyx_k_ruamel_yaml_events), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_nodes, __pyx_k_ruamel_yaml_nodes, sizeof(__pyx_k_ruamel_yaml_nodes), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_parser, __pyx_k_ruamel_yaml_parser, sizeof(__pyx_k_ruamel_yaml_parser), 0, 0, 1, 1}, {&__pyx_kp_s_ruamel_yaml_pyx, __pyx_k_ruamel_yaml_pyx, sizeof(__pyx_k_ruamel_yaml_pyx), 0, 0, 1, 0}, {&__pyx_n_s_ruamel_yaml_reader, __pyx_k_ruamel_yaml_reader, sizeof(__pyx_k_ruamel_yaml_reader), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_representer, __pyx_k_ruamel_yaml_representer, sizeof(__pyx_k_ruamel_yaml_representer), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_scanner, __pyx_k_ruamel_yaml_scanner, sizeof(__pyx_k_ruamel_yaml_scanner), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_serializer, __pyx_k_ruamel_yaml_serializer, sizeof(__pyx_k_ruamel_yaml_serializer), 0, 0, 1, 1}, {&__pyx_n_s_ruamel_yaml_tokens, __pyx_k_ruamel_yaml_tokens, sizeof(__pyx_k_ruamel_yaml_tokens), 0, 0, 1, 1}, {&__pyx_kp_s_second_occurrence, __pyx_k_second_occurrence, sizeof(__pyx_k_second_occurrence), 0, 0, 1, 0}, {&__pyx_kp_u_second_occurrence, __pyx_k_second_occurrence, sizeof(__pyx_k_second_occurrence), 0, 1, 0, 0}, {&__pyx_kp_s_self_parsed_event_cannot_be_conv, __pyx_k_self_parsed_event_cannot_be_conv, sizeof(__pyx_k_self_parsed_event_cannot_be_conv), 0, 0, 1, 0}, {&__pyx_kp_s_serializer_is_already_opened, __pyx_k_serializer_is_already_opened, sizeof(__pyx_k_serializer_is_already_opened), 0, 0, 1, 0}, {&__pyx_kp_u_serializer_is_already_opened, __pyx_k_serializer_is_already_opened, sizeof(__pyx_k_serializer_is_already_opened), 0, 1, 0, 0}, {&__pyx_kp_s_serializer_is_closed, __pyx_k_serializer_is_closed, sizeof(__pyx_k_serializer_is_closed), 0, 0, 1, 0}, {&__pyx_kp_u_serializer_is_closed, __pyx_k_serializer_is_closed, sizeof(__pyx_k_serializer_is_closed), 0, 1, 0, 0}, {&__pyx_kp_s_serializer_is_not_opened, __pyx_k_serializer_is_not_opened, sizeof(__pyx_k_serializer_is_not_opened), 0, 0, 1, 0}, {&__pyx_kp_u_serializer_is_not_opened, __pyx_k_serializer_is_not_opened, sizeof(__pyx_k_serializer_is_not_opened), 0, 1, 0, 0}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_start_mark, __pyx_k_start_mark, sizeof(__pyx_k_start_mark), 0, 0, 1, 1}, {&__pyx_n_s_stream, __pyx_k_stream, sizeof(__pyx_k_stream), 0, 0, 1, 1}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_style, __pyx_k_style, sizeof(__pyx_k_style), 0, 0, 1, 1}, {&__pyx_n_s_tag, __pyx_k_tag, sizeof(__pyx_k_tag), 0, 0, 1, 1}, {&__pyx_kp_s_tag_handle_must_be_a_string, __pyx_k_tag_handle_must_be_a_string, sizeof(__pyx_k_tag_handle_must_be_a_string), 0, 0, 1, 0}, {&__pyx_kp_u_tag_handle_must_be_a_string, __pyx_k_tag_handle_must_be_a_string, sizeof(__pyx_k_tag_handle_must_be_a_string), 0, 1, 0, 0}, {&__pyx_kp_s_tag_must_be_a_string, __pyx_k_tag_must_be_a_string, sizeof(__pyx_k_tag_must_be_a_string), 0, 0, 1, 0}, {&__pyx_kp_u_tag_must_be_a_string, __pyx_k_tag_must_be_a_string, sizeof(__pyx_k_tag_must_be_a_string), 0, 1, 0, 0}, {&__pyx_kp_s_tag_prefix_must_be_a_string, __pyx_k_tag_prefix_must_be_a_string, sizeof(__pyx_k_tag_prefix_must_be_a_string), 0, 0, 1, 0}, {&__pyx_kp_u_tag_prefix_must_be_a_string, __pyx_k_tag_prefix_must_be_a_string, sizeof(__pyx_k_tag_prefix_must_be_a_string), 0, 1, 0, 0}, {&__pyx_n_s_tags, __pyx_k_tags, sizeof(__pyx_k_tags), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_s_too_many_tags, __pyx_k_too_many_tags, sizeof(__pyx_k_too_many_tags), 0, 0, 1, 0}, {&__pyx_kp_u_too_many_tags, __pyx_k_too_many_tags, sizeof(__pyx_k_too_many_tags), 0, 1, 0, 0}, {&__pyx_kp_s_unicode_string, __pyx_k_unicode_string, sizeof(__pyx_k_unicode_string), 0, 0, 1, 0}, {&__pyx_kp_u_unicode_string, __pyx_k_unicode_string, sizeof(__pyx_k_unicode_string), 0, 1, 0, 0}, {&__pyx_kp_s_unknown_event_type, __pyx_k_unknown_event_type, sizeof(__pyx_k_unknown_event_type), 0, 0, 1, 0}, {&__pyx_kp_u_unknown_event_type, __pyx_k_unknown_event_type, sizeof(__pyx_k_unknown_event_type), 0, 1, 0, 0}, {&__pyx_kp_s_unknown_token_type, __pyx_k_unknown_token_type, sizeof(__pyx_k_unknown_token_type), 0, 0, 1, 0}, {&__pyx_kp_u_unknown_token_type, __pyx_k_unknown_token_type, sizeof(__pyx_k_unknown_token_type), 0, 1, 0, 0}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_kp_s_utf_16_be, __pyx_k_utf_16_be, sizeof(__pyx_k_utf_16_be), 0, 0, 1, 0}, {&__pyx_kp_u_utf_16_be, __pyx_k_utf_16_be, sizeof(__pyx_k_utf_16_be), 0, 1, 0, 0}, {&__pyx_kp_s_utf_16_le, __pyx_k_utf_16_le, sizeof(__pyx_k_utf_16_le), 0, 0, 1, 0}, {&__pyx_kp_u_utf_16_le, __pyx_k_utf_16_le, sizeof(__pyx_k_utf_16_le), 0, 1, 0, 0}, {&__pyx_kp_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 0}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_kp_s_value_must_be_a_string, __pyx_k_value_must_be_a_string, sizeof(__pyx_k_value_must_be_a_string), 0, 0, 1, 0}, {&__pyx_kp_u_value_must_be_a_string, __pyx_k_value_must_be_a_string, sizeof(__pyx_k_value_must_be_a_string), 0, 1, 0, 0}, {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1}, {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 264, __pyx_L1_error) __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 269, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 300, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 355, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "_ruamel_yaml.pyx":300 * if PyString_CheckExact(stream) == 0: * if PY_MAJOR_VERSION < 3: * raise TypeError("a string or stream input is required") # <<<<<<<<<<<<<< * else: * raise TypeError(u"a string or stream input is required") */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_a_string_or_stream_input_is_requ); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "_ruamel_yaml.pyx":302 * raise TypeError("a string or stream input is required") * else: * raise TypeError(u"a string or stream input is required") # <<<<<<<<<<<<<< * self.stream = stream * yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_a_string_or_stream_input_is_requ); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "_ruamel_yaml.pyx":355 * return ParserError(context, context_mark, problem, problem_mark) * if PY_MAJOR_VERSION < 3: * raise ValueError("no parser error") # <<<<<<<<<<<<<< * else: * raise ValueError(u"no parser error") */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_no_parser_error); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "_ruamel_yaml.pyx":357 * raise ValueError("no parser error") * else: * raise ValueError(u"no parser error") # <<<<<<<<<<<<<< * * def raw_scan(self): */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_no_parser_error); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 357, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "_ruamel_yaml.pyx":478 * else: * if PY_MAJOR_VERSION < 3: * raise ValueError("unknown token type") # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown token type") */ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_unknown_token_type); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "_ruamel_yaml.pyx":480 * raise ValueError("unknown token type") * else: * raise ValueError(u"unknown token type") # <<<<<<<<<<<<<< * * def get_token(self): */ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_unknown_token_type); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "_ruamel_yaml.pyx":656 * else: * if PY_MAJOR_VERSION < 3: * raise ValueError("unknown event type") # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown event type") */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_unknown_event_type); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 656, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "_ruamel_yaml.pyx":658 * raise ValueError("unknown event type") * else: * raise ValueError(u"unknown event type") # <<<<<<<<<<<<<< * * def get_event(self): */ __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_unknown_event_type); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") */ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_self_parsed_event_cannot_be_conv); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "(tree fragment)":4 * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.parsed_event cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_self_parsed_event_cannot_be_conv); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "_ruamel_yaml.pyx":917 * if PyString_CheckExact(value) == 0: * if PY_MAJOR_VERSION < 3: * raise TypeError("a string value is expected") # <<<<<<<<<<<<<< * else: * raise TypeError(u"a string value is expected") */ __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_a_string_value_is_expected); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "_ruamel_yaml.pyx":919 * raise TypeError("a string value is expected") * else: * raise TypeError(u"a string value is expected") # <<<<<<<<<<<<<< * parser.stream_cache = value * parser.stream_cache_pos = 0 */ __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_u_a_string_value_is_expected); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 919, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "_ruamel_yaml.pyx":1011 * return EmitterError(problem) * if PY_MAJOR_VERSION < 3: * raise ValueError("no emitter error") # <<<<<<<<<<<<<< * else: * raise ValueError(u"no emitter error") */ __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_no_emitter_error); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 1011, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "_ruamel_yaml.pyx":1013 * raise ValueError("no emitter error") * else: * raise ValueError(u"no emitter error") # <<<<<<<<<<<<<< * * cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: */ __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_no_emitter_error); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "_ruamel_yaml.pyx":1057 * if len(event_object.tags) > 128: * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") # <<<<<<<<<<<<<< * else: * raise ValueError(u"too many tags") */ __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_too_many_tags); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 1057, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "_ruamel_yaml.pyx":1059 * raise ValueError("too many tags") * else: * raise ValueError(u"too many tags") # <<<<<<<<<<<<<< * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value */ __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_too_many_tags); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 1059, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "_ruamel_yaml.pyx":1070 * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag handle must be a string") */ __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 1070, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); /* "_ruamel_yaml.pyx":1072 * raise TypeError("tag handle must be a string") * else: * raise TypeError(u"tag handle must be a string") # <<<<<<<<<<<<<< * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): */ __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_u_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); /* "_ruamel_yaml.pyx":1079 * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag prefix must be a string") */ __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 1079, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); /* "_ruamel_yaml.pyx":1081 * raise TypeError("tag prefix must be a string") * else: * raise TypeError(u"tag prefix must be a string") # <<<<<<<<<<<<<< * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 */ __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_u_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 1081, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); /* "_ruamel_yaml.pyx":1102 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 1102, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "_ruamel_yaml.pyx":1104 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * if yaml_alias_event_initialize(event, anchor) == 0: */ __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 1104, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "_ruamel_yaml.pyx":1116 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 1116, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); /* "_ruamel_yaml.pyx":1118 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * tag = NULL */ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 1118, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); /* "_ruamel_yaml.pyx":1127 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 1127, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "_ruamel_yaml.pyx":1129 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * value_object = event_object.value */ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 1129, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); /* "_ruamel_yaml.pyx":1136 * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"value must be a string") */ __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_value_must_be_a_string); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 1136, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); /* "_ruamel_yaml.pyx":1138 * raise TypeError("value must be a string") * else: * raise TypeError(u"value must be a string") # <<<<<<<<<<<<<< * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) */ __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_value_must_be_a_string); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 1138, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__37); __Pyx_GIVEREF(__pyx_tuple__37); /* "_ruamel_yaml.pyx":1167 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 1167, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "_ruamel_yaml.pyx":1169 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * tag = NULL */ __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 1169, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__39); __Pyx_GIVEREF(__pyx_tuple__39); /* "_ruamel_yaml.pyx":1178 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 1178, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); /* "_ruamel_yaml.pyx":1180 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * implicit = 0 */ __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 1180, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); /* "_ruamel_yaml.pyx":1199 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 1199, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); /* "_ruamel_yaml.pyx":1201 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * tag = NULL */ __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 1201, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "_ruamel_yaml.pyx":1210 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 1210, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); /* "_ruamel_yaml.pyx":1212 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * implicit = 0 */ __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 1212, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); /* "_ruamel_yaml.pyx":1262 * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is closed") */ __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_closed); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 1262, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); /* "_ruamel_yaml.pyx":1264 * raise SerializerError("serializer is closed") * else: * raise SerializerError(u"serializer is closed") # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_closed); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 1264, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); /* "_ruamel_yaml.pyx":1267 * else: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is already opened") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is already opened") */ __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_already_opened); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 1267, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); /* "_ruamel_yaml.pyx":1269 * raise SerializerError("serializer is already opened") * else: * raise SerializerError(u"serializer is already opened") # <<<<<<<<<<<<<< * * def close(self): */ __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_already_opened); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 1269, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__49); __Pyx_GIVEREF(__pyx_tuple__49); /* "_ruamel_yaml.pyx":1275 * if self.closed == -1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is not opened") */ __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_not_opened); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 1275, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__50); __Pyx_GIVEREF(__pyx_tuple__50); /* "_ruamel_yaml.pyx":1277 * raise SerializerError("serializer is not opened") * else: * raise SerializerError(u"serializer is not opened") # <<<<<<<<<<<<<< * elif self.closed == 0: * yaml_stream_end_event_initialize(&event) */ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_not_opened); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 1277, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); /* "_ruamel_yaml.pyx":1294 * if self.closed == -1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is not opened") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is not opened") */ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_not_opened); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); /* "_ruamel_yaml.pyx":1296 * raise SerializerError("serializer is not opened") * else: * raise SerializerError(u"serializer is not opened") # <<<<<<<<<<<<<< * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: */ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_not_opened); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 1296, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "_ruamel_yaml.pyx":1299 * elif self.closed == 1: * if PY_MAJOR_VERSION < 3: * raise SerializerError("serializer is closed") # <<<<<<<<<<<<<< * else: * raise SerializerError(u"serializer is closed") */ __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_closed); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 1299, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); /* "_ruamel_yaml.pyx":1301 * raise SerializerError("serializer is closed") * else: * raise SerializerError(u"serializer is closed") # <<<<<<<<<<<<<< * cache = [] * version_directive = NULL */ __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_closed); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 1301, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "_ruamel_yaml.pyx":1313 * if len(self.use_tags) > 128: * if PY_MAJOR_VERSION < 3: * raise ValueError("too many tags") # <<<<<<<<<<<<<< * else: * raise ValueError(u"too many tags") */ __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_s_too_many_tags); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 1313, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "_ruamel_yaml.pyx":1315 * raise ValueError("too many tags") * else: * raise ValueError(u"too many tags") # <<<<<<<<<<<<<< * tag_directives_start = tag_directives_value * tag_directives_end = tag_directives_value */ __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_too_many_tags); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 1315, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); /* "_ruamel_yaml.pyx":1325 * if not PyString_CheckExact(handle): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag handle must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag handle must be a string") */ __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_s_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 1325, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); /* "_ruamel_yaml.pyx":1327 * raise TypeError("tag handle must be a string") * else: * raise TypeError(u"tag handle must be a string") # <<<<<<<<<<<<<< * tag_directives_end.handle = PyString_AS_STRING(handle) * if PyUnicode_CheckExact(prefix): */ __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 1327, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); /* "_ruamel_yaml.pyx":1334 * if not PyString_CheckExact(prefix): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag prefix must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag prefix must be a string") */ __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 1334, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__60); __Pyx_GIVEREF(__pyx_tuple__60); /* "_ruamel_yaml.pyx":1336 * raise TypeError("tag prefix must be a string") * else: * raise TypeError(u"tag prefix must be a string") # <<<<<<<<<<<<<< * tag_directives_end.prefix = PyString_AS_STRING(prefix) * tag_directives_end = tag_directives_end+1 */ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_u_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 1336, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); /* "_ruamel_yaml.pyx":1393 * if not PyString_CheckExact(anchor_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("anchor must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"anchor must be a string") */ __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 1393, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); /* "_ruamel_yaml.pyx":1395 * raise TypeError("anchor must be a string") * else: * raise TypeError(u"anchor must be a string") # <<<<<<<<<<<<<< * anchor = PyString_AS_STRING(anchor_object) * if node in self.serialized_nodes: */ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 1395, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); /* "_ruamel_yaml.pyx":1411 * quoted_implicit = 0 * tag_object = node.tag * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: # <<<<<<<<<<<<<< * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: */ __pyx_tuple__64 = PyTuple_Pack(2, Py_True, Py_False); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); /* "_ruamel_yaml.pyx":1413 * if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: * plain_implicit = 1 * if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: # <<<<<<<<<<<<<< * quoted_implicit = 1 * tag = NULL */ __pyx_tuple__65 = PyTuple_Pack(2, Py_False, Py_True); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); /* "_ruamel_yaml.pyx":1421 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); /* "_ruamel_yaml.pyx":1423 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * value_object = node.value */ __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 1423, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); /* "_ruamel_yaml.pyx":1430 * if not PyString_CheckExact(value_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("value must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"value must be a string") */ __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_s_value_must_be_a_string); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 1430, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); /* "_ruamel_yaml.pyx":1432 * raise TypeError("value must be a string") * else: * raise TypeError(u"value must be a string") # <<<<<<<<<<<<<< * value = PyString_AS_STRING(value_object) * length = PyString_GET_SIZE(value_object) */ __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_u_value_must_be_a_string); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 1432, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); /* "_ruamel_yaml.pyx":1462 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); /* "_ruamel_yaml.pyx":1464 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * sequence_style = YAML_BLOCK_SEQUENCE_STYLE */ __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 1464, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); /* "_ruamel_yaml.pyx":1494 * if not PyString_CheckExact(tag_object): * if PY_MAJOR_VERSION < 3: * raise TypeError("tag must be a string") # <<<<<<<<<<<<<< * else: * raise TypeError(u"tag must be a string") */ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 1494, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); /* "_ruamel_yaml.pyx":1496 * raise TypeError("tag must be a string") * else: * raise TypeError(u"tag must be a string") # <<<<<<<<<<<<<< * tag = PyString_AS_STRING(tag_object) * mapping_style = YAML_BLOCK_MAPPING_STYLE */ __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 1496, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__73); __Pyx_GIVEREF(__pyx_tuple__73); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") */ __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_s_Pickling_of_struct_members_such); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); /* "(tree fragment)":4 * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") * def __setstate_cython__(self, __pyx_state): * raise TypeError("Pickling of struct members such as self.emitter must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< */ __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_s_Pickling_of_struct_members_such); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); /* "_ruamel_yaml.pyx":3 * * * def get_version_string(): # <<<<<<<<<<<<<< * cdef char *value * value = yaml_get_version_string() */ __pyx_tuple__76 = PyTuple_Pack(1, __pyx_n_s_value); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__76); __Pyx_GIVEREF(__pyx_tuple__76); __pyx_codeobj__77 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__76, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ruamel_yaml_pyx, __pyx_n_s_get_version_string, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__77)) __PYX_ERR(0, 3, __pyx_L1_error) /* "_ruamel_yaml.pyx":11 * return PyUnicode_FromString(value) * * def get_version(): # <<<<<<<<<<<<<< * cdef int major, minor, patch * yaml_get_version(&major, &minor, &patch) */ __pyx_tuple__78 = PyTuple_Pack(3, __pyx_n_s_major, __pyx_n_s_minor, __pyx_n_s_patch); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__78); __Pyx_GIVEREF(__pyx_tuple__78); __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__78, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ruamel_yaml_pyx, __pyx_n_s_get_version, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(0, 11, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * if __pyx_checksum != 0x3fa45b6: * from pickle import PickleError as __pyx_PickleError */ __pyx_tuple__80 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__80); __Pyx_GIVEREF(__pyx_tuple__80); __pyx_codeobj__81 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Mark, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__81)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 3, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 3, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 3, __pyx_L1_error) __pyx_int_66733494 = PyInt_FromLong(66733494L); if (unlikely(!__pyx_int_66733494)) __PYX_ERR(0, 3, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC init_ruamel_yaml(void); /*proto*/ PyMODINIT_FUNC init_ruamel_yaml(void) #else PyMODINIT_FUNC PyInit__ruamel_yaml(void); /*proto*/ PyMODINIT_FUNC PyInit__ruamel_yaml(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { result = PyDict_SetItemString(moddict, to_name, value); Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__") < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__") < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__") < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__") < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static int __pyx_pymod_exec__ruamel_yaml(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0; #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__ruamel_yaml(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 3, __pyx_L1_error) __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 3, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 3, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 3, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_ruamel_yaml", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 3, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 3, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 3, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 3, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 3, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif if (__pyx_module_is_main__ruamel_yaml) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 3, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 3, __pyx_L1_error) if (!PyDict_GetItemString(modules, "_ruamel_yaml")) { if (unlikely(PyDict_SetItemString(modules, "_ruamel_yaml", __pyx_m) < 0)) __PYX_ERR(0, 3, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 3, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 3, __pyx_L1_error) /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ if (PyType_Ready(&__pyx_type_12_ruamel_yaml_Mark) < 0) __PYX_ERR(0, 63, __pyx_L1_error) __pyx_type_12_ruamel_yaml_Mark.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "Mark", (PyObject *)&__pyx_type_12_ruamel_yaml_Mark) < 0) __PYX_ERR(0, 63, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_12_ruamel_yaml_Mark) < 0) __PYX_ERR(0, 63, __pyx_L1_error) __pyx_ptype_12_ruamel_yaml_Mark = &__pyx_type_12_ruamel_yaml_Mark; __pyx_vtabptr_12_ruamel_yaml_CParser = &__pyx_vtable_12_ruamel_yaml_CParser; __pyx_vtable_12_ruamel_yaml_CParser._parser_error = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *))__pyx_f_12_ruamel_yaml_7CParser__parser_error; __pyx_vtable_12_ruamel_yaml_CParser._scan = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *))__pyx_f_12_ruamel_yaml_7CParser__scan; __pyx_vtable_12_ruamel_yaml_CParser._token_to_object = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *, yaml_token_t *))__pyx_f_12_ruamel_yaml_7CParser__token_to_object; __pyx_vtable_12_ruamel_yaml_CParser._parse = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *))__pyx_f_12_ruamel_yaml_7CParser__parse; __pyx_vtable_12_ruamel_yaml_CParser._event_to_object = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *, yaml_event_t *))__pyx_f_12_ruamel_yaml_7CParser__event_to_object; __pyx_vtable_12_ruamel_yaml_CParser._compose_document = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *))__pyx_f_12_ruamel_yaml_7CParser__compose_document; __pyx_vtable_12_ruamel_yaml_CParser._compose_node = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *, PyObject *))__pyx_f_12_ruamel_yaml_7CParser__compose_node; __pyx_vtable_12_ruamel_yaml_CParser._compose_scalar_node = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *))__pyx_f_12_ruamel_yaml_7CParser__compose_scalar_node; __pyx_vtable_12_ruamel_yaml_CParser._compose_sequence_node = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *))__pyx_f_12_ruamel_yaml_7CParser__compose_sequence_node; __pyx_vtable_12_ruamel_yaml_CParser._compose_mapping_node = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CParser *, PyObject *))__pyx_f_12_ruamel_yaml_7CParser__compose_mapping_node; __pyx_vtable_12_ruamel_yaml_CParser._parse_next_event = (int (*)(struct __pyx_obj_12_ruamel_yaml_CParser *))__pyx_f_12_ruamel_yaml_7CParser__parse_next_event; if (PyType_Ready(&__pyx_type_12_ruamel_yaml_CParser) < 0) __PYX_ERR(0, 246, __pyx_L1_error) __pyx_type_12_ruamel_yaml_CParser.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_12_ruamel_yaml_CParser.tp_dict, __pyx_vtabptr_12_ruamel_yaml_CParser) < 0) __PYX_ERR(0, 246, __pyx_L1_error) if (PyObject_SetAttrString(__pyx_m, "CParser", (PyObject *)&__pyx_type_12_ruamel_yaml_CParser) < 0) __PYX_ERR(0, 246, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_12_ruamel_yaml_CParser) < 0) __PYX_ERR(0, 246, __pyx_L1_error) __pyx_ptype_12_ruamel_yaml_CParser = &__pyx_type_12_ruamel_yaml_CParser; __pyx_vtabptr_12_ruamel_yaml_CEmitter = &__pyx_vtable_12_ruamel_yaml_CEmitter; __pyx_vtable_12_ruamel_yaml_CEmitter._emitter_error = (PyObject *(*)(struct __pyx_obj_12_ruamel_yaml_CEmitter *))__pyx_f_12_ruamel_yaml_8CEmitter__emitter_error; __pyx_vtable_12_ruamel_yaml_CEmitter._object_to_event = (int (*)(struct __pyx_obj_12_ruamel_yaml_CEmitter *, PyObject *, yaml_event_t *))__pyx_f_12_ruamel_yaml_8CEmitter__object_to_event; __pyx_vtable_12_ruamel_yaml_CEmitter._anchor_node = (int (*)(struct __pyx_obj_12_ruamel_yaml_CEmitter *, PyObject *))__pyx_f_12_ruamel_yaml_8CEmitter__anchor_node; __pyx_vtable_12_ruamel_yaml_CEmitter._serialize_node = (int (*)(struct __pyx_obj_12_ruamel_yaml_CEmitter *, PyObject *, PyObject *, PyObject *))__pyx_f_12_ruamel_yaml_8CEmitter__serialize_node; if (PyType_Ready(&__pyx_type_12_ruamel_yaml_CEmitter) < 0) __PYX_ERR(0, 934, __pyx_L1_error) __pyx_type_12_ruamel_yaml_CEmitter.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_12_ruamel_yaml_CEmitter.tp_dict, __pyx_vtabptr_12_ruamel_yaml_CEmitter) < 0) __PYX_ERR(0, 934, __pyx_L1_error) if (PyObject_SetAttrString(__pyx_m, "CEmitter", (PyObject *)&__pyx_type_12_ruamel_yaml_CEmitter) < 0) __PYX_ERR(0, 934, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_12_ruamel_yaml_CEmitter) < 0) __PYX_ERR(0, 934, __pyx_L1_error) __pyx_ptype_12_ruamel_yaml_CEmitter = &__pyx_type_12_ruamel_yaml_CEmitter; /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 3, __pyx_L1_error) #endif /* "_ruamel_yaml.pyx":3 * * * def get_version_string(): # <<<<<<<<<<<<<< * cdef char *value * value = yaml_get_version_string() */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12_ruamel_yaml_1get_version_string, NULL, __pyx_n_s_ruamel_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_version_string, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":11 * return PyUnicode_FromString(value) * * def get_version(): # <<<<<<<<<<<<<< * cdef int major, minor, patch * yaml_get_version(&major, &minor, &patch) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12_ruamel_yaml_3get_version, NULL, __pyx_n_s_ruamel_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_version, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":17 * * #Mark = yaml.error.Mark * from ruamel.yaml.error import YAMLError # <<<<<<<<<<<<<< * from ruamel.yaml.reader import ReaderError * from ruamel.yaml.scanner import ScannerError */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_YAMLError); __Pyx_GIVEREF(__pyx_n_s_YAMLError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_YAMLError); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_error, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_YAMLError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_YAMLError, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":18 * #Mark = yaml.error.Mark * from ruamel.yaml.error import YAMLError * from ruamel.yaml.reader import ReaderError # <<<<<<<<<<<<<< * from ruamel.yaml.scanner import ScannerError * from ruamel.yaml.parser import ParserError */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_ReaderError); __Pyx_GIVEREF(__pyx_n_s_ReaderError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ReaderError); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_reader, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_ReaderError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ReaderError, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":19 * from ruamel.yaml.error import YAMLError * from ruamel.yaml.reader import ReaderError * from ruamel.yaml.scanner import ScannerError # <<<<<<<<<<<<<< * from ruamel.yaml.parser import ParserError * from ruamel.yaml.composer import ComposerError */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_ScannerError); __Pyx_GIVEREF(__pyx_n_s_ScannerError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ScannerError); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_scanner, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ScannerError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScannerError, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":20 * from ruamel.yaml.reader import ReaderError * from ruamel.yaml.scanner import ScannerError * from ruamel.yaml.parser import ParserError # <<<<<<<<<<<<<< * from ruamel.yaml.composer import ComposerError * from ruamel.yaml.constructor import ConstructorError */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_ParserError); __Pyx_GIVEREF(__pyx_n_s_ParserError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ParserError); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_parser, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_ParserError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ParserError, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":21 * from ruamel.yaml.scanner import ScannerError * from ruamel.yaml.parser import ParserError * from ruamel.yaml.composer import ComposerError # <<<<<<<<<<<<<< * from ruamel.yaml.constructor import ConstructorError * from ruamel.yaml.emitter import EmitterError */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_ComposerError); __Pyx_GIVEREF(__pyx_n_s_ComposerError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ComposerError); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_composer, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ComposerError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ComposerError, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":22 * from ruamel.yaml.parser import ParserError * from ruamel.yaml.composer import ComposerError * from ruamel.yaml.constructor import ConstructorError # <<<<<<<<<<<<<< * from ruamel.yaml.emitter import EmitterError * from ruamel.yaml.serializer import SerializerError */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_ConstructorError); __Pyx_GIVEREF(__pyx_n_s_ConstructorError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ConstructorError); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_constructor, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_ConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ConstructorError, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":23 * from ruamel.yaml.composer import ComposerError * from ruamel.yaml.constructor import ConstructorError * from ruamel.yaml.emitter import EmitterError # <<<<<<<<<<<<<< * from ruamel.yaml.serializer import SerializerError * from ruamel.yaml.representer import RepresenterError */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_EmitterError); __Pyx_GIVEREF(__pyx_n_s_EmitterError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_EmitterError); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_emitter, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_EmitterError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_EmitterError, __pyx_t_1) < 0) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":24 * from ruamel.yaml.constructor import ConstructorError * from ruamel.yaml.emitter import EmitterError * from ruamel.yaml.serializer import SerializerError # <<<<<<<<<<<<<< * from ruamel.yaml.representer import RepresenterError * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_SerializerError); __Pyx_GIVEREF(__pyx_n_s_SerializerError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SerializerError); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_serializer, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_SerializerError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SerializerError, __pyx_t_2) < 0) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":25 * from ruamel.yaml.emitter import EmitterError * from ruamel.yaml.serializer import SerializerError * from ruamel.yaml.representer import RepresenterError # <<<<<<<<<<<<<< * * from ruamel.yaml.tokens import StreamStartToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_RepresenterError); __Pyx_GIVEREF(__pyx_n_s_RepresenterError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_RepresenterError); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_representer, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_RepresenterError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_RepresenterError, __pyx_t_1) < 0) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":27 * from ruamel.yaml.representer import RepresenterError * * from ruamel.yaml.tokens import StreamStartToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import StreamEndToken * from ruamel.yaml.tokens import DirectiveToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_StreamStartToken); __Pyx_GIVEREF(__pyx_n_s_StreamStartToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_StreamStartToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_StreamStartToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamStartToken, __pyx_t_2) < 0) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":28 * * from ruamel.yaml.tokens import StreamStartToken * from ruamel.yaml.tokens import StreamEndToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import DirectiveToken * from ruamel.yaml.tokens import DocumentStartToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_StreamEndToken); __Pyx_GIVEREF(__pyx_n_s_StreamEndToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_StreamEndToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_StreamEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamEndToken, __pyx_t_1) < 0) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":29 * from ruamel.yaml.tokens import StreamStartToken * from ruamel.yaml.tokens import StreamEndToken * from ruamel.yaml.tokens import DirectiveToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import DocumentStartToken * from ruamel.yaml.tokens import DocumentEndToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_DirectiveToken); __Pyx_GIVEREF(__pyx_n_s_DirectiveToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_DirectiveToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_DirectiveToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DirectiveToken, __pyx_t_2) < 0) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":30 * from ruamel.yaml.tokens import StreamEndToken * from ruamel.yaml.tokens import DirectiveToken * from ruamel.yaml.tokens import DocumentStartToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import DocumentEndToken * from ruamel.yaml.tokens import BlockSequenceStartToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_DocumentStartToken); __Pyx_GIVEREF(__pyx_n_s_DocumentStartToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_DocumentStartToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_DocumentStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentStartToken, __pyx_t_1) < 0) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":31 * from ruamel.yaml.tokens import DirectiveToken * from ruamel.yaml.tokens import DocumentStartToken * from ruamel.yaml.tokens import DocumentEndToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import BlockSequenceStartToken * from ruamel.yaml.tokens import BlockMappingStartToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_DocumentEndToken); __Pyx_GIVEREF(__pyx_n_s_DocumentEndToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_DocumentEndToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_DocumentEndToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentEndToken, __pyx_t_2) < 0) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":32 * from ruamel.yaml.tokens import DocumentStartToken * from ruamel.yaml.tokens import DocumentEndToken * from ruamel.yaml.tokens import BlockSequenceStartToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import BlockMappingStartToken * from ruamel.yaml.tokens import BlockEndToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_BlockSequenceStartToken); __Pyx_GIVEREF(__pyx_n_s_BlockSequenceStartToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_BlockSequenceStartToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_BlockSequenceStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockSequenceStartToken, __pyx_t_1) < 0) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":33 * from ruamel.yaml.tokens import DocumentEndToken * from ruamel.yaml.tokens import BlockSequenceStartToken * from ruamel.yaml.tokens import BlockMappingStartToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import BlockEndToken * from ruamel.yaml.tokens import FlowSequenceStartToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_BlockMappingStartToken); __Pyx_GIVEREF(__pyx_n_s_BlockMappingStartToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_BlockMappingStartToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_BlockMappingStartToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockMappingStartToken, __pyx_t_2) < 0) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":34 * from ruamel.yaml.tokens import BlockSequenceStartToken * from ruamel.yaml.tokens import BlockMappingStartToken * from ruamel.yaml.tokens import BlockEndToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import FlowSequenceStartToken * from ruamel.yaml.tokens import FlowMappingStartToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_BlockEndToken); __Pyx_GIVEREF(__pyx_n_s_BlockEndToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_BlockEndToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_BlockEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockEndToken, __pyx_t_1) < 0) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":35 * from ruamel.yaml.tokens import BlockMappingStartToken * from ruamel.yaml.tokens import BlockEndToken * from ruamel.yaml.tokens import FlowSequenceStartToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import FlowMappingStartToken * from ruamel.yaml.tokens import FlowSequenceEndToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_FlowSequenceStartToken); __Pyx_GIVEREF(__pyx_n_s_FlowSequenceStartToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_FlowSequenceStartToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FlowSequenceStartToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowSequenceStartToken, __pyx_t_2) < 0) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":36 * from ruamel.yaml.tokens import BlockEndToken * from ruamel.yaml.tokens import FlowSequenceStartToken * from ruamel.yaml.tokens import FlowMappingStartToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import FlowSequenceEndToken * from ruamel.yaml.tokens import FlowMappingEndToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_FlowMappingStartToken); __Pyx_GIVEREF(__pyx_n_s_FlowMappingStartToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_FlowMappingStartToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FlowMappingStartToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowMappingStartToken, __pyx_t_1) < 0) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":37 * from ruamel.yaml.tokens import FlowSequenceStartToken * from ruamel.yaml.tokens import FlowMappingStartToken * from ruamel.yaml.tokens import FlowSequenceEndToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import FlowMappingEndToken * from ruamel.yaml.tokens import KeyToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_FlowSequenceEndToken); __Pyx_GIVEREF(__pyx_n_s_FlowSequenceEndToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_FlowSequenceEndToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FlowSequenceEndToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowSequenceEndToken, __pyx_t_2) < 0) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":38 * from ruamel.yaml.tokens import FlowMappingStartToken * from ruamel.yaml.tokens import FlowSequenceEndToken * from ruamel.yaml.tokens import FlowMappingEndToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import KeyToken * from ruamel.yaml.tokens import ValueToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_FlowMappingEndToken); __Pyx_GIVEREF(__pyx_n_s_FlowMappingEndToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_FlowMappingEndToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FlowMappingEndToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowMappingEndToken, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":39 * from ruamel.yaml.tokens import FlowSequenceEndToken * from ruamel.yaml.tokens import FlowMappingEndToken * from ruamel.yaml.tokens import KeyToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import ValueToken * from ruamel.yaml.tokens import BlockEntryToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_KeyToken); __Pyx_GIVEREF(__pyx_n_s_KeyToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_KeyToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KeyToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyToken, __pyx_t_2) < 0) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":40 * from ruamel.yaml.tokens import FlowMappingEndToken * from ruamel.yaml.tokens import KeyToken * from ruamel.yaml.tokens import ValueToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import BlockEntryToken * from ruamel.yaml.tokens import FlowEntryToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_ValueToken); __Pyx_GIVEREF(__pyx_n_s_ValueToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ValueToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ValueToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ValueToken, __pyx_t_1) < 0) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":41 * from ruamel.yaml.tokens import KeyToken * from ruamel.yaml.tokens import ValueToken * from ruamel.yaml.tokens import BlockEntryToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import FlowEntryToken * from ruamel.yaml.tokens import AliasToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_BlockEntryToken); __Pyx_GIVEREF(__pyx_n_s_BlockEntryToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_BlockEntryToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_BlockEntryToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockEntryToken, __pyx_t_2) < 0) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":42 * from ruamel.yaml.tokens import ValueToken * from ruamel.yaml.tokens import BlockEntryToken * from ruamel.yaml.tokens import FlowEntryToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import AliasToken * from ruamel.yaml.tokens import AnchorToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_FlowEntryToken); __Pyx_GIVEREF(__pyx_n_s_FlowEntryToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_FlowEntryToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FlowEntryToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowEntryToken, __pyx_t_1) < 0) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":43 * from ruamel.yaml.tokens import BlockEntryToken * from ruamel.yaml.tokens import FlowEntryToken * from ruamel.yaml.tokens import AliasToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import AnchorToken * from ruamel.yaml.tokens import TagToken */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_AliasToken); __Pyx_GIVEREF(__pyx_n_s_AliasToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_AliasToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_AliasToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AliasToken, __pyx_t_2) < 0) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":44 * from ruamel.yaml.tokens import FlowEntryToken * from ruamel.yaml.tokens import AliasToken * from ruamel.yaml.tokens import AnchorToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import TagToken * from ruamel.yaml.tokens import ScalarToken */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_AnchorToken); __Pyx_GIVEREF(__pyx_n_s_AnchorToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_AnchorToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AnchorToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AnchorToken, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":45 * from ruamel.yaml.tokens import AliasToken * from ruamel.yaml.tokens import AnchorToken * from ruamel.yaml.tokens import TagToken # <<<<<<<<<<<<<< * from ruamel.yaml.tokens import ScalarToken * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_TagToken); __Pyx_GIVEREF(__pyx_n_s_TagToken); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_TagToken); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_TagToken); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_TagToken, __pyx_t_2) < 0) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":46 * from ruamel.yaml.tokens import AnchorToken * from ruamel.yaml.tokens import TagToken * from ruamel.yaml.tokens import ScalarToken # <<<<<<<<<<<<<< * * from ruamel.yaml.events import StreamStartEvent */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_ScalarToken); __Pyx_GIVEREF(__pyx_n_s_ScalarToken); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ScalarToken); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_tokens, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ScalarToken); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarToken, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":48 * from ruamel.yaml.tokens import ScalarToken * * from ruamel.yaml.events import StreamStartEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import StreamEndEvent * from ruamel.yaml.events import DocumentStartEvent */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_StreamStartEvent); __Pyx_GIVEREF(__pyx_n_s_StreamStartEvent); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_StreamStartEvent); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_StreamStartEvent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamStartEvent, __pyx_t_2) < 0) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":49 * * from ruamel.yaml.events import StreamStartEvent * from ruamel.yaml.events import StreamEndEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import DocumentStartEvent * from ruamel.yaml.events import DocumentEndEvent */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_StreamEndEvent); __Pyx_GIVEREF(__pyx_n_s_StreamEndEvent); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_StreamEndEvent); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_StreamEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamEndEvent, __pyx_t_1) < 0) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":50 * from ruamel.yaml.events import StreamStartEvent * from ruamel.yaml.events import StreamEndEvent * from ruamel.yaml.events import DocumentStartEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import DocumentEndEvent * from ruamel.yaml.events import AliasEvent */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_DocumentStartEvent); __Pyx_GIVEREF(__pyx_n_s_DocumentStartEvent); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_DocumentStartEvent); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_DocumentStartEvent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentStartEvent, __pyx_t_2) < 0) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":51 * from ruamel.yaml.events import StreamEndEvent * from ruamel.yaml.events import DocumentStartEvent * from ruamel.yaml.events import DocumentEndEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import AliasEvent * from ruamel.yaml.events import ScalarEvent */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_DocumentEndEvent); __Pyx_GIVEREF(__pyx_n_s_DocumentEndEvent); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_DocumentEndEvent); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_DocumentEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentEndEvent, __pyx_t_1) < 0) __PYX_ERR(0, 51, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":52 * from ruamel.yaml.events import DocumentStartEvent * from ruamel.yaml.events import DocumentEndEvent * from ruamel.yaml.events import AliasEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import ScalarEvent * from ruamel.yaml.events import SequenceStartEvent */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_AliasEvent); __Pyx_GIVEREF(__pyx_n_s_AliasEvent); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_AliasEvent); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_AliasEvent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AliasEvent, __pyx_t_2) < 0) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":53 * from ruamel.yaml.events import DocumentEndEvent * from ruamel.yaml.events import AliasEvent * from ruamel.yaml.events import ScalarEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import SequenceStartEvent * from ruamel.yaml.events import SequenceEndEvent */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_ScalarEvent); __Pyx_GIVEREF(__pyx_n_s_ScalarEvent); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ScalarEvent); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ScalarEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarEvent, __pyx_t_1) < 0) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":54 * from ruamel.yaml.events import AliasEvent * from ruamel.yaml.events import ScalarEvent * from ruamel.yaml.events import SequenceStartEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import SequenceEndEvent * from ruamel.yaml.events import MappingStartEvent */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_SequenceStartEvent); __Pyx_GIVEREF(__pyx_n_s_SequenceStartEvent); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SequenceStartEvent); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_SequenceStartEvent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SequenceStartEvent, __pyx_t_2) < 0) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":55 * from ruamel.yaml.events import ScalarEvent * from ruamel.yaml.events import SequenceStartEvent * from ruamel.yaml.events import SequenceEndEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import MappingStartEvent * from ruamel.yaml.events import MappingEndEvent */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_SequenceEndEvent); __Pyx_GIVEREF(__pyx_n_s_SequenceEndEvent); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_SequenceEndEvent); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SequenceEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SequenceEndEvent, __pyx_t_1) < 0) __PYX_ERR(0, 55, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":56 * from ruamel.yaml.events import SequenceStartEvent * from ruamel.yaml.events import SequenceEndEvent * from ruamel.yaml.events import MappingStartEvent # <<<<<<<<<<<<<< * from ruamel.yaml.events import MappingEndEvent * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_MappingStartEvent); __Pyx_GIVEREF(__pyx_n_s_MappingStartEvent); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_MappingStartEvent); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_MappingStartEvent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MappingStartEvent, __pyx_t_2) < 0) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":57 * from ruamel.yaml.events import SequenceEndEvent * from ruamel.yaml.events import MappingStartEvent * from ruamel.yaml.events import MappingEndEvent # <<<<<<<<<<<<<< * * from ruamel.yaml.nodes import ScalarNode */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_MappingEndEvent); __Pyx_GIVEREF(__pyx_n_s_MappingEndEvent); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_MappingEndEvent); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_events, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_MappingEndEvent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MappingEndEvent, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":59 * from ruamel.yaml.events import MappingEndEvent * * from ruamel.yaml.nodes import ScalarNode # <<<<<<<<<<<<<< * from ruamel.yaml.nodes import SequenceNode * from ruamel.yaml.nodes import MappingNode */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_ScalarNode); __Pyx_GIVEREF(__pyx_n_s_ScalarNode); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ScalarNode); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_nodes, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarNode, __pyx_t_2) < 0) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":60 * * from ruamel.yaml.nodes import ScalarNode * from ruamel.yaml.nodes import SequenceNode # <<<<<<<<<<<<<< * from ruamel.yaml.nodes import MappingNode * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_SequenceNode); __Pyx_GIVEREF(__pyx_n_s_SequenceNode); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_SequenceNode); __pyx_t_2 = __Pyx_Import(__pyx_n_s_ruamel_yaml_nodes, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SequenceNode, __pyx_t_1) < 0) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_ruamel_yaml.pyx":61 * from ruamel.yaml.nodes import ScalarNode * from ruamel.yaml.nodes import SequenceNode * from ruamel.yaml.nodes import MappingNode # <<<<<<<<<<<<<< * * cdef class Mark: */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_MappingNode); __Pyx_GIVEREF(__pyx_n_s_MappingNode); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_MappingNode); __pyx_t_1 = __Pyx_Import(__pyx_n_s_ruamel_yaml_nodes, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_MappingNode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MappingNode, __pyx_t_2) < 0) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":1 * def __pyx_unpickle_Mark(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * if __pyx_checksum != 0x3fa45b6: * from pickle import PickleError as __pyx_PickleError */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12_ruamel_yaml_5__pyx_unpickle_Mark, NULL, __pyx_n_s_ruamel_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Mark, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_ruamel_yaml.pyx":3 * * * def get_version_string(): # <<<<<<<<<<<<<< * cdef char *value * value = yaml_get_version_string() */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init _ruamel_yaml", 0, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init _ruamel_yaml"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* GetModuleGlobalName */ static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS result = PyDict_GetItem(__pyx_d, name); if (likely(result)) { Py_INCREF(result); } else { #else result = PyObject_GetItem(__pyx_d, name); if (!result) { PyErr_Clear(); #endif result = __Pyx_GetBuiltinName(name); } return result; } /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if PY_VERSION_HEX >= 0x030700A2 *type = tstate->exc_state.exc_type; *value = tstate->exc_state.exc_value; *tb = tstate->exc_state.exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if PY_VERSION_HEX >= 0x030700A2 tmp_type = tstate->exc_state.exc_type; tmp_value = tstate->exc_state.exc_value; tmp_tb = tstate->exc_state.exc_traceback; tstate->exc_state.exc_type = type; tstate->exc_state.exc_value = value; tstate->exc_state.exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { #endif PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if PY_VERSION_HEX >= 0x030700A2 tmp_type = tstate->exc_state.exc_type; tmp_value = tstate->exc_state.exc_value; tmp_tb = tstate->exc_state.exc_traceback; tstate->exc_state.exc_type = local_type; tstate->exc_state.exc_value = local_value; tstate->exc_state.exc_traceback = local_tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL #include "frameobject.h" static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = f->f_localsplus; for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs); } } #endif /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* None */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; #if CYTHON_USE_PYTYPE_LOOKUP if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; #else if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; #endif #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; } PyType_Modified((PyTypeObject*)type_obj); } } goto GOOD; BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { use_cline = PyDict_GetItem(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (PyObject_Not(use_cline) != 0) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { if (likely(err == exc_type)) return 1; if (likely(PyExceptionClass_Check(err))) { return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); } return PyErr_GivenExceptionMatches(err, exc_type); } static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { if (likely(err == exc_type1 || err == exc_type2)) return 1; if (likely(PyExceptionClass_Check(err))) { return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); } return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); } #endif /* CheckBinaryVersion */ static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) PyErr_Clear(); ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(x); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ ruamel.yaml-0.15.89/ext/api.c0000664000175100001440000010745613351131445016327 0ustar anthonusers00000000000000 #include "yaml_private.h" /* * Get the library version. */ YAML_DECLARE(const char *) yaml_get_version_string(void) { return YAML_VERSION_STRING; } /* * Get the library version numbers. */ YAML_DECLARE(void) yaml_get_version(int *major, int *minor, int *patch) { *major = YAML_VERSION_MAJOR; *minor = YAML_VERSION_MINOR; *patch = YAML_VERSION_PATCH; } /* * Allocate a dynamic memory block. */ YAML_DECLARE(void *) yaml_malloc(size_t size) { return malloc(size ? size : 1); } /* * Reallocate a dynamic memory block. */ YAML_DECLARE(void *) yaml_realloc(void *ptr, size_t size) { return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1); } /* * Free a dynamic memory block. */ YAML_DECLARE(void) yaml_free(void *ptr) { if (ptr) free(ptr); } /* * Duplicate a string. */ YAML_DECLARE(yaml_char_t *) yaml_strdup(const yaml_char_t *str) { if (!str) return NULL; return (yaml_char_t *)strdup((char *)str); } /* * Extend a string. */ YAML_DECLARE(int) yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer, yaml_char_t **end) { yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2); if (!new_start) return 0; memset(new_start + (*end - *start), 0, *end - *start); *pointer = new_start + (*pointer - *start); *end = new_start + (*end - *start)*2; *start = new_start; return 1; } /* * Append a string B to a string A. */ YAML_DECLARE(int) yaml_string_join( yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end, yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end)) { UNUSED_PARAM(b_end) if (*b_start == *b_pointer) return 1; while (*a_end - *a_pointer <= *b_pointer - *b_start) { if (!yaml_string_extend(a_start, a_pointer, a_end)) return 0; } memcpy(*a_pointer, *b_start, *b_pointer - *b_start); *a_pointer += *b_pointer - *b_start; return 1; } /* * Extend a stack. */ YAML_DECLARE(int) yaml_stack_extend(void **start, void **top, void **end) { void *new_start; if ((char *)*end - (char *)*start >= INT_MAX / 2) return 0; new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2); if (!new_start) return 0; *top = (char *)new_start + ((char *)*top - (char *)*start); *end = (char *)new_start + ((char *)*end - (char *)*start)*2; *start = new_start; return 1; } /* * Extend or move a queue. */ YAML_DECLARE(int) yaml_queue_extend(void **start, void **head, void **tail, void **end) { /* Check if we need to resize the queue. */ if (*start == *head && *tail == *end) { void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2); if (!new_start) return 0; *head = (char *)new_start + ((char *)*head - (char *)*start); *tail = (char *)new_start + ((char *)*tail - (char *)*start); *end = (char *)new_start + ((char *)*end - (char *)*start)*2; *start = new_start; } /* Check if we need to move the queue at the beginning of the buffer. */ if (*tail == *end) { if (*head != *tail) { memmove(*start, *head, (char *)*tail - (char *)*head); } *tail = (char *)*tail - (char *)*head + (char *)*start; *head = *start; } return 1; } /* * Create a new parser object. */ YAML_DECLARE(int) yaml_parser_initialize(yaml_parser_t *parser) { assert(parser); /* Non-NULL parser object expected. */ memset(parser, 0, sizeof(yaml_parser_t)); if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE)) goto error; if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE)) goto error; if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*)) goto error; if (!STACK_INIT(parser, parser->indents, int*)) goto error; if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*)) goto error; if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*)) goto error; if (!STACK_INIT(parser, parser->marks, yaml_mark_t*)) goto error; if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*)) goto error; return 1; error: BUFFER_DEL(parser, parser->raw_buffer); BUFFER_DEL(parser, parser->buffer); QUEUE_DEL(parser, parser->tokens); STACK_DEL(parser, parser->indents); STACK_DEL(parser, parser->simple_keys); STACK_DEL(parser, parser->states); STACK_DEL(parser, parser->marks); STACK_DEL(parser, parser->tag_directives); return 0; } /* * Destroy a parser object. */ YAML_DECLARE(void) yaml_parser_delete(yaml_parser_t *parser) { assert(parser); /* Non-NULL parser object expected. */ BUFFER_DEL(parser, parser->raw_buffer); BUFFER_DEL(parser, parser->buffer); while (!QUEUE_EMPTY(parser, parser->tokens)) { yaml_token_delete(&DEQUEUE(parser, parser->tokens)); } QUEUE_DEL(parser, parser->tokens); STACK_DEL(parser, parser->indents); STACK_DEL(parser, parser->simple_keys); STACK_DEL(parser, parser->states); STACK_DEL(parser, parser->marks); while (!STACK_EMPTY(parser, parser->tag_directives)) { yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); yaml_free(tag_directive.handle); yaml_free(tag_directive.prefix); } STACK_DEL(parser, parser->tag_directives); memset(parser, 0, sizeof(yaml_parser_t)); } /* * String read handler. */ static int yaml_string_read_handler(void *data, unsigned char *buffer, size_t size, size_t *size_read) { yaml_parser_t *parser = (yaml_parser_t *)data; if (parser->input.string.current == parser->input.string.end) { *size_read = 0; return 1; } if (size > (size_t)(parser->input.string.end - parser->input.string.current)) { size = parser->input.string.end - parser->input.string.current; } memcpy(buffer, parser->input.string.current, size); parser->input.string.current += size; *size_read = size; return 1; } /* * File read handler. */ static int yaml_file_read_handler(void *data, unsigned char *buffer, size_t size, size_t *size_read) { yaml_parser_t *parser = (yaml_parser_t *)data; *size_read = fread(buffer, 1, size, parser->input.file); return !ferror(parser->input.file); } /* * Set a string input. */ YAML_DECLARE(void) yaml_parser_set_input_string(yaml_parser_t *parser, const unsigned char *input, size_t size) { assert(parser); /* Non-NULL parser object expected. */ assert(!parser->read_handler); /* You can set the source only once. */ assert(input); /* Non-NULL input string expected. */ parser->read_handler = yaml_string_read_handler; parser->read_handler_data = parser; parser->input.string.start = input; parser->input.string.current = input; parser->input.string.end = input+size; } /* * Set a file input. */ YAML_DECLARE(void) yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file) { assert(parser); /* Non-NULL parser object expected. */ assert(!parser->read_handler); /* You can set the source only once. */ assert(file); /* Non-NULL file object expected. */ parser->read_handler = yaml_file_read_handler; parser->read_handler_data = parser; parser->input.file = file; } /* * Set a generic input. */ YAML_DECLARE(void) yaml_parser_set_input(yaml_parser_t *parser, yaml_read_handler_t *handler, void *data) { assert(parser); /* Non-NULL parser object expected. */ assert(!parser->read_handler); /* You can set the source only once. */ assert(handler); /* Non-NULL read handler expected. */ parser->read_handler = handler; parser->read_handler_data = data; } /* * Set the source encoding. */ YAML_DECLARE(void) yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding) { assert(parser); /* Non-NULL parser object expected. */ assert(!parser->encoding); /* Encoding is already set or detected. */ parser->encoding = encoding; } /* * Create a new emitter object. */ YAML_DECLARE(int) yaml_emitter_initialize(yaml_emitter_t *emitter) { assert(emitter); /* Non-NULL emitter object expected. */ memset(emitter, 0, sizeof(yaml_emitter_t)); if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE)) goto error; if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE)) goto error; if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*)) goto error; if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*)) goto error; if (!STACK_INIT(emitter, emitter->indents, int*)) goto error; if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*)) goto error; return 1; error: BUFFER_DEL(emitter, emitter->buffer); BUFFER_DEL(emitter, emitter->raw_buffer); STACK_DEL(emitter, emitter->states); QUEUE_DEL(emitter, emitter->events); STACK_DEL(emitter, emitter->indents); STACK_DEL(emitter, emitter->tag_directives); return 0; } /* * Destroy an emitter object. */ YAML_DECLARE(void) yaml_emitter_delete(yaml_emitter_t *emitter) { assert(emitter); /* Non-NULL emitter object expected. */ BUFFER_DEL(emitter, emitter->buffer); BUFFER_DEL(emitter, emitter->raw_buffer); STACK_DEL(emitter, emitter->states); while (!QUEUE_EMPTY(emitter, emitter->events)) { yaml_event_delete(&DEQUEUE(emitter, emitter->events)); } QUEUE_DEL(emitter, emitter->events); STACK_DEL(emitter, emitter->indents); while (!STACK_EMPTY(empty, emitter->tag_directives)) { yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives); yaml_free(tag_directive.handle); yaml_free(tag_directive.prefix); } STACK_DEL(emitter, emitter->tag_directives); yaml_free(emitter->anchors); memset(emitter, 0, sizeof(yaml_emitter_t)); } /* * String write handler. */ static int yaml_string_write_handler(void *data, unsigned char *buffer, size_t size) { yaml_emitter_t *emitter = (yaml_emitter_t *)data; if (emitter->output.string.size - *emitter->output.string.size_written < size) { memcpy(emitter->output.string.buffer + *emitter->output.string.size_written, buffer, emitter->output.string.size - *emitter->output.string.size_written); *emitter->output.string.size_written = emitter->output.string.size; return 0; } memcpy(emitter->output.string.buffer + *emitter->output.string.size_written, buffer, size); *emitter->output.string.size_written += size; return 1; } /* * File write handler. */ static int yaml_file_write_handler(void *data, unsigned char *buffer, size_t size) { yaml_emitter_t *emitter = (yaml_emitter_t *)data; return (fwrite(buffer, 1, size, emitter->output.file) == size); } /* * Set a string output. */ YAML_DECLARE(void) yaml_emitter_set_output_string(yaml_emitter_t *emitter, unsigned char *output, size_t size, size_t *size_written) { assert(emitter); /* Non-NULL emitter object expected. */ assert(!emitter->write_handler); /* You can set the output only once. */ assert(output); /* Non-NULL output string expected. */ emitter->write_handler = yaml_string_write_handler; emitter->write_handler_data = emitter; emitter->output.string.buffer = output; emitter->output.string.size = size; emitter->output.string.size_written = size_written; *size_written = 0; } /* * Set a file output. */ YAML_DECLARE(void) yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file) { assert(emitter); /* Non-NULL emitter object expected. */ assert(!emitter->write_handler); /* You can set the output only once. */ assert(file); /* Non-NULL file object expected. */ emitter->write_handler = yaml_file_write_handler; emitter->write_handler_data = emitter; emitter->output.file = file; } /* * Set a generic output handler. */ YAML_DECLARE(void) yaml_emitter_set_output(yaml_emitter_t *emitter, yaml_write_handler_t *handler, void *data) { assert(emitter); /* Non-NULL emitter object expected. */ assert(!emitter->write_handler); /* You can set the output only once. */ assert(handler); /* Non-NULL handler object expected. */ emitter->write_handler = handler; emitter->write_handler_data = data; } /* * Set the output encoding. */ YAML_DECLARE(void) yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding) { assert(emitter); /* Non-NULL emitter object expected. */ assert(!emitter->encoding); /* You can set encoding only once. */ emitter->encoding = encoding; } /* * Set the canonical output style. */ YAML_DECLARE(void) yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) { assert(emitter); /* Non-NULL emitter object expected. */ emitter->canonical = (canonical != 0); } /* * Set the indentation increment. */ YAML_DECLARE(void) yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent) { assert(emitter); /* Non-NULL emitter object expected. */ emitter->best_indent = (1 < indent && indent < 10) ? indent : 2; } /* * Set the preferred line width. */ YAML_DECLARE(void) yaml_emitter_set_width(yaml_emitter_t *emitter, int width) { assert(emitter); /* Non-NULL emitter object expected. */ emitter->best_width = (width >= 0) ? width : -1; } /* * Set if unescaped non-ASCII characters are allowed. */ YAML_DECLARE(void) yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) { assert(emitter); /* Non-NULL emitter object expected. */ emitter->unicode = (unicode != 0); } /* * Set the preferred line break character. */ YAML_DECLARE(void) yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break) { assert(emitter); /* Non-NULL emitter object expected. */ emitter->line_break = line_break; } /* * Destroy a token object. */ YAML_DECLARE(void) yaml_token_delete(yaml_token_t *token) { assert(token); /* Non-NULL token object expected. */ switch (token->type) { case YAML_TAG_DIRECTIVE_TOKEN: yaml_free(token->data.tag_directive.handle); yaml_free(token->data.tag_directive.prefix); break; case YAML_ALIAS_TOKEN: yaml_free(token->data.alias.value); break; case YAML_ANCHOR_TOKEN: yaml_free(token->data.anchor.value); break; case YAML_TAG_TOKEN: yaml_free(token->data.tag.handle); yaml_free(token->data.tag.suffix); break; case YAML_SCALAR_TOKEN: yaml_free(token->data.scalar.value); break; default: break; } memset(token, 0, sizeof(yaml_token_t)); } /* * Check if a string is a valid UTF-8 sequence. * * Check 'reader.c' for more details on UTF-8 encoding. */ static int yaml_check_utf8(yaml_char_t *start, size_t length) { yaml_char_t *end = start+length; yaml_char_t *pointer = start; while (pointer < end) { unsigned char octet; unsigned int width; unsigned int value; size_t k; octet = pointer[0]; width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; value = (octet & 0x80) == 0x00 ? octet & 0x7F : (octet & 0xE0) == 0xC0 ? octet & 0x1F : (octet & 0xF0) == 0xE0 ? octet & 0x0F : (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; if (!width) return 0; if (pointer+width > end) return 0; for (k = 1; k < width; k ++) { octet = pointer[k]; if ((octet & 0xC0) != 0x80) return 0; value = (value << 6) + (octet & 0x3F); } if (!((width == 1) || (width == 2 && value >= 0x80) || (width == 3 && value >= 0x800) || (width == 4 && value >= 0x10000))) return 0; pointer += width; } return 1; } /* * Create STREAM-START. */ YAML_DECLARE(int) yaml_stream_start_event_initialize(yaml_event_t *event, yaml_encoding_t encoding) { yaml_mark_t mark = { 0, 0, 0 }; assert(event); /* Non-NULL event object is expected. */ STREAM_START_EVENT_INIT(*event, encoding, mark, mark); return 1; } /* * Create STREAM-END. */ YAML_DECLARE(int) yaml_stream_end_event_initialize(yaml_event_t *event) { yaml_mark_t mark = { 0, 0, 0 }; assert(event); /* Non-NULL event object is expected. */ STREAM_END_EVENT_INIT(*event, mark, mark); return 1; } /* * Create DOCUMENT-START. */ YAML_DECLARE(int) yaml_document_start_event_initialize(yaml_event_t *event, yaml_version_directive_t *version_directive, yaml_tag_directive_t *tag_directives_start, yaml_tag_directive_t *tag_directives_end, int implicit) { struct { yaml_error_type_t error; } context; yaml_mark_t mark = { 0, 0, 0 }; yaml_version_directive_t *version_directive_copy = NULL; struct { yaml_tag_directive_t *start; yaml_tag_directive_t *end; yaml_tag_directive_t *top; } tag_directives_copy = { NULL, NULL, NULL }; yaml_tag_directive_t value = { NULL, NULL }; assert(event); /* Non-NULL event object is expected. */ assert((tag_directives_start && tag_directives_end) || (tag_directives_start == tag_directives_end)); /* Valid tag directives are expected. */ if (version_directive) { version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t); if (!version_directive_copy) goto error; version_directive_copy->major = version_directive->major; version_directive_copy->minor = version_directive->minor; } if (tag_directives_start != tag_directives_end) { yaml_tag_directive_t *tag_directive; if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*)) goto error; for (tag_directive = tag_directives_start; tag_directive != tag_directives_end; tag_directive ++) { assert(tag_directive->handle); assert(tag_directive->prefix); if (!yaml_check_utf8(tag_directive->handle, strlen((char *)tag_directive->handle))) goto error; if (!yaml_check_utf8(tag_directive->prefix, strlen((char *)tag_directive->prefix))) goto error; value.handle = yaml_strdup(tag_directive->handle); value.prefix = yaml_strdup(tag_directive->prefix); if (!value.handle || !value.prefix) goto error; if (!PUSH(&context, tag_directives_copy, value)) goto error; value.handle = NULL; value.prefix = NULL; } } DOCUMENT_START_EVENT_INIT(*event, version_directive_copy, tag_directives_copy.start, tag_directives_copy.top, implicit, mark, mark); return 1; error: yaml_free(version_directive_copy); while (!STACK_EMPTY(context, tag_directives_copy)) { yaml_tag_directive_t value = POP(context, tag_directives_copy); yaml_free(value.handle); yaml_free(value.prefix); } STACK_DEL(context, tag_directives_copy); yaml_free(value.handle); yaml_free(value.prefix); return 0; } /* * Create DOCUMENT-END. */ YAML_DECLARE(int) yaml_document_end_event_initialize(yaml_event_t *event, int implicit) { yaml_mark_t mark = { 0, 0, 0 }; assert(event); /* Non-NULL emitter object is expected. */ DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark); return 1; } /* * Create ALIAS. */ YAML_DECLARE(int) yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; assert(event); /* Non-NULL event object is expected. */ assert(anchor); /* Non-NULL anchor is expected. */ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0; anchor_copy = yaml_strdup(anchor); if (!anchor_copy) return 0; ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark); return 1; } /* * Create SCALAR. */ YAML_DECLARE(int) yaml_scalar_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, yaml_char_t *value, int length, int plain_implicit, int quoted_implicit, yaml_scalar_style_t style) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; yaml_char_t *tag_copy = NULL; yaml_char_t *value_copy = NULL; assert(event); /* Non-NULL event object is expected. */ assert(value); /* Non-NULL anchor is expected. */ if (anchor) { if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; anchor_copy = yaml_strdup(anchor); if (!anchor_copy) goto error; } if (tag) { if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; } if (length < 0) { length = strlen((char *)value); } if (!yaml_check_utf8(value, length)) goto error; value_copy = YAML_MALLOC(length+1); if (!value_copy) goto error; memcpy(value_copy, value, length); value_copy[length] = '\0'; SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length, plain_implicit, quoted_implicit, style, mark, mark); return 1; error: yaml_free(anchor_copy); yaml_free(tag_copy); yaml_free(value_copy); return 0; } /* * Create SEQUENCE-START. */ YAML_DECLARE(int) yaml_sequence_start_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, int implicit, yaml_sequence_style_t style) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; yaml_char_t *tag_copy = NULL; assert(event); /* Non-NULL event object is expected. */ if (anchor) { if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; anchor_copy = yaml_strdup(anchor); if (!anchor_copy) goto error; } if (tag) { if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; } SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy, implicit, style, mark, mark); return 1; error: yaml_free(anchor_copy); yaml_free(tag_copy); return 0; } /* * Create SEQUENCE-END. */ YAML_DECLARE(int) yaml_sequence_end_event_initialize(yaml_event_t *event) { yaml_mark_t mark = { 0, 0, 0 }; assert(event); /* Non-NULL event object is expected. */ SEQUENCE_END_EVENT_INIT(*event, mark, mark); return 1; } /* * Create MAPPING-START. */ YAML_DECLARE(int) yaml_mapping_start_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, int implicit, yaml_mapping_style_t style) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; yaml_char_t *tag_copy = NULL; assert(event); /* Non-NULL event object is expected. */ if (anchor) { if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; anchor_copy = yaml_strdup(anchor); if (!anchor_copy) goto error; } if (tag) { if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; } MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy, implicit, style, mark, mark); return 1; error: yaml_free(anchor_copy); yaml_free(tag_copy); return 0; } /* * Create MAPPING-END. */ YAML_DECLARE(int) yaml_mapping_end_event_initialize(yaml_event_t *event) { yaml_mark_t mark = { 0, 0, 0 }; assert(event); /* Non-NULL event object is expected. */ MAPPING_END_EVENT_INIT(*event, mark, mark); return 1; } /* * Destroy an event object. */ YAML_DECLARE(void) yaml_event_delete(yaml_event_t *event) { yaml_tag_directive_t *tag_directive; assert(event); /* Non-NULL event object expected. */ switch (event->type) { case YAML_DOCUMENT_START_EVENT: yaml_free(event->data.document_start.version_directive); for (tag_directive = event->data.document_start.tag_directives.start; tag_directive != event->data.document_start.tag_directives.end; tag_directive++) { yaml_free(tag_directive->handle); yaml_free(tag_directive->prefix); } yaml_free(event->data.document_start.tag_directives.start); break; case YAML_ALIAS_EVENT: yaml_free(event->data.alias.anchor); break; case YAML_SCALAR_EVENT: yaml_free(event->data.scalar.anchor); yaml_free(event->data.scalar.tag); yaml_free(event->data.scalar.value); break; case YAML_SEQUENCE_START_EVENT: yaml_free(event->data.sequence_start.anchor); yaml_free(event->data.sequence_start.tag); break; case YAML_MAPPING_START_EVENT: yaml_free(event->data.mapping_start.anchor); yaml_free(event->data.mapping_start.tag); break; default: break; } memset(event, 0, sizeof(yaml_event_t)); } /* * Create a document object. */ YAML_DECLARE(int) yaml_document_initialize(yaml_document_t *document, yaml_version_directive_t *version_directive, yaml_tag_directive_t *tag_directives_start, yaml_tag_directive_t *tag_directives_end, int start_implicit, int end_implicit) { struct { yaml_error_type_t error; } context; struct { yaml_node_t *start; yaml_node_t *end; yaml_node_t *top; } nodes = { NULL, NULL, NULL }; yaml_version_directive_t *version_directive_copy = NULL; struct { yaml_tag_directive_t *start; yaml_tag_directive_t *end; yaml_tag_directive_t *top; } tag_directives_copy = { NULL, NULL, NULL }; yaml_tag_directive_t value = { NULL, NULL }; yaml_mark_t mark = { 0, 0, 0 }; assert(document); /* Non-NULL document object is expected. */ assert((tag_directives_start && tag_directives_end) || (tag_directives_start == tag_directives_end)); /* Valid tag directives are expected. */ if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error; if (version_directive) { version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t); if (!version_directive_copy) goto error; version_directive_copy->major = version_directive->major; version_directive_copy->minor = version_directive->minor; } if (tag_directives_start != tag_directives_end) { yaml_tag_directive_t *tag_directive; if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*)) goto error; for (tag_directive = tag_directives_start; tag_directive != tag_directives_end; tag_directive ++) { assert(tag_directive->handle); assert(tag_directive->prefix); if (!yaml_check_utf8(tag_directive->handle, strlen((char *)tag_directive->handle))) goto error; if (!yaml_check_utf8(tag_directive->prefix, strlen((char *)tag_directive->prefix))) goto error; value.handle = yaml_strdup(tag_directive->handle); value.prefix = yaml_strdup(tag_directive->prefix); if (!value.handle || !value.prefix) goto error; if (!PUSH(&context, tag_directives_copy, value)) goto error; value.handle = NULL; value.prefix = NULL; } } DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy, tag_directives_copy.start, tag_directives_copy.top, start_implicit, end_implicit, mark, mark); return 1; error: STACK_DEL(&context, nodes); yaml_free(version_directive_copy); while (!STACK_EMPTY(&context, tag_directives_copy)) { yaml_tag_directive_t value = POP(&context, tag_directives_copy); yaml_free(value.handle); yaml_free(value.prefix); } STACK_DEL(&context, tag_directives_copy); yaml_free(value.handle); yaml_free(value.prefix); return 0; } /* * Destroy a document object. */ YAML_DECLARE(void) yaml_document_delete(yaml_document_t *document) { struct { yaml_error_type_t error; } context; yaml_tag_directive_t *tag_directive; context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */ assert(document); /* Non-NULL document object is expected. */ while (!STACK_EMPTY(&context, document->nodes)) { yaml_node_t node = POP(&context, document->nodes); yaml_free(node.tag); switch (node.type) { case YAML_SCALAR_NODE: yaml_free(node.data.scalar.value); break; case YAML_SEQUENCE_NODE: STACK_DEL(&context, node.data.sequence.items); break; case YAML_MAPPING_NODE: STACK_DEL(&context, node.data.mapping.pairs); break; default: assert(0); /* Should not happen. */ } } STACK_DEL(&context, document->nodes); yaml_free(document->version_directive); for (tag_directive = document->tag_directives.start; tag_directive != document->tag_directives.end; tag_directive++) { yaml_free(tag_directive->handle); yaml_free(tag_directive->prefix); } yaml_free(document->tag_directives.start); memset(document, 0, sizeof(yaml_document_t)); } /** * Get a document node. */ YAML_DECLARE(yaml_node_t *) yaml_document_get_node(yaml_document_t *document, int index) { assert(document); /* Non-NULL document object is expected. */ if (index > 0 && document->nodes.start + index <= document->nodes.top) { return document->nodes.start + index - 1; } return NULL; } /** * Get the root object. */ YAML_DECLARE(yaml_node_t *) yaml_document_get_root_node(yaml_document_t *document) { assert(document); /* Non-NULL document object is expected. */ if (document->nodes.top != document->nodes.start) { return document->nodes.start; } return NULL; } /* * Add a scalar node to a document. */ YAML_DECLARE(int) yaml_document_add_scalar(yaml_document_t *document, yaml_char_t *tag, yaml_char_t *value, int length, yaml_scalar_style_t style) { struct { yaml_error_type_t error; } context; yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *tag_copy = NULL; yaml_char_t *value_copy = NULL; yaml_node_t node; assert(document); /* Non-NULL document object is expected. */ assert(value); /* Non-NULL value is expected. */ if (!tag) { tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG; } if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; if (length < 0) { length = strlen((char *)value); } if (!yaml_check_utf8(value, length)) goto error; value_copy = YAML_MALLOC(length+1); if (!value_copy) goto error; memcpy(value_copy, value, length); value_copy[length] = '\0'; SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark); if (!PUSH(&context, document->nodes, node)) goto error; return document->nodes.top - document->nodes.start; error: yaml_free(tag_copy); yaml_free(value_copy); return 0; } /* * Add a sequence node to a document. */ YAML_DECLARE(int) yaml_document_add_sequence(yaml_document_t *document, yaml_char_t *tag, yaml_sequence_style_t style) { struct { yaml_error_type_t error; } context; yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *tag_copy = NULL; struct { yaml_node_item_t *start; yaml_node_item_t *end; yaml_node_item_t *top; } items = { NULL, NULL, NULL }; yaml_node_t node; assert(document); /* Non-NULL document object is expected. */ if (!tag) { tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG; } if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error; SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end, style, mark, mark); if (!PUSH(&context, document->nodes, node)) goto error; return document->nodes.top - document->nodes.start; error: STACK_DEL(&context, items); yaml_free(tag_copy); return 0; } /* * Add a mapping node to a document. */ YAML_DECLARE(int) yaml_document_add_mapping(yaml_document_t *document, yaml_char_t *tag, yaml_mapping_style_t style) { struct { yaml_error_type_t error; } context; yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *tag_copy = NULL; struct { yaml_node_pair_t *start; yaml_node_pair_t *end; yaml_node_pair_t *top; } pairs = { NULL, NULL, NULL }; yaml_node_t node; assert(document); /* Non-NULL document object is expected. */ if (!tag) { tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG; } if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error; MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end, style, mark, mark); if (!PUSH(&context, document->nodes, node)) goto error; return document->nodes.top - document->nodes.start; error: STACK_DEL(&context, pairs); yaml_free(tag_copy); return 0; } /* * Append an item to a sequence node. */ YAML_DECLARE(int) yaml_document_append_sequence_item(yaml_document_t *document, int sequence, int item) { struct { yaml_error_type_t error; } context; assert(document); /* Non-NULL document is required. */ assert(sequence > 0 && document->nodes.start + sequence <= document->nodes.top); /* Valid sequence id is required. */ assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE); /* A sequence node is required. */ assert(item > 0 && document->nodes.start + item <= document->nodes.top); /* Valid item id is required. */ if (!PUSH(&context, document->nodes.start[sequence-1].data.sequence.items, item)) return 0; return 1; } /* * Append a pair of a key and a value to a mapping node. */ YAML_DECLARE(int) yaml_document_append_mapping_pair(yaml_document_t *document, int mapping, int key, int value) { struct { yaml_error_type_t error; } context; yaml_node_pair_t pair; assert(document); /* Non-NULL document is required. */ assert(mapping > 0 && document->nodes.start + mapping <= document->nodes.top); /* Valid mapping id is required. */ assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE); /* A mapping node is required. */ assert(key > 0 && document->nodes.start + key <= document->nodes.top); /* Valid key id is required. */ assert(value > 0 && document->nodes.start + value <= document->nodes.top); /* Valid value id is required. */ pair.key = key; pair.value = value; if (!PUSH(&context, document->nodes.start[mapping-1].data.mapping.pairs, pair)) return 0; return 1; } ruamel.yaml-0.15.89/ext/yaml.h0000664000175100001440000015210213351131445016511 0ustar anthonusers00000000000000/** * @file yaml.h * @brief Public interface for libyaml. * * Include the header file with the code: * @code * #include * @endcode */ #ifndef YAML_H #define YAML_H #ifdef __cplusplus extern "C" { #endif #include #include #include /** * @defgroup export Export Definitions * @{ */ /** The public API declaration. */ #if defined(__MINGW32__) # define YAML_DECLARE(type) type #elif defined(WIN32) # if defined(YAML_DECLARE_STATIC) # define YAML_DECLARE(type) type # elif defined(YAML_DECLARE_EXPORT) # define YAML_DECLARE(type) __declspec(dllexport) type # else # define YAML_DECLARE(type) __declspec(dllimport) type # endif #else # define YAML_DECLARE(type) type #endif /** @} */ /** * @defgroup version Version Information * @{ */ /** * Get the library version as a string. * * @returns The function returns the pointer to a static string of the form * @c "X.Y.Z", where @c X is the major version number, @c Y is a minor version * number, and @c Z is the patch version number. */ YAML_DECLARE(const char *) yaml_get_version_string(void); /** * Get the library version numbers. * * @param[out] major Major version number. * @param[out] minor Minor version number. * @param[out] patch Patch version number. */ YAML_DECLARE(void) yaml_get_version(int *major, int *minor, int *patch); /** @} */ /** * @defgroup basic Basic Types * @{ */ /** The character type (UTF-8 octet). */ typedef unsigned char yaml_char_t; /** The version directive data. */ typedef struct yaml_version_directive_s { /** The major version number. */ int major; /** The minor version number. */ int minor; } yaml_version_directive_t; /** The tag directive data. */ typedef struct yaml_tag_directive_s { /** The tag handle. */ yaml_char_t *handle; /** The tag prefix. */ yaml_char_t *prefix; } yaml_tag_directive_t; /** The stream encoding. */ typedef enum yaml_encoding_e { /** Let the parser choose the encoding. */ YAML_ANY_ENCODING, /** The default UTF-8 encoding. */ YAML_UTF8_ENCODING, /** The UTF-16-LE encoding with BOM. */ YAML_UTF16LE_ENCODING, /** The UTF-16-BE encoding with BOM. */ YAML_UTF16BE_ENCODING } yaml_encoding_t; /** Line break types. */ typedef enum yaml_break_e { /** Let the parser choose the break type. */ YAML_ANY_BREAK, /** Use CR for line breaks (Mac style). */ YAML_CR_BREAK, /** Use LN for line breaks (Unix style). */ YAML_LN_BREAK, /** Use CR LN for line breaks (DOS style). */ YAML_CRLN_BREAK } yaml_break_t; /** Many bad things could happen with the parser and emitter. */ typedef enum yaml_error_type_e { /** No error is produced. */ YAML_NO_ERROR, /** Cannot allocate or reallocate a block of memory. */ YAML_MEMORY_ERROR, /** Cannot read or decode the input stream. */ YAML_READER_ERROR, /** Cannot scan the input stream. */ YAML_SCANNER_ERROR, /** Cannot parse the input stream. */ YAML_PARSER_ERROR, /** Cannot compose a YAML document. */ YAML_COMPOSER_ERROR, /** Cannot write to the output stream. */ YAML_WRITER_ERROR, /** Cannot emit a YAML stream. */ YAML_EMITTER_ERROR } yaml_error_type_t; /** The pointer position. */ typedef struct yaml_mark_s { /** The position index. */ size_t index; /** The position line. */ size_t line; /** The position column. */ size_t column; } yaml_mark_t; /** @} */ /** * @defgroup styles Node Styles * @{ */ /** Scalar styles. */ typedef enum yaml_scalar_style_e { /** Let the emitter choose the style. */ YAML_ANY_SCALAR_STYLE, /** The plain scalar style. */ YAML_PLAIN_SCALAR_STYLE, /** The single-quoted scalar style. */ YAML_SINGLE_QUOTED_SCALAR_STYLE, /** The double-quoted scalar style. */ YAML_DOUBLE_QUOTED_SCALAR_STYLE, /** The literal scalar style. */ YAML_LITERAL_SCALAR_STYLE, /** The folded scalar style. */ YAML_FOLDED_SCALAR_STYLE } yaml_scalar_style_t; /** Sequence styles. */ typedef enum yaml_sequence_style_e { /** Let the emitter choose the style. */ YAML_ANY_SEQUENCE_STYLE, /** The block sequence style. */ YAML_BLOCK_SEQUENCE_STYLE, /** The flow sequence style. */ YAML_FLOW_SEQUENCE_STYLE } yaml_sequence_style_t; /** Mapping styles. */ typedef enum yaml_mapping_style_e { /** Let the emitter choose the style. */ YAML_ANY_MAPPING_STYLE, /** The block mapping style. */ YAML_BLOCK_MAPPING_STYLE, /** The flow mapping style. */ YAML_FLOW_MAPPING_STYLE /* YAML_FLOW_SET_MAPPING_STYLE */ } yaml_mapping_style_t; /** @} */ /** * @defgroup tokens Tokens * @{ */ /** Token types. */ typedef enum yaml_token_type_e { /** An empty token. */ YAML_NO_TOKEN, /** A STREAM-START token. */ YAML_STREAM_START_TOKEN, /** A STREAM-END token. */ YAML_STREAM_END_TOKEN, /** A VERSION-DIRECTIVE token. */ YAML_VERSION_DIRECTIVE_TOKEN, /** A TAG-DIRECTIVE token. */ YAML_TAG_DIRECTIVE_TOKEN, /** A DOCUMENT-START token. */ YAML_DOCUMENT_START_TOKEN, /** A DOCUMENT-END token. */ YAML_DOCUMENT_END_TOKEN, /** A BLOCK-SEQUENCE-START token. */ YAML_BLOCK_SEQUENCE_START_TOKEN, /** A BLOCK-MAPPING-START token. */ YAML_BLOCK_MAPPING_START_TOKEN, /** A BLOCK-END token. */ YAML_BLOCK_END_TOKEN, /** A FLOW-SEQUENCE-START token. */ YAML_FLOW_SEQUENCE_START_TOKEN, /** A FLOW-SEQUENCE-END token. */ YAML_FLOW_SEQUENCE_END_TOKEN, /** A FLOW-MAPPING-START token. */ YAML_FLOW_MAPPING_START_TOKEN, /** A FLOW-MAPPING-END token. */ YAML_FLOW_MAPPING_END_TOKEN, /** A BLOCK-ENTRY token. */ YAML_BLOCK_ENTRY_TOKEN, /** A FLOW-ENTRY token. */ YAML_FLOW_ENTRY_TOKEN, /** A KEY token. */ YAML_KEY_TOKEN, /** A VALUE token. */ YAML_VALUE_TOKEN, /** An ALIAS token. */ YAML_ALIAS_TOKEN, /** An ANCHOR token. */ YAML_ANCHOR_TOKEN, /** A TAG token. */ YAML_TAG_TOKEN, /** A SCALAR token. */ YAML_SCALAR_TOKEN } yaml_token_type_t; /** The token structure. */ typedef struct yaml_token_s { /** The token type. */ yaml_token_type_t type; /** The token data. */ union { /** The stream start (for @c YAML_STREAM_START_TOKEN). */ struct { /** The stream encoding. */ yaml_encoding_t encoding; } stream_start; /** The alias (for @c YAML_ALIAS_TOKEN). */ struct { /** The alias value. */ yaml_char_t *value; } alias; /** The anchor (for @c YAML_ANCHOR_TOKEN). */ struct { /** The anchor value. */ yaml_char_t *value; } anchor; /** The tag (for @c YAML_TAG_TOKEN). */ struct { /** The tag handle. */ yaml_char_t *handle; /** The tag suffix. */ yaml_char_t *suffix; } tag; /** The scalar value (for @c YAML_SCALAR_TOKEN). */ struct { /** The scalar value. */ yaml_char_t *value; /** The length of the scalar value. */ size_t length; /** The scalar style. */ yaml_scalar_style_t style; } scalar; /** The version directive (for @c YAML_VERSION_DIRECTIVE_TOKEN). */ struct { /** The major version number. */ int major; /** The minor version number. */ int minor; } version_directive; /** The tag directive (for @c YAML_TAG_DIRECTIVE_TOKEN). */ struct { /** The tag handle. */ yaml_char_t *handle; /** The tag prefix. */ yaml_char_t *prefix; } tag_directive; } data; /** The beginning of the token. */ yaml_mark_t start_mark; /** The end of the token. */ yaml_mark_t end_mark; } yaml_token_t; /** * Free any memory allocated for a token object. * * @param[in,out] token A token object. */ YAML_DECLARE(void) yaml_token_delete(yaml_token_t *token); /** @} */ /** * @defgroup events Events * @{ */ /** Event types. */ typedef enum yaml_event_type_e { /** An empty event. */ YAML_NO_EVENT, /** A STREAM-START event. */ YAML_STREAM_START_EVENT, /** A STREAM-END event. */ YAML_STREAM_END_EVENT, /** A DOCUMENT-START event. */ YAML_DOCUMENT_START_EVENT, /** A DOCUMENT-END event. */ YAML_DOCUMENT_END_EVENT, /** An ALIAS event. */ YAML_ALIAS_EVENT, /** A SCALAR event. */ YAML_SCALAR_EVENT, /** A SEQUENCE-START event. */ YAML_SEQUENCE_START_EVENT, /** A SEQUENCE-END event. */ YAML_SEQUENCE_END_EVENT, /** A MAPPING-START event. */ YAML_MAPPING_START_EVENT, /** A MAPPING-END event. */ YAML_MAPPING_END_EVENT } yaml_event_type_t; /** The event structure. */ typedef struct yaml_event_s { /** The event type. */ yaml_event_type_t type; /** The event data. */ union { /** The stream parameters (for @c YAML_STREAM_START_EVENT). */ struct { /** The document encoding. */ yaml_encoding_t encoding; } stream_start; /** The document parameters (for @c YAML_DOCUMENT_START_EVENT). */ struct { /** The version directive. */ yaml_version_directive_t *version_directive; /** The list of tag directives. */ struct { /** The beginning of the tag directives list. */ yaml_tag_directive_t *start; /** The end of the tag directives list. */ yaml_tag_directive_t *end; } tag_directives; /** Is the document indicator implicit? */ int implicit; } document_start; /** The document end parameters (for @c YAML_DOCUMENT_END_EVENT). */ struct { /** Is the document end indicator implicit? */ int implicit; } document_end; /** The alias parameters (for @c YAML_ALIAS_EVENT). */ struct { /** The anchor. */ yaml_char_t *anchor; } alias; /** The scalar parameters (for @c YAML_SCALAR_EVENT). */ struct { /** The anchor. */ yaml_char_t *anchor; /** The tag. */ yaml_char_t *tag; /** The scalar value. */ yaml_char_t *value; /** The length of the scalar value. */ size_t length; /** Is the tag optional for the plain style? */ int plain_implicit; /** Is the tag optional for any non-plain style? */ int quoted_implicit; /** The scalar style. */ yaml_scalar_style_t style; } scalar; /** The sequence parameters (for @c YAML_SEQUENCE_START_EVENT). */ struct { /** The anchor. */ yaml_char_t *anchor; /** The tag. */ yaml_char_t *tag; /** Is the tag optional? */ int implicit; /** The sequence style. */ yaml_sequence_style_t style; } sequence_start; /** The mapping parameters (for @c YAML_MAPPING_START_EVENT). */ struct { /** The anchor. */ yaml_char_t *anchor; /** The tag. */ yaml_char_t *tag; /** Is the tag optional? */ int implicit; /** The mapping style. */ yaml_mapping_style_t style; } mapping_start; } data; /** The beginning of the event. */ yaml_mark_t start_mark; /** The end of the event. */ yaml_mark_t end_mark; } yaml_event_t; /** * Create the STREAM-START event. * * @param[out] event An empty event object. * @param[in] encoding The stream encoding. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_stream_start_event_initialize(yaml_event_t *event, yaml_encoding_t encoding); /** * Create the STREAM-END event. * * @param[out] event An empty event object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_stream_end_event_initialize(yaml_event_t *event); /** * Create the DOCUMENT-START event. * * The @a implicit argument is considered as a stylistic parameter and may be * ignored by the emitter. * * @param[out] event An empty event object. * @param[in] version_directive The %YAML directive value or * @c NULL. * @param[in] tag_directives_start The beginning of the %TAG * directives list. * @param[in] tag_directives_end The end of the %TAG directives * list. * @param[in] implicit If the document start indicator is * implicit. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_document_start_event_initialize(yaml_event_t *event, yaml_version_directive_t *version_directive, yaml_tag_directive_t *tag_directives_start, yaml_tag_directive_t *tag_directives_end, int implicit); /** * Create the DOCUMENT-END event. * * The @a implicit argument is considered as a stylistic parameter and may be * ignored by the emitter. * * @param[out] event An empty event object. * @param[in] implicit If the document end indicator is implicit. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_document_end_event_initialize(yaml_event_t *event, int implicit); /** * Create an ALIAS event. * * @param[out] event An empty event object. * @param[in] anchor The anchor value. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor); /** * Create a SCALAR event. * * The @a style argument may be ignored by the emitter. * * Either the @a tag attribute or one of the @a plain_implicit and * @a quoted_implicit flags must be set. * * @param[out] event An empty event object. * @param[in] anchor The scalar anchor or @c NULL. * @param[in] tag The scalar tag or @c NULL. * @param[in] value The scalar value. * @param[in] length The length of the scalar value. * @param[in] plain_implicit If the tag may be omitted for the plain * style. * @param[in] quoted_implicit If the tag may be omitted for any * non-plain style. * @param[in] style The scalar style. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_scalar_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, yaml_char_t *value, int length, int plain_implicit, int quoted_implicit, yaml_scalar_style_t style); /** * Create a SEQUENCE-START event. * * The @a style argument may be ignored by the emitter. * * Either the @a tag attribute or the @a implicit flag must be set. * * @param[out] event An empty event object. * @param[in] anchor The sequence anchor or @c NULL. * @param[in] tag The sequence tag or @c NULL. * @param[in] implicit If the tag may be omitted. * @param[in] style The sequence style. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_sequence_start_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, int implicit, yaml_sequence_style_t style); /** * Create a SEQUENCE-END event. * * @param[out] event An empty event object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_sequence_end_event_initialize(yaml_event_t *event); /** * Create a MAPPING-START event. * * The @a style argument may be ignored by the emitter. * * Either the @a tag attribute or the @a implicit flag must be set. * * @param[out] event An empty event object. * @param[in] anchor The mapping anchor or @c NULL. * @param[in] tag The mapping tag or @c NULL. * @param[in] implicit If the tag may be omitted. * @param[in] style The mapping style. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_mapping_start_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, int implicit, yaml_mapping_style_t style); /** * Create a MAPPING-END event. * * @param[out] event An empty event object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_mapping_end_event_initialize(yaml_event_t *event); /** * Free any memory allocated for an event object. * * @param[in,out] event An event object. */ YAML_DECLARE(void) yaml_event_delete(yaml_event_t *event); /** @} */ /** * @defgroup nodes Nodes * @{ */ /** The tag @c !!null with the only possible value: @c null. */ #define YAML_NULL_TAG "tag:yaml.org,2002:null" /** The tag @c !!bool with the values: @c true and @c false. */ #define YAML_BOOL_TAG "tag:yaml.org,2002:bool" /** The tag @c !!str for string values. */ #define YAML_STR_TAG "tag:yaml.org,2002:str" /** The tag @c !!int for integer values. */ #define YAML_INT_TAG "tag:yaml.org,2002:int" /** The tag @c !!float for float values. */ #define YAML_FLOAT_TAG "tag:yaml.org,2002:float" /** The tag @c !!timestamp for date and time values. */ #define YAML_TIMESTAMP_TAG "tag:yaml.org,2002:timestamp" /** The tag @c !!seq is used to denote sequences. */ #define YAML_SEQ_TAG "tag:yaml.org,2002:seq" /** The tag @c !!map is used to denote mapping. */ #define YAML_MAP_TAG "tag:yaml.org,2002:map" /** The default scalar tag is @c !!str. */ #define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG /** The default sequence tag is @c !!seq. */ #define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG /** The default mapping tag is @c !!map. */ #define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG /** Node types. */ typedef enum yaml_node_type_e { /** An empty node. */ YAML_NO_NODE, /** A scalar node. */ YAML_SCALAR_NODE, /** A sequence node. */ YAML_SEQUENCE_NODE, /** A mapping node. */ YAML_MAPPING_NODE } yaml_node_type_t; /** The forward definition of a document node structure. */ typedef struct yaml_node_s yaml_node_t; /** An element of a sequence node. */ typedef int yaml_node_item_t; /** An element of a mapping node. */ typedef struct yaml_node_pair_s { /** The key of the element. */ int key; /** The value of the element. */ int value; } yaml_node_pair_t; /** The node structure. */ struct yaml_node_s { /** The node type. */ yaml_node_type_t type; /** The node tag. */ yaml_char_t *tag; /** The node data. */ union { /** The scalar parameters (for @c YAML_SCALAR_NODE). */ struct { /** The scalar value. */ yaml_char_t *value; /** The length of the scalar value. */ size_t length; /** The scalar style. */ yaml_scalar_style_t style; } scalar; /** The sequence parameters (for @c YAML_SEQUENCE_NODE). */ struct { /** The stack of sequence items. */ struct { /** The beginning of the stack. */ yaml_node_item_t *start; /** The end of the stack. */ yaml_node_item_t *end; /** The top of the stack. */ yaml_node_item_t *top; } items; /** The sequence style. */ yaml_sequence_style_t style; } sequence; /** The mapping parameters (for @c YAML_MAPPING_NODE). */ struct { /** The stack of mapping pairs (key, value). */ struct { /** The beginning of the stack. */ yaml_node_pair_t *start; /** The end of the stack. */ yaml_node_pair_t *end; /** The top of the stack. */ yaml_node_pair_t *top; } pairs; /** The mapping style. */ yaml_mapping_style_t style; } mapping; } data; /** The beginning of the node. */ yaml_mark_t start_mark; /** The end of the node. */ yaml_mark_t end_mark; }; /** The document structure. */ typedef struct yaml_document_s { /** The document nodes. */ struct { /** The beginning of the stack. */ yaml_node_t *start; /** The end of the stack. */ yaml_node_t *end; /** The top of the stack. */ yaml_node_t *top; } nodes; /** The version directive. */ yaml_version_directive_t *version_directive; /** The list of tag directives. */ struct { /** The beginning of the tag directives list. */ yaml_tag_directive_t *start; /** The end of the tag directives list. */ yaml_tag_directive_t *end; } tag_directives; /** Is the document start indicator implicit? */ int start_implicit; /** Is the document end indicator implicit? */ int end_implicit; /** The beginning of the document. */ yaml_mark_t start_mark; /** The end of the document. */ yaml_mark_t end_mark; } yaml_document_t; /** * Create a YAML document. * * @param[out] document An empty document object. * @param[in] version_directive The %YAML directive value or * @c NULL. * @param[in] tag_directives_start The beginning of the %TAG * directives list. * @param[in] tag_directives_end The end of the %TAG directives * list. * @param[in] start_implicit If the document start indicator is * implicit. * @param[in] end_implicit If the document end indicator is * implicit. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_document_initialize(yaml_document_t *document, yaml_version_directive_t *version_directive, yaml_tag_directive_t *tag_directives_start, yaml_tag_directive_t *tag_directives_end, int start_implicit, int end_implicit); /** * Delete a YAML document and all its nodes. * * @param[in,out] document A document object. */ YAML_DECLARE(void) yaml_document_delete(yaml_document_t *document); /** * Get a node of a YAML document. * * The pointer returned by this function is valid until any of the functions * modifying the documents are called. * * @param[in] document A document object. * @param[in] index The node id. * * @returns the node objct or @c NULL if @c node_id is out of range. */ YAML_DECLARE(yaml_node_t *) yaml_document_get_node(yaml_document_t *document, int index); /** * Get the root of a YAML document node. * * The root object is the first object added to the document. * * The pointer returned by this function is valid until any of the functions * modifying the documents are called. * * An empty document produced by the parser signifies the end of a YAML * stream. * * @param[in] document A document object. * * @returns the node object or @c NULL if the document is empty. */ YAML_DECLARE(yaml_node_t *) yaml_document_get_root_node(yaml_document_t *document); /** * Create a SCALAR node and attach it to the document. * * The @a style argument may be ignored by the emitter. * * @param[in,out] document A document object. * @param[in] tag The scalar tag. * @param[in] value The scalar value. * @param[in] length The length of the scalar value. * @param[in] style The scalar style. * * @returns the node id or @c 0 on error. */ YAML_DECLARE(int) yaml_document_add_scalar(yaml_document_t *document, yaml_char_t *tag, yaml_char_t *value, int length, yaml_scalar_style_t style); /** * Create a SEQUENCE node and attach it to the document. * * The @a style argument may be ignored by the emitter. * * @param[in,out] document A document object. * @param[in] tag The sequence tag. * @param[in] style The sequence style. * * @returns the node id or @c 0 on error. */ YAML_DECLARE(int) yaml_document_add_sequence(yaml_document_t *document, yaml_char_t *tag, yaml_sequence_style_t style); /** * Create a MAPPING node and attach it to the document. * * The @a style argument may be ignored by the emitter. * * @param[in,out] document A document object. * @param[in] tag The sequence tag. * @param[in] style The sequence style. * * @returns the node id or @c 0 on error. */ YAML_DECLARE(int) yaml_document_add_mapping(yaml_document_t *document, yaml_char_t *tag, yaml_mapping_style_t style); /** * Add an item to a SEQUENCE node. * * @param[in,out] document A document object. * @param[in] sequence The sequence node id. * @param[in] item The item node id. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_document_append_sequence_item(yaml_document_t *document, int sequence, int item); /** * Add a pair of a key and a value to a MAPPING node. * * @param[in,out] document A document object. * @param[in] mapping The mapping node id. * @param[in] key The key node id. * @param[in] value The value node id. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_document_append_mapping_pair(yaml_document_t *document, int mapping, int key, int value); /** @} */ /** * @defgroup parser Parser Definitions * @{ */ /** * The prototype of a read handler. * * The read handler is called when the parser needs to read more bytes from the * source. The handler should write not more than @a size bytes to the @a * buffer. The number of written bytes should be set to the @a length variable. * * @param[in,out] data A pointer to an application data specified by * yaml_parser_set_input(). * @param[out] buffer The buffer to write the data from the source. * @param[in] size The size of the buffer. * @param[out] size_read The actual number of bytes read from the source. * * @returns On success, the handler should return @c 1. If the handler failed, * the returned value should be @c 0. On EOF, the handler should set the * @a size_read to @c 0 and return @c 1. */ typedef int yaml_read_handler_t(void *data, unsigned char *buffer, size_t size, size_t *size_read); /** * This structure holds information about a potential simple key. */ typedef struct yaml_simple_key_s { /** Is a simple key possible? */ int possible; /** Is a simple key required? */ int required; /** The number of the token. */ size_t token_number; /** The position mark. */ yaml_mark_t mark; } yaml_simple_key_t; /** * The states of the parser. */ typedef enum yaml_parser_state_e { /** Expect STREAM-START. */ YAML_PARSE_STREAM_START_STATE, /** Expect the beginning of an implicit document. */ YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE, /** Expect DOCUMENT-START. */ YAML_PARSE_DOCUMENT_START_STATE, /** Expect the content of a document. */ YAML_PARSE_DOCUMENT_CONTENT_STATE, /** Expect DOCUMENT-END. */ YAML_PARSE_DOCUMENT_END_STATE, /** Expect a block node. */ YAML_PARSE_BLOCK_NODE_STATE, /** Expect a block node or indentless sequence. */ YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE, /** Expect a flow node. */ YAML_PARSE_FLOW_NODE_STATE, /** Expect the first entry of a block sequence. */ YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE, /** Expect an entry of a block sequence. */ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE, /** Expect an entry of an indentless sequence. */ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE, /** Expect the first key of a block mapping. */ YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE, /** Expect a block mapping key. */ YAML_PARSE_BLOCK_MAPPING_KEY_STATE, /** Expect a block mapping value. */ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE, /** Expect the first entry of a flow sequence. */ YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE, /** Expect an entry of a flow sequence. */ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE, /** Expect a key of an ordered mapping. */ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE, /** Expect a value of an ordered mapping. */ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE, /** Expect the and of an ordered mapping entry. */ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE, /** Expect the first key of a flow mapping. */ YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE, /** Expect a key of a flow mapping. */ YAML_PARSE_FLOW_MAPPING_KEY_STATE, /** Expect a value of a flow mapping. */ YAML_PARSE_FLOW_MAPPING_VALUE_STATE, /** Expect an empty value of a flow mapping. */ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, /** Expect nothing. */ YAML_PARSE_END_STATE } yaml_parser_state_t; /** * This structure holds aliases data. */ typedef struct yaml_alias_data_s { /** The anchor. */ yaml_char_t *anchor; /** The node id. */ int index; /** The anchor mark. */ yaml_mark_t mark; } yaml_alias_data_t; /** * The parser structure. * * All members are internal. Manage the structure using the @c yaml_parser_ * family of functions. */ typedef struct yaml_parser_s { /** * @name Error handling * @{ */ /** Error type. */ yaml_error_type_t error; /** Error description. */ const char *problem; /** The byte about which the problem occurred. */ size_t problem_offset; /** The problematic value (@c -1 is none). */ int problem_value; /** The problem position. */ yaml_mark_t problem_mark; /** The error context. */ const char *context; /** The context position. */ yaml_mark_t context_mark; /** * @} */ /** * @name Reader stuff * @{ */ /** Read handler. */ yaml_read_handler_t *read_handler; /** A pointer for passing to the read handler. */ void *read_handler_data; /** Standard (string or file) input data. */ union { /** String input data. */ struct { /** The string start pointer. */ const unsigned char *start; /** The string end pointer. */ const unsigned char *end; /** The string current position. */ const unsigned char *current; } string; /** File input data. */ FILE *file; } input; /** EOF flag */ int eof; /** The working buffer. */ struct { /** The beginning of the buffer. */ yaml_char_t *start; /** The end of the buffer. */ yaml_char_t *end; /** The current position of the buffer. */ yaml_char_t *pointer; /** The last filled position of the buffer. */ yaml_char_t *last; } buffer; /* The number of unread characters in the buffer. */ size_t unread; /** The raw buffer. */ struct { /** The beginning of the buffer. */ unsigned char *start; /** The end of the buffer. */ unsigned char *end; /** The current position of the buffer. */ unsigned char *pointer; /** The last filled position of the buffer. */ unsigned char *last; } raw_buffer; /** The input encoding. */ yaml_encoding_t encoding; /** The offset of the current position (in bytes). */ size_t offset; /** The mark of the current position. */ yaml_mark_t mark; /** * @} */ /** * @name Scanner stuff * @{ */ /** Have we started to scan the input stream? */ int stream_start_produced; /** Have we reached the end of the input stream? */ int stream_end_produced; /** The number of unclosed '[' and '{' indicators. */ int flow_level; /** The tokens queue. */ struct { /** The beginning of the tokens queue. */ yaml_token_t *start; /** The end of the tokens queue. */ yaml_token_t *end; /** The head of the tokens queue. */ yaml_token_t *head; /** The tail of the tokens queue. */ yaml_token_t *tail; } tokens; /** The number of tokens fetched from the queue. */ size_t tokens_parsed; /* Does the tokens queue contain a token ready for dequeueing. */ int token_available; /** The indentation levels stack. */ struct { /** The beginning of the stack. */ int *start; /** The end of the stack. */ int *end; /** The top of the stack. */ int *top; } indents; /** The current indentation level. */ int indent; /** May a simple key occur at the current position? */ int simple_key_allowed; /** The stack of simple keys. */ struct { /** The beginning of the stack. */ yaml_simple_key_t *start; /** The end of the stack. */ yaml_simple_key_t *end; /** The top of the stack. */ yaml_simple_key_t *top; } simple_keys; /** * @} */ /** * @name Parser stuff * @{ */ /** The parser states stack. */ struct { /** The beginning of the stack. */ yaml_parser_state_t *start; /** The end of the stack. */ yaml_parser_state_t *end; /** The top of the stack. */ yaml_parser_state_t *top; } states; /** The current parser state. */ yaml_parser_state_t state; /** The stack of marks. */ struct { /** The beginning of the stack. */ yaml_mark_t *start; /** The end of the stack. */ yaml_mark_t *end; /** The top of the stack. */ yaml_mark_t *top; } marks; /** The list of TAG directives. */ struct { /** The beginning of the list. */ yaml_tag_directive_t *start; /** The end of the list. */ yaml_tag_directive_t *end; /** The top of the list. */ yaml_tag_directive_t *top; } tag_directives; /** * @} */ /** * @name Dumper stuff * @{ */ /** The alias data. */ struct { /** The beginning of the list. */ yaml_alias_data_t *start; /** The end of the list. */ yaml_alias_data_t *end; /** The top of the list. */ yaml_alias_data_t *top; } aliases; /** The currently parsed document. */ yaml_document_t *document; /** * @} */ } yaml_parser_t; /** * Initialize a parser. * * This function creates a new parser object. An application is responsible * for destroying the object using the yaml_parser_delete() function. * * @param[out] parser An empty parser object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_parser_initialize(yaml_parser_t *parser); /** * Destroy a parser. * * @param[in,out] parser A parser object. */ YAML_DECLARE(void) yaml_parser_delete(yaml_parser_t *parser); /** * Set a string input. * * Note that the @a input pointer must be valid while the @a parser object * exists. The application is responsible for destroing @a input after * destroying the @a parser. * * @param[in,out] parser A parser object. * @param[in] input A source data. * @param[in] size The length of the source data in bytes. */ YAML_DECLARE(void) yaml_parser_set_input_string(yaml_parser_t *parser, const unsigned char *input, size_t size); /** * Set a file input. * * @a file should be a file object open for reading. The application is * responsible for closing the @a file. * * @param[in,out] parser A parser object. * @param[in] file An open file. */ YAML_DECLARE(void) yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file); /** * Set a generic input handler. * * @param[in,out] parser A parser object. * @param[in] handler A read handler. * @param[in] data Any application data for passing to the read * handler. */ YAML_DECLARE(void) yaml_parser_set_input(yaml_parser_t *parser, yaml_read_handler_t *handler, void *data); /** * Set the source encoding. * * @param[in,out] parser A parser object. * @param[in] encoding The source encoding. */ YAML_DECLARE(void) yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding); /** * Scan the input stream and produce the next token. * * Call the function subsequently to produce a sequence of tokens corresponding * to the input stream. The initial token has the type * @c YAML_STREAM_START_TOKEN while the ending token has the type * @c YAML_STREAM_END_TOKEN. * * An application is responsible for freeing any buffers associated with the * produced token object using the @c yaml_token_delete function. * * An application must not alternate the calls of yaml_parser_scan() with the * calls of yaml_parser_parse() or yaml_parser_load(). Doing this will break * the parser. * * @param[in,out] parser A parser object. * @param[out] token An empty token object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); /** * Parse the input stream and produce the next parsing event. * * Call the function subsequently to produce a sequence of events corresponding * to the input stream. The initial event has the type * @c YAML_STREAM_START_EVENT while the ending event has the type * @c YAML_STREAM_END_EVENT. * * An application is responsible for freeing any buffers associated with the * produced event object using the yaml_event_delete() function. * * An application must not alternate the calls of yaml_parser_parse() with the * calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the * parser. * * @param[in,out] parser A parser object. * @param[out] event An empty event object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); /** * Parse the input stream and produce the next YAML document. * * Call this function subsequently to produce a sequence of documents * constituting the input stream. * * If the produced document has no root node, it means that the document * end has been reached. * * An application is responsible for freeing any data associated with the * produced document object using the yaml_document_delete() function. * * An application must not alternate the calls of yaml_parser_load() with the * calls of yaml_parser_scan() or yaml_parser_parse(). Doing this will break * the parser. * * @param[in,out] parser A parser object. * @param[out] document An empty document object. * * @return @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document); /** @} */ /** * @defgroup emitter Emitter Definitions * @{ */ /** * The prototype of a write handler. * * The write handler is called when the emitter needs to flush the accumulated * characters to the output. The handler should write @a size bytes of the * @a buffer to the output. * * @param[in,out] data A pointer to an application data specified by * yaml_emitter_set_output(). * @param[in] buffer The buffer with bytes to be written. * @param[in] size The size of the buffer. * * @returns On success, the handler should return @c 1. If the handler failed, * the returned value should be @c 0. */ typedef int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size); /** The emitter states. */ typedef enum yaml_emitter_state_e { /** Expect STREAM-START. */ YAML_EMIT_STREAM_START_STATE, /** Expect the first DOCUMENT-START or STREAM-END. */ YAML_EMIT_FIRST_DOCUMENT_START_STATE, /** Expect DOCUMENT-START or STREAM-END. */ YAML_EMIT_DOCUMENT_START_STATE, /** Expect the content of a document. */ YAML_EMIT_DOCUMENT_CONTENT_STATE, /** Expect DOCUMENT-END. */ YAML_EMIT_DOCUMENT_END_STATE, /** Expect the first item of a flow sequence. */ YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE, /** Expect an item of a flow sequence. */ YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE, /** Expect the first key of a flow mapping. */ YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE, /** Expect a key of a flow mapping. */ YAML_EMIT_FLOW_MAPPING_KEY_STATE, /** Expect a value for a simple key of a flow mapping. */ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE, /** Expect a value of a flow mapping. */ YAML_EMIT_FLOW_MAPPING_VALUE_STATE, /** Expect the first item of a block sequence. */ YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE, /** Expect an item of a block sequence. */ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE, /** Expect the first key of a block mapping. */ YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE, /** Expect the key of a block mapping. */ YAML_EMIT_BLOCK_MAPPING_KEY_STATE, /** Expect a value for a simple key of a block mapping. */ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE, /** Expect a value of a block mapping. */ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE, /** Expect nothing. */ YAML_EMIT_END_STATE } yaml_emitter_state_t; /* This is needed for C++ */ typedef struct yaml_anchors_s { /** The number of references. */ int references; /** The anchor id. */ int anchor; /** If the node has been emitted? */ int serialized; } yaml_anchors_t; /** * The emitter structure. * * All members are internal. Manage the structure using the @c yaml_emitter_ * family of functions. */ typedef struct yaml_emitter_s { /** * @name Error handling * @{ */ /** Error type. */ yaml_error_type_t error; /** Error description. */ const char *problem; /** * @} */ /** * @name Writer stuff * @{ */ /** Write handler. */ yaml_write_handler_t *write_handler; /** A pointer for passing to the white handler. */ void *write_handler_data; /** Standard (string or file) output data. */ union { /** String output data. */ struct { /** The buffer pointer. */ unsigned char *buffer; /** The buffer size. */ size_t size; /** The number of written bytes. */ size_t *size_written; } string; /** File output data. */ FILE *file; } output; /** The working buffer. */ struct { /** The beginning of the buffer. */ yaml_char_t *start; /** The end of the buffer. */ yaml_char_t *end; /** The current position of the buffer. */ yaml_char_t *pointer; /** The last filled position of the buffer. */ yaml_char_t *last; } buffer; /** The raw buffer. */ struct { /** The beginning of the buffer. */ unsigned char *start; /** The end of the buffer. */ unsigned char *end; /** The current position of the buffer. */ unsigned char *pointer; /** The last filled position of the buffer. */ unsigned char *last; } raw_buffer; /** The stream encoding. */ yaml_encoding_t encoding; /** * @} */ /** * @name Emitter stuff * @{ */ /** If the output is in the canonical style? */ int canonical; /** The number of indentation spaces. */ int best_indent; /** The preferred width of the output lines. */ int best_width; /** Allow unescaped non-ASCII characters? */ int unicode; /** The preferred line break. */ yaml_break_t line_break; /** The stack of states. */ struct { /** The beginning of the stack. */ yaml_emitter_state_t *start; /** The end of the stack. */ yaml_emitter_state_t *end; /** The top of the stack. */ yaml_emitter_state_t *top; } states; /** The current emitter state. */ yaml_emitter_state_t state; /** The event queue. */ struct { /** The beginning of the event queue. */ yaml_event_t *start; /** The end of the event queue. */ yaml_event_t *end; /** The head of the event queue. */ yaml_event_t *head; /** The tail of the event queue. */ yaml_event_t *tail; } events; /** The stack of indentation levels. */ struct { /** The beginning of the stack. */ int *start; /** The end of the stack. */ int *end; /** The top of the stack. */ int *top; } indents; /** The list of tag directives. */ struct { /** The beginning of the list. */ yaml_tag_directive_t *start; /** The end of the list. */ yaml_tag_directive_t *end; /** The top of the list. */ yaml_tag_directive_t *top; } tag_directives; /** The current indentation level. */ int indent; /** The current flow level. */ int flow_level; /** Is it the document root context? */ int root_context; /** Is it a sequence context? */ int sequence_context; /** Is it a mapping context? */ int mapping_context; /** Is it a simple mapping key context? */ int simple_key_context; /** The current line. */ int line; /** The current column. */ int column; /** If the last character was a whitespace? */ int whitespace; /** If the last character was an indentation character (' ', '-', '?', ':')? */ int indention; /** If an explicit document end is required? */ int open_ended; /** Anchor analysis. */ struct { /** The anchor value. */ yaml_char_t *anchor; /** The anchor length. */ size_t anchor_length; /** Is it an alias? */ int alias; } anchor_data; /** Tag analysis. */ struct { /** The tag handle. */ yaml_char_t *handle; /** The tag handle length. */ size_t handle_length; /** The tag suffix. */ yaml_char_t *suffix; /** The tag suffix length. */ size_t suffix_length; } tag_data; /** Scalar analysis. */ struct { /** The scalar value. */ yaml_char_t *value; /** The scalar length. */ size_t length; /** Does the scalar contain line breaks? */ int multiline; /** Can the scalar be expessed in the flow plain style? */ int flow_plain_allowed; /** Can the scalar be expressed in the block plain style? */ int block_plain_allowed; /** Can the scalar be expressed in the single quoted style? */ int single_quoted_allowed; /** Can the scalar be expressed in the literal or folded styles? */ int block_allowed; /** The output style. */ yaml_scalar_style_t style; } scalar_data; /** * @} */ /** * @name Dumper stuff * @{ */ /** If the stream was already opened? */ int opened; /** If the stream was already closed? */ int closed; /** The information associated with the document nodes. */ yaml_anchors_t *anchors; /** The last assigned anchor id. */ int last_anchor_id; /** The currently emitted document. */ yaml_document_t *document; /** * @} */ } yaml_emitter_t; /** * Initialize an emitter. * * This function creates a new emitter object. An application is responsible * for destroying the object using the yaml_emitter_delete() function. * * @param[out] emitter An empty parser object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_emitter_initialize(yaml_emitter_t *emitter); /** * Destroy an emitter. * * @param[in,out] emitter An emitter object. */ YAML_DECLARE(void) yaml_emitter_delete(yaml_emitter_t *emitter); /** * Set a string output. * * The emitter will write the output characters to the @a output buffer of the * size @a size. The emitter will set @a size_written to the number of written * bytes. If the buffer is smaller than required, the emitter produces the * YAML_WRITE_ERROR error. * * @param[in,out] emitter An emitter object. * @param[in] output An output buffer. * @param[in] size The buffer size. * @param[in] size_written The pointer to save the number of written * bytes. */ YAML_DECLARE(void) yaml_emitter_set_output_string(yaml_emitter_t *emitter, unsigned char *output, size_t size, size_t *size_written); /** * Set a file output. * * @a file should be a file object open for writing. The application is * responsible for closing the @a file. * * @param[in,out] emitter An emitter object. * @param[in] file An open file. */ YAML_DECLARE(void) yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file); /** * Set a generic output handler. * * @param[in,out] emitter An emitter object. * @param[in] handler A write handler. * @param[in] data Any application data for passing to the write * handler. */ YAML_DECLARE(void) yaml_emitter_set_output(yaml_emitter_t *emitter, yaml_write_handler_t *handler, void *data); /** * Set the output encoding. * * @param[in,out] emitter An emitter object. * @param[in] encoding The output encoding. */ YAML_DECLARE(void) yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding); /** * Set if the output should be in the "canonical" format as in the YAML * specification. * * @param[in,out] emitter An emitter object. * @param[in] canonical If the output is canonical. */ YAML_DECLARE(void) yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical); /** * Set the indentation increment. * * @param[in,out] emitter An emitter object. * @param[in] indent The indentation increment (1 < . < 10). */ YAML_DECLARE(void) yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent); /** * Set the preferred line width. @c -1 means unlimited. * * @param[in,out] emitter An emitter object. * @param[in] width The preferred line width. */ YAML_DECLARE(void) yaml_emitter_set_width(yaml_emitter_t *emitter, int width); /** * Set if unescaped non-ASCII characters are allowed. * * @param[in,out] emitter An emitter object. * @param[in] unicode If unescaped Unicode characters are allowed. */ YAML_DECLARE(void) yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode); /** * Set the preferred line break. * * @param[in,out] emitter An emitter object. * @param[in] line_break The preferred line break. */ YAML_DECLARE(void) yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break); /** * Emit an event. * * The event object may be generated using the yaml_parser_parse() function. * The emitter takes the responsibility for the event object and destroys its * content after it is emitted. The event object is destroyed even if the * function fails. * * @param[in,out] emitter An emitter object. * @param[in,out] event An event object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); /** * Start a YAML stream. * * This function should be used before yaml_emitter_dump() is called. * * @param[in,out] emitter An emitter object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_emitter_open(yaml_emitter_t *emitter); /** * Finish a YAML stream. * * This function should be used after yaml_emitter_dump() is called. * * @param[in,out] emitter An emitter object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_emitter_close(yaml_emitter_t *emitter); /** * Emit a YAML document. * * The documen object may be generated using the yaml_parser_load() function * or the yaml_document_initialize() function. The emitter takes the * responsibility for the document object and destroys its content after * it is emitted. The document object is destroyed even if the function fails. * * @param[in,out] emitter An emitter object. * @param[in,out] document A document object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document); /** * Flush the accumulated characters to the output. * * @param[in,out] emitter An emitter object. * * @returns @c 1 if the function succeeded, @c 0 on error. */ YAML_DECLARE(int) yaml_emitter_flush(yaml_emitter_t *emitter); /** @} */ #ifdef __cplusplus } #endif #endif /* #ifndef YAML_H */ ruamel.yaml-0.15.89/ext/writer.c0000664000175100001440000000771313310164625017066 0ustar anthonusers00000000000000 #include "yaml_private.h" /* * Declarations. */ static int yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem); YAML_DECLARE(int) yaml_emitter_flush(yaml_emitter_t *emitter); /* * Set the writer error and return 0. */ static int yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem) { emitter->error = YAML_WRITER_ERROR; emitter->problem = problem; return 0; } /* * Flush the output buffer. */ YAML_DECLARE(int) yaml_emitter_flush(yaml_emitter_t *emitter) { int low, high; assert(emitter); /* Non-NULL emitter object is expected. */ assert(emitter->write_handler); /* Write handler must be set. */ assert(emitter->encoding); /* Output encoding must be set. */ emitter->buffer.last = emitter->buffer.pointer; emitter->buffer.pointer = emitter->buffer.start; /* Check if the buffer is empty. */ if (emitter->buffer.start == emitter->buffer.last) { return 1; } /* If the output encoding is UTF-8, we don't need to recode the buffer. */ if (emitter->encoding == YAML_UTF8_ENCODING) { if (emitter->write_handler(emitter->write_handler_data, emitter->buffer.start, emitter->buffer.last - emitter->buffer.start)) { emitter->buffer.last = emitter->buffer.start; emitter->buffer.pointer = emitter->buffer.start; return 1; } else { return yaml_emitter_set_writer_error(emitter, "write error"); } } /* Recode the buffer into the raw buffer. */ low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1); high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); while (emitter->buffer.pointer != emitter->buffer.last) { unsigned char octet; unsigned int width; unsigned int value; size_t k; /* * See the "reader.c" code for more details on UTF-8 encoding. Note * that we assume that the buffer contains a valid UTF-8 sequence. */ /* Read the next UTF-8 character. */ octet = emitter->buffer.pointer[0]; width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; value = (octet & 0x80) == 0x00 ? octet & 0x7F : (octet & 0xE0) == 0xC0 ? octet & 0x1F : (octet & 0xF0) == 0xE0 ? octet & 0x0F : (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; for (k = 1; k < width; k ++) { octet = emitter->buffer.pointer[k]; value = (value << 6) + (octet & 0x3F); } emitter->buffer.pointer += width; /* Write the character. */ if (value < 0x10000) { emitter->raw_buffer.last[high] = value >> 8; emitter->raw_buffer.last[low] = value & 0xFF; emitter->raw_buffer.last += 2; } else { /* Write the character using a surrogate pair (check "reader.c"). */ value -= 0x10000; emitter->raw_buffer.last[high] = 0xD8 + (value >> 18); emitter->raw_buffer.last[low] = (value >> 10) & 0xFF; emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF); emitter->raw_buffer.last[low+2] = value & 0xFF; emitter->raw_buffer.last += 4; } } /* Write the raw buffer. */ if (emitter->write_handler(emitter->write_handler_data, emitter->raw_buffer.start, emitter->raw_buffer.last - emitter->raw_buffer.start)) { emitter->buffer.last = emitter->buffer.start; emitter->buffer.pointer = emitter->buffer.start; emitter->raw_buffer.last = emitter->raw_buffer.start; emitter->raw_buffer.pointer = emitter->raw_buffer.start; return 1; } else { return yaml_emitter_set_writer_error(emitter, "write error"); } } ruamel.yaml-0.15.89/ext/config.h0000664000175100001440000000434013310164625017015 0ustar anthonusers00000000000000/* config.h. Generated from config.h.in by configure. */ /* config.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if you have the header file. */ #define HAVE_DLFCN_H 1 /* Define to 1 if you have the header file. */ #define HAVE_INTTYPES_H 1 /* Define to 1 if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDINT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STRINGS_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STRING_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define to 1 if you have the header file. */ #define HAVE_UNISTD_H 1 /* Define to the sub-directory in which libtool stores uninstalled libraries. */ #define LT_OBJDIR ".libs/" /* Name of package */ #define PACKAGE "yaml" /* Define to the address where bug reports for this package should be sent. */ #define PACKAGE_BUGREPORT "http://pyyaml.org/newticket?component=libyaml" /* Define to the full name of this package. */ #define PACKAGE_NAME "yaml" /* Define to the full name and version of this package. */ #define PACKAGE_STRING "yaml 0.1.7" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "yaml" /* Define to the home page for this package. */ #define PACKAGE_URL "" /* Define to the version of this package. */ #define PACKAGE_VERSION "0.1.7" /* Define to 1 if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Version number of package */ #define VERSION "0.1.7" /* Define the major version number. */ #define YAML_VERSION_MAJOR 0 /* Define the minor version number. */ #define YAML_VERSION_MINOR 1 /* Define the patch version number. */ #define YAML_VERSION_PATCH 7 /* Define the version string. */ #define YAML_VERSION_STRING "0.1.7" /* Define to empty if `const' does not conform to ANSI C. */ /* #undef const */ /* Define to `unsigned int' if does not define. */ /* #undef size_t */ ruamel.yaml-0.15.89/ext/reader.c0000664000175100001440000004045013351131445017006 0ustar anthonusers00000000000000 #include "yaml_private.h" /* * Declarations. */ static int yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem, size_t offset, int value); static int yaml_parser_update_raw_buffer(yaml_parser_t *parser); static int yaml_parser_determine_encoding(yaml_parser_t *parser); YAML_DECLARE(int) yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); /* * Set the reader error and return 0. */ static int yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem, size_t offset, int value) { parser->error = YAML_READER_ERROR; parser->problem = problem; parser->problem_offset = offset; parser->problem_value = value; return 0; } /* * Byte order marks. */ #define BOM_UTF8 "\xef\xbb\xbf" #define BOM_UTF16LE "\xff\xfe" #define BOM_UTF16BE "\xfe\xff" /* * Determine the input stream encoding by checking the BOM symbol. If no BOM is * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. */ static int yaml_parser_determine_encoding(yaml_parser_t *parser) { /* Ensure that we had enough bytes in the raw buffer. */ while (!parser->eof && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) { if (!yaml_parser_update_raw_buffer(parser)) { return 0; } } /* Determine the encoding. */ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) { parser->encoding = YAML_UTF16LE_ENCODING; parser->raw_buffer.pointer += 2; parser->offset += 2; } else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) { parser->encoding = YAML_UTF16BE_ENCODING; parser->raw_buffer.pointer += 2; parser->offset += 2; } else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3 && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) { parser->encoding = YAML_UTF8_ENCODING; parser->raw_buffer.pointer += 3; parser->offset += 3; } else { parser->encoding = YAML_UTF8_ENCODING; } return 1; } /* * Update the raw buffer. */ static int yaml_parser_update_raw_buffer(yaml_parser_t *parser) { size_t size_read = 0; /* Return if the raw buffer is full. */ if (parser->raw_buffer.start == parser->raw_buffer.pointer && parser->raw_buffer.last == parser->raw_buffer.end) return 1; /* Return on EOF. */ if (parser->eof) return 1; /* Move the remaining bytes in the raw buffer to the beginning. */ if (parser->raw_buffer.start < parser->raw_buffer.pointer && parser->raw_buffer.pointer < parser->raw_buffer.last) { memmove(parser->raw_buffer.start, parser->raw_buffer.pointer, parser->raw_buffer.last - parser->raw_buffer.pointer); } parser->raw_buffer.last -= parser->raw_buffer.pointer - parser->raw_buffer.start; parser->raw_buffer.pointer = parser->raw_buffer.start; /* Call the read handler to fill the buffer. */ if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last, parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) { return yaml_parser_set_reader_error(parser, "input error", parser->offset, -1); } parser->raw_buffer.last += size_read; if (!size_read) { parser->eof = 1; } return 1; } /* * Ensure that the buffer contains at least `length` characters. * Return 1 on success, 0 on failure. * * The length is supposed to be significantly less that the buffer size. */ YAML_DECLARE(int) yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) { int first = 1; assert(parser->read_handler); /* Read handler must be set. */ /* If the EOF flag is set and the raw buffer is empty, do nothing. */ if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last) return 1; /* Return if the buffer contains enough characters. */ if (parser->unread >= length) return 1; /* Determine the input encoding if it is not known yet. */ if (!parser->encoding) { if (!yaml_parser_determine_encoding(parser)) return 0; } /* Move the unread characters to the beginning of the buffer. */ if (parser->buffer.start < parser->buffer.pointer && parser->buffer.pointer < parser->buffer.last) { size_t size = parser->buffer.last - parser->buffer.pointer; memmove(parser->buffer.start, parser->buffer.pointer, size); parser->buffer.pointer = parser->buffer.start; parser->buffer.last = parser->buffer.start + size; } else if (parser->buffer.pointer == parser->buffer.last) { parser->buffer.pointer = parser->buffer.start; parser->buffer.last = parser->buffer.start; } /* Fill the buffer until it has enough characters. */ while (parser->unread < length) { /* Fill the raw buffer if necessary. */ if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) { if (!yaml_parser_update_raw_buffer(parser)) return 0; } first = 0; /* Decode the raw buffer. */ while (parser->raw_buffer.pointer != parser->raw_buffer.last) { unsigned int value = 0, value2 = 0; int incomplete = 0; unsigned char octet; unsigned int width = 0; int low, high; size_t k; size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer; /* Decode the next character. */ switch (parser->encoding) { case YAML_UTF8_ENCODING: /* * Decode a UTF-8 character. Check RFC 3629 * (http://www.ietf.org/rfc/rfc3629.txt) for more details. * * The following table (taken from the RFC) is used for * decoding. * * Char. number range | UTF-8 octet sequence * (hexadecimal) | (binary) * --------------------+------------------------------------ * 0000 0000-0000 007F | 0xxxxxxx * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx * * Additionally, the characters in the range 0xD800-0xDFFF * are prohibited as they are reserved for use with UTF-16 * surrogate pairs. */ /* Determine the length of the UTF-8 sequence. */ octet = parser->raw_buffer.pointer[0]; width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; /* Check if the leading octet is valid. */ if (!width) return yaml_parser_set_reader_error(parser, "invalid leading UTF-8 octet", parser->offset, octet); /* Check if the raw buffer contains an incomplete character. */ if (width > raw_unread) { if (parser->eof) { return yaml_parser_set_reader_error(parser, "incomplete UTF-8 octet sequence", parser->offset, -1); } incomplete = 1; break; } /* Decode the leading octet. */ value = (octet & 0x80) == 0x00 ? octet & 0x7F : (octet & 0xE0) == 0xC0 ? octet & 0x1F : (octet & 0xF0) == 0xE0 ? octet & 0x0F : (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; /* Check and decode the trailing octets. */ for (k = 1; k < width; k ++) { octet = parser->raw_buffer.pointer[k]; /* Check if the octet is valid. */ if ((octet & 0xC0) != 0x80) return yaml_parser_set_reader_error(parser, "invalid trailing UTF-8 octet", parser->offset+k, octet); /* Decode the octet. */ value = (value << 6) + (octet & 0x3F); } /* Check the length of the sequence against the value. */ if (!((width == 1) || (width == 2 && value >= 0x80) || (width == 3 && value >= 0x800) || (width == 4 && value >= 0x10000))) return yaml_parser_set_reader_error(parser, "invalid length of a UTF-8 sequence", parser->offset, -1); /* Check the range of the value. */ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) return yaml_parser_set_reader_error(parser, "invalid Unicode character", parser->offset, value); break; case YAML_UTF16LE_ENCODING: case YAML_UTF16BE_ENCODING: low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1); high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); /* * The UTF-16 encoding is not as simple as one might * naively think. Check RFC 2781 * (http://www.ietf.org/rfc/rfc2781.txt). * * Normally, two subsequent bytes describe a Unicode * character. However a special technique (called a * surrogate pair) is used for specifying character * values larger than 0xFFFF. * * A surrogate pair consists of two pseudo-characters: * high surrogate area (0xD800-0xDBFF) * low surrogate area (0xDC00-0xDFFF) * * The following formulas are used for decoding * and encoding characters using surrogate pairs: * * U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF) * U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF) * W1 = 110110yyyyyyyyyy * W2 = 110111xxxxxxxxxx * * where U is the character value, W1 is the high surrogate * area, W2 is the low surrogate area. */ /* Check for incomplete UTF-16 character. */ if (raw_unread < 2) { if (parser->eof) { return yaml_parser_set_reader_error(parser, "incomplete UTF-16 character", parser->offset, -1); } incomplete = 1; break; } /* Get the character. */ value = parser->raw_buffer.pointer[low] + (parser->raw_buffer.pointer[high] << 8); /* Check for unexpected low surrogate area. */ if ((value & 0xFC00) == 0xDC00) return yaml_parser_set_reader_error(parser, "unexpected low surrogate area", parser->offset, value); /* Check for a high surrogate area. */ if ((value & 0xFC00) == 0xD800) { width = 4; /* Check for incomplete surrogate pair. */ if (raw_unread < 4) { if (parser->eof) { return yaml_parser_set_reader_error(parser, "incomplete UTF-16 surrogate pair", parser->offset, -1); } incomplete = 1; break; } /* Get the next character. */ value2 = parser->raw_buffer.pointer[low+2] + (parser->raw_buffer.pointer[high+2] << 8); /* Check for a low surrogate area. */ if ((value2 & 0xFC00) != 0xDC00) return yaml_parser_set_reader_error(parser, "expected low surrogate area", parser->offset+2, value2); /* Generate the value of the surrogate pair. */ value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF); } else { width = 2; } break; default: assert(1); /* Impossible. */ } /* Check if the raw buffer contains enough bytes to form a character. */ if (incomplete) break; /* * Check if the character is in the allowed range: * #x9 | #xA | #xD | [#x20-#x7E] (8 bit) * | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit) * | [#x10000-#x10FFFF] (32 bit) */ if (! (value == 0x09 || value == 0x0A || value == 0x0D || (value >= 0x20 && value <= 0x7E) || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF) || (value >= 0xE000 && value <= 0xFFFD) || (value >= 0x10000 && value <= 0x10FFFF))) return yaml_parser_set_reader_error(parser, "control characters are not allowed", parser->offset, value); /* Move the raw pointers. */ parser->raw_buffer.pointer += width; parser->offset += width; /* Finally put the character into the buffer. */ /* 0000 0000-0000 007F -> 0xxxxxxx */ if (value <= 0x7F) { *(parser->buffer.last++) = value; } /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ else if (value <= 0x7FF) { *(parser->buffer.last++) = 0xC0 + (value >> 6); *(parser->buffer.last++) = 0x80 + (value & 0x3F); } /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ else if (value <= 0xFFFF) { *(parser->buffer.last++) = 0xE0 + (value >> 12); *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); *(parser->buffer.last++) = 0x80 + (value & 0x3F); } /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ else { *(parser->buffer.last++) = 0xF0 + (value >> 18); *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F); *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); *(parser->buffer.last++) = 0x80 + (value & 0x3F); } parser->unread ++; } /* On EOF, put NUL into the buffer and return. */ if (parser->eof) { *(parser->buffer.last++) = '\0'; parser->unread ++; return 1; } } if (parser->offset >= MAX_FILE_SIZE) { return yaml_parser_set_reader_error(parser, "input is too long", parser->offset, -1); } return 1; } ruamel.yaml-0.15.89/ext/parser.c0000664000175100001440000013045113351131445017041 0ustar anthonusers00000000000000 /* * The parser implements the following grammar: * * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END * implicit_document ::= block_node DOCUMENT-END* * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* * block_node_or_indentless_sequence ::= * ALIAS * | properties (block_content | indentless_block_sequence)? * | block_content * | indentless_block_sequence * block_node ::= ALIAS * | properties block_content? * | block_content * flow_node ::= ALIAS * | properties flow_content? * | flow_content * properties ::= TAG ANCHOR? | ANCHOR TAG? * block_content ::= block_collection | flow_collection | SCALAR * flow_content ::= flow_collection | SCALAR * block_collection ::= block_sequence | block_mapping * flow_collection ::= flow_sequence | flow_mapping * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END * indentless_sequence ::= (BLOCK-ENTRY block_node?)+ * block_mapping ::= BLOCK-MAPPING_START * ((KEY block_node_or_indentless_sequence?)? * (VALUE block_node_or_indentless_sequence?)?)* * BLOCK-END * flow_sequence ::= FLOW-SEQUENCE-START * (flow_sequence_entry FLOW-ENTRY)* * flow_sequence_entry? * FLOW-SEQUENCE-END * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * flow_mapping ::= FLOW-MAPPING-START * (flow_mapping_entry FLOW-ENTRY)* * flow_mapping_entry? * FLOW-MAPPING-END * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? */ #include "yaml_private.h" /* * Peek the next token in the token queue. */ #define PEEK_TOKEN(parser) \ ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ parser->tokens.head : NULL) /* * Remove the next token from the queue (must be called after PEEK_TOKEN). */ #define SKIP_TOKEN(parser) \ (parser->token_available = 0, \ parser->tokens_parsed ++, \ parser->stream_end_produced = \ (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ parser->tokens.head ++) /* * Public API declarations. */ YAML_DECLARE(int) yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); /* * Error handling. */ static int yaml_parser_set_parser_error(yaml_parser_t *parser, const char *problem, yaml_mark_t problem_mark); static int yaml_parser_set_parser_error_context(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem, yaml_mark_t problem_mark); /* * State functions. */ static int yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event, int implicit); static int yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event, int block, int indentless_sequence); static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, yaml_event_t *event, int first); static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, yaml_event_t *event, int first); static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, yaml_event_t *event, int first); static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser, yaml_event_t *event); static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, yaml_event_t *event, int first); static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, yaml_event_t *event, int empty); /* * Utility functions. */ static int yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event, yaml_mark_t mark); static int yaml_parser_process_directives(yaml_parser_t *parser, yaml_version_directive_t **version_directive_ref, yaml_tag_directive_t **tag_directives_start_ref, yaml_tag_directive_t **tag_directives_end_ref); static int yaml_parser_append_tag_directive(yaml_parser_t *parser, yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark); /* * Get the next event. */ YAML_DECLARE(int) yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) { assert(parser); /* Non-NULL parser object is expected. */ assert(event); /* Non-NULL event object is expected. */ /* Erase the event object. */ memset(event, 0, sizeof(yaml_event_t)); /* No events after the end of the stream or error. */ if (parser->stream_end_produced || parser->error || parser->state == YAML_PARSE_END_STATE) { return 1; } /* Generate the next event. */ return yaml_parser_state_machine(parser, event); } /* * Set parser error. */ static int yaml_parser_set_parser_error(yaml_parser_t *parser, const char *problem, yaml_mark_t problem_mark) { parser->error = YAML_PARSER_ERROR; parser->problem = problem; parser->problem_mark = problem_mark; return 0; } static int yaml_parser_set_parser_error_context(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem, yaml_mark_t problem_mark) { parser->error = YAML_PARSER_ERROR; parser->context = context; parser->context_mark = context_mark; parser->problem = problem; parser->problem_mark = problem_mark; return 0; } /* * State dispatcher. */ static int yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event) { switch (parser->state) { case YAML_PARSE_STREAM_START_STATE: return yaml_parser_parse_stream_start(parser, event); case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE: return yaml_parser_parse_document_start(parser, event, 1); case YAML_PARSE_DOCUMENT_START_STATE: return yaml_parser_parse_document_start(parser, event, 0); case YAML_PARSE_DOCUMENT_CONTENT_STATE: return yaml_parser_parse_document_content(parser, event); case YAML_PARSE_DOCUMENT_END_STATE: return yaml_parser_parse_document_end(parser, event); case YAML_PARSE_BLOCK_NODE_STATE: return yaml_parser_parse_node(parser, event, 1, 0); case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: return yaml_parser_parse_node(parser, event, 1, 1); case YAML_PARSE_FLOW_NODE_STATE: return yaml_parser_parse_node(parser, event, 0, 0); case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: return yaml_parser_parse_block_sequence_entry(parser, event, 1); case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: return yaml_parser_parse_block_sequence_entry(parser, event, 0); case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: return yaml_parser_parse_indentless_sequence_entry(parser, event); case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: return yaml_parser_parse_block_mapping_key(parser, event, 1); case YAML_PARSE_BLOCK_MAPPING_KEY_STATE: return yaml_parser_parse_block_mapping_key(parser, event, 0); case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE: return yaml_parser_parse_block_mapping_value(parser, event); case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: return yaml_parser_parse_flow_sequence_entry(parser, event, 1); case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE: return yaml_parser_parse_flow_sequence_entry(parser, event, 0); case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event); case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event); case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event); case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: return yaml_parser_parse_flow_mapping_key(parser, event, 1); case YAML_PARSE_FLOW_MAPPING_KEY_STATE: return yaml_parser_parse_flow_mapping_key(parser, event, 0); case YAML_PARSE_FLOW_MAPPING_VALUE_STATE: return yaml_parser_parse_flow_mapping_value(parser, event, 0); case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: return yaml_parser_parse_flow_mapping_value(parser, event, 1); default: assert(1); /* Invalid state. */ } return 0; } /* * Parse the production: * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END * ************ */ static int yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_STREAM_START_TOKEN) { return yaml_parser_set_parser_error(parser, "did not find expected ", token->start_mark); } parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE; STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding, token->start_mark, token->start_mark); SKIP_TOKEN(parser); return 1; } /* * Parse the productions: * implicit_document ::= block_node DOCUMENT-END* * * * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* * ************************* */ static int yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event, int implicit) { yaml_token_t *token; yaml_version_directive_t *version_directive = NULL; struct { yaml_tag_directive_t *start; yaml_tag_directive_t *end; } tag_directives = { NULL, NULL }; token = PEEK_TOKEN(parser); if (!token) return 0; /* Parse extra document end indicators. */ if (!implicit) { while (token->type == YAML_DOCUMENT_END_TOKEN) { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; } } /* Parse an implicit document. */ if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN && token->type != YAML_TAG_DIRECTIVE_TOKEN && token->type != YAML_DOCUMENT_START_TOKEN && token->type != YAML_STREAM_END_TOKEN) { if (!yaml_parser_process_directives(parser, NULL, NULL, NULL)) return 0; if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) return 0; parser->state = YAML_PARSE_BLOCK_NODE_STATE; DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1, token->start_mark, token->start_mark); return 1; } /* Parse an explicit document. */ else if (token->type != YAML_STREAM_END_TOKEN) { yaml_mark_t start_mark, end_mark; start_mark = token->start_mark; if (!yaml_parser_process_directives(parser, &version_directive, &tag_directives.start, &tag_directives.end)) return 0; token = PEEK_TOKEN(parser); if (!token) goto error; if (token->type != YAML_DOCUMENT_START_TOKEN) { yaml_parser_set_parser_error(parser, "did not find expected ", token->start_mark); goto error; } if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) goto error; parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE; end_mark = token->end_mark; DOCUMENT_START_EVENT_INIT(*event, version_directive, tag_directives.start, tag_directives.end, 0, start_mark, end_mark); SKIP_TOKEN(parser); version_directive = NULL; tag_directives.start = tag_directives.end = NULL; return 1; } /* Parse the stream end. */ else { parser->state = YAML_PARSE_END_STATE; STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } error: yaml_free(version_directive); while (tag_directives.start != tag_directives.end) { yaml_free(tag_directives.end[-1].handle); yaml_free(tag_directives.end[-1].prefix); tag_directives.end --; } yaml_free(tag_directives.start); return 0; } /* * Parse the productions: * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* * *********** */ static int yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_VERSION_DIRECTIVE_TOKEN || token->type == YAML_TAG_DIRECTIVE_TOKEN || token->type == YAML_DOCUMENT_START_TOKEN || token->type == YAML_DOCUMENT_END_TOKEN || token->type == YAML_STREAM_END_TOKEN) { parser->state = POP(parser, parser->states); return yaml_parser_process_empty_scalar(parser, event, token->start_mark); } else { return yaml_parser_parse_node(parser, event, 1, 0); } } /* * Parse the productions: * implicit_document ::= block_node DOCUMENT-END* * ************* * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* * ************* */ static int yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; yaml_mark_t start_mark, end_mark; int implicit = 1; token = PEEK_TOKEN(parser); if (!token) return 0; start_mark = end_mark = token->start_mark; if (token->type == YAML_DOCUMENT_END_TOKEN) { end_mark = token->end_mark; SKIP_TOKEN(parser); implicit = 0; } while (!STACK_EMPTY(parser, parser->tag_directives)) { yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); yaml_free(tag_directive.handle); yaml_free(tag_directive.prefix); } parser->state = YAML_PARSE_DOCUMENT_START_STATE; DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark); return 1; } /* * Parse the productions: * block_node_or_indentless_sequence ::= * ALIAS * ***** * | properties (block_content | indentless_block_sequence)? * ********** * * | block_content | indentless_block_sequence * * * block_node ::= ALIAS * ***** * | properties block_content? * ********** * * | block_content * * * flow_node ::= ALIAS * ***** * | properties flow_content? * ********** * * | flow_content * * * properties ::= TAG ANCHOR? | ANCHOR TAG? * ************************* * block_content ::= block_collection | flow_collection | SCALAR * ****** * flow_content ::= flow_collection | SCALAR * ****** */ static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event, int block, int indentless_sequence) { yaml_token_t *token; yaml_char_t *anchor = NULL; yaml_char_t *tag_handle = NULL; yaml_char_t *tag_suffix = NULL; yaml_char_t *tag = NULL; yaml_mark_t start_mark, end_mark, tag_mark; int implicit; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_ALIAS_TOKEN) { parser->state = POP(parser, parser->states); ALIAS_EVENT_INIT(*event, token->data.alias.value, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } else { start_mark = end_mark = token->start_mark; if (token->type == YAML_ANCHOR_TOKEN) { anchor = token->data.anchor.value; start_mark = token->start_mark; end_mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) goto error; if (token->type == YAML_TAG_TOKEN) { tag_handle = token->data.tag.handle; tag_suffix = token->data.tag.suffix; tag_mark = token->start_mark; end_mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) goto error; } } else if (token->type == YAML_TAG_TOKEN) { tag_handle = token->data.tag.handle; tag_suffix = token->data.tag.suffix; start_mark = tag_mark = token->start_mark; end_mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) goto error; if (token->type == YAML_ANCHOR_TOKEN) { anchor = token->data.anchor.value; end_mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) goto error; } } if (tag_handle) { if (!*tag_handle) { tag = tag_suffix; yaml_free(tag_handle); tag_handle = tag_suffix = NULL; } else { yaml_tag_directive_t *tag_directive; for (tag_directive = parser->tag_directives.start; tag_directive != parser->tag_directives.top; tag_directive ++) { if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { size_t prefix_len = strlen((char *)tag_directive->prefix); size_t suffix_len = strlen((char *)tag_suffix); tag = YAML_MALLOC(prefix_len+suffix_len+1); if (!tag) { parser->error = YAML_MEMORY_ERROR; goto error; } memcpy(tag, tag_directive->prefix, prefix_len); memcpy(tag+prefix_len, tag_suffix, suffix_len); tag[prefix_len+suffix_len] = '\0'; yaml_free(tag_handle); yaml_free(tag_suffix); tag_handle = tag_suffix = NULL; break; } } if (!tag) { yaml_parser_set_parser_error_context(parser, "while parsing a node", start_mark, "found undefined tag handle", tag_mark); goto error; } } } implicit = (!tag || !*tag); if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) { end_mark = token->end_mark; parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); return 1; } else { if (token->type == YAML_SCALAR_TOKEN) { int plain_implicit = 0; int quoted_implicit = 0; end_mark = token->end_mark; if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag) || (tag && strcmp((char *)tag, "!") == 0)) { plain_implicit = 1; } else if (!tag) { quoted_implicit = 1; } parser->state = POP(parser, parser->states); SCALAR_EVENT_INIT(*event, anchor, tag, token->data.scalar.value, token->data.scalar.length, plain_implicit, quoted_implicit, token->data.scalar.style, start_mark, end_mark); SKIP_TOKEN(parser); return 1; } else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) { end_mark = token->end_mark; parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE; SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark); return 1; } else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) { end_mark = token->end_mark; parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE; MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, YAML_FLOW_MAPPING_STYLE, start_mark, end_mark); return 1; } else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) { end_mark = token->end_mark; parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE; SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); return 1; } else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) { end_mark = token->end_mark; parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE; MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark); return 1; } else if (anchor || tag) { yaml_char_t *value = YAML_MALLOC(1); if (!value) { parser->error = YAML_MEMORY_ERROR; goto error; } value[0] = '\0'; parser->state = POP(parser, parser->states); SCALAR_EVENT_INIT(*event, anchor, tag, value, 0, implicit, 0, YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark); return 1; } else { yaml_parser_set_parser_error_context(parser, (block ? "while parsing a block node" : "while parsing a flow node"), start_mark, "did not find expected node content", token->start_mark); goto error; } } } error: yaml_free(anchor); yaml_free(tag_handle); yaml_free(tag_suffix); yaml_free(tag); return 0; } /* * Parse the productions: * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END * ******************** *********** * ********* */ static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, yaml_event_t *event, int first) { yaml_token_t *token; if (first) { token = PEEK_TOKEN(parser); if (!PUSH(parser, parser->marks, token->start_mark)) return 0; SKIP_TOKEN(parser); } token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_BLOCK_ENTRY_TOKEN) { yaml_mark_t mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_BLOCK_ENTRY_TOKEN && token->type != YAML_BLOCK_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)) return 0; return yaml_parser_parse_node(parser, event, 1, 0); } else { parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE; return yaml_parser_process_empty_scalar(parser, event, mark); } } else if (token->type == YAML_BLOCK_END_TOKEN) { yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */ parser->state = POP(parser, parser->states); dummy_mark = POP(parser, parser->marks); SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } else { return yaml_parser_set_parser_error_context(parser, "while parsing a block collection", POP(parser, parser->marks), "did not find expected '-' indicator", token->start_mark); } } /* * Parse the productions: * indentless_sequence ::= (BLOCK-ENTRY block_node?)+ * *********** * */ static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_BLOCK_ENTRY_TOKEN) { yaml_mark_t mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_BLOCK_ENTRY_TOKEN && token->type != YAML_KEY_TOKEN && token->type != YAML_VALUE_TOKEN && token->type != YAML_BLOCK_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)) return 0; return yaml_parser_parse_node(parser, event, 1, 0); } else { parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; return yaml_parser_process_empty_scalar(parser, event, mark); } } else { parser->state = POP(parser, parser->states); SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark); return 1; } } /* * Parse the productions: * block_mapping ::= BLOCK-MAPPING_START * ******************* * ((KEY block_node_or_indentless_sequence?)? * *** * * (VALUE block_node_or_indentless_sequence?)?)* * * BLOCK-END * ********* */ static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, yaml_event_t *event, int first) { yaml_token_t *token; if (first) { token = PEEK_TOKEN(parser); if (!PUSH(parser, parser->marks, token->start_mark)) return 0; SKIP_TOKEN(parser); } token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_KEY_TOKEN) { yaml_mark_t mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_KEY_TOKEN && token->type != YAML_VALUE_TOKEN && token->type != YAML_BLOCK_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_BLOCK_MAPPING_VALUE_STATE)) return 0; return yaml_parser_parse_node(parser, event, 1, 1); } else { parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE; return yaml_parser_process_empty_scalar(parser, event, mark); } } else if (token->type == YAML_BLOCK_END_TOKEN) { yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */ parser->state = POP(parser, parser->states); dummy_mark = POP(parser, parser->marks); MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } else { return yaml_parser_set_parser_error_context(parser, "while parsing a block mapping", POP(parser, parser->marks), "did not find expected key", token->start_mark); } } /* * Parse the productions: * block_mapping ::= BLOCK-MAPPING_START * * ((KEY block_node_or_indentless_sequence?)? * * (VALUE block_node_or_indentless_sequence?)?)* * ***** * * BLOCK-END * */ static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_VALUE_TOKEN) { yaml_mark_t mark = token->end_mark; SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_KEY_TOKEN && token->type != YAML_VALUE_TOKEN && token->type != YAML_BLOCK_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_BLOCK_MAPPING_KEY_STATE)) return 0; return yaml_parser_parse_node(parser, event, 1, 1); } else { parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; return yaml_parser_process_empty_scalar(parser, event, mark); } } else { parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; return yaml_parser_process_empty_scalar(parser, event, token->start_mark); } } /* * Parse the productions: * flow_sequence ::= FLOW-SEQUENCE-START * ******************* * (flow_sequence_entry FLOW-ENTRY)* * * ********** * flow_sequence_entry? * * * FLOW-SEQUENCE-END * ***************** * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * * */ static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, yaml_event_t *event, int first) { yaml_token_t *token; yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */ if (first) { token = PEEK_TOKEN(parser); if (!PUSH(parser, parser->marks, token->start_mark)) return 0; SKIP_TOKEN(parser); } token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { if (!first) { if (token->type == YAML_FLOW_ENTRY_TOKEN) { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; } else { return yaml_parser_set_parser_error_context(parser, "while parsing a flow sequence", POP(parser, parser->marks), "did not find expected ',' or ']'", token->start_mark); } } if (token->type == YAML_KEY_TOKEN) { parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE; MAPPING_START_EVENT_INIT(*event, NULL, NULL, 1, YAML_FLOW_MAPPING_STYLE, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE)) return 0; return yaml_parser_parse_node(parser, event, 0, 0); } } parser->state = POP(parser, parser->states); dummy_mark = POP(parser, parser->marks); SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } /* * Parse the productions: * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * *** * */ static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)) return 0; return yaml_parser_parse_node(parser, event, 0, 0); } else { yaml_mark_t mark = token->end_mark; SKIP_TOKEN(parser); parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; return yaml_parser_process_empty_scalar(parser, event, mark); } } /* * Parse the productions: * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * ***** * */ static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type == YAML_VALUE_TOKEN) { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_FLOW_ENTRY_TOKEN && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)) return 0; return yaml_parser_parse_node(parser, event, 0, 0); } } parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE; return yaml_parser_process_empty_scalar(parser, event, token->start_mark); } /* * Parse the productions: * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * * */ static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser, yaml_event_t *event) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE; MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark); return 1; } /* * Parse the productions: * flow_mapping ::= FLOW-MAPPING-START * ****************** * (flow_mapping_entry FLOW-ENTRY)* * * ********** * flow_mapping_entry? * ****************** * FLOW-MAPPING-END * **************** * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * * *** * */ static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, yaml_event_t *event, int first) { yaml_token_t *token; yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */ if (first) { token = PEEK_TOKEN(parser); if (!PUSH(parser, parser->marks, token->start_mark)) return 0; SKIP_TOKEN(parser); } token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_FLOW_MAPPING_END_TOKEN) { if (!first) { if (token->type == YAML_FLOW_ENTRY_TOKEN) { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; } else { return yaml_parser_set_parser_error_context(parser, "while parsing a flow mapping", POP(parser, parser->marks), "did not find expected ',' or '}'", token->start_mark); } } if (token->type == YAML_KEY_TOKEN) { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN && token->type != YAML_FLOW_MAPPING_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_FLOW_MAPPING_VALUE_STATE)) return 0; return yaml_parser_parse_node(parser, event, 0, 0); } else { parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE; return yaml_parser_process_empty_scalar(parser, event, token->start_mark); } } else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)) return 0; return yaml_parser_parse_node(parser, event, 0, 0); } } parser->state = POP(parser, parser->states); dummy_mark = POP(parser, parser->marks); MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); SKIP_TOKEN(parser); return 1; } /* * Parse the productions: * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? * * ***** * */ static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, yaml_event_t *event, int empty) { yaml_token_t *token; token = PEEK_TOKEN(parser); if (!token) return 0; if (empty) { parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; return yaml_parser_process_empty_scalar(parser, event, token->start_mark); } if (token->type == YAML_VALUE_TOKEN) { SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) return 0; if (token->type != YAML_FLOW_ENTRY_TOKEN && token->type != YAML_FLOW_MAPPING_END_TOKEN) { if (!PUSH(parser, parser->states, YAML_PARSE_FLOW_MAPPING_KEY_STATE)) return 0; return yaml_parser_parse_node(parser, event, 0, 0); } } parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; return yaml_parser_process_empty_scalar(parser, event, token->start_mark); } /* * Generate an empty scalar event. */ static int yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event, yaml_mark_t mark) { yaml_char_t *value; value = YAML_MALLOC(1); if (!value) { parser->error = YAML_MEMORY_ERROR; return 0; } value[0] = '\0'; SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0, 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark); return 1; } /* * Parse directives. */ static int yaml_parser_process_directives(yaml_parser_t *parser, yaml_version_directive_t **version_directive_ref, yaml_tag_directive_t **tag_directives_start_ref, yaml_tag_directive_t **tag_directives_end_ref) { yaml_tag_directive_t default_tag_directives[] = { {(yaml_char_t *)"!", (yaml_char_t *)"!"}, {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, {NULL, NULL} }; yaml_tag_directive_t *default_tag_directive; yaml_version_directive_t *version_directive = NULL; struct { yaml_tag_directive_t *start; yaml_tag_directive_t *end; yaml_tag_directive_t *top; } tag_directives = { NULL, NULL, NULL }; yaml_token_t *token; if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*)) goto error; token = PEEK_TOKEN(parser); if (!token) goto error; while (token->type == YAML_VERSION_DIRECTIVE_TOKEN || token->type == YAML_TAG_DIRECTIVE_TOKEN) { if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) { if (version_directive) { yaml_parser_set_parser_error(parser, "found duplicate %YAML directive", token->start_mark); goto error; } if (token->data.version_directive.major != 1 || (token->data.version_directive.minor != 1 && token->data.version_directive.minor != 2 ) ) { yaml_parser_set_parser_error(parser, "found incompatible YAML document", token->start_mark); goto error; } version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t); if (!version_directive) { parser->error = YAML_MEMORY_ERROR; goto error; } version_directive->major = token->data.version_directive.major; version_directive->minor = token->data.version_directive.minor; } else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) { yaml_tag_directive_t value; value.handle = token->data.tag_directive.handle; value.prefix = token->data.tag_directive.prefix; if (!yaml_parser_append_tag_directive(parser, value, 0, token->start_mark)) goto error; if (!PUSH(parser, tag_directives, value)) goto error; } SKIP_TOKEN(parser); token = PEEK_TOKEN(parser); if (!token) goto error; } for (default_tag_directive = default_tag_directives; default_tag_directive->handle; default_tag_directive++) { if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1, token->start_mark)) goto error; } if (version_directive_ref) { *version_directive_ref = version_directive; } if (tag_directives_start_ref) { if (STACK_EMPTY(parser, tag_directives)) { *tag_directives_start_ref = *tag_directives_end_ref = NULL; STACK_DEL(parser, tag_directives); } else { *tag_directives_start_ref = tag_directives.start; *tag_directives_end_ref = tag_directives.top; } } else { STACK_DEL(parser, tag_directives); } if (!version_directive_ref) yaml_free(version_directive); return 1; error: yaml_free(version_directive); while (!STACK_EMPTY(parser, tag_directives)) { yaml_tag_directive_t tag_directive = POP(parser, tag_directives); yaml_free(tag_directive.handle); yaml_free(tag_directive.prefix); } STACK_DEL(parser, tag_directives); return 0; } /* * Append a tag directive to the directives stack. */ static int yaml_parser_append_tag_directive(yaml_parser_t *parser, yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark) { yaml_tag_directive_t *tag_directive; yaml_tag_directive_t copy = { NULL, NULL }; for (tag_directive = parser->tag_directives.start; tag_directive != parser->tag_directives.top; tag_directive ++) { if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { if (allow_duplicates) return 1; return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark); } } copy.handle = yaml_strdup(value.handle); copy.prefix = yaml_strdup(value.prefix); if (!copy.handle || !copy.prefix) { parser->error = YAML_MEMORY_ERROR; goto error; } if (!PUSH(parser, parser->tag_directives, copy)) goto error; return 1; error: yaml_free(copy.handle); yaml_free(copy.prefix); return 0; } ruamel.yaml-0.15.89/ext/emitter.c0000664000175100001440000020124513351131445017216 0ustar anthonusers00000000000000 #include "yaml_private.h" /* * Flush the buffer if needed. */ #define FLUSH(emitter) \ ((emitter->buffer.pointer+5 < emitter->buffer.end) \ || yaml_emitter_flush(emitter)) /* * Put a character to the output buffer. */ #define PUT(emitter,value) \ (FLUSH(emitter) \ && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ emitter->column++, \ 1)) /* * Put a line break to the output buffer. */ #define PUT_BREAK(emitter) \ (FLUSH(emitter) \ && ((emitter->line_break == YAML_CR_BREAK ? \ (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ emitter->line_break == YAML_LN_BREAK ? \ (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ emitter->line_break == YAML_CRLN_BREAK ? \ (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ emitter->column = 0, \ emitter->line ++, \ 1)) /* * Copy a character from a string into buffer. */ #define WRITE(emitter,string) \ (FLUSH(emitter) \ && (COPY(emitter->buffer,string), \ emitter->column ++, \ 1)) /* * Copy a line break character from a string into buffer. */ #define WRITE_BREAK(emitter,string) \ (FLUSH(emitter) \ && (CHECK(string,'\n') ? \ (PUT_BREAK(emitter), \ string.pointer ++, \ 1) : \ (COPY(emitter->buffer,string), \ emitter->column = 0, \ emitter->line ++, \ 1))) /* * API functions. */ YAML_DECLARE(int) yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); /* * Utility functions. */ static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem); static int yaml_emitter_need_more_events(yaml_emitter_t *emitter); static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter, yaml_tag_directive_t value, int allow_duplicates); static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow, int indentless); /* * State functions. */ static int yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter, yaml_event_t *event, int first); static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter, yaml_event_t *event, int first); static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter, yaml_event_t *event, int first); static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter, yaml_event_t *event, int simple); static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter, yaml_event_t *event, int first); static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter, yaml_event_t *event, int first); static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter, yaml_event_t *event, int simple); static int yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event, int root, int sequence, int mapping, int simple_key); static int yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event); static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event); /* * Checkers. */ static int yaml_emitter_check_empty_document(yaml_emitter_t *emitter); static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter); static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter); static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter); static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event); /* * Processors. */ static int yaml_emitter_process_anchor(yaml_emitter_t *emitter); static int yaml_emitter_process_tag(yaml_emitter_t *emitter); static int yaml_emitter_process_scalar(yaml_emitter_t *emitter); /* * Analyzers. */ static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter, yaml_version_directive_t version_directive); static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter, yaml_tag_directive_t tag_directive); static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter, yaml_char_t *anchor, int alias); static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag); static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length); static int yaml_emitter_analyze_event(yaml_emitter_t *emitter, yaml_event_t *event); /* * Writers. */ static int yaml_emitter_write_bom(yaml_emitter_t *emitter); static int yaml_emitter_write_indent(yaml_emitter_t *emitter); static int yaml_emitter_write_indicator(yaml_emitter_t *emitter, const char *indicator, int need_whitespace, int is_whitespace, int is_indention); static int yaml_emitter_write_anchor(yaml_emitter_t *emitter, yaml_char_t *value, size_t length); static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, yaml_char_t *value, size_t length); static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int need_whitespace); static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks); static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks); static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks); static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter, yaml_string_t string); static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length); static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length); /* * Set an emitter error and return 0. */ static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem) { emitter->error = YAML_EMITTER_ERROR; emitter->problem = problem; return 0; } /* * Emit an event. */ YAML_DECLARE(int) yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) { if (!ENQUEUE(emitter, emitter->events, *event)) { yaml_event_delete(event); return 0; } while (!yaml_emitter_need_more_events(emitter)) { if (!yaml_emitter_analyze_event(emitter, emitter->events.head)) return 0; if (!yaml_emitter_state_machine(emitter, emitter->events.head)) return 0; yaml_event_delete(&DEQUEUE(emitter, emitter->events)); } return 1; } /* * Check if we need to accumulate more events before emitting. * * We accumulate extra * - 1 event for DOCUMENT-START * - 2 events for SEQUENCE-START * - 3 events for MAPPING-START */ static int yaml_emitter_need_more_events(yaml_emitter_t *emitter) { int level = 0; int accumulate = 0; yaml_event_t *event; if (QUEUE_EMPTY(emitter, emitter->events)) return 1; switch (emitter->events.head->type) { case YAML_DOCUMENT_START_EVENT: accumulate = 1; break; case YAML_SEQUENCE_START_EVENT: accumulate = 2; break; case YAML_MAPPING_START_EVENT: accumulate = 3; break; default: return 0; } if (emitter->events.tail - emitter->events.head > accumulate) return 0; for (event = emitter->events.head; event != emitter->events.tail; event ++) { switch (event->type) { case YAML_STREAM_START_EVENT: case YAML_DOCUMENT_START_EVENT: case YAML_SEQUENCE_START_EVENT: case YAML_MAPPING_START_EVENT: level += 1; break; case YAML_STREAM_END_EVENT: case YAML_DOCUMENT_END_EVENT: case YAML_SEQUENCE_END_EVENT: case YAML_MAPPING_END_EVENT: level -= 1; break; default: break; } if (!level) return 0; } return 1; } /* * Append a directive to the directives stack. */ static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter, yaml_tag_directive_t value, int allow_duplicates) { yaml_tag_directive_t *tag_directive; yaml_tag_directive_t copy = { NULL, NULL }; for (tag_directive = emitter->tag_directives.start; tag_directive != emitter->tag_directives.top; tag_directive ++) { if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { if (allow_duplicates) return 1; return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive"); } } copy.handle = yaml_strdup(value.handle); copy.prefix = yaml_strdup(value.prefix); if (!copy.handle || !copy.prefix) { emitter->error = YAML_MEMORY_ERROR; goto error; } if (!PUSH(emitter, emitter->tag_directives, copy)) goto error; return 1; error: yaml_free(copy.handle); yaml_free(copy.prefix); return 0; } /* * Increase the indentation level. */ static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow, int indentless) { if (!PUSH(emitter, emitter->indents, emitter->indent)) return 0; if (emitter->indent < 0) { emitter->indent = flow ? emitter->best_indent : 0; } else if (!indentless) { emitter->indent += emitter->best_indent; } return 1; } /* * State dispatcher. */ static int yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event) { switch (emitter->state) { case YAML_EMIT_STREAM_START_STATE: return yaml_emitter_emit_stream_start(emitter, event); case YAML_EMIT_FIRST_DOCUMENT_START_STATE: return yaml_emitter_emit_document_start(emitter, event, 1); case YAML_EMIT_DOCUMENT_START_STATE: return yaml_emitter_emit_document_start(emitter, event, 0); case YAML_EMIT_DOCUMENT_CONTENT_STATE: return yaml_emitter_emit_document_content(emitter, event); case YAML_EMIT_DOCUMENT_END_STATE: return yaml_emitter_emit_document_end(emitter, event); case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE: return yaml_emitter_emit_flow_sequence_item(emitter, event, 1); case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE: return yaml_emitter_emit_flow_sequence_item(emitter, event, 0); case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE: return yaml_emitter_emit_flow_mapping_key(emitter, event, 1); case YAML_EMIT_FLOW_MAPPING_KEY_STATE: return yaml_emitter_emit_flow_mapping_key(emitter, event, 0); case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE: return yaml_emitter_emit_flow_mapping_value(emitter, event, 1); case YAML_EMIT_FLOW_MAPPING_VALUE_STATE: return yaml_emitter_emit_flow_mapping_value(emitter, event, 0); case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE: return yaml_emitter_emit_block_sequence_item(emitter, event, 1); case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE: return yaml_emitter_emit_block_sequence_item(emitter, event, 0); case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE: return yaml_emitter_emit_block_mapping_key(emitter, event, 1); case YAML_EMIT_BLOCK_MAPPING_KEY_STATE: return yaml_emitter_emit_block_mapping_key(emitter, event, 0); case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE: return yaml_emitter_emit_block_mapping_value(emitter, event, 1); case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE: return yaml_emitter_emit_block_mapping_value(emitter, event, 0); case YAML_EMIT_END_STATE: return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END"); default: assert(1); /* Invalid state. */ } return 0; } /* * Expect STREAM-START. */ static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter, yaml_event_t *event) { if (event->type == YAML_STREAM_START_EVENT) { if (!emitter->encoding) { emitter->encoding = event->data.stream_start.encoding; } if (!emitter->encoding) { emitter->encoding = YAML_UTF8_ENCODING; } if (emitter->best_indent < 2 || emitter->best_indent > 9) { emitter->best_indent = 2; } if (emitter->best_width >= 0 && emitter->best_width <= emitter->best_indent*2) { emitter->best_width = 80; } if (emitter->best_width < 0) { emitter->best_width = INT_MAX; } if (!emitter->line_break) { emitter->line_break = YAML_LN_BREAK; } emitter->indent = -1; emitter->line = 0; emitter->column = 0; emitter->whitespace = 1; emitter->indention = 1; if (emitter->encoding != YAML_UTF8_ENCODING) { if (!yaml_emitter_write_bom(emitter)) return 0; } emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE; return 1; } return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START"); } /* * Expect DOCUMENT-START or STREAM-END. */ /* assume 2 digits + . + 2 digits max and NUL*/ #define VERSION_BUF_LEN 50 static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter, yaml_event_t *event, int first) { char version_buf[VERSION_BUF_LEN]; yaml_version_directive_t vdp; if (event->type == YAML_DOCUMENT_START_EVENT) { yaml_tag_directive_t default_tag_directives[] = { {(yaml_char_t *)"!", (yaml_char_t *)"!"}, {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, {NULL, NULL} }; yaml_tag_directive_t *tag_directive; int implicit; if (event->data.document_start.version_directive) { if (!yaml_emitter_analyze_version_directive(emitter, *event->data.document_start.version_directive)) return 0; } for (tag_directive = event->data.document_start.tag_directives.start; tag_directive != event->data.document_start.tag_directives.end; tag_directive ++) { if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive)) return 0; if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0)) return 0; } for (tag_directive = default_tag_directives; tag_directive->handle; tag_directive ++) { if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1)) return 0; } implicit = event->data.document_start.implicit; if (!first || emitter->canonical) { implicit = 0; } if ((event->data.document_start.version_directive || (event->data.document_start.tag_directives.start != event->data.document_start.tag_directives.end)) && emitter->open_ended) { if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } if (event->data.document_start.version_directive) { implicit = 0; if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0)) return 0; /* if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0)) */ vdp = *event->data.document_start.version_directive; sprintf(version_buf, "%d.%d", vdp.major, vdp.minor); if (!yaml_emitter_write_indicator(emitter, version_buf, 1, 0, 0)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } if (event->data.document_start.tag_directives.start != event->data.document_start.tag_directives.end) { implicit = 0; for (tag_directive = event->data.document_start.tag_directives.start; tag_directive != event->data.document_start.tag_directives.end; tag_directive ++) { if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0)) return 0; if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle, strlen((char *)tag_directive->handle))) return 0; if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix, strlen((char *)tag_directive->prefix), 1)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } } if (yaml_emitter_check_empty_document(emitter)) { implicit = 0; } if (!implicit) { if (!yaml_emitter_write_indent(emitter)) return 0; if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0)) return 0; if (emitter->canonical) { if (!yaml_emitter_write_indent(emitter)) return 0; } } emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE; return 1; } else if (event->type == YAML_STREAM_END_EVENT) { if (emitter->open_ended) { if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } if (!yaml_emitter_flush(emitter)) return 0; emitter->state = YAML_EMIT_END_STATE; return 1; } return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END"); } /* * Expect the root node. */ static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter, yaml_event_t *event) { if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0); } /* * Expect DOCUMENT-END. */ static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter, yaml_event_t *event) { if (event->type == YAML_DOCUMENT_END_EVENT) { if (!yaml_emitter_write_indent(emitter)) return 0; if (!event->data.document_end.implicit) { if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } if (!yaml_emitter_flush(emitter)) return 0; emitter->state = YAML_EMIT_DOCUMENT_START_STATE; while (!STACK_EMPTY(emitter, emitter->tag_directives)) { yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives); yaml_free(tag_directive.handle); yaml_free(tag_directive.prefix); } return 1; } return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END"); } /* * * Expect a flow item node. */ static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter, yaml_event_t *event, int first) { if (first) { if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0)) return 0; if (!yaml_emitter_increase_indent(emitter, 1, 0)) return 0; emitter->flow_level ++; } if (event->type == YAML_SEQUENCE_END_EVENT) { emitter->flow_level --; emitter->indent = POP(emitter, emitter->indents); if (emitter->canonical && !first) { if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0)) return 0; emitter->state = POP(emitter, emitter->states); return 1; } if (!first) { if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) return 0; } if (emitter->canonical || emitter->column > emitter->best_width) { if (!yaml_emitter_write_indent(emitter)) return 0; } if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); } /* * Expect a flow key node. */ static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter, yaml_event_t *event, int first) { if (first) { if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0)) return 0; if (!yaml_emitter_increase_indent(emitter, 1, 0)) return 0; emitter->flow_level ++; } if (event->type == YAML_MAPPING_END_EVENT) { emitter->flow_level --; emitter->indent = POP(emitter, emitter->indents); if (emitter->canonical && !first) { if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) return 0; if (!yaml_emitter_write_indent(emitter)) return 0; } if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0)) return 0; emitter->state = POP(emitter, emitter->states); return 1; } if (!first) { if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) return 0; } if (emitter->canonical || emitter->column > emitter->best_width) { if (!yaml_emitter_write_indent(emitter)) return 0; } if (!emitter->canonical && yaml_emitter_check_simple_key(emitter)) { if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); } else { if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0)) return 0; if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_VALUE_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); } } /* * Expect a flow value node. */ static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter, yaml_event_t *event, int simple) { if (simple) { if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) return 0; } else { if (emitter->canonical || emitter->column > emitter->best_width) { if (!yaml_emitter_write_indent(emitter)) return 0; } if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0)) return 0; } if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); } /* * Expect a block item node. */ static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter, yaml_event_t *event, int first) { if (first) { if (!yaml_emitter_increase_indent(emitter, 0, (emitter->mapping_context && !emitter->indention))) return 0; } if (event->type == YAML_SEQUENCE_END_EVENT) { emitter->indent = POP(emitter, emitter->indents); emitter->state = POP(emitter, emitter->states); return 1; } if (!yaml_emitter_write_indent(emitter)) return 0; if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1)) return 0; if (!PUSH(emitter, emitter->states, YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); } /* * Expect a block key node. */ static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter, yaml_event_t *event, int first) { if (first) { if (!yaml_emitter_increase_indent(emitter, 0, 0)) return 0; } if (event->type == YAML_MAPPING_END_EVENT) { emitter->indent = POP(emitter, emitter->indents); emitter->state = POP(emitter, emitter->states); return 1; } if (!yaml_emitter_write_indent(emitter)) return 0; if (yaml_emitter_check_simple_key(emitter)) { if (!PUSH(emitter, emitter->states, YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); } else { if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1)) return 0; if (!PUSH(emitter, emitter->states, YAML_EMIT_BLOCK_MAPPING_VALUE_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); } } /* * Expect a block value node. */ static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter, yaml_event_t *event, int simple) { if (simple) { if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) return 0; } else { if (!yaml_emitter_write_indent(emitter)) return 0; if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1)) return 0; } if (!PUSH(emitter, emitter->states, YAML_EMIT_BLOCK_MAPPING_KEY_STATE)) return 0; return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); } /* * Expect a node. */ static int yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event, int root, int sequence, int mapping, int simple_key) { emitter->root_context = root; emitter->sequence_context = sequence; emitter->mapping_context = mapping; emitter->simple_key_context = simple_key; switch (event->type) { case YAML_ALIAS_EVENT: return yaml_emitter_emit_alias(emitter, event); case YAML_SCALAR_EVENT: return yaml_emitter_emit_scalar(emitter, event); case YAML_SEQUENCE_START_EVENT: return yaml_emitter_emit_sequence_start(emitter, event); case YAML_MAPPING_START_EVENT: return yaml_emitter_emit_mapping_start(emitter, event); default: return yaml_emitter_set_emitter_error(emitter, "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS"); } return 0; } /* * Expect ALIAS. */ static int yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event)) { if (!yaml_emitter_process_anchor(emitter)) return 0; emitter->state = POP(emitter, emitter->states); return 1; } /* * Expect SCALAR. */ static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event) { if (!yaml_emitter_select_scalar_style(emitter, event)) return 0; if (!yaml_emitter_process_anchor(emitter)) return 0; if (!yaml_emitter_process_tag(emitter)) return 0; if (!yaml_emitter_increase_indent(emitter, 1, 0)) return 0; if (!yaml_emitter_process_scalar(emitter)) return 0; emitter->indent = POP(emitter, emitter->indents); emitter->state = POP(emitter, emitter->states); return 1; } /* * Expect SEQUENCE-START. */ static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event) { if (!yaml_emitter_process_anchor(emitter)) return 0; if (!yaml_emitter_process_tag(emitter)) return 0; if (emitter->flow_level || emitter->canonical || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE || yaml_emitter_check_empty_sequence(emitter)) { emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE; } else { emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE; } return 1; } /* * Expect MAPPING-START. */ static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event) { if (!yaml_emitter_process_anchor(emitter)) return 0; if (!yaml_emitter_process_tag(emitter)) return 0; if (emitter->flow_level || emitter->canonical || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE || yaml_emitter_check_empty_mapping(emitter)) { emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE; } else { emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE; } return 1; } /* * Check if the document content is an empty scalar. */ static int yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter)) { return 0; } /* * Check if the next events represent an empty sequence. */ static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter) { if (emitter->events.tail - emitter->events.head < 2) return 0; return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT); } /* * Check if the next events represent an empty mapping. */ static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter) { if (emitter->events.tail - emitter->events.head < 2) return 0; return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT && emitter->events.head[1].type == YAML_MAPPING_END_EVENT); } /* * Check if the next node can be expressed as a simple key. */ static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter) { yaml_event_t *event = emitter->events.head; size_t length = 0; switch (event->type) { case YAML_ALIAS_EVENT: length += emitter->anchor_data.anchor_length; break; case YAML_SCALAR_EVENT: if (emitter->scalar_data.multiline) return 0; length += emitter->anchor_data.anchor_length + emitter->tag_data.handle_length + emitter->tag_data.suffix_length + emitter->scalar_data.length; break; case YAML_SEQUENCE_START_EVENT: if (!yaml_emitter_check_empty_sequence(emitter)) return 0; length += emitter->anchor_data.anchor_length + emitter->tag_data.handle_length + emitter->tag_data.suffix_length; break; case YAML_MAPPING_START_EVENT: if (!yaml_emitter_check_empty_mapping(emitter)) return 0; length += emitter->anchor_data.anchor_length + emitter->tag_data.handle_length + emitter->tag_data.suffix_length; break; default: return 0; } if (length > 128) return 0; return 1; } /* * Determine an acceptable scalar style. */ static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event) { yaml_scalar_style_t style = event->data.scalar.style; int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix); if (no_tag && !event->data.scalar.plain_implicit && !event->data.scalar.quoted_implicit) { return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified"); } if (style == YAML_ANY_SCALAR_STYLE) style = YAML_PLAIN_SCALAR_STYLE; if (emitter->canonical) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; if (emitter->simple_key_context && emitter->scalar_data.multiline) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; if (style == YAML_PLAIN_SCALAR_STYLE) { if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed) || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed)) style = YAML_SINGLE_QUOTED_SCALAR_STYLE; if (!emitter->scalar_data.length && (emitter->flow_level || emitter->simple_key_context)) style = YAML_SINGLE_QUOTED_SCALAR_STYLE; if (no_tag && !event->data.scalar.plain_implicit) style = YAML_SINGLE_QUOTED_SCALAR_STYLE; } if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE) { if (!emitter->scalar_data.single_quoted_allowed) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; } if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE) { if (!emitter->scalar_data.block_allowed || emitter->flow_level || emitter->simple_key_context) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; } if (no_tag && !event->data.scalar.quoted_implicit && style != YAML_PLAIN_SCALAR_STYLE) { emitter->tag_data.handle = (yaml_char_t *)"!"; emitter->tag_data.handle_length = 1; } emitter->scalar_data.style = style; return 1; } /* * Write an achor. */ static int yaml_emitter_process_anchor(yaml_emitter_t *emitter) { if (!emitter->anchor_data.anchor) return 1; if (!yaml_emitter_write_indicator(emitter, (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0)) return 0; return yaml_emitter_write_anchor(emitter, emitter->anchor_data.anchor, emitter->anchor_data.anchor_length); } /* * Write a tag. */ static int yaml_emitter_process_tag(yaml_emitter_t *emitter) { if (!emitter->tag_data.handle && !emitter->tag_data.suffix) return 1; if (emitter->tag_data.handle) { if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle, emitter->tag_data.handle_length)) return 0; if (emitter->tag_data.suffix) { if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, emitter->tag_data.suffix_length, 0)) return 0; } } else { if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0)) return 0; if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, emitter->tag_data.suffix_length, 0)) return 0; if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0)) return 0; } return 1; } /* * Write a scalar. */ static int yaml_emitter_process_scalar(yaml_emitter_t *emitter) { switch (emitter->scalar_data.style) { case YAML_PLAIN_SCALAR_STYLE: return yaml_emitter_write_plain_scalar(emitter, emitter->scalar_data.value, emitter->scalar_data.length, !emitter->simple_key_context); case YAML_SINGLE_QUOTED_SCALAR_STYLE: return yaml_emitter_write_single_quoted_scalar(emitter, emitter->scalar_data.value, emitter->scalar_data.length, !emitter->simple_key_context); case YAML_DOUBLE_QUOTED_SCALAR_STYLE: return yaml_emitter_write_double_quoted_scalar(emitter, emitter->scalar_data.value, emitter->scalar_data.length, !emitter->simple_key_context); case YAML_LITERAL_SCALAR_STYLE: return yaml_emitter_write_literal_scalar(emitter, emitter->scalar_data.value, emitter->scalar_data.length); case YAML_FOLDED_SCALAR_STYLE: return yaml_emitter_write_folded_scalar(emitter, emitter->scalar_data.value, emitter->scalar_data.length); default: assert(1); /* Impossible. */ } return 0; } /* * Check if a %YAML directive is valid. */ static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter, yaml_version_directive_t version_directive) { if (version_directive.major != 1 || ( version_directive.minor != 1 && version_directive.minor != 2) ) { return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive"); } return 1; } /* * Check if a %TAG directive is valid. */ static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter, yaml_tag_directive_t tag_directive) { yaml_string_t handle; yaml_string_t prefix; size_t handle_length; size_t prefix_length; handle_length = strlen((char *)tag_directive.handle); prefix_length = strlen((char *)tag_directive.prefix); STRING_ASSIGN(handle, tag_directive.handle, handle_length); STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length); if (handle.start == handle.end) { return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty"); } if (handle.start[0] != '!') { return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'"); } if (handle.end[-1] != '!') { return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'"); } handle.pointer ++; while (handle.pointer < handle.end-1) { if (!IS_ALPHA(handle)) { return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only"); } MOVE(handle); } if (prefix.start == prefix.end) { return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty"); } return 1; } /* * Check if an anchor is valid. */ static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter, yaml_char_t *anchor, int alias) { size_t anchor_length; yaml_string_t string; anchor_length = strlen((char *)anchor); STRING_ASSIGN(string, anchor, anchor_length); if (string.start == string.end) { return yaml_emitter_set_emitter_error(emitter, alias ? "alias value must not be empty" : "anchor value must not be empty"); } while (string.pointer != string.end) { if (!IS_ALPHA(string)) { return yaml_emitter_set_emitter_error(emitter, alias ? "alias value must contain alphanumerical characters only" : "anchor value must contain alphanumerical characters only"); } MOVE(string); } emitter->anchor_data.anchor = string.start; emitter->anchor_data.anchor_length = string.end - string.start; emitter->anchor_data.alias = alias; return 1; } /* * Check if a tag is valid. */ static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag) { size_t tag_length; yaml_string_t string; yaml_tag_directive_t *tag_directive; tag_length = strlen((char *)tag); STRING_ASSIGN(string, tag, tag_length); if (string.start == string.end) { return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty"); } for (tag_directive = emitter->tag_directives.start; tag_directive != emitter->tag_directives.top; tag_directive ++) { size_t prefix_length = strlen((char *)tag_directive->prefix); if (prefix_length < (size_t)(string.end - string.start) && strncmp((char *)tag_directive->prefix, (char *)string.start, prefix_length) == 0) { emitter->tag_data.handle = tag_directive->handle; emitter->tag_data.handle_length = strlen((char *)tag_directive->handle); emitter->tag_data.suffix = string.start + prefix_length; emitter->tag_data.suffix_length = (string.end - string.start) - prefix_length; return 1; } } emitter->tag_data.suffix = string.start; emitter->tag_data.suffix_length = string.end - string.start; return 1; } /* * Check if a scalar is valid. */ static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length) { yaml_string_t string; int block_indicators = 0; int flow_indicators = 0; int line_breaks = 0; int special_characters = 0; int leading_space = 0; int leading_break = 0; int trailing_space = 0; int trailing_break = 0; int break_space = 0; int space_break = 0; int preceded_by_whitespace = 0; int followed_by_whitespace = 0; int previous_space = 0; int previous_break = 0; STRING_ASSIGN(string, value, length); emitter->scalar_data.value = value; emitter->scalar_data.length = length; if (string.start == string.end) { emitter->scalar_data.multiline = 0; emitter->scalar_data.flow_plain_allowed = 0; emitter->scalar_data.block_plain_allowed = 1; emitter->scalar_data.single_quoted_allowed = 1; emitter->scalar_data.block_allowed = 0; return 1; } if ((CHECK_AT(string, '-', 0) && CHECK_AT(string, '-', 1) && CHECK_AT(string, '-', 2)) || (CHECK_AT(string, '.', 0) && CHECK_AT(string, '.', 1) && CHECK_AT(string, '.', 2))) { block_indicators = 1; flow_indicators = 1; } preceded_by_whitespace = 1; followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); while (string.pointer != string.end) { if (string.start == string.pointer) { if (CHECK(string, '#') || CHECK(string, ',') || CHECK(string, '[') || CHECK(string, ']') || CHECK(string, '{') || CHECK(string, '}') || CHECK(string, '&') || CHECK(string, '*') || CHECK(string, '!') || CHECK(string, '|') || CHECK(string, '>') || CHECK(string, '\'') || CHECK(string, '"') || CHECK(string, '%') || CHECK(string, '@') || CHECK(string, '`')) { flow_indicators = 1; block_indicators = 1; } if (CHECK(string, '?') || CHECK(string, ':')) { flow_indicators = 1; if (followed_by_whitespace) { block_indicators = 1; } } if (CHECK(string, '-') && followed_by_whitespace) { flow_indicators = 1; block_indicators = 1; } } else { if (CHECK(string, ',') || CHECK(string, '?') || CHECK(string, '[') || CHECK(string, ']') || CHECK(string, '{') || CHECK(string, '}')) { flow_indicators = 1; } if (CHECK(string, ':')) { flow_indicators = 1; if (followed_by_whitespace) { block_indicators = 1; } } if (CHECK(string, '#') && preceded_by_whitespace) { flow_indicators = 1; block_indicators = 1; } } if (!IS_PRINTABLE(string) || (!IS_ASCII(string) && !emitter->unicode)) { special_characters = 1; } if (IS_BREAK(string)) { line_breaks = 1; } if (IS_SPACE(string)) { if (string.start == string.pointer) { leading_space = 1; } if (string.pointer+WIDTH(string) == string.end) { trailing_space = 1; } if (previous_break) { break_space = 1; } previous_space = 1; previous_break = 0; } else if (IS_BREAK(string)) { if (string.start == string.pointer) { leading_break = 1; } if (string.pointer+WIDTH(string) == string.end) { trailing_break = 1; } if (previous_space) { space_break = 1; } previous_space = 0; previous_break = 1; } else { previous_space = 0; previous_break = 0; } preceded_by_whitespace = IS_BLANKZ(string); MOVE(string); if (string.pointer != string.end) { followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); } } emitter->scalar_data.multiline = line_breaks; emitter->scalar_data.flow_plain_allowed = 1; emitter->scalar_data.block_plain_allowed = 1; emitter->scalar_data.single_quoted_allowed = 1; emitter->scalar_data.block_allowed = 1; if (leading_space || leading_break || trailing_space || trailing_break) { emitter->scalar_data.flow_plain_allowed = 0; emitter->scalar_data.block_plain_allowed = 0; } if (trailing_space) { emitter->scalar_data.block_allowed = 0; } if (break_space) { emitter->scalar_data.flow_plain_allowed = 0; emitter->scalar_data.block_plain_allowed = 0; emitter->scalar_data.single_quoted_allowed = 0; } if (space_break || special_characters) { emitter->scalar_data.flow_plain_allowed = 0; emitter->scalar_data.block_plain_allowed = 0; emitter->scalar_data.single_quoted_allowed = 0; emitter->scalar_data.block_allowed = 0; } if (line_breaks) { emitter->scalar_data.flow_plain_allowed = 0; emitter->scalar_data.block_plain_allowed = 0; } if (flow_indicators) { emitter->scalar_data.flow_plain_allowed = 0; } if (block_indicators) { emitter->scalar_data.block_plain_allowed = 0; } return 1; } /* * Check if the event data is valid. */ static int yaml_emitter_analyze_event(yaml_emitter_t *emitter, yaml_event_t *event) { emitter->anchor_data.anchor = NULL; emitter->anchor_data.anchor_length = 0; emitter->tag_data.handle = NULL; emitter->tag_data.handle_length = 0; emitter->tag_data.suffix = NULL; emitter->tag_data.suffix_length = 0; emitter->scalar_data.value = NULL; emitter->scalar_data.length = 0; switch (event->type) { case YAML_ALIAS_EVENT: if (!yaml_emitter_analyze_anchor(emitter, event->data.alias.anchor, 1)) return 0; return 1; case YAML_SCALAR_EVENT: if (event->data.scalar.anchor) { if (!yaml_emitter_analyze_anchor(emitter, event->data.scalar.anchor, 0)) return 0; } if (event->data.scalar.tag && (emitter->canonical || (!event->data.scalar.plain_implicit && !event->data.scalar.quoted_implicit))) { if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag)) return 0; } if (!yaml_emitter_analyze_scalar(emitter, event->data.scalar.value, event->data.scalar.length)) return 0; return 1; case YAML_SEQUENCE_START_EVENT: if (event->data.sequence_start.anchor) { if (!yaml_emitter_analyze_anchor(emitter, event->data.sequence_start.anchor, 0)) return 0; } if (event->data.sequence_start.tag && (emitter->canonical || !event->data.sequence_start.implicit)) { if (!yaml_emitter_analyze_tag(emitter, event->data.sequence_start.tag)) return 0; } return 1; case YAML_MAPPING_START_EVENT: if (event->data.mapping_start.anchor) { if (!yaml_emitter_analyze_anchor(emitter, event->data.mapping_start.anchor, 0)) return 0; } if (event->data.mapping_start.tag && (emitter->canonical || !event->data.mapping_start.implicit)) { if (!yaml_emitter_analyze_tag(emitter, event->data.mapping_start.tag)) return 0; } return 1; default: return 1; } } /* * Write the BOM character. */ static int yaml_emitter_write_bom(yaml_emitter_t *emitter) { if (!FLUSH(emitter)) return 0; *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF'; *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB'; *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF'; return 1; } static int yaml_emitter_write_indent(yaml_emitter_t *emitter) { int indent = (emitter->indent >= 0) ? emitter->indent : 0; if (!emitter->indention || emitter->column > indent || (emitter->column == indent && !emitter->whitespace)) { if (!PUT_BREAK(emitter)) return 0; } while (emitter->column < indent) { if (!PUT(emitter, ' ')) return 0; } emitter->whitespace = 1; emitter->indention = 1; return 1; } static int yaml_emitter_write_indicator(yaml_emitter_t *emitter, const char *indicator, int need_whitespace, int is_whitespace, int is_indention) { size_t indicator_length; yaml_string_t string; indicator_length = strlen(indicator); STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length); if (need_whitespace && !emitter->whitespace) { if (!PUT(emitter, ' ')) return 0; } while (string.pointer != string.end) { if (!WRITE(emitter, string)) return 0; } emitter->whitespace = is_whitespace; emitter->indention = (emitter->indention && is_indention); emitter->open_ended = 0; return 1; } static int yaml_emitter_write_anchor(yaml_emitter_t *emitter, yaml_char_t *value, size_t length) { yaml_string_t string; STRING_ASSIGN(string, value, length); while (string.pointer != string.end) { if (!WRITE(emitter, string)) return 0; } emitter->whitespace = 0; emitter->indention = 0; return 1; } static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, yaml_char_t *value, size_t length) { yaml_string_t string; STRING_ASSIGN(string, value, length); if (!emitter->whitespace) { if (!PUT(emitter, ' ')) return 0; } while (string.pointer != string.end) { if (!WRITE(emitter, string)) return 0; } emitter->whitespace = 0; emitter->indention = 0; return 1; } static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int need_whitespace) { yaml_string_t string; STRING_ASSIGN(string, value, length); if (need_whitespace && !emitter->whitespace) { if (!PUT(emitter, ' ')) return 0; } while (string.pointer != string.end) { if (IS_ALPHA(string) || CHECK(string, ';') || CHECK(string, '/') || CHECK(string, '?') || CHECK(string, ':') || CHECK(string, '@') || CHECK(string, '&') || CHECK(string, '=') || CHECK(string, '+') || CHECK(string, '$') || CHECK(string, ',') || CHECK(string, '_') || CHECK(string, '.') || CHECK(string, '~') || CHECK(string, '*') || CHECK(string, '\'') || CHECK(string, '(') || CHECK(string, ')') || CHECK(string, '[') || CHECK(string, ']')) { if (!WRITE(emitter, string)) return 0; } else { int width = WIDTH(string); unsigned int value; while (width --) { value = *(string.pointer++); if (!PUT(emitter, '%')) return 0; if (!PUT(emitter, (value >> 4) + ((value >> 4) < 10 ? '0' : 'A' - 10))) return 0; if (!PUT(emitter, (value & 0x0F) + ((value & 0x0F) < 10 ? '0' : 'A' - 10))) return 0; } } } emitter->whitespace = 0; emitter->indention = 0; return 1; } static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks) { yaml_string_t string; int spaces = 0; int breaks = 0; STRING_ASSIGN(string, value, length); if (!emitter->whitespace) { if (!PUT(emitter, ' ')) return 0; } while (string.pointer != string.end) { if (IS_SPACE(string)) { if (allow_breaks && !spaces && emitter->column > emitter->best_width && !IS_SPACE_AT(string, 1)) { if (!yaml_emitter_write_indent(emitter)) return 0; MOVE(string); } else { if (!WRITE(emitter, string)) return 0; } spaces = 1; } else if (IS_BREAK(string)) { if (!breaks && CHECK(string, '\n')) { if (!PUT_BREAK(emitter)) return 0; } if (!WRITE_BREAK(emitter, string)) return 0; emitter->indention = 1; breaks = 1; } else { if (breaks) { if (!yaml_emitter_write_indent(emitter)) return 0; } if (!WRITE(emitter, string)) return 0; emitter->indention = 0; spaces = 0; breaks = 0; } } emitter->whitespace = 0; emitter->indention = 0; if (emitter->root_context) { emitter->open_ended = 1; } return 1; } static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks) { yaml_string_t string; int spaces = 0; int breaks = 0; STRING_ASSIGN(string, value, length); if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0)) return 0; while (string.pointer != string.end) { if (IS_SPACE(string)) { if (allow_breaks && !spaces && emitter->column > emitter->best_width && string.pointer != string.start && string.pointer != string.end - 1 && !IS_SPACE_AT(string, 1)) { if (!yaml_emitter_write_indent(emitter)) return 0; MOVE(string); } else { if (!WRITE(emitter, string)) return 0; } spaces = 1; } else if (IS_BREAK(string)) { if (!breaks && CHECK(string, '\n')) { if (!PUT_BREAK(emitter)) return 0; } if (!WRITE_BREAK(emitter, string)) return 0; emitter->indention = 1; breaks = 1; } else { if (breaks) { if (!yaml_emitter_write_indent(emitter)) return 0; } if (CHECK(string, '\'')) { if (!PUT(emitter, '\'')) return 0; } if (!WRITE(emitter, string)) return 0; emitter->indention = 0; spaces = 0; breaks = 0; } } if (breaks) if (!yaml_emitter_write_indent(emitter)) return 0; if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0)) return 0; emitter->whitespace = 0; emitter->indention = 0; return 1; } static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks) { yaml_string_t string; int spaces = 0; STRING_ASSIGN(string, value, length); if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0)) return 0; while (string.pointer != string.end) { if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string)) || IS_BOM(string) || IS_BREAK(string) || CHECK(string, '"') || CHECK(string, '\\')) { unsigned char octet; unsigned int width; unsigned int value; int k; octet = string.pointer[0]; width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; value = (octet & 0x80) == 0x00 ? octet & 0x7F : (octet & 0xE0) == 0xC0 ? octet & 0x1F : (octet & 0xF0) == 0xE0 ? octet & 0x0F : (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; for (k = 1; k < (int)width; k ++) { octet = string.pointer[k]; value = (value << 6) + (octet & 0x3F); } string.pointer += width; if (!PUT(emitter, '\\')) return 0; switch (value) { case 0x00: if (!PUT(emitter, '0')) return 0; break; case 0x07: if (!PUT(emitter, 'a')) return 0; break; case 0x08: if (!PUT(emitter, 'b')) return 0; break; case 0x09: if (!PUT(emitter, 't')) return 0; break; case 0x0A: if (!PUT(emitter, 'n')) return 0; break; case 0x0B: if (!PUT(emitter, 'v')) return 0; break; case 0x0C: if (!PUT(emitter, 'f')) return 0; break; case 0x0D: if (!PUT(emitter, 'r')) return 0; break; case 0x1B: if (!PUT(emitter, 'e')) return 0; break; case 0x22: if (!PUT(emitter, '\"')) return 0; break; case 0x5C: if (!PUT(emitter, '\\')) return 0; break; case 0x85: if (!PUT(emitter, 'N')) return 0; break; case 0xA0: if (!PUT(emitter, '_')) return 0; break; case 0x2028: if (!PUT(emitter, 'L')) return 0; break; case 0x2029: if (!PUT(emitter, 'P')) return 0; break; default: if (value <= 0xFF) { if (!PUT(emitter, 'x')) return 0; width = 2; } else if (value <= 0xFFFF) { if (!PUT(emitter, 'u')) return 0; width = 4; } else { if (!PUT(emitter, 'U')) return 0; width = 8; } for (k = (width-1)*4; k >= 0; k -= 4) { int digit = (value >> k) & 0x0F; if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10))) return 0; } } spaces = 0; } else if (IS_SPACE(string)) { if (allow_breaks && !spaces && emitter->column > emitter->best_width && string.pointer != string.start && string.pointer != string.end - 1) { if (!yaml_emitter_write_indent(emitter)) return 0; if (IS_SPACE_AT(string, 1)) { if (!PUT(emitter, '\\')) return 0; } MOVE(string); } else { if (!WRITE(emitter, string)) return 0; } spaces = 1; } else { if (!WRITE(emitter, string)) return 0; spaces = 0; } } if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0)) return 0; emitter->whitespace = 0; emitter->indention = 0; return 1; } static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter, yaml_string_t string) { char indent_hint[2]; const char *chomp_hint = NULL; if (IS_SPACE(string) || IS_BREAK(string)) { indent_hint[0] = '0' + (char)emitter->best_indent; indent_hint[1] = '\0'; if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0)) return 0; } emitter->open_ended = 0; string.pointer = string.end; if (string.start == string.pointer) { chomp_hint = "-"; } else { do { string.pointer --; } while ((*string.pointer & 0xC0) == 0x80); if (!IS_BREAK(string)) { chomp_hint = "-"; } else if (string.start == string.pointer) { chomp_hint = "+"; emitter->open_ended = 1; } else { do { string.pointer --; } while ((*string.pointer & 0xC0) == 0x80); if (IS_BREAK(string)) { chomp_hint = "+"; emitter->open_ended = 1; } } } if (chomp_hint) { if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0)) return 0; } return 1; } static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length) { yaml_string_t string; int breaks = 1; STRING_ASSIGN(string, value, length); if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0)) return 0; if (!yaml_emitter_write_block_scalar_hints(emitter, string)) return 0; if (!PUT_BREAK(emitter)) return 0; emitter->indention = 1; emitter->whitespace = 1; while (string.pointer != string.end) { if (IS_BREAK(string)) { if (!WRITE_BREAK(emitter, string)) return 0; emitter->indention = 1; breaks = 1; } else { if (breaks) { if (!yaml_emitter_write_indent(emitter)) return 0; } if (!WRITE(emitter, string)) return 0; emitter->indention = 0; breaks = 0; } } return 1; } static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length) { yaml_string_t string; int breaks = 1; int leading_spaces = 1; STRING_ASSIGN(string, value, length); if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0)) return 0; if (!yaml_emitter_write_block_scalar_hints(emitter, string)) return 0; if (!PUT_BREAK(emitter)) return 0; emitter->indention = 1; emitter->whitespace = 1; while (string.pointer != string.end) { if (IS_BREAK(string)) { if (!breaks && !leading_spaces && CHECK(string, '\n')) { int k = 0; while (IS_BREAK_AT(string, k)) { k += WIDTH_AT(string, k); } if (!IS_BLANKZ_AT(string, k)) { if (!PUT_BREAK(emitter)) return 0; } } if (!WRITE_BREAK(emitter, string)) return 0; emitter->indention = 1; breaks = 1; } else { if (breaks) { if (!yaml_emitter_write_indent(emitter)) return 0; leading_spaces = IS_BLANK(string); } if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1) && emitter->column > emitter->best_width) { if (!yaml_emitter_write_indent(emitter)) return 0; MOVE(string); } else { if (!WRITE(emitter, string)) return 0; } emitter->indention = 0; breaks = 0; } } return 1; } ruamel.yaml-0.15.89/ext/scanner.c0000664000175100001440000030000113351131445017164 0ustar anthonusers00000000000000 /* * Introduction * ************ * * The following notes assume that you are familiar with the YAML specification * (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in * some cases we are less restrictive that it requires. * * The process of transforming a YAML stream into a sequence of events is * divided on two steps: Scanning and Parsing. * * The Scanner transforms the input stream into a sequence of tokens, while the * parser transform the sequence of tokens produced by the Scanner into a * sequence of parsing events. * * The Scanner is rather clever and complicated. The Parser, on the contrary, * is a straightforward implementation of a recursive-descendant parser (or, * LL(1) parser, as it is usually called). * * Actually there are two issues of Scanning that might be called "clever", the * rest is quite straightforward. The issues are "block collection start" and * "simple keys". Both issues are explained below in details. * * Here the Scanning step is explained and implemented. We start with the list * of all the tokens produced by the Scanner together with short descriptions. * * Now, tokens: * * STREAM-START(encoding) # The stream start. * STREAM-END # The stream end. * VERSION-DIRECTIVE(major,minor) # The '%YAML' directive. * TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive. * DOCUMENT-START # '---' * DOCUMENT-END # '...' * BLOCK-SEQUENCE-START # Indentation increase denoting a block * BLOCK-MAPPING-START # sequence or a block mapping. * BLOCK-END # Indentation decrease. * FLOW-SEQUENCE-START # '[' * FLOW-SEQUENCE-END # ']' * FLOW-MAPPING-START # '{' * FLOW-MAPPING-END # '}' * BLOCK-ENTRY # '-' * FLOW-ENTRY # ',' * KEY # '?' or nothing (simple keys). * VALUE # ':' * ALIAS(anchor) # '*anchor' * ANCHOR(anchor) # '&anchor' * TAG(handle,suffix) # '!handle!suffix' * SCALAR(value,style) # A scalar. * * The following two tokens are "virtual" tokens denoting the beginning and the * end of the stream: * * STREAM-START(encoding) * STREAM-END * * We pass the information about the input stream encoding with the * STREAM-START token. * * The next two tokens are responsible for tags: * * VERSION-DIRECTIVE(major,minor) * TAG-DIRECTIVE(handle,prefix) * * Example: * * %YAML 1.1 * %TAG ! !foo * %TAG !yaml! tag:yaml.org,2002: * --- * * The corresponding sequence of tokens: * * STREAM-START(utf-8) * VERSION-DIRECTIVE(1,1) * TAG-DIRECTIVE("!","!foo") * TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:") * DOCUMENT-START * STREAM-END * * Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole * line. * * The document start and end indicators are represented by: * * DOCUMENT-START * DOCUMENT-END * * Note that if a YAML stream contains an implicit document (without '---' * and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be * produced. * * In the following examples, we present whole documents together with the * produced tokens. * * 1. An implicit document: * * 'a scalar' * * Tokens: * * STREAM-START(utf-8) * SCALAR("a scalar",single-quoted) * STREAM-END * * 2. An explicit document: * * --- * 'a scalar' * ... * * Tokens: * * STREAM-START(utf-8) * DOCUMENT-START * SCALAR("a scalar",single-quoted) * DOCUMENT-END * STREAM-END * * 3. Several documents in a stream: * * 'a scalar' * --- * 'another scalar' * --- * 'yet another scalar' * * Tokens: * * STREAM-START(utf-8) * SCALAR("a scalar",single-quoted) * DOCUMENT-START * SCALAR("another scalar",single-quoted) * DOCUMENT-START * SCALAR("yet another scalar",single-quoted) * STREAM-END * * We have already introduced the SCALAR token above. The following tokens are * used to describe aliases, anchors, tag, and scalars: * * ALIAS(anchor) * ANCHOR(anchor) * TAG(handle,suffix) * SCALAR(value,style) * * The following series of examples illustrate the usage of these tokens: * * 1. A recursive sequence: * * &A [ *A ] * * Tokens: * * STREAM-START(utf-8) * ANCHOR("A") * FLOW-SEQUENCE-START * ALIAS("A") * FLOW-SEQUENCE-END * STREAM-END * * 2. A tagged scalar: * * !!float "3.14" # A good approximation. * * Tokens: * * STREAM-START(utf-8) * TAG("!!","float") * SCALAR("3.14",double-quoted) * STREAM-END * * 3. Various scalar styles: * * --- # Implicit empty plain scalars do not produce tokens. * --- a plain scalar * --- 'a single-quoted scalar' * --- "a double-quoted scalar" * --- |- * a literal scalar * --- >- * a folded * scalar * * Tokens: * * STREAM-START(utf-8) * DOCUMENT-START * DOCUMENT-START * SCALAR("a plain scalar",plain) * DOCUMENT-START * SCALAR("a single-quoted scalar",single-quoted) * DOCUMENT-START * SCALAR("a double-quoted scalar",double-quoted) * DOCUMENT-START * SCALAR("a literal scalar",literal) * DOCUMENT-START * SCALAR("a folded scalar",folded) * STREAM-END * * Now it's time to review collection-related tokens. We will start with * flow collections: * * FLOW-SEQUENCE-START * FLOW-SEQUENCE-END * FLOW-MAPPING-START * FLOW-MAPPING-END * FLOW-ENTRY * KEY * VALUE * * The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and * FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}' * correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the * indicators '?' and ':', which are used for denoting mapping keys and values, * are represented by the KEY and VALUE tokens. * * The following examples show flow collections: * * 1. A flow sequence: * * [item 1, item 2, item 3] * * Tokens: * * STREAM-START(utf-8) * FLOW-SEQUENCE-START * SCALAR("item 1",plain) * FLOW-ENTRY * SCALAR("item 2",plain) * FLOW-ENTRY * SCALAR("item 3",plain) * FLOW-SEQUENCE-END * STREAM-END * * 2. A flow mapping: * * { * a simple key: a value, # Note that the KEY token is produced. * ? a complex key: another value, * } * * Tokens: * * STREAM-START(utf-8) * FLOW-MAPPING-START * KEY * SCALAR("a simple key",plain) * VALUE * SCALAR("a value",plain) * FLOW-ENTRY * KEY * SCALAR("a complex key",plain) * VALUE * SCALAR("another value",plain) * FLOW-ENTRY * FLOW-MAPPING-END * STREAM-END * * A simple key is a key which is not denoted by the '?' indicator. Note that * the Scanner still produce the KEY token whenever it encounters a simple key. * * For scanning block collections, the following tokens are used (note that we * repeat KEY and VALUE here): * * BLOCK-SEQUENCE-START * BLOCK-MAPPING-START * BLOCK-END * BLOCK-ENTRY * KEY * VALUE * * The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation * increase that precedes a block collection (cf. the INDENT token in Python). * The token BLOCK-END denote indentation decrease that ends a block collection * (cf. the DEDENT token in Python). However YAML has some syntax pecularities * that makes detections of these tokens more complex. * * The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators * '-', '?', and ':' correspondingly. * * The following examples show how the tokens BLOCK-SEQUENCE-START, * BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner: * * 1. Block sequences: * * - item 1 * - item 2 * - * - item 3.1 * - item 3.2 * - * key 1: value 1 * key 2: value 2 * * Tokens: * * STREAM-START(utf-8) * BLOCK-SEQUENCE-START * BLOCK-ENTRY * SCALAR("item 1",plain) * BLOCK-ENTRY * SCALAR("item 2",plain) * BLOCK-ENTRY * BLOCK-SEQUENCE-START * BLOCK-ENTRY * SCALAR("item 3.1",plain) * BLOCK-ENTRY * SCALAR("item 3.2",plain) * BLOCK-END * BLOCK-ENTRY * BLOCK-MAPPING-START * KEY * SCALAR("key 1",plain) * VALUE * SCALAR("value 1",plain) * KEY * SCALAR("key 2",plain) * VALUE * SCALAR("value 2",plain) * BLOCK-END * BLOCK-END * STREAM-END * * 2. Block mappings: * * a simple key: a value # The KEY token is produced here. * ? a complex key * : another value * a mapping: * key 1: value 1 * key 2: value 2 * a sequence: * - item 1 * - item 2 * * Tokens: * * STREAM-START(utf-8) * BLOCK-MAPPING-START * KEY * SCALAR("a simple key",plain) * VALUE * SCALAR("a value",plain) * KEY * SCALAR("a complex key",plain) * VALUE * SCALAR("another value",plain) * KEY * SCALAR("a mapping",plain) * BLOCK-MAPPING-START * KEY * SCALAR("key 1",plain) * VALUE * SCALAR("value 1",plain) * KEY * SCALAR("key 2",plain) * VALUE * SCALAR("value 2",plain) * BLOCK-END * KEY * SCALAR("a sequence",plain) * VALUE * BLOCK-SEQUENCE-START * BLOCK-ENTRY * SCALAR("item 1",plain) * BLOCK-ENTRY * SCALAR("item 2",plain) * BLOCK-END * BLOCK-END * STREAM-END * * YAML does not always require to start a new block collection from a new * line. If the current line contains only '-', '?', and ':' indicators, a new * block collection may start at the current line. The following examples * illustrate this case: * * 1. Collections in a sequence: * * - - item 1 * - item 2 * - key 1: value 1 * key 2: value 2 * - ? complex key * : complex value * * Tokens: * * STREAM-START(utf-8) * BLOCK-SEQUENCE-START * BLOCK-ENTRY * BLOCK-SEQUENCE-START * BLOCK-ENTRY * SCALAR("item 1",plain) * BLOCK-ENTRY * SCALAR("item 2",plain) * BLOCK-END * BLOCK-ENTRY * BLOCK-MAPPING-START * KEY * SCALAR("key 1",plain) * VALUE * SCALAR("value 1",plain) * KEY * SCALAR("key 2",plain) * VALUE * SCALAR("value 2",plain) * BLOCK-END * BLOCK-ENTRY * BLOCK-MAPPING-START * KEY * SCALAR("complex key") * VALUE * SCALAR("complex value") * BLOCK-END * BLOCK-END * STREAM-END * * 2. Collections in a mapping: * * ? a sequence * : - item 1 * - item 2 * ? a mapping * : key 1: value 1 * key 2: value 2 * * Tokens: * * STREAM-START(utf-8) * BLOCK-MAPPING-START * KEY * SCALAR("a sequence",plain) * VALUE * BLOCK-SEQUENCE-START * BLOCK-ENTRY * SCALAR("item 1",plain) * BLOCK-ENTRY * SCALAR("item 2",plain) * BLOCK-END * KEY * SCALAR("a mapping",plain) * VALUE * BLOCK-MAPPING-START * KEY * SCALAR("key 1",plain) * VALUE * SCALAR("value 1",plain) * KEY * SCALAR("key 2",plain) * VALUE * SCALAR("value 2",plain) * BLOCK-END * BLOCK-END * STREAM-END * * YAML also permits non-indented sequences if they are included into a block * mapping. In this case, the token BLOCK-SEQUENCE-START is not produced: * * key: * - item 1 # BLOCK-SEQUENCE-START is NOT produced here. * - item 2 * * Tokens: * * STREAM-START(utf-8) * BLOCK-MAPPING-START * KEY * SCALAR("key",plain) * VALUE * BLOCK-ENTRY * SCALAR("item 1",plain) * BLOCK-ENTRY * SCALAR("item 2",plain) * BLOCK-END */ #include "yaml_private.h" /* * Ensure that the buffer contains the required number of characters. * Return 1 on success, 0 on failure (reader error or memory error). */ #define CACHE(parser,length) \ (parser->unread >= (length) \ ? 1 \ : yaml_parser_update_buffer(parser, (length))) /* * Advance the buffer pointer. */ #define SKIP(parser) \ (parser->mark.index ++, \ parser->mark.column ++, \ parser->unread --, \ parser->buffer.pointer += WIDTH(parser->buffer)) #define SKIP_LINE(parser) \ (IS_CRLF(parser->buffer) ? \ (parser->mark.index += 2, \ parser->mark.column = 0, \ parser->mark.line ++, \ parser->unread -= 2, \ parser->buffer.pointer += 2) : \ IS_BREAK(parser->buffer) ? \ (parser->mark.index ++, \ parser->mark.column = 0, \ parser->mark.line ++, \ parser->unread --, \ parser->buffer.pointer += WIDTH(parser->buffer)) : 0) /* * Copy a character to a string buffer and advance pointers. */ #define READ(parser,string) \ (STRING_EXTEND(parser,string) ? \ (COPY(string,parser->buffer), \ parser->mark.index ++, \ parser->mark.column ++, \ parser->unread --, \ 1) : 0) /* * Copy a line break character to a string buffer and advance pointers. */ #define READ_LINE(parser,string) \ (STRING_EXTEND(parser,string) ? \ (((CHECK_AT(parser->buffer,'\r',0) \ && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ (*((string).pointer++) = (yaml_char_t) '\n', \ parser->buffer.pointer += 2, \ parser->mark.index += 2, \ parser->mark.column = 0, \ parser->mark.line ++, \ parser->unread -= 2) : \ (CHECK_AT(parser->buffer,'\r',0) \ || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ (*((string).pointer++) = (yaml_char_t) '\n', \ parser->buffer.pointer ++, \ parser->mark.index ++, \ parser->mark.column = 0, \ parser->mark.line ++, \ parser->unread --) : \ (CHECK_AT(parser->buffer,'\xC2',0) \ && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ (*((string).pointer++) = (yaml_char_t) '\n', \ parser->buffer.pointer += 2, \ parser->mark.index ++, \ parser->mark.column = 0, \ parser->mark.line ++, \ parser->unread --) : \ (CHECK_AT(parser->buffer,'\xE2',0) && \ CHECK_AT(parser->buffer,'\x80',1) && \ (CHECK_AT(parser->buffer,'\xA8',2) || \ CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ (*((string).pointer++) = *(parser->buffer.pointer++), \ *((string).pointer++) = *(parser->buffer.pointer++), \ *((string).pointer++) = *(parser->buffer.pointer++), \ parser->mark.index ++, \ parser->mark.column = 0, \ parser->mark.line ++, \ parser->unread --) : 0), \ 1) : 0) /* * Public API declarations. */ YAML_DECLARE(int) yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); /* * Error handling. */ static int yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem); /* * High-level token API. */ YAML_DECLARE(int) yaml_parser_fetch_more_tokens(yaml_parser_t *parser); static int yaml_parser_fetch_next_token(yaml_parser_t *parser); /* * Potential simple keys. */ static int yaml_parser_stale_simple_keys(yaml_parser_t *parser); static int yaml_parser_save_simple_key(yaml_parser_t *parser); static int yaml_parser_remove_simple_key(yaml_parser_t *parser); static int yaml_parser_increase_flow_level(yaml_parser_t *parser); static int yaml_parser_decrease_flow_level(yaml_parser_t *parser); /* * Indentation treatment. */ static int yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column, ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark); static int yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column); /* * Token fetchers. */ static int yaml_parser_fetch_stream_start(yaml_parser_t *parser); static int yaml_parser_fetch_stream_end(yaml_parser_t *parser); static int yaml_parser_fetch_directive(yaml_parser_t *parser); static int yaml_parser_fetch_document_indicator(yaml_parser_t *parser, yaml_token_type_t type); static int yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser, yaml_token_type_t type); static int yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser, yaml_token_type_t type); static int yaml_parser_fetch_flow_entry(yaml_parser_t *parser); static int yaml_parser_fetch_block_entry(yaml_parser_t *parser); static int yaml_parser_fetch_key(yaml_parser_t *parser); static int yaml_parser_fetch_value(yaml_parser_t *parser); static int yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type); static int yaml_parser_fetch_tag(yaml_parser_t *parser); static int yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal); static int yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single); static int yaml_parser_fetch_plain_scalar(yaml_parser_t *parser); /* * Token scanners. */ static int yaml_parser_scan_to_next_token(yaml_parser_t *parser); static int yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token); static int yaml_parser_scan_directive_name(yaml_parser_t *parser, yaml_mark_t start_mark, yaml_char_t **name); static int yaml_parser_scan_version_directive_value(yaml_parser_t *parser, yaml_mark_t start_mark, int *major, int *minor); static int yaml_parser_scan_version_directive_number(yaml_parser_t *parser, yaml_mark_t start_mark, int *number); static int yaml_parser_scan_tag_directive_value(yaml_parser_t *parser, yaml_mark_t mark, yaml_char_t **handle, yaml_char_t **prefix); static int yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token, yaml_token_type_t type); static int yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token); static int yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive, yaml_mark_t start_mark, yaml_char_t **handle); static int yaml_parser_scan_tag_uri(yaml_parser_t *parser, int directive, yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri); static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, yaml_mark_t start_mark, yaml_string_t *string); static int yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token, int literal); static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, int *indent, yaml_string_t *breaks, yaml_mark_t start_mark, yaml_mark_t *end_mark); static int yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token, int single); static int yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token); /* * Get the next token. */ YAML_DECLARE(int) yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) { assert(parser); /* Non-NULL parser object is expected. */ assert(token); /* Non-NULL token object is expected. */ /* Erase the token object. */ memset(token, 0, sizeof(yaml_token_t)); /* No tokens after STREAM-END or error. */ if (parser->stream_end_produced || parser->error) { return 1; } /* Ensure that the tokens queue contains enough tokens. */ if (!parser->token_available) { if (!yaml_parser_fetch_more_tokens(parser)) return 0; } /* Fetch the next token from the queue. */ *token = DEQUEUE(parser, parser->tokens); parser->token_available = 0; parser->tokens_parsed ++; if (token->type == YAML_STREAM_END_TOKEN) { parser->stream_end_produced = 1; } return 1; } /* * Set the scanner error and return 0. */ static int yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem) { parser->error = YAML_SCANNER_ERROR; parser->context = context; parser->context_mark = context_mark; parser->problem = problem; parser->problem_mark = parser->mark; return 0; } /* * Ensure that the tokens queue contains at least one token which can be * returned to the Parser. */ YAML_DECLARE(int) yaml_parser_fetch_more_tokens(yaml_parser_t *parser) { int need_more_tokens; /* While we need more tokens to fetch, do it. */ while (1) { /* * Check if we really need to fetch more tokens. */ need_more_tokens = 0; if (parser->tokens.head == parser->tokens.tail) { /* Queue is empty. */ need_more_tokens = 1; } else { yaml_simple_key_t *simple_key; /* Check if any potential simple key may occupy the head position. */ if (!yaml_parser_stale_simple_keys(parser)) return 0; for (simple_key = parser->simple_keys.start; simple_key != parser->simple_keys.top; simple_key++) { if (simple_key->possible && simple_key->token_number == parser->tokens_parsed) { need_more_tokens = 1; break; } } } /* We are finished. */ if (!need_more_tokens) break; /* Fetch the next token. */ if (!yaml_parser_fetch_next_token(parser)) return 0; } parser->token_available = 1; return 1; } /* * The dispatcher for token fetchers. */ static int yaml_parser_fetch_next_token(yaml_parser_t *parser) { /* Ensure that the buffer is initialized. */ if (!CACHE(parser, 1)) return 0; /* Check if we just started scanning. Fetch STREAM-START then. */ if (!parser->stream_start_produced) return yaml_parser_fetch_stream_start(parser); /* Eat whitespaces and comments until we reach the next token. */ if (!yaml_parser_scan_to_next_token(parser)) return 0; /* Remove obsolete potential simple keys. */ if (!yaml_parser_stale_simple_keys(parser)) return 0; /* Check the indentation level against the current column. */ if (!yaml_parser_unroll_indent(parser, parser->mark.column)) return 0; /* * Ensure that the buffer contains at least 4 characters. 4 is the length * of the longest indicators ('--- ' and '... '). */ if (!CACHE(parser, 4)) return 0; /* Is it the end of the stream? */ if (IS_Z(parser->buffer)) return yaml_parser_fetch_stream_end(parser); /* Is it a directive? */ if (parser->mark.column == 0 && CHECK(parser->buffer, '%')) return yaml_parser_fetch_directive(parser); /* Is it the document start indicator? */ if (parser->mark.column == 0 && CHECK_AT(parser->buffer, '-', 0) && CHECK_AT(parser->buffer, '-', 1) && CHECK_AT(parser->buffer, '-', 2) && IS_BLANKZ_AT(parser->buffer, 3)) return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_START_TOKEN); /* Is it the document end indicator? */ if (parser->mark.column == 0 && CHECK_AT(parser->buffer, '.', 0) && CHECK_AT(parser->buffer, '.', 1) && CHECK_AT(parser->buffer, '.', 2) && IS_BLANKZ_AT(parser->buffer, 3)) return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_END_TOKEN); /* Is it the flow sequence start indicator? */ if (CHECK(parser->buffer, '[')) return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_SEQUENCE_START_TOKEN); /* Is it the flow mapping start indicator? */ if (CHECK(parser->buffer, '{')) return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_MAPPING_START_TOKEN); /* Is it the flow sequence end indicator? */ if (CHECK(parser->buffer, ']')) return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_SEQUENCE_END_TOKEN); /* Is it the flow mapping end indicator? */ if (CHECK(parser->buffer, '}')) return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_MAPPING_END_TOKEN); /* Is it the flow entry indicator? */ if (CHECK(parser->buffer, ',')) return yaml_parser_fetch_flow_entry(parser); /* Is it the block entry indicator? */ if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) return yaml_parser_fetch_block_entry(parser); /* Is it the key indicator? */ if (CHECK(parser->buffer, '?') && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) return yaml_parser_fetch_key(parser); /* Is it the value indicator? */ if (CHECK(parser->buffer, ':') && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) return yaml_parser_fetch_value(parser); /* Is it an alias? */ if (CHECK(parser->buffer, '*')) return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN); /* Is it an anchor? */ if (CHECK(parser->buffer, '&')) return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN); /* Is it a tag? */ if (CHECK(parser->buffer, '!')) return yaml_parser_fetch_tag(parser); /* Is it a literal scalar? */ if (CHECK(parser->buffer, '|') && !parser->flow_level) return yaml_parser_fetch_block_scalar(parser, 1); /* Is it a folded scalar? */ if (CHECK(parser->buffer, '>') && !parser->flow_level) return yaml_parser_fetch_block_scalar(parser, 0); /* Is it a single-quoted scalar? */ if (CHECK(parser->buffer, '\'')) return yaml_parser_fetch_flow_scalar(parser, 1); /* Is it a double-quoted scalar? */ if (CHECK(parser->buffer, '"')) return yaml_parser_fetch_flow_scalar(parser, 0); /* * Is it a plain scalar? * * A plain scalar may start with any non-blank characters except * * '-', '?', ':', ',', '[', ']', '{', '}', * '#', '&', '*', '!', '|', '>', '\'', '\"', * '%', '@', '`'. * * In the block context (and, for the '-' indicator, in the flow context * too), it may also start with the characters * * '-', '?', ':' * * if it is followed by a non-space character. * * The last rule is more restrictive than the specification requires. */ if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-') || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#') || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|') || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'') || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) || (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) || (!parser->flow_level && (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) && !IS_BLANKZ_AT(parser->buffer, 1))) return yaml_parser_fetch_plain_scalar(parser); /* * If we don't determine the token type so far, it is an error. */ return yaml_parser_set_scanner_error(parser, "while scanning for the next token", parser->mark, "found character that cannot start any token"); } /* * Check the list of potential simple keys and remove the positions that * cannot contain simple keys anymore. */ static int yaml_parser_stale_simple_keys(yaml_parser_t *parser) { yaml_simple_key_t *simple_key; /* Check for a potential simple key for each flow level. */ for (simple_key = parser->simple_keys.start; simple_key != parser->simple_keys.top; simple_key ++) { /* * The specification requires that a simple key * * - is limited to a single line, * - is shorter than 1024 characters. */ if (simple_key->possible && (simple_key->mark.line < parser->mark.line || simple_key->mark.index+1024 < parser->mark.index)) { /* Check if the potential simple key to be removed is required. */ if (simple_key->required) { return yaml_parser_set_scanner_error(parser, "while scanning a simple key", simple_key->mark, "could not find expected ':'"); } simple_key->possible = 0; } } return 1; } /* * Check if a simple key may start at the current position and add it if * needed. */ static int yaml_parser_save_simple_key(yaml_parser_t *parser) { /* * A simple key is required at the current position if the scanner is in * the block context and the current column coincides with the indentation * level. */ int required = (!parser->flow_level && parser->indent == (ptrdiff_t)parser->mark.column); /* * If the current position may start a simple key, save it. */ if (parser->simple_key_allowed) { yaml_simple_key_t simple_key; simple_key.possible = 1; simple_key.required = required; simple_key.token_number = parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head); simple_key.mark = parser->mark; if (!yaml_parser_remove_simple_key(parser)) return 0; *(parser->simple_keys.top-1) = simple_key; } return 1; } /* * Remove a potential simple key at the current flow level. */ static int yaml_parser_remove_simple_key(yaml_parser_t *parser) { yaml_simple_key_t *simple_key = parser->simple_keys.top-1; if (simple_key->possible) { /* If the key is required, it is an error. */ if (simple_key->required) { return yaml_parser_set_scanner_error(parser, "while scanning a simple key", simple_key->mark, "could not find expected ':'"); } } /* Remove the key from the stack. */ simple_key->possible = 0; return 1; } /* * Increase the flow level and resize the simple key list if needed. */ static int yaml_parser_increase_flow_level(yaml_parser_t *parser) { yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } }; /* Reset the simple key on the next level. */ if (!PUSH(parser, parser->simple_keys, empty_simple_key)) return 0; /* Increase the flow level. */ if (parser->flow_level == INT_MAX) { parser->error = YAML_MEMORY_ERROR; return 0; } parser->flow_level++; return 1; } /* * Decrease the flow level. */ static int yaml_parser_decrease_flow_level(yaml_parser_t *parser) { yaml_simple_key_t dummy_key; /* Used to eliminate a compiler warning. */ if (parser->flow_level) { parser->flow_level --; dummy_key = POP(parser, parser->simple_keys); } return 1; } /* * Push the current indentation level to the stack and set the new level * the current column is greater than the indentation level. In this case, * append or insert the specified token into the token queue. * */ static int yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column, ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark) { yaml_token_t token; /* In the flow context, do nothing. */ if (parser->flow_level) return 1; if (parser->indent < column) { /* * Push the current indentation level to the stack and set the new * indentation level. */ if (!PUSH(parser, parser->indents, parser->indent)) return 0; if (column > INT_MAX) { parser->error = YAML_MEMORY_ERROR; return 0; } parser->indent = column; /* Create a token and insert it into the queue. */ TOKEN_INIT(token, type, mark, mark); if (number == -1) { if (!ENQUEUE(parser, parser->tokens, token)) return 0; } else { if (!QUEUE_INSERT(parser, parser->tokens, number - parser->tokens_parsed, token)) return 0; } } return 1; } /* * Pop indentation levels from the indents stack until the current level * becomes less or equal to the column. For each indentation level, append * the BLOCK-END token. */ static int yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column) { yaml_token_t token; /* In the flow context, do nothing. */ if (parser->flow_level) return 1; /* Loop through the indentation levels in the stack. */ while (parser->indent > column) { /* Create a token and append it to the queue. */ TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; /* Pop the indentation level. */ parser->indent = POP(parser, parser->indents); } return 1; } /* * Initialize the scanner and produce the STREAM-START token. */ static int yaml_parser_fetch_stream_start(yaml_parser_t *parser) { yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } }; yaml_token_t token; /* Set the initial indentation. */ parser->indent = -1; /* Initialize the simple key stack. */ if (!PUSH(parser, parser->simple_keys, simple_key)) return 0; /* A simple key is allowed at the beginning of the stream. */ parser->simple_key_allowed = 1; /* We have started. */ parser->stream_start_produced = 1; /* Create the STREAM-START token and append it to the queue. */ STREAM_START_TOKEN_INIT(token, parser->encoding, parser->mark, parser->mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the STREAM-END token and shut down the scanner. */ static int yaml_parser_fetch_stream_end(yaml_parser_t *parser) { yaml_token_t token; /* Force new line. */ if (parser->mark.column != 0) { parser->mark.column = 0; parser->mark.line ++; } /* Reset the indentation level. */ if (!yaml_parser_unroll_indent(parser, -1)) return 0; /* Reset simple keys. */ if (!yaml_parser_remove_simple_key(parser)) return 0; parser->simple_key_allowed = 0; /* Create the STREAM-END token and append it to the queue. */ STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token. */ static int yaml_parser_fetch_directive(yaml_parser_t *parser) { yaml_token_t token; /* Reset the indentation level. */ if (!yaml_parser_unroll_indent(parser, -1)) return 0; /* Reset simple keys. */ if (!yaml_parser_remove_simple_key(parser)) return 0; parser->simple_key_allowed = 0; /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ if (!yaml_parser_scan_directive(parser, &token)) return 0; /* Append the token to the queue. */ if (!ENQUEUE(parser, parser->tokens, token)) { yaml_token_delete(&token); return 0; } return 1; } /* * Produce the DOCUMENT-START or DOCUMENT-END token. */ static int yaml_parser_fetch_document_indicator(yaml_parser_t *parser, yaml_token_type_t type) { yaml_mark_t start_mark, end_mark; yaml_token_t token; /* Reset the indentation level. */ if (!yaml_parser_unroll_indent(parser, -1)) return 0; /* Reset simple keys. */ if (!yaml_parser_remove_simple_key(parser)) return 0; parser->simple_key_allowed = 0; /* Consume the token. */ start_mark = parser->mark; SKIP(parser); SKIP(parser); SKIP(parser); end_mark = parser->mark; /* Create the DOCUMENT-START or DOCUMENT-END token. */ TOKEN_INIT(token, type, start_mark, end_mark); /* Append the token to the queue. */ if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token. */ static int yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser, yaml_token_type_t type) { yaml_mark_t start_mark, end_mark; yaml_token_t token; /* The indicators '[' and '{' may start a simple key. */ if (!yaml_parser_save_simple_key(parser)) return 0; /* Increase the flow level. */ if (!yaml_parser_increase_flow_level(parser)) return 0; /* A simple key may follow the indicators '[' and '{'. */ parser->simple_key_allowed = 1; /* Consume the token. */ start_mark = parser->mark; SKIP(parser); end_mark = parser->mark; /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */ TOKEN_INIT(token, type, start_mark, end_mark); /* Append the token to the queue. */ if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token. */ static int yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser, yaml_token_type_t type) { yaml_mark_t start_mark, end_mark; yaml_token_t token; /* Reset any potential simple key on the current flow level. */ if (!yaml_parser_remove_simple_key(parser)) return 0; /* Decrease the flow level. */ if (!yaml_parser_decrease_flow_level(parser)) return 0; /* No simple keys after the indicators ']' and '}'. */ parser->simple_key_allowed = 0; /* Consume the token. */ start_mark = parser->mark; SKIP(parser); end_mark = parser->mark; /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */ TOKEN_INIT(token, type, start_mark, end_mark); /* Append the token to the queue. */ if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the FLOW-ENTRY token. */ static int yaml_parser_fetch_flow_entry(yaml_parser_t *parser) { yaml_mark_t start_mark, end_mark; yaml_token_t token; /* Reset any potential simple keys on the current flow level. */ if (!yaml_parser_remove_simple_key(parser)) return 0; /* Simple keys are allowed after ','. */ parser->simple_key_allowed = 1; /* Consume the token. */ start_mark = parser->mark; SKIP(parser); end_mark = parser->mark; /* Create the FLOW-ENTRY token and append it to the queue. */ TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the BLOCK-ENTRY token. */ static int yaml_parser_fetch_block_entry(yaml_parser_t *parser) { yaml_mark_t start_mark, end_mark; yaml_token_t token; /* Check if the scanner is in the block context. */ if (!parser->flow_level) { /* Check if we are allowed to start a new entry. */ if (!parser->simple_key_allowed) { return yaml_parser_set_scanner_error(parser, NULL, parser->mark, "block sequence entries are not allowed in this context"); } /* Add the BLOCK-SEQUENCE-START token if needed. */ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark)) return 0; } else { /* * It is an error for the '-' indicator to occur in the flow context, * but we let the Parser detect and report about it because the Parser * is able to point to the context. */ } /* Reset any potential simple keys on the current flow level. */ if (!yaml_parser_remove_simple_key(parser)) return 0; /* Simple keys are allowed after '-'. */ parser->simple_key_allowed = 1; /* Consume the token. */ start_mark = parser->mark; SKIP(parser); end_mark = parser->mark; /* Create the BLOCK-ENTRY token and append it to the queue. */ TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the KEY token. */ static int yaml_parser_fetch_key(yaml_parser_t *parser) { yaml_mark_t start_mark, end_mark; yaml_token_t token; /* In the block context, additional checks are required. */ if (!parser->flow_level) { /* Check if we are allowed to start a new key (not necessary simple). */ if (!parser->simple_key_allowed) { return yaml_parser_set_scanner_error(parser, NULL, parser->mark, "mapping keys are not allowed in this context"); } /* Add the BLOCK-MAPPING-START token if needed. */ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) return 0; } /* Reset any potential simple keys on the current flow level. */ if (!yaml_parser_remove_simple_key(parser)) return 0; /* Simple keys are allowed after '?' in the block context. */ parser->simple_key_allowed = (!parser->flow_level); /* Consume the token. */ start_mark = parser->mark; SKIP(parser); end_mark = parser->mark; /* Create the KEY token and append it to the queue. */ TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the VALUE token. */ static int yaml_parser_fetch_value(yaml_parser_t *parser) { yaml_mark_t start_mark, end_mark; yaml_token_t token; yaml_simple_key_t *simple_key = parser->simple_keys.top-1; /* Have we found a simple key? */ if (simple_key->possible) { /* Create the KEY token and insert it into the queue. */ TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark); if (!QUEUE_INSERT(parser, parser->tokens, simple_key->token_number - parser->tokens_parsed, token)) return 0; /* In the block context, we may need to add the BLOCK-MAPPING-START token. */ if (!yaml_parser_roll_indent(parser, simple_key->mark.column, simple_key->token_number, YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark)) return 0; /* Remove the simple key. */ simple_key->possible = 0; /* A simple key cannot follow another simple key. */ parser->simple_key_allowed = 0; } else { /* The ':' indicator follows a complex key. */ /* In the block context, extra checks are required. */ if (!parser->flow_level) { /* Check if we are allowed to start a complex value. */ if (!parser->simple_key_allowed) { return yaml_parser_set_scanner_error(parser, NULL, parser->mark, "mapping values are not allowed in this context"); } /* Add the BLOCK-MAPPING-START token if needed. */ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) return 0; } /* Simple keys after ':' are allowed in the block context. */ parser->simple_key_allowed = (!parser->flow_level); } /* Consume the token. */ start_mark = parser->mark; SKIP(parser); end_mark = parser->mark; /* Create the VALUE token and append it to the queue. */ TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark); if (!ENQUEUE(parser, parser->tokens, token)) return 0; return 1; } /* * Produce the ALIAS or ANCHOR token. */ static int yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type) { yaml_token_t token; /* An anchor or an alias could be a simple key. */ if (!yaml_parser_save_simple_key(parser)) return 0; /* A simple key cannot follow an anchor or an alias. */ parser->simple_key_allowed = 0; /* Create the ALIAS or ANCHOR token and append it to the queue. */ if (!yaml_parser_scan_anchor(parser, &token, type)) return 0; if (!ENQUEUE(parser, parser->tokens, token)) { yaml_token_delete(&token); return 0; } return 1; } /* * Produce the TAG token. */ static int yaml_parser_fetch_tag(yaml_parser_t *parser) { yaml_token_t token; /* A tag could be a simple key. */ if (!yaml_parser_save_simple_key(parser)) return 0; /* A simple key cannot follow a tag. */ parser->simple_key_allowed = 0; /* Create the TAG token and append it to the queue. */ if (!yaml_parser_scan_tag(parser, &token)) return 0; if (!ENQUEUE(parser, parser->tokens, token)) { yaml_token_delete(&token); return 0; } return 1; } /* * Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens. */ static int yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal) { yaml_token_t token; /* Remove any potential simple keys. */ if (!yaml_parser_remove_simple_key(parser)) return 0; /* A simple key may follow a block scalar. */ parser->simple_key_allowed = 1; /* Create the SCALAR token and append it to the queue. */ if (!yaml_parser_scan_block_scalar(parser, &token, literal)) return 0; if (!ENQUEUE(parser, parser->tokens, token)) { yaml_token_delete(&token); return 0; } return 1; } /* * Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens. */ static int yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single) { yaml_token_t token; /* A plain scalar could be a simple key. */ if (!yaml_parser_save_simple_key(parser)) return 0; /* A simple key cannot follow a flow scalar. */ parser->simple_key_allowed = 0; /* Create the SCALAR token and append it to the queue. */ if (!yaml_parser_scan_flow_scalar(parser, &token, single)) return 0; if (!ENQUEUE(parser, parser->tokens, token)) { yaml_token_delete(&token); return 0; } return 1; } /* * Produce the SCALAR(...,plain) token. */ static int yaml_parser_fetch_plain_scalar(yaml_parser_t *parser) { yaml_token_t token; /* A plain scalar could be a simple key. */ if (!yaml_parser_save_simple_key(parser)) return 0; /* A simple key cannot follow a flow scalar. */ parser->simple_key_allowed = 0; /* Create the SCALAR token and append it to the queue. */ if (!yaml_parser_scan_plain_scalar(parser, &token)) return 0; if (!ENQUEUE(parser, parser->tokens, token)) { yaml_token_delete(&token); return 0; } return 1; } /* * Eat whitespaces and comments until the next token is found. */ static int yaml_parser_scan_to_next_token(yaml_parser_t *parser) { /* Until the next token is not found. */ while (1) { /* Allow the BOM mark to start a line. */ if (!CACHE(parser, 1)) return 0; if (parser->mark.column == 0 && IS_BOM(parser->buffer)) SKIP(parser); /* * Eat whitespaces. * * Tabs are allowed: * * - in the flow context; * - in the block context, but not at the beginning of the line or * after '-', '?', or ':' (complex value). */ if (!CACHE(parser, 1)) return 0; while (CHECK(parser->buffer,' ') || ((parser->flow_level || !parser->simple_key_allowed) && CHECK(parser->buffer, '\t'))) { SKIP(parser); if (!CACHE(parser, 1)) return 0; } /* Eat a comment until a line break. */ if (CHECK(parser->buffer, '#')) { while (!IS_BREAKZ(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) return 0; } } /* If it is a line break, eat it. */ if (IS_BREAK(parser->buffer)) { if (!CACHE(parser, 2)) return 0; SKIP_LINE(parser); /* In the block context, a new line may start a simple key. */ if (!parser->flow_level) { parser->simple_key_allowed = 1; } } else { /* We have found a token. */ break; } } return 1; } /* * Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token. * * Scope: * %YAML 1.1 # a comment \n * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * %TAG !yaml! tag:yaml.org,2002: \n * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ int yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token) { yaml_mark_t start_mark, end_mark; yaml_char_t *name = NULL; int major, minor; yaml_char_t *handle = NULL, *prefix = NULL; /* Eat '%'. */ start_mark = parser->mark; SKIP(parser); /* Scan the directive name. */ if (!yaml_parser_scan_directive_name(parser, start_mark, &name)) goto error; /* Is it a YAML directive? */ if (strcmp((char *)name, "YAML") == 0) { /* Scan the VERSION directive value. */ if (!yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor)) goto error; end_mark = parser->mark; /* Create a VERSION-DIRECTIVE token. */ VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor, start_mark, end_mark); } /* Is it a TAG directive? */ else if (strcmp((char *)name, "TAG") == 0) { /* Scan the TAG directive value. */ if (!yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix)) goto error; end_mark = parser->mark; /* Create a TAG-DIRECTIVE token. */ TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix, start_mark, end_mark); } /* Unknown directive. */ else { yaml_parser_set_scanner_error(parser, "while scanning a directive", start_mark, "found unknown directive name"); goto error; } /* Eat the rest of the line including any comments. */ if (!CACHE(parser, 1)) goto error; while (IS_BLANK(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) goto error; } if (CHECK(parser->buffer, '#')) { while (!IS_BREAKZ(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) goto error; } } /* Check if we are at the end of the line. */ if (!IS_BREAKZ(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a directive", start_mark, "did not find expected comment or line break"); goto error; } /* Eat a line break. */ if (IS_BREAK(parser->buffer)) { if (!CACHE(parser, 2)) goto error; SKIP_LINE(parser); } yaml_free(name); return 1; error: yaml_free(prefix); yaml_free(handle); yaml_free(name); return 0; } /* * Scan the directive name. * * Scope: * %YAML 1.1 # a comment \n * ^^^^ * %TAG !yaml! tag:yaml.org,2002: \n * ^^^ */ static int yaml_parser_scan_directive_name(yaml_parser_t *parser, yaml_mark_t start_mark, yaml_char_t **name) { yaml_string_t string = NULL_STRING; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; /* Consume the directive name. */ if (!CACHE(parser, 1)) goto error; while (IS_ALPHA(parser->buffer)) { if (!READ(parser, string)) goto error; if (!CACHE(parser, 1)) goto error; } /* Check if the name is empty. */ if (string.start == string.pointer) { yaml_parser_set_scanner_error(parser, "while scanning a directive", start_mark, "could not find expected directive name"); goto error; } /* Check for an blank character after the name. */ if (!IS_BLANKZ(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a directive", start_mark, "found unexpected non-alphabetical character"); goto error; } *name = string.start; return 1; error: STRING_DEL(parser, string); return 0; } /* * Scan the value of VERSION-DIRECTIVE. * * Scope: * %YAML 1.1 # a comment \n * ^^^^^^ */ static int yaml_parser_scan_version_directive_value(yaml_parser_t *parser, yaml_mark_t start_mark, int *major, int *minor) { /* Eat whitespaces. */ if (!CACHE(parser, 1)) return 0; while (IS_BLANK(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) return 0; } /* Consume the major version number. */ if (!yaml_parser_scan_version_directive_number(parser, start_mark, major)) return 0; /* Eat '.'. */ if (!CHECK(parser->buffer, '.')) { return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", start_mark, "did not find expected digit or '.' character"); } SKIP(parser); /* Consume the minor version number. */ if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor)) return 0; return 1; } #define MAX_NUMBER_LENGTH 9 /* * Scan the version number of VERSION-DIRECTIVE. * * Scope: * %YAML 1.1 # a comment \n * ^ * %YAML 1.1 # a comment \n * ^ */ static int yaml_parser_scan_version_directive_number(yaml_parser_t *parser, yaml_mark_t start_mark, int *number) { int value = 0; size_t length = 0; /* Repeat while the next character is digit. */ if (!CACHE(parser, 1)) return 0; while (IS_DIGIT(parser->buffer)) { /* Check if the number is too long. */ if (++length > MAX_NUMBER_LENGTH) { return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", start_mark, "found extremely long version number"); } value = value*10 + AS_DIGIT(parser->buffer); SKIP(parser); if (!CACHE(parser, 1)) return 0; } /* Check if the number was present. */ if (!length) { return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", start_mark, "did not find expected version number"); } *number = value; return 1; } /* * Scan the value of a TAG-DIRECTIVE token. * * Scope: * %TAG !yaml! tag:yaml.org,2002: \n * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ static int yaml_parser_scan_tag_directive_value(yaml_parser_t *parser, yaml_mark_t start_mark, yaml_char_t **handle, yaml_char_t **prefix) { yaml_char_t *handle_value = NULL; yaml_char_t *prefix_value = NULL; /* Eat whitespaces. */ if (!CACHE(parser, 1)) goto error; while (IS_BLANK(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) goto error; } /* Scan a handle. */ if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value)) goto error; /* Expect a whitespace. */ if (!CACHE(parser, 1)) goto error; if (!IS_BLANK(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", start_mark, "did not find expected whitespace"); goto error; } /* Eat whitespaces. */ while (IS_BLANK(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) goto error; } /* Scan a prefix. */ if (!yaml_parser_scan_tag_uri(parser, 1, NULL, start_mark, &prefix_value)) goto error; /* Expect a whitespace or line break. */ if (!CACHE(parser, 1)) goto error; if (!IS_BLANKZ(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", start_mark, "did not find expected whitespace or line break"); goto error; } *handle = handle_value; *prefix = prefix_value; return 1; error: yaml_free(handle_value); yaml_free(prefix_value); return 0; } static int yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token, yaml_token_type_t type) { int length = 0; yaml_mark_t start_mark, end_mark; yaml_string_t string = NULL_STRING; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; /* Eat the indicator character. */ start_mark = parser->mark; SKIP(parser); /* Consume the value. */ if (!CACHE(parser, 1)) goto error; while (IS_ALPHA(parser->buffer)) { if (!READ(parser, string)) goto error; if (!CACHE(parser, 1)) goto error; length ++; } end_mark = parser->mark; /* * Check if length of the anchor is greater than 0 and it is followed by * a whitespace character or one of the indicators: * * '?', ':', ',', ']', '}', '%', '@', '`'. */ if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`'))) { yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ? "while scanning an anchor" : "while scanning an alias", start_mark, "did not find expected alphabetic or numeric character"); goto error; } /* Create a token. */ if (type == YAML_ANCHOR_TOKEN) { ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark); } else { ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark); } return 1; error: STRING_DEL(parser, string); return 0; } /* * Scan a TAG token. */ static int yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token) { yaml_char_t *handle = NULL; yaml_char_t *suffix = NULL; yaml_mark_t start_mark, end_mark; start_mark = parser->mark; /* Check if the tag is in the canonical form. */ if (!CACHE(parser, 2)) goto error; if (CHECK_AT(parser->buffer, '<', 1)) { /* Set the handle to '' */ handle = YAML_MALLOC(1); if (!handle) goto error; handle[0] = '\0'; /* Eat '!<' */ SKIP(parser); SKIP(parser); /* Consume the tag value. */ if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix)) goto error; /* Check for '>' and eat it. */ if (!CHECK(parser->buffer, '>')) { yaml_parser_set_scanner_error(parser, "while scanning a tag", start_mark, "did not find the expected '>'"); goto error; } SKIP(parser); } else { /* The tag has either the '!suffix' or the '!handle!suffix' form. */ /* First, try to scan a handle. */ if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle)) goto error; /* Check if it is, indeed, handle. */ if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!') { /* Scan the suffix now. */ if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix)) goto error; } else { /* It wasn't a handle after all. Scan the rest of the tag. */ if (!yaml_parser_scan_tag_uri(parser, 0, handle, start_mark, &suffix)) goto error; /* Set the handle to '!'. */ yaml_free(handle); handle = YAML_MALLOC(2); if (!handle) goto error; handle[0] = '!'; handle[1] = '\0'; /* * A special case: the '!' tag. Set the handle to '' and the * suffix to '!'. */ if (suffix[0] == '\0') { yaml_char_t *tmp = handle; handle = suffix; suffix = tmp; } } } /* Check the character which ends the tag. */ if (!CACHE(parser, 1)) goto error; if (!IS_BLANKZ(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a tag", start_mark, "did not find expected whitespace or line break"); goto error; } end_mark = parser->mark; /* Create a token. */ TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark); return 1; error: yaml_free(handle); yaml_free(suffix); return 0; } /* * Scan a tag handle. */ static int yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive, yaml_mark_t start_mark, yaml_char_t **handle) { yaml_string_t string = NULL_STRING; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; /* Check the initial '!' character. */ if (!CACHE(parser, 1)) goto error; if (!CHECK(parser->buffer, '!')) { yaml_parser_set_scanner_error(parser, directive ? "while scanning a tag directive" : "while scanning a tag", start_mark, "did not find expected '!'"); goto error; } /* Copy the '!' character. */ if (!READ(parser, string)) goto error; /* Copy all subsequent alphabetical and numerical characters. */ if (!CACHE(parser, 1)) goto error; while (IS_ALPHA(parser->buffer)) { if (!READ(parser, string)) goto error; if (!CACHE(parser, 1)) goto error; } /* Check if the trailing character is '!' and copy it. */ if (CHECK(parser->buffer, '!')) { if (!READ(parser, string)) goto error; } else { /* * It's either the '!' tag or not really a tag handle. If it's a %TAG * directive, it's an error. If it's a tag token, it must be a part of * URI. */ if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) { yaml_parser_set_scanner_error(parser, "while parsing a tag directive", start_mark, "did not find expected '!'"); goto error; } } *handle = string.start; return 1; error: STRING_DEL(parser, string); return 0; } /* * Scan a tag. */ static int yaml_parser_scan_tag_uri(yaml_parser_t *parser, int directive, yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri) { size_t length = head ? strlen((char *)head) : 0; yaml_string_t string = NULL_STRING; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; /* Resize the string to include the head. */ while ((size_t)(string.end - string.start) <= length) { if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) { parser->error = YAML_MEMORY_ERROR; goto error; } } /* * Copy the head if needed. * * Note that we don't copy the leading '!' character. */ if (length > 1) { memcpy(string.start, head+1, length-1); string.pointer += length-1; } /* Scan the tag. */ if (!CACHE(parser, 1)) goto error; /* * The set of characters that may appear in URI is as follows: * * '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&', * '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']', * '%'. */ while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.') || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '%')) { /* Check if it is a URI-escape sequence. */ if (CHECK(parser->buffer, '%')) { if (!STRING_EXTEND(parser, string)) goto error; if (!yaml_parser_scan_uri_escapes(parser, directive, start_mark, &string)) goto error; } else { if (!READ(parser, string)) goto error; } length ++; if (!CACHE(parser, 1)) goto error; } /* Check if the tag is non-empty. */ if (!length) { if (!STRING_EXTEND(parser, string)) goto error; yaml_parser_set_scanner_error(parser, directive ? "while parsing a %TAG directive" : "while parsing a tag", start_mark, "did not find expected tag URI"); goto error; } *uri = string.start; return 1; error: STRING_DEL(parser, string); return 0; } /* * Decode an URI-escape sequence corresponding to a single UTF-8 character. */ static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, yaml_mark_t start_mark, yaml_string_t *string) { int width = 0; /* Decode the required number of characters. */ do { unsigned char octet = 0; /* Check for a URI-escaped octet. */ if (!CACHE(parser, 3)) return 0; if (!(CHECK(parser->buffer, '%') && IS_HEX_AT(parser->buffer, 1) && IS_HEX_AT(parser->buffer, 2))) { return yaml_parser_set_scanner_error(parser, directive ? "while parsing a %TAG directive" : "while parsing a tag", start_mark, "did not find URI escaped octet"); } /* Get the octet. */ octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); /* If it is the leading octet, determine the length of the UTF-8 sequence. */ if (!width) { width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : (octet & 0xF8) == 0xF0 ? 4 : 0; if (!width) { return yaml_parser_set_scanner_error(parser, directive ? "while parsing a %TAG directive" : "while parsing a tag", start_mark, "found an incorrect leading UTF-8 octet"); } } else { /* Check if the trailing octet is correct. */ if ((octet & 0xC0) != 0x80) { return yaml_parser_set_scanner_error(parser, directive ? "while parsing a %TAG directive" : "while parsing a tag", start_mark, "found an incorrect trailing UTF-8 octet"); } } /* Copy the octet and move the pointers. */ *(string->pointer++) = octet; SKIP(parser); SKIP(parser); SKIP(parser); } while (--width); return 1; } /* * Scan a block scalar. */ static int yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token, int literal) { yaml_mark_t start_mark; yaml_mark_t end_mark; yaml_string_t string = NULL_STRING; yaml_string_t leading_break = NULL_STRING; yaml_string_t trailing_breaks = NULL_STRING; int chomping = 0; int increment = 0; int indent = 0; int leading_blank = 0; int trailing_blank = 0; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; /* Eat the indicator '|' or '>'. */ start_mark = parser->mark; SKIP(parser); /* Scan the additional block scalar indicators. */ if (!CACHE(parser, 1)) goto error; /* Check for a chomping indicator. */ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { /* Set the chomping method and eat the indicator. */ chomping = CHECK(parser->buffer, '+') ? +1 : -1; SKIP(parser); /* Check for an indentation indicator. */ if (!CACHE(parser, 1)) goto error; if (IS_DIGIT(parser->buffer)) { /* Check that the indentation is greater than 0. */ if (CHECK(parser->buffer, '0')) { yaml_parser_set_scanner_error(parser, "while scanning a block scalar", start_mark, "found an indentation indicator equal to 0"); goto error; } /* Get the indentation level and eat the indicator. */ increment = AS_DIGIT(parser->buffer); SKIP(parser); } } /* Do the same as above, but in the opposite order. */ else if (IS_DIGIT(parser->buffer)) { if (CHECK(parser->buffer, '0')) { yaml_parser_set_scanner_error(parser, "while scanning a block scalar", start_mark, "found an indentation indicator equal to 0"); goto error; } increment = AS_DIGIT(parser->buffer); SKIP(parser); if (!CACHE(parser, 1)) goto error; if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { chomping = CHECK(parser->buffer, '+') ? +1 : -1; SKIP(parser); } } /* Eat whitespaces and comments to the end of the line. */ if (!CACHE(parser, 1)) goto error; while (IS_BLANK(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) goto error; } if (CHECK(parser->buffer, '#')) { while (!IS_BREAKZ(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) goto error; } } /* Check if we are at the end of the line. */ if (!IS_BREAKZ(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a block scalar", start_mark, "did not find expected comment or line break"); goto error; } /* Eat a line break. */ if (IS_BREAK(parser->buffer)) { if (!CACHE(parser, 2)) goto error; SKIP_LINE(parser); } end_mark = parser->mark; /* Set the indentation level if it was specified. */ if (increment) { indent = parser->indent >= 0 ? parser->indent+increment : increment; } /* Scan the leading line breaks and determine the indentation level if needed. */ if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark)) goto error; /* Scan the block scalar content. */ if (!CACHE(parser, 1)) goto error; while ((int)parser->mark.column == indent && !IS_Z(parser->buffer)) { /* * We are at the beginning of a non-empty line. */ /* Is it a trailing whitespace? */ trailing_blank = IS_BLANK(parser->buffer); /* Check if we need to fold the leading line break. */ if (!literal && (*leading_break.start == '\n') && !leading_blank && !trailing_blank) { /* Do we need to join the lines by space? */ if (*trailing_breaks.start == '\0') { if (!STRING_EXTEND(parser, string)) goto error; *(string.pointer ++) = ' '; } CLEAR(parser, leading_break); } else { if (!JOIN(parser, string, leading_break)) goto error; CLEAR(parser, leading_break); } /* Append the remaining line breaks. */ if (!JOIN(parser, string, trailing_breaks)) goto error; CLEAR(parser, trailing_breaks); /* Is it a leading whitespace? */ leading_blank = IS_BLANK(parser->buffer); /* Consume the current line. */ while (!IS_BREAKZ(parser->buffer)) { if (!READ(parser, string)) goto error; if (!CACHE(parser, 1)) goto error; } /* Consume the line break. */ if (!CACHE(parser, 2)) goto error; if (!READ_LINE(parser, leading_break)) goto error; /* Eat the following indentation spaces and line breaks. */ if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark)) goto error; } /* Chomp the tail. */ if (chomping != -1) { if (!JOIN(parser, string, leading_break)) goto error; } if (chomping == 1) { if (!JOIN(parser, string, trailing_breaks)) goto error; } /* Create a token. */ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE, start_mark, end_mark); STRING_DEL(parser, leading_break); STRING_DEL(parser, trailing_breaks); return 1; error: STRING_DEL(parser, string); STRING_DEL(parser, leading_break); STRING_DEL(parser, trailing_breaks); return 0; } /* * Scan indentation spaces and line breaks for a block scalar. Determine the * indentation level if needed. */ static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, int *indent, yaml_string_t *breaks, yaml_mark_t start_mark, yaml_mark_t *end_mark) { int max_indent = 0; *end_mark = parser->mark; /* Eat the indentation spaces and line breaks. */ while (1) { /* Eat the indentation spaces. */ if (!CACHE(parser, 1)) return 0; while ((!*indent || (int)parser->mark.column < *indent) && IS_SPACE(parser->buffer)) { SKIP(parser); if (!CACHE(parser, 1)) return 0; } if ((int)parser->mark.column > max_indent) max_indent = (int)parser->mark.column; /* Check for a tab character messing the indentation. */ if ((!*indent || (int)parser->mark.column < *indent) && IS_TAB(parser->buffer)) { return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", start_mark, "found a tab character where an indentation space is expected"); } /* Have we found a non-empty line? */ if (!IS_BREAK(parser->buffer)) break; /* Consume the line break. */ if (!CACHE(parser, 2)) return 0; if (!READ_LINE(parser, *breaks)) return 0; *end_mark = parser->mark; } /* Determine the indentation level if needed. */ if (!*indent) { *indent = max_indent; if (*indent < parser->indent + 1) *indent = parser->indent + 1; if (*indent < 1) *indent = 1; } return 1; } /* * Scan a quoted scalar. */ static int yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token, int single) { yaml_mark_t start_mark; yaml_mark_t end_mark; yaml_string_t string = NULL_STRING; yaml_string_t leading_break = NULL_STRING; yaml_string_t trailing_breaks = NULL_STRING; yaml_string_t whitespaces = NULL_STRING; int leading_blanks; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; /* Eat the left quote. */ start_mark = parser->mark; SKIP(parser); /* Consume the content of the quoted scalar. */ while (1) { /* Check that there are no document indicators at the beginning of the line. */ if (!CACHE(parser, 4)) goto error; if (parser->mark.column == 0 && ((CHECK_AT(parser->buffer, '-', 0) && CHECK_AT(parser->buffer, '-', 1) && CHECK_AT(parser->buffer, '-', 2)) || (CHECK_AT(parser->buffer, '.', 0) && CHECK_AT(parser->buffer, '.', 1) && CHECK_AT(parser->buffer, '.', 2))) && IS_BLANKZ_AT(parser->buffer, 3)) { yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", start_mark, "found unexpected document indicator"); goto error; } /* Check for EOF. */ if (IS_Z(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", start_mark, "found unexpected end of stream"); goto error; } /* Consume non-blank characters. */ if (!CACHE(parser, 2)) goto error; leading_blanks = 0; while (!IS_BLANKZ(parser->buffer)) { /* Check for an escaped single quote. */ if (single && CHECK_AT(parser->buffer, '\'', 0) && CHECK_AT(parser->buffer, '\'', 1)) { if (!STRING_EXTEND(parser, string)) goto error; *(string.pointer++) = '\''; SKIP(parser); SKIP(parser); } /* Check for the right quote. */ else if (CHECK(parser->buffer, single ? '\'' : '"')) { break; } /* Check for an escaped line break. */ else if (!single && CHECK(parser->buffer, '\\') && IS_BREAK_AT(parser->buffer, 1)) { if (!CACHE(parser, 3)) goto error; SKIP(parser); SKIP_LINE(parser); leading_blanks = 1; break; } /* Check for an escape sequence. */ else if (!single && CHECK(parser->buffer, '\\')) { size_t code_length = 0; if (!STRING_EXTEND(parser, string)) goto error; /* Check the escape character. */ switch (parser->buffer.pointer[1]) { case '0': *(string.pointer++) = '\0'; break; case 'a': *(string.pointer++) = '\x07'; break; case 'b': *(string.pointer++) = '\x08'; break; case 't': case '\t': *(string.pointer++) = '\x09'; break; case 'n': *(string.pointer++) = '\x0A'; break; case 'v': *(string.pointer++) = '\x0B'; break; case 'f': *(string.pointer++) = '\x0C'; break; case 'r': *(string.pointer++) = '\x0D'; break; case 'e': *(string.pointer++) = '\x1B'; break; case ' ': *(string.pointer++) = '\x20'; break; case '"': *(string.pointer++) = '"'; break; case '\\': *(string.pointer++) = '\\'; break; case 'N': /* NEL (#x85) */ *(string.pointer++) = '\xC2'; *(string.pointer++) = '\x85'; break; case '_': /* #xA0 */ *(string.pointer++) = '\xC2'; *(string.pointer++) = '\xA0'; break; case 'L': /* LS (#x2028) */ *(string.pointer++) = '\xE2'; *(string.pointer++) = '\x80'; *(string.pointer++) = '\xA8'; break; case 'P': /* PS (#x2029) */ *(string.pointer++) = '\xE2'; *(string.pointer++) = '\x80'; *(string.pointer++) = '\xA9'; break; case 'x': code_length = 2; break; case 'u': code_length = 4; break; case 'U': code_length = 8; break; case '/': *(string.pointer++) = '/'; /* JSON -> YAML 1.2 */ break; default: yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", start_mark, "found unknown escape character"); goto error; } SKIP(parser); SKIP(parser); /* Consume an arbitrary escape code. */ if (code_length) { unsigned int value = 0; size_t k; /* Scan the character value. */ if (!CACHE(parser, code_length)) goto error; for (k = 0; k < code_length; k ++) { if (!IS_HEX_AT(parser->buffer, k)) { yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", start_mark, "did not find expected hexdecimal number"); goto error; } value = (value << 4) + AS_HEX_AT(parser->buffer, k); } /* Check the value and write the character. */ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", start_mark, "found invalid Unicode character escape code"); goto error; } if (value <= 0x7F) { *(string.pointer++) = value; } else if (value <= 0x7FF) { *(string.pointer++) = 0xC0 + (value >> 6); *(string.pointer++) = 0x80 + (value & 0x3F); } else if (value <= 0xFFFF) { *(string.pointer++) = 0xE0 + (value >> 12); *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); *(string.pointer++) = 0x80 + (value & 0x3F); } else { *(string.pointer++) = 0xF0 + (value >> 18); *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F); *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); *(string.pointer++) = 0x80 + (value & 0x3F); } /* Advance the pointer. */ for (k = 0; k < code_length; k ++) { SKIP(parser); } } } else { /* It is a non-escaped non-blank character. */ if (!READ(parser, string)) goto error; } if (!CACHE(parser, 2)) goto error; } /* Check if we are at the end of the scalar. */ if (CHECK(parser->buffer, single ? '\'' : '"')) break; /* Consume blank characters. */ if (!CACHE(parser, 1)) goto error; while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) { if (IS_BLANK(parser->buffer)) { /* Consume a space or a tab character. */ if (!leading_blanks) { if (!READ(parser, whitespaces)) goto error; } else { SKIP(parser); } } else { if (!CACHE(parser, 2)) goto error; /* Check if it is a first line break. */ if (!leading_blanks) { CLEAR(parser, whitespaces); if (!READ_LINE(parser, leading_break)) goto error; leading_blanks = 1; } else { if (!READ_LINE(parser, trailing_breaks)) goto error; } } if (!CACHE(parser, 1)) goto error; } /* Join the whitespaces or fold line breaks. */ if (leading_blanks) { /* Do we need to fold line breaks? */ if (leading_break.start[0] == '\n') { if (trailing_breaks.start[0] == '\0') { if (!STRING_EXTEND(parser, string)) goto error; *(string.pointer++) = ' '; } else { if (!JOIN(parser, string, trailing_breaks)) goto error; CLEAR(parser, trailing_breaks); } CLEAR(parser, leading_break); } else { if (!JOIN(parser, string, leading_break)) goto error; if (!JOIN(parser, string, trailing_breaks)) goto error; CLEAR(parser, leading_break); CLEAR(parser, trailing_breaks); } } else { if (!JOIN(parser, string, whitespaces)) goto error; CLEAR(parser, whitespaces); } } /* Eat the right quote. */ SKIP(parser); end_mark = parser->mark; /* Create a token. */ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE, start_mark, end_mark); STRING_DEL(parser, leading_break); STRING_DEL(parser, trailing_breaks); STRING_DEL(parser, whitespaces); return 1; error: STRING_DEL(parser, string); STRING_DEL(parser, leading_break); STRING_DEL(parser, trailing_breaks); STRING_DEL(parser, whitespaces); return 0; } /* * Scan a plain scalar. */ static int yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token) { yaml_mark_t start_mark; yaml_mark_t end_mark; yaml_string_t string = NULL_STRING; yaml_string_t leading_break = NULL_STRING; yaml_string_t trailing_breaks = NULL_STRING; yaml_string_t whitespaces = NULL_STRING; int leading_blanks = 0; int indent = parser->indent+1; if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; start_mark = end_mark = parser->mark; /* Consume the content of the plain scalar. */ while (1) { /* Check for a document indicator. */ if (!CACHE(parser, 4)) goto error; if (parser->mark.column == 0 && ((CHECK_AT(parser->buffer, '-', 0) && CHECK_AT(parser->buffer, '-', 1) && CHECK_AT(parser->buffer, '-', 2)) || (CHECK_AT(parser->buffer, '.', 0) && CHECK_AT(parser->buffer, '.', 1) && CHECK_AT(parser->buffer, '.', 2))) && IS_BLANKZ_AT(parser->buffer, 3)) break; /* Check for a comment. */ if (CHECK(parser->buffer, '#')) break; /* Consume non-blank characters. */ while (!IS_BLANKZ(parser->buffer)) { /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */ if (parser->flow_level && CHECK(parser->buffer, ':') && !IS_BLANKZ_AT(parser->buffer, 1)) { yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", start_mark, "found unexpected ':'"); goto error; } /* Check for indicators that may end a plain scalar. */ if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1)) || (parser->flow_level && (CHECK(parser->buffer, ',') || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') || CHECK(parser->buffer, '}')))) break; /* Check if we need to join whitespaces and breaks. */ if (leading_blanks || whitespaces.start != whitespaces.pointer) { if (leading_blanks) { /* Do we need to fold line breaks? */ if (leading_break.start[0] == '\n') { if (trailing_breaks.start[0] == '\0') { if (!STRING_EXTEND(parser, string)) goto error; *(string.pointer++) = ' '; } else { if (!JOIN(parser, string, trailing_breaks)) goto error; CLEAR(parser, trailing_breaks); } CLEAR(parser, leading_break); } else { if (!JOIN(parser, string, leading_break)) goto error; if (!JOIN(parser, string, trailing_breaks)) goto error; CLEAR(parser, leading_break); CLEAR(parser, trailing_breaks); } leading_blanks = 0; } else { if (!JOIN(parser, string, whitespaces)) goto error; CLEAR(parser, whitespaces); } } /* Copy the character. */ if (!READ(parser, string)) goto error; end_mark = parser->mark; if (!CACHE(parser, 2)) goto error; } /* Is it the end? */ if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) break; /* Consume blank characters. */ if (!CACHE(parser, 1)) goto error; while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) { if (IS_BLANK(parser->buffer)) { /* Check for tab characters that abuse indentation. */ if (leading_blanks && (int)parser->mark.column < indent && IS_TAB(parser->buffer)) { yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", start_mark, "found a tab character that violates indentation"); goto error; } /* Consume a space or a tab character. */ if (!leading_blanks) { if (!READ(parser, whitespaces)) goto error; } else { SKIP(parser); } } else { if (!CACHE(parser, 2)) goto error; /* Check if it is a first line break. */ if (!leading_blanks) { CLEAR(parser, whitespaces); if (!READ_LINE(parser, leading_break)) goto error; leading_blanks = 1; } else { if (!READ_LINE(parser, trailing_breaks)) goto error; } } if (!CACHE(parser, 1)) goto error; } /* Check indentation level. */ if (!parser->flow_level && (int)parser->mark.column < indent) break; } /* Create a token. */ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark); /* Note that we change the 'simple_key_allowed' flag. */ if (leading_blanks) { parser->simple_key_allowed = 1; } STRING_DEL(parser, leading_break); STRING_DEL(parser, trailing_breaks); STRING_DEL(parser, whitespaces); return 1; error: STRING_DEL(parser, string); STRING_DEL(parser, leading_break); STRING_DEL(parser, trailing_breaks); STRING_DEL(parser, whitespaces); return 0; } ruamel.yaml-0.15.89/ext/yaml_private.h0000664000175100001440000007344613351131445020260 0ustar anthonusers00000000000000 #include "config.h" #include "yaml.h" #include #include #include /* * Memory management. */ YAML_DECLARE(void *) yaml_malloc(size_t size); YAML_DECLARE(void *) yaml_realloc(void *ptr, size_t size); YAML_DECLARE(void) yaml_free(void *ptr); YAML_DECLARE(yaml_char_t *) yaml_strdup(const yaml_char_t *); /* * Reader: Ensure that the buffer contains at least `length` characters. */ YAML_DECLARE(int) yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); /* * Scanner: Ensure that the token stack contains at least one token ready. */ YAML_DECLARE(int) yaml_parser_fetch_more_tokens(yaml_parser_t *parser); /* * The size of the input raw buffer. */ #define INPUT_RAW_BUFFER_SIZE 16384 /* * The size of the input buffer. * * It should be possible to decode the whole raw buffer. */ #define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3) /* * The size of the output buffer. */ #define OUTPUT_BUFFER_SIZE 16384 /* * The size of the output raw buffer. * * It should be possible to encode the whole output buffer. */ #define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2) /* * The maximum size of a YAML input file. * This used to be PTRDIFF_MAX, but that's not entirely portable * because stdint.h isn't available on all platforms. * It is not entirely clear why this isn't the maximum value * that can fit into the parser->offset field. */ #define MAX_FILE_SIZE (~(size_t)0 / 2) /* * The size of other stacks and queues. */ #define INITIAL_STACK_SIZE 16 #define INITIAL_QUEUE_SIZE 16 #define INITIAL_STRING_SIZE 16 /* * Buffer management. */ #define BUFFER_INIT(context,buffer,size) \ (((buffer).start = YAML_MALLOC(size)) ? \ ((buffer).last = (buffer).pointer = (buffer).start, \ (buffer).end = (buffer).start+(size), \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define BUFFER_DEL(context,buffer) \ (yaml_free((buffer).start), \ (buffer).start = (buffer).pointer = (buffer).end = 0) /* * String management. */ typedef struct { yaml_char_t *start; yaml_char_t *end; yaml_char_t *pointer; } yaml_string_t; YAML_DECLARE(int) yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer, yaml_char_t **end); YAML_DECLARE(int) yaml_string_join( yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end, yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end); #define NULL_STRING { NULL, NULL, NULL } #define STRING(string,length) { (string), (string)+(length), (string) } #define STRING_ASSIGN(value,string,length) \ ((value).start = (string), \ (value).end = (string)+(length), \ (value).pointer = (string)) #define STRING_INIT(context,string,size) \ (((string).start = YAML_MALLOC(size)) ? \ ((string).pointer = (string).start, \ (string).end = (string).start+(size), \ memset((string).start, 0, (size)), \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define STRING_DEL(context,string) \ (yaml_free((string).start), \ (string).start = (string).pointer = (string).end = 0) #define STRING_EXTEND(context,string) \ ((((string).pointer+5 < (string).end) \ || yaml_string_extend(&(string).start, \ &(string).pointer, &(string).end)) ? \ 1 : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define CLEAR(context,string) \ ((string).pointer = (string).start, \ memset((string).start, 0, (string).end-(string).start)) #define JOIN(context,string_a,string_b) \ ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ &(string_a).end, &(string_b).start, \ &(string_b).pointer, &(string_b).end)) ? \ ((string_b).pointer = (string_b).start, \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) /* * String check operations. */ /* * Check the octet at the specified position. */ #define CHECK_AT(string,octet,offset) \ ((string).pointer[offset] == (yaml_char_t)(octet)) /* * Check the current octet in the buffer. */ #define CHECK(string,octet) CHECK_AT((string),(octet),0) /* * Check if the character at the specified position is an alphabetical * character, a digit, '_', or '-'. */ #define IS_ALPHA_AT(string,offset) \ (((string).pointer[offset] >= (yaml_char_t) '0' && \ (string).pointer[offset] <= (yaml_char_t) '9') || \ ((string).pointer[offset] >= (yaml_char_t) 'A' && \ (string).pointer[offset] <= (yaml_char_t) 'Z') || \ ((string).pointer[offset] >= (yaml_char_t) 'a' && \ (string).pointer[offset] <= (yaml_char_t) 'z') || \ (string).pointer[offset] == '_' || \ (string).pointer[offset] == '-') #define IS_ALPHA(string) IS_ALPHA_AT((string),0) /* * Check if the character at the specified position is a digit. */ #define IS_DIGIT_AT(string,offset) \ (((string).pointer[offset] >= (yaml_char_t) '0' && \ (string).pointer[offset] <= (yaml_char_t) '9')) #define IS_DIGIT(string) IS_DIGIT_AT((string),0) /* * Get the value of a digit. */ #define AS_DIGIT_AT(string,offset) \ ((string).pointer[offset] - (yaml_char_t) '0') #define AS_DIGIT(string) AS_DIGIT_AT((string),0) /* * Check if the character at the specified position is a hex-digit. */ #define IS_HEX_AT(string,offset) \ (((string).pointer[offset] >= (yaml_char_t) '0' && \ (string).pointer[offset] <= (yaml_char_t) '9') || \ ((string).pointer[offset] >= (yaml_char_t) 'A' && \ (string).pointer[offset] <= (yaml_char_t) 'F') || \ ((string).pointer[offset] >= (yaml_char_t) 'a' && \ (string).pointer[offset] <= (yaml_char_t) 'f')) #define IS_HEX(string) IS_HEX_AT((string),0) /* * Get the value of a hex-digit. */ #define AS_HEX_AT(string,offset) \ (((string).pointer[offset] >= (yaml_char_t) 'A' && \ (string).pointer[offset] <= (yaml_char_t) 'F') ? \ ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ ((string).pointer[offset] >= (yaml_char_t) 'a' && \ (string).pointer[offset] <= (yaml_char_t) 'f') ? \ ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ ((string).pointer[offset] - (yaml_char_t) '0')) #define AS_HEX(string) AS_HEX_AT((string),0) /* * Check if the character is ASCII. */ #define IS_ASCII_AT(string,offset) \ ((string).pointer[offset] <= (yaml_char_t) '\x7F') #define IS_ASCII(string) IS_ASCII_AT((string),0) /* * Check if the character can be printed unescaped. */ #define IS_PRINTABLE_AT(string,offset) \ (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ && (string).pointer[offset] <= 0x7E) \ || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ && (string).pointer[offset+1] >= 0xA0) \ || ((string).pointer[offset] > 0xC2 \ && (string).pointer[offset] < 0xED) \ || ((string).pointer[offset] == 0xED \ && (string).pointer[offset+1] < 0xA0) \ || ((string).pointer[offset] == 0xEE) \ || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ && (string).pointer[offset+2] == 0xBF) \ && !((string).pointer[offset+1] == 0xBF \ && ((string).pointer[offset+2] == 0xBE \ || (string).pointer[offset+2] == 0xBF)))) #define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) /* * Check if the character at the specified position is NUL. */ #define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) #define IS_Z(string) IS_Z_AT((string),0) /* * Check if the character at the specified position is BOM. */ #define IS_BOM_AT(string,offset) \ (CHECK_AT((string),'\xEF',(offset)) \ && CHECK_AT((string),'\xBB',(offset)+1) \ && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ #define IS_BOM(string) IS_BOM_AT(string,0) /* * Check if the character at the specified position is space. */ #define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) #define IS_SPACE(string) IS_SPACE_AT((string),0) /* * Check if the character at the specified position is tab. */ #define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) #define IS_TAB(string) IS_TAB_AT((string),0) /* * Check if the character at the specified position is blank (space or tab). */ #define IS_BLANK_AT(string,offset) \ (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) #define IS_BLANK(string) IS_BLANK_AT((string),0) /* * Check if the character at the specified position is a line break. */ #define IS_BREAK_AT(string,offset) \ (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ || (CHECK_AT((string),'\xC2',(offset)) \ && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ || (CHECK_AT((string),'\xE2',(offset)) \ && CHECK_AT((string),'\x80',(offset)+1) \ && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ || (CHECK_AT((string),'\xE2',(offset)) \ && CHECK_AT((string),'\x80',(offset)+1) \ && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ #define IS_BREAK(string) IS_BREAK_AT((string),0) #define IS_CRLF_AT(string,offset) \ (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) #define IS_CRLF(string) IS_CRLF_AT((string),0) /* * Check if the character is a line break or NUL. */ #define IS_BREAKZ_AT(string,offset) \ (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) #define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) /* * Check if the character is a line break, space, or NUL. */ #define IS_SPACEZ_AT(string,offset) \ (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) #define IS_SPACEZ(string) IS_SPACEZ_AT((string),0) /* * Check if the character is a line break, space, tab, or NUL. */ #define IS_BLANKZ_AT(string,offset) \ (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) #define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) /* * Determine the width of the character. */ #define WIDTH_AT(string,offset) \ (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) #define WIDTH(string) WIDTH_AT((string),0) /* * Move the string pointer to the next character. */ #define MOVE(string) ((string).pointer += WIDTH((string))) /* * Copy a character and move the pointers of both strings. */ #define COPY(string_a,string_b) \ ((*(string_b).pointer & 0x80) == 0x00 ? \ (*((string_a).pointer++) = *((string_b).pointer++)) : \ (*(string_b).pointer & 0xE0) == 0xC0 ? \ (*((string_a).pointer++) = *((string_b).pointer++), \ *((string_a).pointer++) = *((string_b).pointer++)) : \ (*(string_b).pointer & 0xF0) == 0xE0 ? \ (*((string_a).pointer++) = *((string_b).pointer++), \ *((string_a).pointer++) = *((string_b).pointer++), \ *((string_a).pointer++) = *((string_b).pointer++)) : \ (*(string_b).pointer & 0xF8) == 0xF0 ? \ (*((string_a).pointer++) = *((string_b).pointer++), \ *((string_a).pointer++) = *((string_b).pointer++), \ *((string_a).pointer++) = *((string_b).pointer++), \ *((string_a).pointer++) = *((string_b).pointer++)) : 0) /* * Stack and queue management. */ YAML_DECLARE(int) yaml_stack_extend(void **start, void **top, void **end); YAML_DECLARE(int) yaml_queue_extend(void **start, void **head, void **tail, void **end); #define STACK_INIT(context,stack,type) \ (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ ((stack).top = (stack).start, \ (stack).end = (stack).start+INITIAL_STACK_SIZE, \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define STACK_DEL(context,stack) \ (yaml_free((stack).start), \ (stack).start = (stack).top = (stack).end = 0) #define STACK_EMPTY(context,stack) \ ((stack).start == (stack).top) #define STACK_LIMIT(context,stack,size) \ ((stack).top - (stack).start < (size) ? \ 1 : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define PUSH(context,stack,value) \ (((stack).top != (stack).end \ || yaml_stack_extend((void **)&(stack).start, \ (void **)&(stack).top, (void **)&(stack).end)) ? \ (*((stack).top++) = value, \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define POP(context,stack) \ (*(--(stack).top)) #define QUEUE_INIT(context,queue,size,type) \ (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \ ((queue).head = (queue).tail = (queue).start, \ (queue).end = (queue).start+(size), \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define QUEUE_DEL(context,queue) \ (yaml_free((queue).start), \ (queue).start = (queue).head = (queue).tail = (queue).end = 0) #define QUEUE_EMPTY(context,queue) \ ((queue).head == (queue).tail) #define ENQUEUE(context,queue,value) \ (((queue).tail != (queue).end \ || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ (void **)&(queue).tail, (void **)&(queue).end)) ? \ (*((queue).tail++) = value, \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) #define DEQUEUE(context,queue) \ (*((queue).head++)) #define QUEUE_INSERT(context,queue,index,value) \ (((queue).tail != (queue).end \ || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ (void **)&(queue).tail, (void **)&(queue).end)) ? \ (memmove((queue).head+(index)+1,(queue).head+(index), \ ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ *((queue).head+(index)) = value, \ (queue).tail++, \ 1) : \ ((context)->error = YAML_MEMORY_ERROR, \ 0)) /* * Token initializers. */ #define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \ (memset(&(token), 0, sizeof(yaml_token_t)), \ (token).type = (token_type), \ (token).start_mark = (token_start_mark), \ (token).end_mark = (token_end_mark)) #define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \ (token).data.stream_start.encoding = (token_encoding)) #define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) #define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \ (token).data.alias.value = (token_value)) #define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \ (token).data.anchor.value = (token_value)) #define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \ (token).data.tag.handle = (token_handle), \ (token).data.tag.suffix = (token_suffix)) #define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ (token).data.scalar.value = (token_value), \ (token).data.scalar.length = (token_length), \ (token).data.scalar.style = (token_style)) #define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ (token).data.version_directive.major = (token_major), \ (token).data.version_directive.minor = (token_minor)) #define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \ (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ (token).data.tag_directive.handle = (token_handle), \ (token).data.tag_directive.prefix = (token_prefix)) /* * Event initializers. */ #define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \ (memset(&(event), 0, sizeof(yaml_event_t)), \ (event).type = (event_type), \ (event).start_mark = (event_start_mark), \ (event).end_mark = (event_end_mark)) #define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \ (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \ (event).data.stream_start.encoding = (event_encoding)) #define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \ (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) #define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \ event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \ (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ (event).data.document_start.version_directive = (event_version_directive), \ (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ (event).data.document_start.implicit = (event_implicit)) #define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \ (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ (event).data.document_end.implicit = (event_implicit)) #define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \ (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ (event).data.alias.anchor = (event_anchor)) #define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \ event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \ (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ (event).data.scalar.anchor = (event_anchor), \ (event).data.scalar.tag = (event_tag), \ (event).data.scalar.value = (event_value), \ (event).data.scalar.length = (event_length), \ (event).data.scalar.plain_implicit = (event_plain_implicit), \ (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ (event).data.scalar.style = (event_style)) #define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \ event_implicit,event_style,start_mark,end_mark) \ (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ (event).data.sequence_start.anchor = (event_anchor), \ (event).data.sequence_start.tag = (event_tag), \ (event).data.sequence_start.implicit = (event_implicit), \ (event).data.sequence_start.style = (event_style)) #define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \ (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) #define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \ event_implicit,event_style,start_mark,end_mark) \ (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ (event).data.mapping_start.anchor = (event_anchor), \ (event).data.mapping_start.tag = (event_tag), \ (event).data.mapping_start.implicit = (event_implicit), \ (event).data.mapping_start.style = (event_style)) #define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \ (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) /* * Document initializer. */ #define DOCUMENT_INIT(document,document_nodes_start,document_nodes_end, \ document_version_directive,document_tag_directives_start, \ document_tag_directives_end,document_start_implicit, \ document_end_implicit,document_start_mark,document_end_mark) \ (memset(&(document), 0, sizeof(yaml_document_t)), \ (document).nodes.start = (document_nodes_start), \ (document).nodes.end = (document_nodes_end), \ (document).nodes.top = (document_nodes_start), \ (document).version_directive = (document_version_directive), \ (document).tag_directives.start = (document_tag_directives_start), \ (document).tag_directives.end = (document_tag_directives_end), \ (document).start_implicit = (document_start_implicit), \ (document).end_implicit = (document_end_implicit), \ (document).start_mark = (document_start_mark), \ (document).end_mark = (document_end_mark)) /* * Node initializers. */ #define NODE_INIT(node,node_type,node_tag,node_start_mark,node_end_mark) \ (memset(&(node), 0, sizeof(yaml_node_t)), \ (node).type = (node_type), \ (node).tag = (node_tag), \ (node).start_mark = (node_start_mark), \ (node).end_mark = (node_end_mark)) #define SCALAR_NODE_INIT(node,node_tag,node_value,node_length, \ node_style,start_mark,end_mark) \ (NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \ (node).data.scalar.value = (node_value), \ (node).data.scalar.length = (node_length), \ (node).data.scalar.style = (node_style)) #define SEQUENCE_NODE_INIT(node,node_tag,node_items_start,node_items_end, \ node_style,start_mark,end_mark) \ (NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \ (node).data.sequence.items.start = (node_items_start), \ (node).data.sequence.items.end = (node_items_end), \ (node).data.sequence.items.top = (node_items_start), \ (node).data.sequence.style = (node_style)) #define MAPPING_NODE_INIT(node,node_tag,node_pairs_start,node_pairs_end, \ node_style,start_mark,end_mark) \ (NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \ (node).data.mapping.pairs.start = (node_pairs_start), \ (node).data.mapping.pairs.end = (node_pairs_end), \ (node).data.mapping.pairs.top = (node_pairs_start), \ (node).data.mapping.style = (node_style)) /* Strict C compiler warning helpers */ #if defined(__clang__) || defined(__GNUC__) # define HASATTRIBUTE_UNUSED #endif #ifdef HASATTRIBUTE_UNUSED # define __attribute__unused__ __attribute__((__unused__)) #else # define __attribute__unused__ #endif /* Shim arguments are arguments that must be included in your function, * but serve no purpose inside. Silence compiler warnings. */ #define SHIM(a) /*@unused@*/ a __attribute__unused__ /* UNUSED_PARAM() marks a shim argument in the body to silence compiler warnings */ #ifdef __clang__ # define UNUSED_PARAM(a) (void)(a); #else # define UNUSED_PARAM(a) /*@-noeffect*/if (0) (void)(a)/*@=noeffect*/; #endif #define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type)) #define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ruamel.yaml-0.15.89/resolver.py0000664000175100001440000003573113435576550017036 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import import re if False: # MYPY from typing import Any, Dict, List, Union, Text, Optional # NOQA from ruamel.yaml.compat import VersionType # NOQA from ruamel.yaml.compat import string_types, _DEFAULT_YAML_VERSION # NOQA from ruamel.yaml.error import * # NOQA from ruamel.yaml.nodes import MappingNode, ScalarNode, SequenceNode # NOQA from ruamel.yaml.util import RegExp # NOQA __all__ = ['BaseResolver', 'Resolver', 'VersionedResolver'] # fmt: off # resolvers consist of # - a list of applicable version # - a tag # - a regexp # - a list of first characters to match implicit_resolvers = [ ([(1, 2)], u'tag:yaml.org,2002:bool', RegExp(u'''^(?:true|True|TRUE|false|False|FALSE)$''', re.X), list(u'tTfF')), ([(1, 1)], u'tag:yaml.org,2002:bool', RegExp(u'''^(?:yes|Yes|YES|no|No|NO |true|True|TRUE|false|False|FALSE |on|On|ON|off|Off|OFF)$''', re.X), list(u'yYnNtTfFoO')), ([(1, 2)], u'tag:yaml.org,2002:float', RegExp(u'''^(?: [-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+]?[0-9]+)? |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+) |[-+]?\\.[0-9_]+(?:[eE][-+][0-9]+)? |[-+]?\\.(?:inf|Inf|INF) |\\.(?:nan|NaN|NAN))$''', re.X), list(u'-+0123456789.')), ([(1, 1)], u'tag:yaml.org,2002:float', RegExp(u'''^(?: [-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+]?[0-9]+)? |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+) |\\.[0-9_]+(?:[eE][-+][0-9]+)? |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]* # sexagesimal float |[-+]?\\.(?:inf|Inf|INF) |\\.(?:nan|NaN|NAN))$''', re.X), list(u'-+0123456789.')), ([(1, 2)], u'tag:yaml.org,2002:int', RegExp(u'''^(?:[-+]?0b[0-1_]+ |[-+]?0o?[0-7_]+ |[-+]?[0-9_]+ |[-+]?0x[0-9a-fA-F_]+)$''', re.X), list(u'-+0123456789')), ([(1, 1)], u'tag:yaml.org,2002:int', RegExp(u'''^(?:[-+]?0b[0-1_]+ |[-+]?0?[0-7_]+ |[-+]?(?:0|[1-9][0-9_]*) |[-+]?0x[0-9a-fA-F_]+ |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), # sexagesimal int list(u'-+0123456789')), ([(1, 2), (1, 1)], u'tag:yaml.org,2002:merge', RegExp(u'^(?:<<)$'), [u'<']), ([(1, 2), (1, 1)], u'tag:yaml.org,2002:null', RegExp(u'''^(?: ~ |null|Null|NULL | )$''', re.X), [u'~', u'n', u'N', u'']), ([(1, 2), (1, 1)], u'tag:yaml.org,2002:timestamp', RegExp(u'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]? (?:[Tt]|[ \\t]+)[0-9][0-9]? :[0-9][0-9] :[0-9][0-9] (?:\\.[0-9]*)? (?:[ \\t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X), list(u'0123456789')), ([(1, 2), (1, 1)], u'tag:yaml.org,2002:value', RegExp(u'^(?:=)$'), [u'=']), # The following resolver is only for documentation purposes. It cannot work # because plain scalars cannot start with '!', '&', or '*'. ([(1, 2), (1, 1)], u'tag:yaml.org,2002:yaml', RegExp(u'^(?:!|&|\\*)$'), list(u'!&*')), ] # fmt: on class ResolverError(YAMLError): pass class BaseResolver(object): DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str' DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq' DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map' yaml_implicit_resolvers = {} # type: Dict[Any, Any] yaml_path_resolvers = {} # type: Dict[Any, Any] def __init__(self, loadumper=None): # type: (Any, Any) -> None self.loadumper = loadumper if self.loadumper is not None and getattr(self.loadumper, '_resolver', None) is None: self.loadumper._resolver = self.loadumper self._loader_version = None # type: Any self.resolver_exact_paths = [] # type: List[Any] self.resolver_prefix_paths = [] # type: List[Any] @property def parser(self): # type: () -> Any if self.loadumper is not None: if hasattr(self.loadumper, 'typ'): return self.loadumper.parser return self.loadumper._parser return None @classmethod def add_implicit_resolver_base(cls, tag, regexp, first): # type: (Any, Any, Any) -> None if 'yaml_implicit_resolvers' not in cls.__dict__: # deepcopy doesn't work here cls.yaml_implicit_resolvers = dict( (k, cls.yaml_implicit_resolvers[k][:]) for k in cls.yaml_implicit_resolvers ) if first is None: first = [None] for ch in first: cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp)) @classmethod def add_implicit_resolver(cls, tag, regexp, first): # type: (Any, Any, Any) -> None if 'yaml_implicit_resolvers' not in cls.__dict__: # deepcopy doesn't work here cls.yaml_implicit_resolvers = dict( (k, cls.yaml_implicit_resolvers[k][:]) for k in cls.yaml_implicit_resolvers ) if first is None: first = [None] for ch in first: cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp)) implicit_resolvers.append(([(1, 2), (1, 1)], tag, regexp, first)) # @classmethod # def add_implicit_resolver(cls, tag, regexp, first): @classmethod def add_path_resolver(cls, tag, path, kind=None): # type: (Any, Any, Any) -> None # Note: `add_path_resolver` is experimental. The API could be changed. # `new_path` is a pattern that is matched against the path from the # root to the node that is being considered. `node_path` elements are # tuples `(node_check, index_check)`. `node_check` is a node class: # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`. `None` # matches any kind of a node. `index_check` could be `None`, a boolean # value, a string value, or a number. `None` and `False` match against # any _value_ of sequence and mapping nodes. `True` matches against # any _key_ of a mapping node. A string `index_check` matches against # a mapping value that corresponds to a scalar key which content is # equal to the `index_check` value. An integer `index_check` matches # against a sequence value with the index equal to `index_check`. if 'yaml_path_resolvers' not in cls.__dict__: cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy() new_path = [] # type: List[Any] for element in path: if isinstance(element, (list, tuple)): if len(element) == 2: node_check, index_check = element elif len(element) == 1: node_check = element[0] index_check = True else: raise ResolverError('Invalid path element: %s' % (element,)) else: node_check = None index_check = element if node_check is str: node_check = ScalarNode elif node_check is list: node_check = SequenceNode elif node_check is dict: node_check = MappingNode elif ( node_check not in [ScalarNode, SequenceNode, MappingNode] and not isinstance(node_check, string_types) and node_check is not None ): raise ResolverError('Invalid node checker: %s' % (node_check,)) if not isinstance(index_check, (string_types, int)) and index_check is not None: raise ResolverError('Invalid index checker: %s' % (index_check,)) new_path.append((node_check, index_check)) if kind is str: kind = ScalarNode elif kind is list: kind = SequenceNode elif kind is dict: kind = MappingNode elif kind not in [ScalarNode, SequenceNode, MappingNode] and kind is not None: raise ResolverError('Invalid node kind: %s' % (kind,)) cls.yaml_path_resolvers[tuple(new_path), kind] = tag def descend_resolver(self, current_node, current_index): # type: (Any, Any) -> None if not self.yaml_path_resolvers: return exact_paths = {} prefix_paths = [] if current_node: depth = len(self.resolver_prefix_paths) for path, kind in self.resolver_prefix_paths[-1]: if self.check_resolver_prefix(depth, path, kind, current_node, current_index): if len(path) > depth: prefix_paths.append((path, kind)) else: exact_paths[kind] = self.yaml_path_resolvers[path, kind] else: for path, kind in self.yaml_path_resolvers: if not path: exact_paths[kind] = self.yaml_path_resolvers[path, kind] else: prefix_paths.append((path, kind)) self.resolver_exact_paths.append(exact_paths) self.resolver_prefix_paths.append(prefix_paths) def ascend_resolver(self): # type: () -> None if not self.yaml_path_resolvers: return self.resolver_exact_paths.pop() self.resolver_prefix_paths.pop() def check_resolver_prefix(self, depth, path, kind, current_node, current_index): # type: (int, Text, Any, Any, Any) -> bool node_check, index_check = path[depth - 1] if isinstance(node_check, string_types): if current_node.tag != node_check: return False elif node_check is not None: if not isinstance(current_node, node_check): return False if index_check is True and current_index is not None: return False if (index_check is False or index_check is None) and current_index is None: return False if isinstance(index_check, string_types): if not ( isinstance(current_index, ScalarNode) and index_check == current_index.value ): return False elif isinstance(index_check, int) and not isinstance(index_check, bool): if index_check != current_index: return False return True def resolve(self, kind, value, implicit): # type: (Any, Any, Any) -> Any if kind is ScalarNode and implicit[0]: if value == "": resolvers = self.yaml_implicit_resolvers.get("", []) else: resolvers = self.yaml_implicit_resolvers.get(value[0], []) resolvers += self.yaml_implicit_resolvers.get(None, []) for tag, regexp in resolvers: if regexp.match(value): return tag implicit = implicit[1] if bool(self.yaml_path_resolvers): exact_paths = self.resolver_exact_paths[-1] if kind in exact_paths: return exact_paths[kind] if None in exact_paths: return exact_paths[None] if kind is ScalarNode: return self.DEFAULT_SCALAR_TAG elif kind is SequenceNode: return self.DEFAULT_SEQUENCE_TAG elif kind is MappingNode: return self.DEFAULT_MAPPING_TAG @property def processing_version(self): # type: () -> Any return None class Resolver(BaseResolver): pass for ir in implicit_resolvers: if (1, 2) in ir[0]: Resolver.add_implicit_resolver_base(*ir[1:]) class VersionedResolver(BaseResolver): """ contrary to the "normal" resolver, the smart resolver delays loading the pattern matching rules. That way it can decide to load 1.1 rules or the (default) 1.2 rules, that no longer support octal without 0o, sexagesimals and Yes/No/On/Off booleans. """ def __init__(self, version=None, loader=None, loadumper=None): # type: (Optional[VersionType], Any, Any) -> None if loader is None and loadumper is not None: loader = loadumper BaseResolver.__init__(self, loader) self._loader_version = self.get_loader_version(version) self._version_implicit_resolver = {} # type: Dict[Any, Any] def add_version_implicit_resolver(self, version, tag, regexp, first): # type: (VersionType, Any, Any, Any) -> None if first is None: first = [None] impl_resolver = self._version_implicit_resolver.setdefault(version, {}) for ch in first: impl_resolver.setdefault(ch, []).append((tag, regexp)) def get_loader_version(self, version): # type: (Optional[VersionType]) -> Any if version is None or isinstance(version, tuple): return version if isinstance(version, list): return tuple(version) # assume string return tuple(map(int, version.split(u'.'))) @property def versioned_resolver(self): # type: () -> Any """ select the resolver based on the version we are parsing """ version = self.processing_version if version not in self._version_implicit_resolver: for x in implicit_resolvers: if version in x[0]: self.add_version_implicit_resolver(version, x[1], x[2], x[3]) return self._version_implicit_resolver[version] def resolve(self, kind, value, implicit): # type: (Any, Any, Any) -> Any if kind is ScalarNode and implicit[0]: if value == "": resolvers = self.versioned_resolver.get("", []) else: resolvers = self.versioned_resolver.get(value[0], []) resolvers += self.versioned_resolver.get(None, []) for tag, regexp in resolvers: if regexp.match(value): return tag implicit = implicit[1] if bool(self.yaml_path_resolvers): exact_paths = self.resolver_exact_paths[-1] if kind in exact_paths: return exact_paths[kind] if None in exact_paths: return exact_paths[None] if kind is ScalarNode: return self.DEFAULT_SCALAR_TAG elif kind is SequenceNode: return self.DEFAULT_SEQUENCE_TAG elif kind is MappingNode: return self.DEFAULT_MAPPING_TAG @property def processing_version(self): # type: () -> Any try: version = self.parser.yaml_version except AttributeError: try: if hasattr(self.loadumper, 'typ'): version = self.loadumper.version else: version = self.loadumper._serializer.use_version # dumping except AttributeError: version = None if version is None: version = self._loader_version if version is None: version = _DEFAULT_YAML_VERSION return version ruamel.yaml-0.15.89/ruamel.yaml.egg-info/0000775000175100001440000000000013435603756020531 5ustar anthonusers00000000000000ruamel.yaml-0.15.89/ruamel.yaml.egg-info/namespace_packages.txt0000664000175100001440000000000713435603753025056 0ustar anthonusers00000000000000ruamel ruamel.yaml-0.15.89/ruamel.yaml.egg-info/SOURCES.txt0000664000175100001440000000161013435603753022410 0ustar anthonusers00000000000000CHANGES LICENSE MANIFEST.in README.rst setup.py ./LICENSE ./__init__.py ./anchor.py ./comments.py ./compat.py ./composer.py ./configobjwalker.py ./constructor.py ./cyaml.py ./dumper.py ./emitter.py ./error.py ./events.py ./loader.py ./main.py ./nodes.py ./parser.py ./reader.py ./representer.py ./resolver.py ./scalarbool.py ./scalarfloat.py ./scalarint.py ./scalarstring.py ./scanner.py ./serializer.py ./timestamp.py ./tokens.py ./util.py .ruamel/__init__.py ext/_ruamel_yaml.c ext/_ruamel_yaml.h ext/_ruamel_yaml.pxd ext/_ruamel_yaml.pyx ext/api.c ext/config.h ext/dumper.c ext/emitter.c ext/loader.c ext/parser.c ext/reader.c ext/scanner.c ext/writer.c ext/yaml.h ext/yaml_private.h ruamel.yaml.egg-info/PKG-INFO ruamel.yaml.egg-info/SOURCES.txt ruamel.yaml.egg-info/dependency_links.txt ruamel.yaml.egg-info/namespace_packages.txt ruamel.yaml.egg-info/requires.txt ruamel.yaml.egg-info/top_level.txtruamel.yaml-0.15.89/ruamel.yaml.egg-info/PKG-INFO0000664000175100001440000010342113435603753021624 0ustar anthonusers00000000000000Metadata-Version: 1.1 Name: ruamel.yaml Version: 0.15.89 Summary: ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order Home-page: https://bitbucket.org/ruamel/yaml Author: Anthon van der Neut Author-email: a.van.der.neut@ruamel.eu License: MIT license Description: ruamel.yaml =========== ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python. :version: 0.15.89 :updated: 2019-02-27 :documentation: http://yaml.readthedocs.io :repository: https://bitbucket.org/ruamel/ :pypi: https://pypi.org/project/ruamel.yaml/ Starting with version 0.15.0 the way YAML files are loaded and dumped is changing. See the API doc for details. Currently existing functionality will throw a warning before being changed/removed. **For production systems you should pin the version being used with ``ruamel.yaml<=0.15``**. There might be bug fixes in the 0.14 series, but new functionality is likely only to be available via the new API. If your package uses ``ruamel.yaml`` and is not listed on PyPI, drop me an email, preferably with some information on how you use the package (or a link to bitbucket/github) and I'll keep you informed when the status of the API is stable enough to make the transition. * `Overview `_ * `Installing `_ * `Basic Usage `_ * `Details `_ * `Examples `_ * `API `_ * `Differences with PyYAML `_ .. image:: https://readthedocs.org/projects/yaml/badge/?version=stable :target: https://yaml.readthedocs.org/en/stable .. image:: https://bestpractices.coreinfrastructure.org/projects/1128/badge :target: https://bestpractices.coreinfrastructure.org/projects/1128 .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/license.svg :target: https://opensource.org/licenses/MIT .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/pypi.svg :target: https://pypi.org/project/ruamel.yaml/ .. image:: https://bitbucket.org/ruamel/oitnb/raw/default/_doc/_static/oitnb.svg :target: https://pypi.org/project/oitnb/ .. image:: http://www.mypy-lang.org/static/mypy_badge.svg :target: http://mypy-lang.org/ ChangeLog ========= .. should insert NEXT: at the beginning of line for next key (with empty line) 0.15.89 (2019-02-27): - fix for items with flow-mapping in block sequence output on single line (reported by `Zahari Dim `__) - fix for safe dumping erroring in creation of representereror when dumping namedtuple (reported and solution by `Jaakko Kantojärvi `__) 0.15.88 (2019-02-12): - fix inclusing of python code from the subpackage data (containing extra tests, reported by `Florian Apolloner `__) 0.15.87 (2019-01-22): - fix problem with empty lists and the code to reinsert merge keys (reported via email by Zaloo) 0.15.86 (2019-01-16): - reinsert merge key in its old position (reported by grumbler on `__) - fix for issue with non-ASCII anchor names (reported and fix provided by Dandaleon Flux via email) - fix for issue when parsing flow mapping value starting with colon (in pure Python only) (reported by `FichteFoll `__) 0.15.85 (2019-01-08): - the types used by ``SafeConstructor`` for mappings and sequences can now by set by assigning to ``XXXConstructor.yaml_base_dict_type`` (and ``..._list_type``), preventing the need to copy two methods with 50+ lines that had ``var = {}`` hardcoded. (Implemented to help solve an feature request by `Anthony Sottile `__ in an easier way) 0.15.84 (2019-01-07): - fix for ``CommentedMap.copy()`` not returning ``CommentedMap``, let alone copying comments etc. (reported by `Anthony Sottile `__) 0.15.83 (2019-01-02): - fix for bug in roundtripping aliases used as key (reported via email by Zaloo) 0.15.82 (2018-12-28): - anchors and aliases on scalar int, float, string and bool are now preserved. Anchors do not need a referring alias for these (reported by `Alex Harvey `__) - anchors no longer lost on tagged objects when roundtripping (reported by `Zaloo `__) 0.15.81 (2018-12-06): - fix issue dumping methods of metaclass derived classes (reported and fix provided by `Douglas Raillard `__) 0.15.80 (2018-11-26): - fix issue emitting BEL character when round-tripping invalid folded input (reported by Isaac on `StackOverflow `__) 0.15.79 (2018-11-21): - fix issue with anchors nested deeper than alias (reported by gaFF on `StackOverflow `__) 0.15.78 (2018-11-15): - fix setup issue for 3.8 (reported by `Sidney Kuyateh `__) 0.15.77 (2018-11-09): - setting `yaml.sort_base_mapping_type_on_output = False`, will prevent explicit sorting by keys in the base representer of mappings. Roundtrip already did not do this. Usage only makes real sense for Python 3.6+ (feature request by `Sebastian Gerber `__). - implement Python version check in YAML metadata in ``_test/test_z_data.py`` 0.15.76 (2018-11-01): - fix issue with empty mapping and sequence loaded as flow-style (mapping reported by `Min RK `__, sequence by `Maged Ahmed `__) 0.15.75 (2018-10-27): - fix issue with single '?' scalar (reported by `Terrance `__) - fix issue with duplicate merge keys (prompted by `answering `__ a `StackOverflow question `__ by `math `__) 0.15.74 (2018-10-17): - fix dropping of comment on rt before sequence item that is sequence item (reported by `Thorsten Kampe `__) 0.15.73 (2018-10-16): - fix irregular output on pre-comment in sequence within sequence (reported by `Thorsten Kampe `__) - allow non-compact (i.e. next line) dumping sequence/mapping within sequence. 0.15.72 (2018-10-06): - fix regression on explicit 1.1 loading with the C based scanner/parser (reported by `Tomas Vavra `__) 0.15.71 (2018-09-26): - some of the tests now live in YAML files in the `yaml.data `__ repository. ``_test/test_z_data.py`` processes these. - fix regression where handcrafted CommentedMaps could not be initiated (reported by `Dan Helfman `__) - fix regression with non-root literal scalars that needed indent indicator (reported by `Clark Breyman `__) - tag:yaml.org,2002:python/object/apply now also uses __qualname__ on PY3 (reported by `Douglas RAILLARD `__) - issue with self-referring object creation (reported and fix by `Douglas RAILLARD `__) 0.15.70 (2018-09-21): - reverted CommentedMap and CommentedSeq to subclass ordereddict resp. list, reimplemented merge maps so that both ``dict(**commented_map_instance)`` and JSON dumping works. This also allows checking with ``isinstance()`` on ``dict`` resp. ``list``. (Proposed by `Stuart Berg `__, with feedback from `blhsing `__ on `StackOverflow `__) 0.15.69 (2018-09-20): - fix issue with dump_all gobbling end-of-document comments on parsing (reported by `Pierre B. `__) 0.15.68 (2018-09-20): - fix issue with parsabel, but incorrect output with nested flow-style sequences (reported by `Dougal Seeley `__) - fix issue with loading Python objects that have __setstate__ and recursion in parameters (reported by `Douglas RAILLARD `__) 0.15.67 (2018-09-19): - fix issue with extra space inserted with non-root literal strings (Issue reported and PR with fix provided by `Naomi Seyfer `__.) 0.15.66 (2018-09-07): - fix issue with fold indicating characters inserted in safe_load-ed folded strings (reported by `Maximilian Hils `__). 0.15.65 (2018-09-07): - fix issue #232 revert to throw ParserError for unexcpected ``]`` and ``}`` instead of IndexError. (Issue reported and PR with fix provided by `Naomi Seyfer `__.) - added ``key`` and ``reverse`` parameter (suggested by Jannik Klemm via email) - indent root level literal scalars that have directive or document end markers at the beginning of a line 0.15.64 (2018-08-30): - support round-trip of tagged sequences: ``!Arg [a, {b: 1}]`` - single entry mappings in flow sequences now written by default without braces, set ``yaml.brace_single_entry_mapping_in_flow_sequence=True`` to force getting ``[a, {b: 1}, {c: {d: 2}}]`` instead of the default ``[a, b: 1, c: {d: 2}]`` - fix issue when roundtripping floats starting with a dot such as ``.5`` (reported by `Harrison Gregg `__) 0.15.63 (2018-08-29): - small fix only necessary for Windows users that don't use wheels. 0.15.62 (2018-08-29): - C based reader/scanner & emitter now allow setting of 1.2 as YAML version. ** The loading/dumping is still YAML 1.1 code**, so use the common subset of YAML 1.2 and 1.1 (reported by `Ge Yang `__) 0.15.61 (2018-08-23): - support for round-tripping folded style scalars (initially requested by `Johnathan Viduchinsky `__) - update of C code - speed up of scanning (~30% depending on the input) 0.15.60 (2018-08-18): - again allow single entry map in flow sequence context (reported by `Lee Goolsbee `__) - cleanup for mypy - spurious print in library (reported by `Lele Gaifax `__), now automatically checked 0.15.59 (2018-08-17): - issue with C based loader and leading zeros (reported by `Tom Hamilton Stubber `__) 0.15.58 (2018-08-17): - simple mappings can now be used as keys when round-tripping:: {a: 1, b: 2}: hello world although using the obvious operations (del, popitem) on the key will fail, you can mutilate it by going through its attributes. If you load the above YAML in `d`, then changing the value is cumbersome: d = {CommentedKeyMap([('a', 1), ('b', 2)]): "goodbye"} and changing the key even more so: d[CommentedKeyMap([('b', 1), ('a', 2)])] = d.pop( CommentedKeyMap([('a', 1), ('b', 2)])) (you can use a `dict` instead of a list of tuples (or ordereddict), but that might result in a different order, of the keys of the key, in the output) - check integers to dump with 1.2 patterns instead of 1.1 (reported by `Lele Gaifax `__) 0.15.57 (2018-08-15): - Fix that CommentedSeq could no longer be used in adding or do a sort (reported by `Christopher Wright `__) 0.15.56 (2018-08-15): - fix issue with ``python -O`` optimizing away code (reported, and detailed cause pinpointed, by `Alex Grönholm `__) 0.15.55 (2018-08-14): - unmade ``CommentedSeq`` a subclass of ``list``. It is now indirectly a subclass of the standard ``collections.abc.MutableSequence`` (without .abc if you are still on Python2.7). If you do ``isinstance(yaml.load('[1, 2]'), list)``) anywhere in your code replace ``list`` with ``MutableSequence``. Directly, ``CommentedSeq`` is a subclass of the abstract baseclass ``ruamel.yaml.compat.MutableScliceableSequence``, with the result that *(extended) slicing is supported on ``CommentedSeq``*. (reported by `Stuart Berg `__) - duplicate keys (or their values) with non-ascii now correctly report in Python2, instead of raising a Unicode error. (Reported by `Jonathan Pyle `__) 0.15.54 (2018-08-13): - fix issue where a comment could pop-up twice in the output (reported by `Mike Kazantsev `__ and by `Nate Peterson `__) - fix issue where JSON object (mapping) without spaces was not parsed properly (reported by `Marc Schmidt `__) - fix issue where comments after empty flow-style mappings were not emitted (reported by `Qinfench Chen `__) 0.15.53 (2018-08-12): - fix issue with flow style mapping with comments gobbled newline (reported by `Christopher Lambert `__) - fix issue where single '+' under YAML 1.2 was interpreted as integer, erroring out (reported by `Jethro Yu `__) 0.15.52 (2018-08-09): - added `.copy()` mapping representation for round-tripping (``CommentedMap``) to fix incomplete copies of merged mappings (reported by `Will Richards `__) - Also unmade that class a subclass of ordereddict to solve incorrect behaviour for ``{**merged-mapping}`` and ``dict(**merged-mapping)`` (reported independently by `Tim Olsson `__ and `Filip Matzner `__) 0.15.51 (2018-08-08): - Fix method name dumps (were not dotted) and loads (reported by `Douglas Raillard `__) - Fix spurious trailing white-space caused when the comment start column was no longer reached and there was no actual EOL comment (e.g. following empty line) and doing substitutions, or when quotes around scalars got dropped. (reported by `Thomas Guillet `__) 0.15.50 (2018-08-05): - Allow ``YAML()`` as a context manager for output, thereby making it much easier to generate multi-documents in a stream. - Fix issue with incorrect type information for `load()` and `dump()` (reported by `Jimbo Jim `__) 0.15.49 (2018-08-05): - fix preservation of leading newlines in root level literal style scalar, and preserve comment after literal style indicator (``| # some comment``) Both needed for round-tripping multi-doc streams in `ryd `__. 0.15.48 (2018-08-03): - housekeeping: ``oitnb`` for formatting, mypy 0.620 upgrade and conformity 0.15.47 (2018-07-31): - fix broken 3.6 manylinux1, the result of an unclean ``build`` (reported by `Roman Sichnyi `__) 0.15.46 (2018-07-29): - fixed DeprecationWarning for importing from ``collections`` on 3.7 (issue 210, reported by `Reinoud Elhorst `__). It was `difficult to find why tox/pytest did not report `__ and as time consuming to actually `fix `__ the tests. 0.15.45 (2018-07-26): - After adding failing test for ``YAML.load_all(Path())``, remove StopIteration (PR provided by `Zachary Buhman `__, also reported by `Steven Hiscocks `__. 0.15.44 (2018-07-14): - Correct loading plain scalars consisting of numerals only and starting with `0`, when not explicitly specifying YAML version 1.1. This also fixes the issue about dumping string `'019'` as plain scalars as reported by `Min RK `__, that prompted this chance. 0.15.43 (2018-07-12): - merge PR33: Python2.7 on Windows is narrow, but has no ``sysconfig.get_config_var('Py_UNICODE_SIZE')``. (merge provided by `Marcel Bargull `__) - ``register_class()`` now returns class (proposed by `Mike Nerone `__} 0.15.42 (2018-07-01): - fix regression showing only on narrow Python 2.7 (py27mu) builds (with help from `Marcel Bargull `__ and `Colm O'Connor `__). - run pre-commit ``tox`` on Python 2.7 wide and narrow, as well as 3.4/3.5/3.6/3.7/pypy 0.15.41 (2018-06-27): - add detection of C-compile failure (investigation prompted by `StackOverlow `__ by `Emmanuel Blot `__), which was removed while no longer dependent on ``libyaml``, C-extensions compilation still needs a compiler though. 0.15.40 (2018-06-18): - added links to landing places as suggested in issue 190 by `KostisA `__ - fixes issue #201: decoding unicode escaped tags on Python2, reported by `Dan Abolafia `__ 0.15.39 (2018-06-17): - merge PR27 improving package startup time (and loading when regexp not actually used), provided by `Marcel Bargull `__ 0.15.38 (2018-06-13): - fix for losing precision when roundtripping floats by `Rolf Wojtech `__ - fix for hardcoded dir separator not working for Windows by `Nuno André `__ - typo fix by `Andrey Somov `__ 0.15.37 (2018-03-21): - again trying to create installable files for 187 0.15.36 (2018-02-07): - fix issue 187, incompatibility of C extension with 3.7 (reported by Daniel Blanchard) 0.15.35 (2017-12-03): - allow ``None`` as stream when specifying ``transform`` parameters to ``YAML.dump()``. This is useful if the transforming function doesn't return a meaningful value (inspired by `StackOverflow `__ by `rsaw `__). 0.15.34 (2017-09-17): - fix for issue 157: CDumper not dumping floats (reported by Jan Smitka) 0.15.33 (2017-08-31): - support for "undefined" round-tripping tagged scalar objects (in addition to tagged mapping object). Inspired by a use case presented by Matthew Patton on `StackOverflow `__. - fix issue 148: replace cryptic error message when using !!timestamp with an incorrectly formatted or non- scalar. Reported by FichteFoll. 0.15.32 (2017-08-21): - allow setting ``yaml.default_flow_style = None`` (default: ``False``) for for ``typ='rt'``. - fix for issue 149: multiplications on ``ScalarFloat`` now return ``float`` (reported by jan.brezina@tul.cz) 0.15.31 (2017-08-15): - fix Comment dumping 0.15.30 (2017-08-14): - fix for issue with "compact JSON" not parsing: ``{"in":{},"out":{}}`` (reported on `StackOverflow `__ by `mjalkio `_ 0.15.29 (2017-08-14): - fix issue #51: different indents for mappings and sequences (reported by Alex Harvey) - fix for flow sequence/mapping as element/value of block sequence with sequence-indent minus dash-offset not equal two. 0.15.28 (2017-08-13): - fix issue #61: merge of merge cannot be __repr__-ed (reported by Tal Liron) 0.15.27 (2017-08-13): - fix issue 62, YAML 1.2 allows ``?`` and ``:`` in plain scalars if non-ambigious (reported by nowox) - fix lists within lists which would make comments disappear 0.15.26 (2017-08-10): - fix for disappearing comment after empty flow sequence (reported by oit-tzhimmash) 0.15.25 (2017-08-09): - fix for problem with dumping (unloaded) floats (reported by eyenseo) 0.15.24 (2017-08-09): - added ScalarFloat which supports roundtripping of 23.1, 23.100, 42.00E+56, 0.0, -0.0 etc. while keeping the format. Underscores in mantissas are not preserved/supported (yet, is anybody using that?). - (finally) fixed longstanding issue 23 (reported by `Antony Sottile `__), now handling comment between block mapping key and value correctly - warn on YAML 1.1 float input that is incorrect (triggered by invalid YAML provided by Cecil Curry) - allow setting of boolean representation (`false`, `true`) by using: ``yaml.boolean_representation = [u'False', u'True']`` 0.15.23 (2017-08-01): - fix for round_tripping integers on 2.7.X > sys.maxint (reported by ccatterina) 0.15.22 (2017-07-28): - fix for round_tripping singe excl. mark tags doubling (reported and fix by Jan Brezina) 0.15.21 (2017-07-25): - fix for writing unicode in new API, (reported on `StackOverflow `__ 0.15.20 (2017-07-23): - wheels for windows including C extensions 0.15.19 (2017-07-13): - added object constructor for rt, decorator ``yaml_object`` to replace YAMLObject. - fix for problem using load_all with Path() instance - fix for load_all in combination with zero indent block style literal (``pure=True`` only!) 0.15.18 (2017-07-04): - missing ``pure`` attribute on ``YAML`` useful for implementing `!include` tag constructor for `including YAML files in a YAML file `__ - some documentation improvements - trigger of doc build on new revision 0.15.17 (2017-07-03): - support for Unicode supplementary Plane **output** (input was already supported, triggered by `this `__ Stack Overflow Q&A) 0.15.16 (2017-07-01): - minor typing issues (reported and fix provided by `Manvendra Singh `__ - small doc improvements 0.15.15 (2017-06-27): - fix for issue 135, typ='safe' not dumping in Python 2.7 (reported by Andrzej Ostrowski `__) 0.15.14 (2017-06-25): - fix for issue 133, in setup.py: change ModuleNotFoundError to ImportError (reported and fix by `Asley Drake `__) 0.15.13 (2017-06-24): - suppress duplicate key warning on mappings with merge keys (reported by Cameron Sweeney) 0.15.12 (2017-06-24): - remove fatal dependency of setup.py on wheel package (reported by Cameron Sweeney) 0.15.11 (2017-06-24): - fix for issue 130, regression in nested merge keys (reported by `David Fee `__) 0.15.10 (2017-06-23): - top level PreservedScalarString not indented if not explicitly asked to - remove Makefile (not very useful anyway) - some mypy additions 0.15.9 (2017-06-16): - fix for issue 127: tagged scalars were always quoted and seperated by a newline when in a block sequence (reported and largely fixed by `Tommy Wang `__) 0.15.8 (2017-06-15): - allow plug-in install via ``install ruamel.yaml[jinja2]`` 0.15.7 (2017-06-14): - add plug-in mechanism for load/dump pre resp. post-processing 0.15.6 (2017-06-10): - a set() with duplicate elements now throws error in rt loading - support for toplevel column zero literal/folded scalar in explicit documents 0.15.5 (2017-06-08): - repeat `load()` on a single `YAML()` instance would fail. 0.15.4 (2017-06-08): - `transform` parameter on dump that expects a function taking a string and returning a string. This allows transformation of the output before it is written to stream. This forces creation of the complete output in memory! - some updates to the docs 0.15.3 (2017-06-07): - No longer try to compile C extensions on Windows. Compilation can be forced by setting the environment variable `RUAMEL_FORCE_EXT_BUILD` to some value before starting the `pip install`. 0.15.2 (2017-06-07): - update to conform to mypy 0.511: mypy --strict 0.15.1 (2017-06-07): - `duplicate keys `__ in mappings generate an error (in the old API this change generates a warning until 0.16) - dependecy on ruamel.ordereddict for 2.7 now via extras_require 0.15.0 (2017-06-04): - it is now allowed to pass in a ``pathlib.Path`` as "stream" parameter to all load/dump functions - passing in a non-supported object (e.g. a string) as "stream" will result in a much more meaningful YAMLStreamError. - assigning a normal string value to an existing CommentedMap key or CommentedSeq element will result in a value cast to the previous value's type if possible. - added ``YAML`` class for new API 0.14.12 (2017-05-14): - fix for issue 119, deepcopy not returning subclasses (reported and PR by Constantine Evans ) 0.14.11 (2017-05-01): - fix for issue 103 allowing implicit documents after document end marker line (``...``) in YAML 1.2 0.14.10 (2017-04-26): - fix problem with emitting using cyaml 0.14.9 (2017-04-22): - remove dependency on ``typing`` while still supporting ``mypy`` (http://stackoverflow.com/a/43516781/1307905) - fix unclarity in doc that stated 2.6 is supported (reported by feetdust) 0.14.8 (2017-04-19): - fix Text not available on 3.5.0 and 3.5.1, now proactively setting version guards on all files (reported by `João Paulo Magalhães `__) 0.14.7 (2017-04-18): - round trip of integers (decimal, octal, hex, binary) now preserve leading zero(s) padding and underscores. Underscores are presumed to be at regular distances (i.e. ``0o12_345_67`` dumps back as ``0o1_23_45_67`` as the space from the last digit to the underscore before that is the determining factor). 0.14.6 (2017-04-14): - binary, octal and hex integers are now preserved by default. This was a known deficiency. Working on this was prompted by the issue report (112) from devnoname120, as well as the additional experience with `.replace()` on `scalarstring` classes. - fix issues 114: cannot install on Buildozer (reported by mixmastamyk). Setting env. var ``RUAMEL_NO_PIP_INSTALL_CHECK`` will suppress ``pip``-check. 0.14.5 (2017-04-04): - fix issue 109: None not dumping correctly at top level (reported by Andrea Censi) - fix issue 110: .replace on Preserved/DoubleQuoted/SingleQuoted ScalarString would give back "normal" string (reported by sandres23) 0.14.4 (2017-03-31): - fix readme 0.14.3 (2017-03-31): - fix for 0o52 not being a string in YAML 1.1 (reported on `StackOverflow Q&A 43138503 `__ by `Frank D `__) 0.14.2 (2017-03-23): - fix for old default pip on Ubuntu 14.04 (reported by Sébastien Maccagnoni-Munch) 0.14.1 (2017-03-22): - fix Text not available on 3.5.0 and 3.5.1 (reported by Charles Bouchard-Légaré) 0.14.0 (2017-03-21): - updates for mypy --strict - preparation for moving away from inheritance in Loader and Dumper, calls from e.g. the Representer to the Serializer.serialize() are now done via the attribute .serializer.serialize(). Usage of .serialize() outside of Serializer will be deprecated soon - some extra tests on main.py functions ---- For older changes see the file `CHANGES `_ Keywords: yaml 1.2 parser round-trip preserve quotes order config Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: Jython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Processing :: Markup ruamel.yaml-0.15.89/ruamel.yaml.egg-info/top_level.txt0000664000175100001440000000002413435603753023254 0ustar anthonusers00000000000000_ruamel_yaml ruamel ruamel.yaml-0.15.89/ruamel.yaml.egg-info/requires.txt0000664000175100001440000000021113435603753023120 0ustar anthonusers00000000000000 [:platform_python_implementation=="CPython" and python_version<="2.7"] ruamel.ordereddict [docs] ryd [jinja2] ruamel.yaml.jinja2>=0.2 ruamel.yaml-0.15.89/ruamel.yaml.egg-info/dependency_links.txt0000664000175100001440000000000113435603753024574 0ustar anthonusers00000000000000 ruamel.yaml-0.15.89/serializer.py0000664000175100001440000002033413411124274017321 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import from ruamel.yaml.error import YAMLError from ruamel.yaml.compat import nprint, DBG_NODE, dbg, string_types, nprintf # NOQA from ruamel.yaml.util import RegExp from ruamel.yaml.events import ( StreamStartEvent, StreamEndEvent, MappingStartEvent, MappingEndEvent, SequenceStartEvent, SequenceEndEvent, AliasEvent, ScalarEvent, DocumentStartEvent, DocumentEndEvent, ) from ruamel.yaml.nodes import MappingNode, ScalarNode, SequenceNode if False: # MYPY from typing import Any, Dict, Union, Text, Optional # NOQA from ruamel.yaml.compat import VersionType # NOQA __all__ = ['Serializer', 'SerializerError'] class SerializerError(YAMLError): pass class Serializer(object): # 'id' and 3+ numbers, but not 000 ANCHOR_TEMPLATE = u'id%03d' ANCHOR_RE = RegExp(u'id(?!000$)\\d{3,}') def __init__( self, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, dumper=None, ): # type: (Any, Optional[bool], Optional[bool], Optional[VersionType], Any, Any) -> None # NOQA self.dumper = dumper if self.dumper is not None: self.dumper._serializer = self self.use_encoding = encoding self.use_explicit_start = explicit_start self.use_explicit_end = explicit_end if isinstance(version, string_types): self.use_version = tuple(map(int, version.split('.'))) else: self.use_version = version # type: ignore self.use_tags = tags self.serialized_nodes = {} # type: Dict[Any, Any] self.anchors = {} # type: Dict[Any, Any] self.last_anchor_id = 0 self.closed = None # type: Optional[bool] self._templated_id = None @property def emitter(self): # type: () -> Any if hasattr(self.dumper, 'typ'): return self.dumper.emitter return self.dumper._emitter @property def resolver(self): # type: () -> Any if hasattr(self.dumper, 'typ'): self.dumper.resolver return self.dumper._resolver def open(self): # type: () -> None if self.closed is None: self.emitter.emit(StreamStartEvent(encoding=self.use_encoding)) self.closed = False elif self.closed: raise SerializerError('serializer is closed') else: raise SerializerError('serializer is already opened') def close(self): # type: () -> None if self.closed is None: raise SerializerError('serializer is not opened') elif not self.closed: self.emitter.emit(StreamEndEvent()) self.closed = True # def __del__(self): # self.close() def serialize(self, node): # type: (Any) -> None if dbg(DBG_NODE): nprint('Serializing nodes') node.dump() if self.closed is None: raise SerializerError('serializer is not opened') elif self.closed: raise SerializerError('serializer is closed') self.emitter.emit( DocumentStartEvent( explicit=self.use_explicit_start, version=self.use_version, tags=self.use_tags ) ) self.anchor_node(node) self.serialize_node(node, None, None) self.emitter.emit(DocumentEndEvent(explicit=self.use_explicit_end)) self.serialized_nodes = {} self.anchors = {} self.last_anchor_id = 0 def anchor_node(self, node): # type: (Any) -> None if node in self.anchors: if self.anchors[node] is None: self.anchors[node] = self.generate_anchor(node) else: anchor = None try: if node.anchor.always_dump: anchor = node.anchor.value except: # NOQA pass self.anchors[node] = anchor if isinstance(node, SequenceNode): for item in node.value: self.anchor_node(item) elif isinstance(node, MappingNode): for key, value in node.value: self.anchor_node(key) self.anchor_node(value) def generate_anchor(self, node): # type: (Any) -> Any try: anchor = node.anchor.value except: # NOQA anchor = None if anchor is None: self.last_anchor_id += 1 return self.ANCHOR_TEMPLATE % self.last_anchor_id return anchor def serialize_node(self, node, parent, index): # type: (Any, Any, Any) -> None alias = self.anchors[node] if node in self.serialized_nodes: self.emitter.emit(AliasEvent(alias)) else: self.serialized_nodes[node] = True self.resolver.descend_resolver(parent, index) if isinstance(node, ScalarNode): # here check if the node.tag equals the one that would result from parsing # if not equal quoting is necessary for strings detected_tag = self.resolver.resolve(ScalarNode, node.value, (True, False)) default_tag = self.resolver.resolve(ScalarNode, node.value, (False, True)) implicit = ( (node.tag == detected_tag), (node.tag == default_tag), node.tag.startswith('tag:yaml.org,2002:'), ) self.emitter.emit( ScalarEvent( alias, node.tag, implicit, node.value, style=node.style, comment=node.comment, ) ) elif isinstance(node, SequenceNode): implicit = node.tag == self.resolver.resolve(SequenceNode, node.value, True) comment = node.comment end_comment = None seq_comment = None if node.flow_style is True: if comment: # eol comment on flow style sequence seq_comment = comment[0] # comment[0] = None if comment and len(comment) > 2: end_comment = comment[2] else: end_comment = None self.emitter.emit( SequenceStartEvent( alias, node.tag, implicit, flow_style=node.flow_style, comment=node.comment, ) ) index = 0 for item in node.value: self.serialize_node(item, node, index) index += 1 self.emitter.emit(SequenceEndEvent(comment=[seq_comment, end_comment])) elif isinstance(node, MappingNode): implicit = node.tag == self.resolver.resolve(MappingNode, node.value, True) comment = node.comment end_comment = None map_comment = None if node.flow_style is True: if comment: # eol comment on flow style sequence map_comment = comment[0] # comment[0] = None if comment and len(comment) > 2: end_comment = comment[2] self.emitter.emit( MappingStartEvent( alias, node.tag, implicit, flow_style=node.flow_style, comment=node.comment, nr_items=len(node.value), ) ) for key, value in node.value: self.serialize_node(key, node, None) self.serialize_node(value, node, key) self.emitter.emit(MappingEndEvent(comment=[map_comment, end_comment])) self.resolver.ascend_resolver() def templated_id(s): # type: (Text) -> Any return Serializer.ANCHOR_RE.match(s) ruamel.yaml-0.15.89/loader.py0000664000175100001440000000560713373303256016432 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import from ruamel.yaml.reader import Reader from ruamel.yaml.scanner import Scanner, RoundTripScanner from ruamel.yaml.parser import Parser, RoundTripParser from ruamel.yaml.composer import Composer from ruamel.yaml.constructor import ( BaseConstructor, SafeConstructor, Constructor, RoundTripConstructor, ) from ruamel.yaml.resolver import VersionedResolver if False: # MYPY from typing import Any, Dict, List, Union, Optional # NOQA from ruamel.yaml.compat import StreamTextType, VersionType # NOQA __all__ = ['BaseLoader', 'SafeLoader', 'Loader', 'RoundTripLoader'] class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, VersionedResolver): def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None Reader.__init__(self, stream, loader=self) Scanner.__init__(self, loader=self) Parser.__init__(self, loader=self) Composer.__init__(self, loader=self) BaseConstructor.__init__(self, loader=self) VersionedResolver.__init__(self, version, loader=self) class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, VersionedResolver): def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None Reader.__init__(self, stream, loader=self) Scanner.__init__(self, loader=self) Parser.__init__(self, loader=self) Composer.__init__(self, loader=self) SafeConstructor.__init__(self, loader=self) VersionedResolver.__init__(self, version, loader=self) class Loader(Reader, Scanner, Parser, Composer, Constructor, VersionedResolver): def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None Reader.__init__(self, stream, loader=self) Scanner.__init__(self, loader=self) Parser.__init__(self, loader=self) Composer.__init__(self, loader=self) Constructor.__init__(self, loader=self) VersionedResolver.__init__(self, version, loader=self) class RoundTripLoader( Reader, RoundTripScanner, RoundTripParser, Composer, RoundTripConstructor, VersionedResolver, ): def __init__(self, stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None # self.reader = Reader.__init__(self, stream) Reader.__init__(self, stream, loader=self) RoundTripScanner.__init__(self, loader=self) RoundTripParser.__init__(self, loader=self) Composer.__init__(self, loader=self) RoundTripConstructor.__init__(self, preserve_quotes=preserve_quotes, loader=self) VersionedResolver.__init__(self, version, loader=self) ruamel.yaml-0.15.89/comments.py0000644000175100001440000010355113414640627017006 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import, print_function """ stuff to deal with comments and formatting on dict/list/ordereddict/set these are not really related, formatting could be factored out as a separate base """ import sys import copy from ruamel.yaml.compat import ordereddict, PY2, string_types, MutableSliceableSequence from ruamel.yaml.scalarstring import ScalarString from ruamel.yaml.anchor import Anchor if PY2: from collections import MutableSet, Sized, Set, Mapping else: from collections.abc import MutableSet, Sized, Set, Mapping if False: # MYPY from typing import Any, Dict, Optional, List, Union, Optional, Iterator # NOQA # fmt: off __all__ = ['CommentedSeq', 'CommentedKeySeq', 'CommentedMap', 'CommentedOrderedMap', 'CommentedSet', 'comment_attrib', 'merge_attrib'] # fmt: on comment_attrib = '_yaml_comment' format_attrib = '_yaml_format' line_col_attrib = '_yaml_line_col' merge_attrib = '_yaml_merge' tag_attrib = '_yaml_tag' class Comment(object): # sys.getsize tested the Comment objects, __slots__ makes them bigger # and adding self.end did not matter __slots__ = 'comment', '_items', '_end', '_start' attrib = comment_attrib def __init__(self): # type: () -> None self.comment = None # [post, [pre]] # map key (mapping/omap/dict) or index (sequence/list) to a list of # dict: post_key, pre_key, post_value, pre_value # list: pre item, post item self._items = {} # type: Dict[Any, Any] # self._start = [] # should not put these on first item self._end = [] # type: List[Any] # end of document comments def __str__(self): # type: () -> str if bool(self._end): end = ',\n end=' + str(self._end) else: end = "" return 'Comment(comment={0},\n items={1}{2})'.format(self.comment, self._items, end) @property def items(self): # type: () -> Any return self._items @property def end(self): # type: () -> Any return self._end @end.setter def end(self, value): # type: (Any) -> None self._end = value @property def start(self): # type: () -> Any return self._start @start.setter def start(self, value): # type: (Any) -> None self._start = value # to distinguish key from None def NoComment(): # type: () -> None pass class Format(object): __slots__ = ('_flow_style',) attrib = format_attrib def __init__(self): # type: () -> None self._flow_style = None # type: Any def set_flow_style(self): # type: () -> None self._flow_style = True def set_block_style(self): # type: () -> None self._flow_style = False def flow_style(self, default=None): # type: (Optional[Any]) -> Any """if default (the flow_style) is None, the flow style tacked on to the object explicitly will be taken. If that is None as well the default flow style rules the format down the line, or the type of the constituent values (simple -> flow, map/list -> block)""" if self._flow_style is None: return default return self._flow_style class LineCol(object): attrib = line_col_attrib def __init__(self): # type: () -> None self.line = None self.col = None self.data = None # type: Optional[Dict[Any, Any]] def add_kv_line_col(self, key, data): # type: (Any, Any) -> None if self.data is None: self.data = {} self.data[key] = data def key(self, k): # type: (Any) -> Any return self._kv(k, 0, 1) def value(self, k): # type: (Any) -> Any return self._kv(k, 2, 3) def _kv(self, k, x0, x1): # type: (Any, Any, Any) -> Any if self.data is None: return None data = self.data[k] return data[x0], data[x1] def item(self, idx): # type: (Any) -> Any if self.data is None: return None return self.data[idx][0], self.data[idx][1] def add_idx_line_col(self, key, data): # type: (Any, Any) -> None if self.data is None: self.data = {} # type: Dict[Any, Any] self.data[key] = data class Tag(object): """store tag information for roundtripping""" __slots__ = ('value',) attrib = tag_attrib def __init__(self): # type: () -> None self.value = None def __repr__(self): # type: () -> Any return '{0.__class__.__name__}({0.value!r})'.format(self) class CommentedBase(object): @property def ca(self): # type: () -> Any if not hasattr(self, Comment.attrib): setattr(self, Comment.attrib, Comment()) return getattr(self, Comment.attrib) def yaml_end_comment_extend(self, comment, clear=False): # type: (Any, bool) -> None if comment is None: return if clear or self.ca.end is None: self.ca.end = [] self.ca.end.extend(comment) def yaml_key_comment_extend(self, key, comment, clear=False): # type: (Any, Any, bool) -> None r = self.ca._items.setdefault(key, [None, None, None, None]) if clear or r[1] is None: if comment[1] is not None: assert isinstance(comment[1], list) r[1] = comment[1] else: r[1].extend(comment[0]) r[0] = comment[0] def yaml_value_comment_extend(self, key, comment, clear=False): # type: (Any, Any, bool) -> None r = self.ca._items.setdefault(key, [None, None, None, None]) if clear or r[3] is None: if comment[1] is not None: assert isinstance(comment[1], list) r[3] = comment[1] else: r[3].extend(comment[0]) r[2] = comment[0] def yaml_set_start_comment(self, comment, indent=0): # type: (Any, Any) -> None """overwrites any preceding comment lines on an object expects comment to be without `#` and possible have multiple lines """ from .error import CommentMark from .tokens import CommentToken pre_comments = self._yaml_get_pre_comment() if comment[-1] == '\n': comment = comment[:-1] # strip final newline if there start_mark = CommentMark(indent) for com in comment.split('\n'): pre_comments.append(CommentToken('# ' + com + '\n', start_mark, None)) def yaml_set_comment_before_after_key( self, key, before=None, indent=0, after=None, after_indent=None ): # type: (Any, Any, Any, Any, Any) -> None """ expects comment (before/after) to be without `#` and possible have multiple lines """ from ruamel.yaml.error import CommentMark from ruamel.yaml.tokens import CommentToken def comment_token(s, mark): # type: (Any, Any) -> Any # handle empty lines as having no comment return CommentToken(('# ' if s else "") + s + '\n', mark, None) if after_indent is None: after_indent = indent + 2 if before and (len(before) > 1) and before[-1] == '\n': before = before[:-1] # strip final newline if there if after and after[-1] == '\n': after = after[:-1] # strip final newline if there start_mark = CommentMark(indent) c = self.ca.items.setdefault(key, [None, [], None, None]) if before == '\n': c[1].append(comment_token("", start_mark)) elif before: for com in before.split('\n'): c[1].append(comment_token(com, start_mark)) if after: start_mark = CommentMark(after_indent) if c[3] is None: c[3] = [] for com in after.split('\n'): c[3].append(comment_token(com, start_mark)) # type: ignore @property def fa(self): # type: () -> Any """format attribute set_flow_style()/set_block_style()""" if not hasattr(self, Format.attrib): setattr(self, Format.attrib, Format()) return getattr(self, Format.attrib) def yaml_add_eol_comment(self, comment, key=NoComment, column=None): # type: (Any, Optional[Any], Optional[Any]) -> None """ there is a problem as eol comments should start with ' #' (but at the beginning of the line the space doesn't have to be before the #. The column index is for the # mark """ from .tokens import CommentToken from .error import CommentMark if column is None: try: column = self._yaml_get_column(key) except AttributeError: column = 0 if comment[0] != '#': comment = '# ' + comment if column is None: if comment[0] == '#': comment = ' ' + comment column = 0 start_mark = CommentMark(column) ct = [CommentToken(comment, start_mark, None), None] self._yaml_add_eol_comment(ct, key=key) @property def lc(self): # type: () -> Any if not hasattr(self, LineCol.attrib): setattr(self, LineCol.attrib, LineCol()) return getattr(self, LineCol.attrib) def _yaml_set_line_col(self, line, col): # type: (Any, Any) -> None self.lc.line = line self.lc.col = col def _yaml_set_kv_line_col(self, key, data): # type: (Any, Any) -> None self.lc.add_kv_line_col(key, data) def _yaml_set_idx_line_col(self, key, data): # type: (Any, Any) -> None self.lc.add_idx_line_col(key, data) @property def anchor(self): # type: () -> Any if not hasattr(self, Anchor.attrib): setattr(self, Anchor.attrib, Anchor()) return getattr(self, Anchor.attrib) def yaml_anchor(self): # type: () -> Any if not hasattr(self, Anchor.attrib): return None return self.anchor def yaml_set_anchor(self, value, always_dump=False): # type: (Any, bool) -> None self.anchor.value = value self.anchor.always_dump = always_dump @property def tag(self): # type: () -> Any if not hasattr(self, Tag.attrib): setattr(self, Tag.attrib, Tag()) return getattr(self, Tag.attrib) def yaml_set_tag(self, value): # type: (Any) -> None self.tag.value = value def copy_attributes(self, t, deep=False): # type: (Any, bool) -> None # fmt: off for a in [Comment.attrib, Format.attrib, LineCol.attrib, Anchor.attrib, Tag.attrib, merge_attrib]: if hasattr(self, a): if deep: setattr(t, a, copy.deepcopy(getattr(self, a))) else: setattr(t, a, getattr(self, a)) # fmt: on def _yaml_add_eol_comment(self, comment, key): # type: (Any, Any) -> None raise NotImplementedError def _yaml_get_pre_comment(self): # type: () -> Any raise NotImplementedError def _yaml_get_column(self, key): # type: (Any) -> Any raise NotImplementedError class CommentedSeq(MutableSliceableSequence, list, CommentedBase): # type: ignore __slots__ = (Comment.attrib, '_lst') def __init__(self, *args, **kw): # type: (Any, Any) -> None list.__init__(self, *args, **kw) def __getsingleitem__(self, idx): # type: (Any) -> Any return list.__getitem__(self, idx) def __setsingleitem__(self, idx, value): # type: (Any, Any) -> None # try to preserve the scalarstring type if setting an existing key to a new value if idx < len(self): if ( isinstance(value, string_types) and not isinstance(value, ScalarString) and isinstance(self[idx], ScalarString) ): value = type(self[idx])(value) list.__setitem__(self, idx, value) def __delsingleitem__(self, idx=None): # type: (Any) -> Any list.__delitem__(self, idx) self.ca.items.pop(idx, None) # might not be there -> default value for list_index in sorted(self.ca.items): if list_index < idx: continue self.ca.items[list_index - 1] = self.ca.items.pop(list_index) def __len__(self): # type: () -> int return list.__len__(self) def insert(self, idx, val): # type: (Any, Any) -> None """the comments after the insertion have to move forward""" list.insert(self, idx, val) for list_index in sorted(self.ca.items, reverse=True): if list_index < idx: break self.ca.items[list_index + 1] = self.ca.items.pop(list_index) def extend(self, val): # type: (Any) -> None list.extend(self, val) def __eq__(self, other): # type: (Any) -> bool return list.__eq__(self, other) def _yaml_add_comment(self, comment, key=NoComment): # type: (Any, Optional[Any]) -> None if key is not NoComment: self.yaml_key_comment_extend(key, comment) else: self.ca.comment = comment def _yaml_add_eol_comment(self, comment, key): # type: (Any, Any) -> None self._yaml_add_comment(comment, key=key) def _yaml_get_columnX(self, key): # type: (Any) -> Any return self.ca.items[key][0].start_mark.column def _yaml_get_column(self, key): # type: (Any) -> Any column = None sel_idx = None pre, post = key - 1, key + 1 if pre in self.ca.items: sel_idx = pre elif post in self.ca.items: sel_idx = post else: # self.ca.items is not ordered for row_idx, _k1 in enumerate(self): if row_idx >= key: break if row_idx not in self.ca.items: continue sel_idx = row_idx if sel_idx is not None: column = self._yaml_get_columnX(sel_idx) return column def _yaml_get_pre_comment(self): # type: () -> Any pre_comments = [] # type: List[Any] if self.ca.comment is None: self.ca.comment = [None, pre_comments] else: self.ca.comment[1] = pre_comments return pre_comments def __deepcopy__(self, memo): # type: (Any) -> Any res = self.__class__() memo[id(self)] = res for k in self: res.append(copy.deepcopy(k)) self.copy_attributes(res, deep=True) return res def __add__(self, other): # type: (Any) -> Any return list.__add__(self, other) def sort(self, key=None, reverse=False): # type: ignore # type: (Any, bool) -> None if key is None: tmp_lst = sorted(zip(self, range(len(self))), reverse=reverse) list.__init__(self, [x[0] for x in tmp_lst]) else: tmp_lst = sorted( zip(map(key, list.__iter__(self)), range(len(self))), reverse=reverse ) list.__init__(self, [list.__getitem__(self, x[1]) for x in tmp_lst]) itm = self.ca.items self.ca._items = {} for idx, x in enumerate(tmp_lst): old_index = x[1] if old_index in itm: self.ca.items[idx] = itm[old_index] def __repr__(self): # type: () -> Any return list.__repr__(self) class CommentedKeySeq(tuple, CommentedBase): # type: ignore """This primarily exists to be able to roundtrip keys that are sequences""" def _yaml_add_comment(self, comment, key=NoComment): # type: (Any, Optional[Any]) -> None if key is not NoComment: self.yaml_key_comment_extend(key, comment) else: self.ca.comment = comment def _yaml_add_eol_comment(self, comment, key): # type: (Any, Any) -> None self._yaml_add_comment(comment, key=key) def _yaml_get_columnX(self, key): # type: (Any) -> Any return self.ca.items[key][0].start_mark.column def _yaml_get_column(self, key): # type: (Any) -> Any column = None sel_idx = None pre, post = key - 1, key + 1 if pre in self.ca.items: sel_idx = pre elif post in self.ca.items: sel_idx = post else: # self.ca.items is not ordered for row_idx, _k1 in enumerate(self): if row_idx >= key: break if row_idx not in self.ca.items: continue sel_idx = row_idx if sel_idx is not None: column = self._yaml_get_columnX(sel_idx) return column def _yaml_get_pre_comment(self): # type: () -> Any pre_comments = [] # type: List[Any] if self.ca.comment is None: self.ca.comment = [None, pre_comments] else: self.ca.comment[1] = pre_comments return pre_comments class CommentedMapView(Sized): __slots__ = ('_mapping',) def __init__(self, mapping): # type: (Any) -> None self._mapping = mapping def __len__(self): # type: () -> int count = len(self._mapping) return count class CommentedMapKeysView(CommentedMapView, Set): # type: ignore __slots__ = () @classmethod def _from_iterable(self, it): # type: (Any) -> Any return set(it) def __contains__(self, key): # type: (Any) -> Any return key in self._mapping def __iter__(self): # type: () -> Any # yield from self._mapping # not in py27, pypy # for x in self._mapping._keys(): for x in self._mapping: yield x class CommentedMapItemsView(CommentedMapView, Set): # type: ignore __slots__ = () @classmethod def _from_iterable(self, it): # type: (Any) -> Any return set(it) def __contains__(self, item): # type: (Any) -> Any key, value = item try: v = self._mapping[key] except KeyError: return False else: return v == value def __iter__(self): # type: () -> Any for key in self._mapping._keys(): yield (key, self._mapping[key]) class CommentedMapValuesView(CommentedMapView): __slots__ = () def __contains__(self, value): # type: (Any) -> Any for key in self._mapping: if value == self._mapping[key]: return True return False def __iter__(self): # type: () -> Any for key in self._mapping._keys(): yield self._mapping[key] class CommentedMap(ordereddict, CommentedBase): __slots__ = (Comment.attrib, '_ok', '_ref') def __init__(self, *args, **kw): # type: (Any, Any) -> None self._ok = set() # type: MutableSet[Any] # own keys self._ref = [] # type: List[CommentedMap] ordereddict.__init__(self, *args, **kw) def _yaml_add_comment(self, comment, key=NoComment, value=NoComment): # type: (Any, Optional[Any], Optional[Any]) -> None """values is set to key to indicate a value attachment of comment""" if key is not NoComment: self.yaml_key_comment_extend(key, comment) return if value is not NoComment: self.yaml_value_comment_extend(value, comment) else: self.ca.comment = comment def _yaml_add_eol_comment(self, comment, key): # type: (Any, Any) -> None """add on the value line, with value specified by the key""" self._yaml_add_comment(comment, value=key) def _yaml_get_columnX(self, key): # type: (Any) -> Any return self.ca.items[key][2].start_mark.column def _yaml_get_column(self, key): # type: (Any) -> Any column = None sel_idx = None pre, post, last = None, None, None for x in self: if pre is not None and x != key: post = x break if x == key: pre = last last = x if pre in self.ca.items: sel_idx = pre elif post in self.ca.items: sel_idx = post else: # self.ca.items is not ordered for k1 in self: if k1 >= key: break if k1 not in self.ca.items: continue sel_idx = k1 if sel_idx is not None: column = self._yaml_get_columnX(sel_idx) return column def _yaml_get_pre_comment(self): # type: () -> Any pre_comments = [] # type: List[Any] if self.ca.comment is None: self.ca.comment = [None, pre_comments] else: self.ca.comment[1] = pre_comments return pre_comments def update(self, vals): # type: ignore # type: (Any) -> None try: ordereddict.update(self, vals) self._ok.update(vals.keys()) # type: ignore except TypeError: # probably a dict that is used for x in vals: self[x] = vals[x] def insert(self, pos, key, value, comment=None): # type: (Any, Any, Any, Optional[Any]) -> None """insert key value into given position attach comment if provided """ ordereddict.insert(self, pos, key, value) self._ok.add(key) if comment is not None: self.yaml_add_eol_comment(comment, key=key) def mlget(self, key, default=None, list_ok=False): # type: (Any, Any, Any) -> Any """multi-level get that expects dicts within dicts""" if not isinstance(key, list): return self.get(key, default) # assume that the key is a list of recursively accessible dicts def get_one_level(key_list, level, d): # type: (Any, Any, Any) -> Any if not list_ok: assert isinstance(d, dict) if level >= len(key_list): if level > len(key_list): raise IndexError return d[key_list[level - 1]] return get_one_level(key_list, level + 1, d[key_list[level - 1]]) try: return get_one_level(key, 1, self) except KeyError: return default except (TypeError, IndexError): if not list_ok: raise return default def __getitem__(self, key): # type: (Any) -> Any try: return ordereddict.__getitem__(self, key) except KeyError: for merged in getattr(self, merge_attrib, []): if key in merged[1]: return merged[1][key] raise def __setitem__(self, key, value): # type: (Any, Any) -> None # try to preserve the scalarstring type if setting an existing key to a new value if key in self: if ( isinstance(value, string_types) and not isinstance(value, ScalarString) and isinstance(self[key], ScalarString) ): value = type(self[key])(value) ordereddict.__setitem__(self, key, value) self._ok.add(key) def _unmerged_contains(self, key): # type: (Any) -> Any if key in self._ok: return True return None def __contains__(self, key): # type: (Any) -> bool return bool(ordereddict.__contains__(self, key)) def get(self, key, default=None): # type: (Any, Any) -> Any try: return self.__getitem__(key) except: # NOQA return default def __repr__(self): # type: () -> Any return ordereddict.__repr__(self).replace('CommentedMap', 'ordereddict') def non_merged_items(self): # type: () -> Any for x in ordereddict.__iter__(self): if x in self._ok: yield x, ordereddict.__getitem__(self, x) def __delitem__(self, key): # type: (Any) -> None # for merged in getattr(self, merge_attrib, []): # if key in merged[1]: # value = merged[1][key] # break # else: # # not found in merged in stuff # ordereddict.__delitem__(self, key) # for referer in self._ref: # referer.update_key_value(key) # return # # ordereddict.__setitem__(self, key, value) # merge might have different value # self._ok.discard(key) self._ok.discard(key) ordereddict.__delitem__(self, key) for referer in self._ref: referer.update_key_value(key) def __iter__(self): # type: () -> Any for x in ordereddict.__iter__(self): yield x def _keys(self): # type: () -> Any for x in ordereddict.__iter__(self): yield x def __len__(self): # type: () -> int return ordereddict.__len__(self) def __eq__(self, other): # type: (Any) -> bool return bool(dict(self) == other) if PY2: def keys(self): # type: () -> Any return list(self._keys()) def iterkeys(self): # type: () -> Any return self._keys() def viewkeys(self): # type: () -> Any return CommentedMapKeysView(self) else: def keys(self): # type: () -> Any return CommentedMapKeysView(self) if PY2: def _values(self): # type: () -> Any for x in ordereddict.__iter__(self): yield ordereddict.__getitem__(self, x) def values(self): # type: () -> Any return list(self._values()) def itervalues(self): # type: () -> Any return self._values() def viewvalues(self): # type: () -> Any return CommentedMapValuesView(self) else: def values(self): # type: () -> Any return CommentedMapValuesView(self) def _items(self): # type: () -> Any for x in ordereddict.__iter__(self): yield x, ordereddict.__getitem__(self, x) if PY2: def items(self): # type: () -> Any return list(self._items()) def iteritems(self): # type: () -> Any return self._items() def viewitems(self): # type: () -> Any return CommentedMapItemsView(self) else: def items(self): # type: () -> Any return CommentedMapItemsView(self) @property def merge(self): # type: () -> Any if not hasattr(self, merge_attrib): setattr(self, merge_attrib, []) return getattr(self, merge_attrib) def copy(self): # type: () -> Any x = type(self)() # update doesn't work for k, v in self._items(): x[k] = v self.copy_attributes(x) return x def add_referent(self, cm): # type: (Any) -> None if cm not in self._ref: self._ref.append(cm) def add_yaml_merge(self, value): # type: (Any) -> None for v in value: v[1].add_referent(self) for k, v in v[1].items(): if ordereddict.__contains__(self, k): continue ordereddict.__setitem__(self, k, v) self.merge.extend(value) def update_key_value(self, key): # type: (Any) -> None if key in self._ok: return for v in self.merge: if key in v[1]: ordereddict.__setitem__(self, key, v[1][key]) return ordereddict.__delitem__(self, key) def __deepcopy__(self, memo): # type: (Any) -> Any res = self.__class__() memo[id(self)] = res for k in self: res[k] = copy.deepcopy(self[k]) self.copy_attributes(res, deep=True) return res # based on brownie mappings @classmethod # type: ignore def raise_immutable(cls, *args, **kwargs): # type: (Any, *Any, **Any) -> None raise TypeError('{} objects are immutable'.format(cls.__name__)) class CommentedKeyMap(CommentedBase, Mapping): # type: ignore __slots__ = Comment.attrib, '_od' """This primarily exists to be able to roundtrip keys that are mappings""" def __init__(self, *args, **kw): # type: (Any, Any) -> None if hasattr(self, '_od'): raise_immutable(self) try: self._od = ordereddict(*args, **kw) except TypeError: if PY2: self._od = ordereddict(args[0].items()) else: raise __delitem__ = __setitem__ = clear = pop = popitem = setdefault = update = raise_immutable # need to implement __getitem__, __iter__ and __len__ def __getitem__(self, index): # type: (Any) -> Any return self._od[index] def __iter__(self): # type: () -> Iterator[Any] for x in self._od.__iter__(): yield x def __len__(self): # type: () -> int return len(self._od) def __hash__(self): # type: () -> Any return hash(tuple(self.items())) def __repr__(self): # type: () -> Any if not hasattr(self, merge_attrib): return self._od.__repr__() return 'ordereddict(' + repr(list(self._od.items())) + ')' @classmethod def fromkeys(keys, v=None): # type: (Any, Any) -> Any return CommentedKeyMap(dict.fromkeys(keys, v)) def _yaml_add_comment(self, comment, key=NoComment): # type: (Any, Optional[Any]) -> None if key is not NoComment: self.yaml_key_comment_extend(key, comment) else: self.ca.comment = comment def _yaml_add_eol_comment(self, comment, key): # type: (Any, Any) -> None self._yaml_add_comment(comment, key=key) def _yaml_get_columnX(self, key): # type: (Any) -> Any return self.ca.items[key][0].start_mark.column def _yaml_get_column(self, key): # type: (Any) -> Any column = None sel_idx = None pre, post = key - 1, key + 1 if pre in self.ca.items: sel_idx = pre elif post in self.ca.items: sel_idx = post else: # self.ca.items is not ordered for row_idx, _k1 in enumerate(self): if row_idx >= key: break if row_idx not in self.ca.items: continue sel_idx = row_idx if sel_idx is not None: column = self._yaml_get_columnX(sel_idx) return column def _yaml_get_pre_comment(self): # type: () -> Any pre_comments = [] # type: List[Any] if self.ca.comment is None: self.ca.comment = [None, pre_comments] else: self.ca.comment[1] = pre_comments return pre_comments class CommentedOrderedMap(CommentedMap): __slots__ = (Comment.attrib,) class CommentedSet(MutableSet, CommentedBase): # type: ignore # NOQA __slots__ = Comment.attrib, 'odict' def __init__(self, values=None): # type: (Any) -> None self.odict = ordereddict() MutableSet.__init__(self) if values is not None: self |= values # type: ignore def _yaml_add_comment(self, comment, key=NoComment, value=NoComment): # type: (Any, Optional[Any], Optional[Any]) -> None """values is set to key to indicate a value attachment of comment""" if key is not NoComment: self.yaml_key_comment_extend(key, comment) return if value is not NoComment: self.yaml_value_comment_extend(value, comment) else: self.ca.comment = comment def _yaml_add_eol_comment(self, comment, key): # type: (Any, Any) -> None """add on the value line, with value specified by the key""" self._yaml_add_comment(comment, value=key) def add(self, value): # type: (Any) -> None """Add an element.""" self.odict[value] = None def discard(self, value): # type: (Any) -> None """Remove an element. Do not raise an exception if absent.""" del self.odict[value] def __contains__(self, x): # type: (Any) -> Any return x in self.odict def __iter__(self): # type: () -> Any for x in self.odict: yield x def __len__(self): # type: () -> int return len(self.odict) def __repr__(self): # type: () -> str return 'set({0!r})'.format(self.odict.keys()) class TaggedScalar(CommentedBase): # the value and style attributes are set during roundtrip construction def __init__(self): # type: () -> None self.value = None self.style = None def __str__(self): # type: () -> Any return self.value def dump_comments(d, name="", sep='.', out=sys.stdout): # type: (Any, str, str, Any) -> None """ recursively dump comments, all but the toplevel preceded by the path in dotted form x.0.a """ if isinstance(d, dict) and hasattr(d, 'ca'): if name: sys.stdout.write('{}\n'.format(name)) out.write('{}\n'.format(d.ca)) # type: ignore for k in d: dump_comments(d[k], name=(name + sep + k) if name else k, sep=sep, out=out) elif isinstance(d, list) and hasattr(d, 'ca'): if name: sys.stdout.write('{}\n'.format(name)) out.write('{}\n'.format(d.ca)) # type: ignore for idx, k in enumerate(d): dump_comments( k, name=(name + sep + str(idx)) if name else str(idx), sep=sep, out=out ) ruamel.yaml-0.15.89/scanner.py0000644000175100001440000021152013435576712016614 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals # Scanner produces tokens of the following types: # STREAM-START # STREAM-END # DIRECTIVE(name, value) # DOCUMENT-START # DOCUMENT-END # BLOCK-SEQUENCE-START # BLOCK-MAPPING-START # BLOCK-END # FLOW-SEQUENCE-START # FLOW-MAPPING-START # FLOW-SEQUENCE-END # FLOW-MAPPING-END # BLOCK-ENTRY # FLOW-ENTRY # KEY # VALUE # ALIAS(value) # ANCHOR(value) # TAG(value) # SCALAR(value, plain, style) # # RoundTripScanner # COMMENT(value) # # Read comments in the Scanner code for more details. # from ruamel.yaml.error import MarkedYAMLError from ruamel.yaml.tokens import * # NOQA from ruamel.yaml.compat import utf8, unichr, PY3, check_anchorname_char, nprint # NOQA if False: # MYPY from typing import Any, Dict, Optional, List, Union, Text # NOQA from ruamel.yaml.compat import VersionType # NOQA __all__ = ['Scanner', 'RoundTripScanner', 'ScannerError'] _THE_END = '\n\0\r\x85\u2028\u2029' _THE_END_SPACE_TAB = ' \n\0\t\r\x85\u2028\u2029' _SPACE_TAB = ' \t' class ScannerError(MarkedYAMLError): pass class SimpleKey(object): # See below simple keys treatment. def __init__(self, token_number, required, index, line, column, mark): # type: (Any, Any, int, int, int, Any) -> None self.token_number = token_number self.required = required self.index = index self.line = line self.column = column self.mark = mark class Scanner(object): def __init__(self, loader=None): # type: (Any) -> None """Initialize the scanner.""" # It is assumed that Scanner and Reader will have a common descendant. # Reader do the dirty work of checking for BOM and converting the # input data to Unicode. It also adds NUL to the end. # # Reader supports the following methods # self.peek(i=0) # peek the next i-th character # self.prefix(l=1) # peek the next l characters # self.forward(l=1) # read the next l characters and move the pointer self.loader = loader if self.loader is not None and getattr(self.loader, '_scanner', None) is None: self.loader._scanner = self self.reset_scanner() self.first_time = False @property def flow_level(self): # type: () -> int return len(self.flow_context) def reset_scanner(self): # type: () -> None # Had we reached the end of the stream? self.done = False # flow_context is an expanding/shrinking list consisting of '{' and '[' # for each unclosed flow context. If empty list that means block context self.flow_context = [] # type: List[Text] # List of processed tokens that are not yet emitted. self.tokens = [] # type: List[Any] # Add the STREAM-START token. self.fetch_stream_start() # Number of tokens that were emitted through the `get_token` method. self.tokens_taken = 0 # The current indentation level. self.indent = -1 # Past indentation levels. self.indents = [] # type: List[int] # Variables related to simple keys treatment. # A simple key is a key that is not denoted by the '?' indicator. # Example of simple keys: # --- # block simple key: value # ? not a simple key: # : { flow simple key: value } # We emit the KEY token before all keys, so when we find a potential # simple key, we try to locate the corresponding ':' indicator. # Simple keys should be limited to a single line and 1024 characters. # Can a simple key start at the current position? A simple key may # start: # - at the beginning of the line, not counting indentation spaces # (in block context), # - after '{', '[', ',' (in the flow context), # - after '?', ':', '-' (in the block context). # In the block context, this flag also signifies if a block collection # may start at the current position. self.allow_simple_key = True # Keep track of possible simple keys. This is a dictionary. The key # is `flow_level`; there can be no more that one possible simple key # for each level. The value is a SimpleKey record: # (token_number, required, index, line, column, mark) # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), # '[', or '{' tokens. self.possible_simple_keys = {} # type: Dict[Any, Any] @property def reader(self): # type: () -> Any try: return self._scanner_reader # type: ignore except AttributeError: if hasattr(self.loader, 'typ'): self._scanner_reader = self.loader.reader else: self._scanner_reader = self.loader._reader return self._scanner_reader @property def scanner_processing_version(self): # prefix until un-composited # type: () -> VersionType if hasattr(self.loader, 'typ'): return self.loader.resolver.processing_version # type: ignore return self.loader.processing_version # type: ignore # Public methods. def check_token(self, *choices): # type: (Any) -> bool # Check if the next token is one of the given types. while self.need_more_tokens(): self.fetch_more_tokens() if bool(self.tokens): if not choices: return True for choice in choices: if isinstance(self.tokens[0], choice): return True return False def peek_token(self): # type: () -> Any # Return the next token, but do not delete if from the queue. while self.need_more_tokens(): self.fetch_more_tokens() if bool(self.tokens): return self.tokens[0] def get_token(self): # type: () -> Any # Return the next token. while self.need_more_tokens(): self.fetch_more_tokens() if bool(self.tokens): self.tokens_taken += 1 return self.tokens.pop(0) # Private methods. def need_more_tokens(self): # type: () -> bool if self.done: return False if not self.tokens: return True # The current token may be a potential simple key, so we # need to look further. self.stale_possible_simple_keys() if self.next_possible_simple_key() == self.tokens_taken: return True return False def fetch_comment(self, comment): # type: (Any) -> None raise NotImplementedError def fetch_more_tokens(self): # type: () -> Any # Eat whitespaces and comments until we reach the next token. comment = self.scan_to_next_token() if comment is not None: # never happens for base scanner return self.fetch_comment(comment) # Remove obsolete possible simple keys. self.stale_possible_simple_keys() # Compare the current indentation and column. It may add some tokens # and decrease the current indentation level. self.unwind_indent(self.reader.column) # Peek the next character. ch = self.reader.peek() # Is it the end of stream? if ch == '\0': return self.fetch_stream_end() # Is it a directive? if ch == '%' and self.check_directive(): return self.fetch_directive() # Is it the document start? if ch == '-' and self.check_document_start(): return self.fetch_document_start() # Is it the document end? if ch == '.' and self.check_document_end(): return self.fetch_document_end() # TODO: support for BOM within a stream. # if ch == u'\uFEFF': # return self.fetch_bom() <-- issue BOMToken # Note: the order of the following checks is NOT significant. # Is it the flow sequence start indicator? if ch == '[': return self.fetch_flow_sequence_start() # Is it the flow mapping start indicator? if ch == '{': return self.fetch_flow_mapping_start() # Is it the flow sequence end indicator? if ch == ']': return self.fetch_flow_sequence_end() # Is it the flow mapping end indicator? if ch == '}': return self.fetch_flow_mapping_end() # Is it the flow entry indicator? if ch == ',': return self.fetch_flow_entry() # Is it the block entry indicator? if ch == '-' and self.check_block_entry(): return self.fetch_block_entry() # Is it the key indicator? if ch == '?' and self.check_key(): return self.fetch_key() # Is it the value indicator? if ch == ':' and self.check_value(): return self.fetch_value() # Is it an alias? if ch == '*': return self.fetch_alias() # Is it an anchor? if ch == '&': return self.fetch_anchor() # Is it a tag? if ch == '!': return self.fetch_tag() # Is it a literal scalar? if ch == '|' and not self.flow_level: return self.fetch_literal() # Is it a folded scalar? if ch == '>' and not self.flow_level: return self.fetch_folded() # Is it a single quoted scalar? if ch == "'": return self.fetch_single() # Is it a double quoted scalar? if ch == '"': return self.fetch_double() # It must be a plain scalar then. if self.check_plain(): return self.fetch_plain() # No? It's an error. Let's produce a nice error message. raise ScannerError( 'while scanning for the next token', None, 'found character %r that cannot start any token' % utf8(ch), self.reader.get_mark(), ) # Simple keys treatment. def next_possible_simple_key(self): # type: () -> Any # Return the number of the nearest possible simple key. Actually we # don't need to loop through the whole dictionary. We may replace it # with the following code: # if not self.possible_simple_keys: # return None # return self.possible_simple_keys[ # min(self.possible_simple_keys.keys())].token_number min_token_number = None for level in self.possible_simple_keys: key = self.possible_simple_keys[level] if min_token_number is None or key.token_number < min_token_number: min_token_number = key.token_number return min_token_number def stale_possible_simple_keys(self): # type: () -> None # Remove entries that are no longer possible simple keys. According to # the YAML specification, simple keys # - should be limited to a single line, # - should be no longer than 1024 characters. # Disabling this procedure will allow simple keys of any length and # height (may cause problems if indentation is broken though). for level in list(self.possible_simple_keys): key = self.possible_simple_keys[level] if key.line != self.reader.line or self.reader.index - key.index > 1024: if key.required: raise ScannerError( 'while scanning a simple key', key.mark, "could not find expected ':'", self.reader.get_mark(), ) del self.possible_simple_keys[level] def save_possible_simple_key(self): # type: () -> None # The next token may start a simple key. We check if it's possible # and save its position. This function is called for # ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'. # Check if a simple key is required at the current position. required = not self.flow_level and self.indent == self.reader.column # The next token might be a simple key. Let's save it's number and # position. if self.allow_simple_key: self.remove_possible_simple_key() token_number = self.tokens_taken + len(self.tokens) key = SimpleKey( token_number, required, self.reader.index, self.reader.line, self.reader.column, self.reader.get_mark(), ) self.possible_simple_keys[self.flow_level] = key def remove_possible_simple_key(self): # type: () -> None # Remove the saved possible key position at the current flow level. if self.flow_level in self.possible_simple_keys: key = self.possible_simple_keys[self.flow_level] if key.required: raise ScannerError( 'while scanning a simple key', key.mark, "could not find expected ':'", self.reader.get_mark(), ) del self.possible_simple_keys[self.flow_level] # Indentation functions. def unwind_indent(self, column): # type: (Any) -> None # In flow context, tokens should respect indentation. # Actually the condition should be `self.indent >= column` according to # the spec. But this condition will prohibit intuitively correct # constructions such as # key : { # } # #### # if self.flow_level and self.indent > column: # raise ScannerError(None, None, # "invalid intendation or unclosed '[' or '{'", # self.reader.get_mark()) # In the flow context, indentation is ignored. We make the scanner less # restrictive then specification requires. if bool(self.flow_level): return # In block context, we may need to issue the BLOCK-END tokens. while self.indent > column: mark = self.reader.get_mark() self.indent = self.indents.pop() self.tokens.append(BlockEndToken(mark, mark)) def add_indent(self, column): # type: (int) -> bool # Check if we need to increase indentation. if self.indent < column: self.indents.append(self.indent) self.indent = column return True return False # Fetchers. def fetch_stream_start(self): # type: () -> None # We always add STREAM-START as the first token and STREAM-END as the # last token. # Read the token. mark = self.reader.get_mark() # Add STREAM-START. self.tokens.append(StreamStartToken(mark, mark, encoding=self.reader.encoding)) def fetch_stream_end(self): # type: () -> None # Set the current intendation to -1. self.unwind_indent(-1) # Reset simple keys. self.remove_possible_simple_key() self.allow_simple_key = False self.possible_simple_keys = {} # type: Dict[Any, Any] # Read the token. mark = self.reader.get_mark() # Add STREAM-END. self.tokens.append(StreamEndToken(mark, mark)) # The steam is finished. self.done = True def fetch_directive(self): # type: () -> None # Set the current intendation to -1. self.unwind_indent(-1) # Reset simple keys. self.remove_possible_simple_key() self.allow_simple_key = False # Scan and add DIRECTIVE. self.tokens.append(self.scan_directive()) def fetch_document_start(self): # type: () -> None self.fetch_document_indicator(DocumentStartToken) def fetch_document_end(self): # type: () -> None self.fetch_document_indicator(DocumentEndToken) def fetch_document_indicator(self, TokenClass): # type: (Any) -> None # Set the current intendation to -1. self.unwind_indent(-1) # Reset simple keys. Note that there could not be a block collection # after '---'. self.remove_possible_simple_key() self.allow_simple_key = False # Add DOCUMENT-START or DOCUMENT-END. start_mark = self.reader.get_mark() self.reader.forward(3) end_mark = self.reader.get_mark() self.tokens.append(TokenClass(start_mark, end_mark)) def fetch_flow_sequence_start(self): # type: () -> None self.fetch_flow_collection_start(FlowSequenceStartToken, to_push='[') def fetch_flow_mapping_start(self): # type: () -> None self.fetch_flow_collection_start(FlowMappingStartToken, to_push='{') def fetch_flow_collection_start(self, TokenClass, to_push): # type: (Any, Text) -> None # '[' and '{' may start a simple key. self.save_possible_simple_key() # Increase the flow level. self.flow_context.append(to_push) # Simple keys are allowed after '[' and '{'. self.allow_simple_key = True # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. start_mark = self.reader.get_mark() self.reader.forward() end_mark = self.reader.get_mark() self.tokens.append(TokenClass(start_mark, end_mark)) def fetch_flow_sequence_end(self): # type: () -> None self.fetch_flow_collection_end(FlowSequenceEndToken) def fetch_flow_mapping_end(self): # type: () -> None self.fetch_flow_collection_end(FlowMappingEndToken) def fetch_flow_collection_end(self, TokenClass): # type: (Any) -> None # Reset possible simple key on the current level. self.remove_possible_simple_key() # Decrease the flow level. try: popped = self.flow_context.pop() # NOQA except IndexError: # We must not be in a list or object. # Defer error handling to the parser. pass # No simple keys after ']' or '}'. self.allow_simple_key = False # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. start_mark = self.reader.get_mark() self.reader.forward() end_mark = self.reader.get_mark() self.tokens.append(TokenClass(start_mark, end_mark)) def fetch_flow_entry(self): # type: () -> None # Simple keys are allowed after ','. self.allow_simple_key = True # Reset possible simple key on the current level. self.remove_possible_simple_key() # Add FLOW-ENTRY. start_mark = self.reader.get_mark() self.reader.forward() end_mark = self.reader.get_mark() self.tokens.append(FlowEntryToken(start_mark, end_mark)) def fetch_block_entry(self): # type: () -> None # Block context needs additional checks. if not self.flow_level: # Are we allowed to start a new entry? if not self.allow_simple_key: raise ScannerError( None, None, 'sequence entries are not allowed here', self.reader.get_mark() ) # We may need to add BLOCK-SEQUENCE-START. if self.add_indent(self.reader.column): mark = self.reader.get_mark() self.tokens.append(BlockSequenceStartToken(mark, mark)) # It's an error for the block entry to occur in the flow context, # but we let the parser detect this. else: pass # Simple keys are allowed after '-'. self.allow_simple_key = True # Reset possible simple key on the current level. self.remove_possible_simple_key() # Add BLOCK-ENTRY. start_mark = self.reader.get_mark() self.reader.forward() end_mark = self.reader.get_mark() self.tokens.append(BlockEntryToken(start_mark, end_mark)) def fetch_key(self): # type: () -> None # Block context needs additional checks. if not self.flow_level: # Are we allowed to start a key (not nessesary a simple)? if not self.allow_simple_key: raise ScannerError( None, None, 'mapping keys are not allowed here', self.reader.get_mark() ) # We may need to add BLOCK-MAPPING-START. if self.add_indent(self.reader.column): mark = self.reader.get_mark() self.tokens.append(BlockMappingStartToken(mark, mark)) # Simple keys are allowed after '?' in the block context. self.allow_simple_key = not self.flow_level # Reset possible simple key on the current level. self.remove_possible_simple_key() # Add KEY. start_mark = self.reader.get_mark() self.reader.forward() end_mark = self.reader.get_mark() self.tokens.append(KeyToken(start_mark, end_mark)) def fetch_value(self): # type: () -> None # Do we determine a simple key? if self.flow_level in self.possible_simple_keys: # Add KEY. key = self.possible_simple_keys[self.flow_level] del self.possible_simple_keys[self.flow_level] self.tokens.insert( key.token_number - self.tokens_taken, KeyToken(key.mark, key.mark) ) # If this key starts a new block mapping, we need to add # BLOCK-MAPPING-START. if not self.flow_level: if self.add_indent(key.column): self.tokens.insert( key.token_number - self.tokens_taken, BlockMappingStartToken(key.mark, key.mark), ) # There cannot be two simple keys one after another. self.allow_simple_key = False # It must be a part of a complex key. else: # Block context needs additional checks. # (Do we really need them? They will be caught by the parser # anyway.) if not self.flow_level: # We are allowed to start a complex value if and only if # we can start a simple key. if not self.allow_simple_key: raise ScannerError( None, None, 'mapping values are not allowed here', self.reader.get_mark(), ) # If this value starts a new block mapping, we need to add # BLOCK-MAPPING-START. It will be detected as an error later by # the parser. if not self.flow_level: if self.add_indent(self.reader.column): mark = self.reader.get_mark() self.tokens.append(BlockMappingStartToken(mark, mark)) # Simple keys are allowed after ':' in the block context. self.allow_simple_key = not self.flow_level # Reset possible simple key on the current level. self.remove_possible_simple_key() # Add VALUE. start_mark = self.reader.get_mark() self.reader.forward() end_mark = self.reader.get_mark() self.tokens.append(ValueToken(start_mark, end_mark)) def fetch_alias(self): # type: () -> None # ALIAS could be a simple key. self.save_possible_simple_key() # No simple keys after ALIAS. self.allow_simple_key = False # Scan and add ALIAS. self.tokens.append(self.scan_anchor(AliasToken)) def fetch_anchor(self): # type: () -> None # ANCHOR could start a simple key. self.save_possible_simple_key() # No simple keys after ANCHOR. self.allow_simple_key = False # Scan and add ANCHOR. self.tokens.append(self.scan_anchor(AnchorToken)) def fetch_tag(self): # type: () -> None # TAG could start a simple key. self.save_possible_simple_key() # No simple keys after TAG. self.allow_simple_key = False # Scan and add TAG. self.tokens.append(self.scan_tag()) def fetch_literal(self): # type: () -> None self.fetch_block_scalar(style='|') def fetch_folded(self): # type: () -> None self.fetch_block_scalar(style='>') def fetch_block_scalar(self, style): # type: (Any) -> None # A simple key may follow a block scalar. self.allow_simple_key = True # Reset possible simple key on the current level. self.remove_possible_simple_key() # Scan and add SCALAR. self.tokens.append(self.scan_block_scalar(style)) def fetch_single(self): # type: () -> None self.fetch_flow_scalar(style="'") def fetch_double(self): # type: () -> None self.fetch_flow_scalar(style='"') def fetch_flow_scalar(self, style): # type: (Any) -> None # A flow scalar could be a simple key. self.save_possible_simple_key() # No simple keys after flow scalars. self.allow_simple_key = False # Scan and add SCALAR. self.tokens.append(self.scan_flow_scalar(style)) def fetch_plain(self): # type: () -> None # A plain scalar could be a simple key. self.save_possible_simple_key() # No simple keys after plain scalars. But note that `scan_plain` will # change this flag if the scan is finished at the beginning of the # line. self.allow_simple_key = False # Scan and add SCALAR. May change `allow_simple_key`. self.tokens.append(self.scan_plain()) # Checkers. def check_directive(self): # type: () -> Any # DIRECTIVE: ^ '%' ... # The '%' indicator is already checked. if self.reader.column == 0: return True return None def check_document_start(self): # type: () -> Any # DOCUMENT-START: ^ '---' (' '|'\n') if self.reader.column == 0: if self.reader.prefix(3) == '---' and self.reader.peek(3) in _THE_END_SPACE_TAB: return True return None def check_document_end(self): # type: () -> Any # DOCUMENT-END: ^ '...' (' '|'\n') if self.reader.column == 0: if self.reader.prefix(3) == '...' and self.reader.peek(3) in _THE_END_SPACE_TAB: return True return None def check_block_entry(self): # type: () -> Any # BLOCK-ENTRY: '-' (' '|'\n') return self.reader.peek(1) in _THE_END_SPACE_TAB def check_key(self): # type: () -> Any # KEY(flow context): '?' if bool(self.flow_level): return True # KEY(block context): '?' (' '|'\n') return self.reader.peek(1) in _THE_END_SPACE_TAB def check_value(self): # type: () -> Any # VALUE(flow context): ':' if self.scanner_processing_version == (1, 1): if bool(self.flow_level): return True else: if bool(self.flow_level): if self.flow_context[-1] == '[': if self.reader.peek(1) not in _THE_END_SPACE_TAB: return False elif self.tokens and isinstance(self.tokens[-1], ValueToken): # mapping flow context scanning a value token if self.reader.peek(1) not in _THE_END_SPACE_TAB: return False return True # VALUE(block context): ':' (' '|'\n') return self.reader.peek(1) in _THE_END_SPACE_TAB def check_plain(self): # type: () -> Any # A plain scalar may start with any non-space character except: # '-', '?', ':', ',', '[', ']', '{', '}', # '#', '&', '*', '!', '|', '>', '\'', '\"', # '%', '@', '`'. # # It may also start with # '-', '?', ':' # if it is followed by a non-space character. # # Note that we limit the last rule to the block context (except the # '-' character) because we want the flow context to be space # independent. srp = self.reader.peek ch = srp() if self.scanner_processing_version == (1, 1): return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'"%@`' or ( srp(1) not in _THE_END_SPACE_TAB and (ch == '-' or (not self.flow_level and ch in '?:')) ) # YAML 1.2 if ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'"%@`': # ################### ^ ??? return True ch1 = srp(1) if ch == '-' and ch1 not in _THE_END_SPACE_TAB: return True if ch == ':' and bool(self.flow_level) and ch1 not in _SPACE_TAB: return True return srp(1) not in _THE_END_SPACE_TAB and ( ch == '-' or (not self.flow_level and ch in '?:') ) # Scanners. def scan_to_next_token(self): # type: () -> Any # We ignore spaces, line breaks and comments. # If we find a line break in the block context, we set the flag # `allow_simple_key` on. # The byte order mark is stripped if it's the first character in the # stream. We do not yet support BOM inside the stream as the # specification requires. Any such mark will be considered as a part # of the document. # # TODO: We need to make tab handling rules more sane. A good rule is # Tabs cannot precede tokens # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END, # KEY(block), VALUE(block), BLOCK-ENTRY # So the checking code is # if : # self.allow_simple_keys = False # We also need to add the check for `allow_simple_keys == True` to # `unwind_indent` before issuing BLOCK-END. # Scanners for block, flow, and plain scalars need to be modified. srp = self.reader.peek srf = self.reader.forward if self.reader.index == 0 and srp() == '\uFEFF': srf() found = False _the_end = _THE_END while not found: while srp() == ' ': srf() if srp() == '#': while srp() not in _the_end: srf() if self.scan_line_break(): if not self.flow_level: self.allow_simple_key = True else: found = True return None def scan_directive(self): # type: () -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward start_mark = self.reader.get_mark() srf() name = self.scan_directive_name(start_mark) value = None if name == 'YAML': value = self.scan_yaml_directive_value(start_mark) end_mark = self.reader.get_mark() elif name == 'TAG': value = self.scan_tag_directive_value(start_mark) end_mark = self.reader.get_mark() else: end_mark = self.reader.get_mark() while srp() not in _THE_END: srf() self.scan_directive_ignored_line(start_mark) return DirectiveToken(name, value, start_mark, end_mark) def scan_directive_name(self, start_mark): # type: (Any) -> Any # See the specification for details. length = 0 srp = self.reader.peek ch = srp(length) while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' or ch in '-_:.': length += 1 ch = srp(length) if not length: raise ScannerError( 'while scanning a directive', start_mark, 'expected alphabetic or numeric character, but found %r' % utf8(ch), self.reader.get_mark(), ) value = self.reader.prefix(length) self.reader.forward(length) ch = srp() if ch not in '\0 \r\n\x85\u2028\u2029': raise ScannerError( 'while scanning a directive', start_mark, 'expected alphabetic or numeric character, but found %r' % utf8(ch), self.reader.get_mark(), ) return value def scan_yaml_directive_value(self, start_mark): # type: (Any) -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward while srp() == ' ': srf() major = self.scan_yaml_directive_number(start_mark) if srp() != '.': raise ScannerError( 'while scanning a directive', start_mark, "expected a digit or '.', but found %r" % utf8(srp()), self.reader.get_mark(), ) srf() minor = self.scan_yaml_directive_number(start_mark) if srp() not in '\0 \r\n\x85\u2028\u2029': raise ScannerError( 'while scanning a directive', start_mark, "expected a digit or ' ', but found %r" % utf8(srp()), self.reader.get_mark(), ) return (major, minor) def scan_yaml_directive_number(self, start_mark): # type: (Any) -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward ch = srp() if not ('0' <= ch <= '9'): raise ScannerError( 'while scanning a directive', start_mark, 'expected a digit, but found %r' % utf8(ch), self.reader.get_mark(), ) length = 0 while '0' <= srp(length) <= '9': length += 1 value = int(self.reader.prefix(length)) srf(length) return value def scan_tag_directive_value(self, start_mark): # type: (Any) -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward while srp() == ' ': srf() handle = self.scan_tag_directive_handle(start_mark) while srp() == ' ': srf() prefix = self.scan_tag_directive_prefix(start_mark) return (handle, prefix) def scan_tag_directive_handle(self, start_mark): # type: (Any) -> Any # See the specification for details. value = self.scan_tag_handle('directive', start_mark) ch = self.reader.peek() if ch != ' ': raise ScannerError( 'while scanning a directive', start_mark, "expected ' ', but found %r" % utf8(ch), self.reader.get_mark(), ) return value def scan_tag_directive_prefix(self, start_mark): # type: (Any) -> Any # See the specification for details. value = self.scan_tag_uri('directive', start_mark) ch = self.reader.peek() if ch not in '\0 \r\n\x85\u2028\u2029': raise ScannerError( 'while scanning a directive', start_mark, "expected ' ', but found %r" % utf8(ch), self.reader.get_mark(), ) return value def scan_directive_ignored_line(self, start_mark): # type: (Any) -> None # See the specification for details. srp = self.reader.peek srf = self.reader.forward while srp() == ' ': srf() if srp() == '#': while srp() not in _THE_END: srf() ch = srp() if ch not in _THE_END: raise ScannerError( 'while scanning a directive', start_mark, 'expected a comment or a line break, but found %r' % utf8(ch), self.reader.get_mark(), ) self.scan_line_break() def scan_anchor(self, TokenClass): # type: (Any) -> Any # The specification does not restrict characters for anchors and # aliases. This may lead to problems, for instance, the document: # [ *alias, value ] # can be interpteted in two ways, as # [ "value" ] # and # [ *alias , "value" ] # Therefore we restrict aliases to numbers and ASCII letters. srp = self.reader.peek start_mark = self.reader.get_mark() indicator = srp() if indicator == '*': name = 'alias' else: name = 'anchor' self.reader.forward() length = 0 ch = srp(length) # while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ # or ch in u'-_': while check_anchorname_char(ch): length += 1 ch = srp(length) if not length: raise ScannerError( 'while scanning an %s' % (name,), start_mark, 'expected alphabetic or numeric character, but found %r' % utf8(ch), self.reader.get_mark(), ) value = self.reader.prefix(length) self.reader.forward(length) # ch1 = ch # ch = srp() # no need to peek, ch is already set # assert ch1 == ch if ch not in '\0 \t\r\n\x85\u2028\u2029?:,[]{}%@`': raise ScannerError( 'while scanning an %s' % (name,), start_mark, 'expected alphabetic or numeric character, but found %r' % utf8(ch), self.reader.get_mark(), ) end_mark = self.reader.get_mark() return TokenClass(value, start_mark, end_mark) def scan_tag(self): # type: () -> Any # See the specification for details. srp = self.reader.peek start_mark = self.reader.get_mark() ch = srp(1) if ch == '<': handle = None self.reader.forward(2) suffix = self.scan_tag_uri('tag', start_mark) if srp() != '>': raise ScannerError( 'while parsing a tag', start_mark, "expected '>', but found %r" % utf8(srp()), self.reader.get_mark(), ) self.reader.forward() elif ch in _THE_END_SPACE_TAB: handle = None suffix = '!' self.reader.forward() else: length = 1 use_handle = False while ch not in '\0 \r\n\x85\u2028\u2029': if ch == '!': use_handle = True break length += 1 ch = srp(length) handle = '!' if use_handle: handle = self.scan_tag_handle('tag', start_mark) else: handle = '!' self.reader.forward() suffix = self.scan_tag_uri('tag', start_mark) ch = srp() if ch not in '\0 \r\n\x85\u2028\u2029': raise ScannerError( 'while scanning a tag', start_mark, "expected ' ', but found %r" % utf8(ch), self.reader.get_mark(), ) value = (handle, suffix) end_mark = self.reader.get_mark() return TagToken(value, start_mark, end_mark) def scan_block_scalar(self, style, rt=False): # type: (Any, Optional[bool]) -> Any # See the specification for details. srp = self.reader.peek if style == '>': folded = True else: folded = False chunks = [] # type: List[Any] start_mark = self.reader.get_mark() # Scan the header. self.reader.forward() chomping, increment = self.scan_block_scalar_indicators(start_mark) # block scalar comment e.g. : |+ # comment text block_scalar_comment = self.scan_block_scalar_ignored_line(start_mark) # Determine the indentation level and go to the first non-empty line. min_indent = self.indent + 1 if increment is None: # no increment and top level, min_indent could be 0 if min_indent < 1 and ( style not in '|>' or (self.scanner_processing_version == (1, 1)) and getattr( self.loader, 'top_level_block_style_scalar_no_indent_error_1_1', False ) ): min_indent = 1 breaks, max_indent, end_mark = self.scan_block_scalar_indentation() indent = max(min_indent, max_indent) else: if min_indent < 1: min_indent = 1 indent = min_indent + increment - 1 breaks, end_mark = self.scan_block_scalar_breaks(indent) line_break = "" # Scan the inner part of the block scalar. while self.reader.column == indent and srp() != '\0': chunks.extend(breaks) leading_non_space = srp() not in ' \t' length = 0 while srp(length) not in _THE_END: length += 1 chunks.append(self.reader.prefix(length)) self.reader.forward(length) line_break = self.scan_line_break() breaks, end_mark = self.scan_block_scalar_breaks(indent) if style in '|>' and min_indent == 0: # at the beginning of a line, if in block style see if # end of document/start_new_document if self.check_document_start() or self.check_document_end(): break if self.reader.column == indent and srp() != '\0': # Unfortunately, folding rules are ambiguous. # # This is the folding according to the specification: if rt and folded and line_break == '\n': chunks.append('\a') if folded and line_break == '\n' and leading_non_space and srp() not in ' \t': if not breaks: chunks.append(' ') else: chunks.append(line_break) # This is Clark Evans's interpretation (also in the spec # examples): # # if folded and line_break == u'\n': # if not breaks: # if srp() not in ' \t': # chunks.append(u' ') # else: # chunks.append(line_break) # else: # chunks.append(line_break) else: break # Process trailing line breaks. The 'chomping' setting determines # whether they are included in the value. trailing = [] # type: List[Any] if chomping in [None, True]: chunks.append(line_break) if chomping is True: chunks.extend(breaks) elif chomping in [None, False]: trailing.extend(breaks) # We are done. token = ScalarToken("".join(chunks), False, start_mark, end_mark, style) if block_scalar_comment is not None: token.add_pre_comments([block_scalar_comment]) if len(trailing) > 0: # nprint('trailing 1', trailing) # XXXXX # Eat whitespaces and comments until we reach the next token. comment = self.scan_to_next_token() while comment: trailing.append(comment[0]) comment = self.scan_to_next_token() # Keep track of the trailing whitespace and following comments # as a comment token, if isn't all included in the actual value. comment_end_mark = self.reader.get_mark() comment = CommentToken("".join(trailing), end_mark, comment_end_mark) token.add_post_comment(comment) return token def scan_block_scalar_indicators(self, start_mark): # type: (Any) -> Any # See the specification for details. srp = self.reader.peek chomping = None increment = None ch = srp() if ch in '+-': if ch == '+': chomping = True else: chomping = False self.reader.forward() ch = srp() if ch in '0123456789': increment = int(ch) if increment == 0: raise ScannerError( 'while scanning a block scalar', start_mark, 'expected indentation indicator in the range 1-9, ' 'but found 0', self.reader.get_mark(), ) self.reader.forward() elif ch in '0123456789': increment = int(ch) if increment == 0: raise ScannerError( 'while scanning a block scalar', start_mark, 'expected indentation indicator in the range 1-9, ' 'but found 0', self.reader.get_mark(), ) self.reader.forward() ch = srp() if ch in '+-': if ch == '+': chomping = True else: chomping = False self.reader.forward() ch = srp() if ch not in '\0 \r\n\x85\u2028\u2029': raise ScannerError( 'while scanning a block scalar', start_mark, 'expected chomping or indentation indicators, but found %r' % utf8(ch), self.reader.get_mark(), ) return chomping, increment def scan_block_scalar_ignored_line(self, start_mark): # type: (Any) -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward prefix = '' comment = None while srp() == ' ': prefix += srp() srf() if srp() == '#': comment = prefix while srp() not in _THE_END: comment += srp() srf() ch = srp() if ch not in _THE_END: raise ScannerError( 'while scanning a block scalar', start_mark, 'expected a comment or a line break, but found %r' % utf8(ch), self.reader.get_mark(), ) self.scan_line_break() return comment def scan_block_scalar_indentation(self): # type: () -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward chunks = [] max_indent = 0 end_mark = self.reader.get_mark() while srp() in ' \r\n\x85\u2028\u2029': if srp() != ' ': chunks.append(self.scan_line_break()) end_mark = self.reader.get_mark() else: srf() if self.reader.column > max_indent: max_indent = self.reader.column return chunks, max_indent, end_mark def scan_block_scalar_breaks(self, indent): # type: (int) -> Any # See the specification for details. chunks = [] srp = self.reader.peek srf = self.reader.forward end_mark = self.reader.get_mark() while self.reader.column < indent and srp() == ' ': srf() while srp() in '\r\n\x85\u2028\u2029': chunks.append(self.scan_line_break()) end_mark = self.reader.get_mark() while self.reader.column < indent and srp() == ' ': srf() return chunks, end_mark def scan_flow_scalar(self, style): # type: (Any) -> Any # See the specification for details. # Note that we loose indentation rules for quoted scalars. Quoted # scalars don't need to adhere indentation because " and ' clearly # mark the beginning and the end of them. Therefore we are less # restrictive then the specification requires. We only need to check # that document separators are not included in scalars. if style == '"': double = True else: double = False srp = self.reader.peek chunks = [] # type: List[Any] start_mark = self.reader.get_mark() quote = srp() self.reader.forward() chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) while srp() != quote: chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) self.reader.forward() end_mark = self.reader.get_mark() return ScalarToken("".join(chunks), False, start_mark, end_mark, style) ESCAPE_REPLACEMENTS = { '0': '\0', 'a': '\x07', 'b': '\x08', 't': '\x09', '\t': '\x09', 'n': '\x0A', 'v': '\x0B', 'f': '\x0C', 'r': '\x0D', 'e': '\x1B', ' ': '\x20', '"': '"', '/': '/', # as per http://www.json.org/ '\\': '\\', 'N': '\x85', '_': '\xA0', 'L': '\u2028', 'P': '\u2029', } ESCAPE_CODES = {'x': 2, 'u': 4, 'U': 8} def scan_flow_scalar_non_spaces(self, double, start_mark): # type: (Any, Any) -> Any # See the specification for details. chunks = [] # type: List[Any] srp = self.reader.peek srf = self.reader.forward while True: length = 0 while srp(length) not in ' \n\'"\\\0\t\r\x85\u2028\u2029': length += 1 if length != 0: chunks.append(self.reader.prefix(length)) srf(length) ch = srp() if not double and ch == "'" and srp(1) == "'": chunks.append("'") srf(2) elif (double and ch == "'") or (not double and ch in '"\\'): chunks.append(ch) srf() elif double and ch == '\\': srf() ch = srp() if ch in self.ESCAPE_REPLACEMENTS: chunks.append(self.ESCAPE_REPLACEMENTS[ch]) srf() elif ch in self.ESCAPE_CODES: length = self.ESCAPE_CODES[ch] srf() for k in range(length): if srp(k) not in '0123456789ABCDEFabcdef': raise ScannerError( 'while scanning a double-quoted scalar', start_mark, 'expected escape sequence of %d hexdecimal ' 'numbers, but found %r' % (length, utf8(srp(k))), self.reader.get_mark(), ) code = int(self.reader.prefix(length), 16) chunks.append(unichr(code)) srf(length) elif ch in '\n\r\x85\u2028\u2029': self.scan_line_break() chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) else: raise ScannerError( 'while scanning a double-quoted scalar', start_mark, 'found unknown escape character %r' % utf8(ch), self.reader.get_mark(), ) else: return chunks def scan_flow_scalar_spaces(self, double, start_mark): # type: (Any, Any) -> Any # See the specification for details. srp = self.reader.peek chunks = [] length = 0 while srp(length) in ' \t': length += 1 whitespaces = self.reader.prefix(length) self.reader.forward(length) ch = srp() if ch == '\0': raise ScannerError( 'while scanning a quoted scalar', start_mark, 'found unexpected end of stream', self.reader.get_mark(), ) elif ch in '\r\n\x85\u2028\u2029': line_break = self.scan_line_break() breaks = self.scan_flow_scalar_breaks(double, start_mark) if line_break != '\n': chunks.append(line_break) elif not breaks: chunks.append(' ') chunks.extend(breaks) else: chunks.append(whitespaces) return chunks def scan_flow_scalar_breaks(self, double, start_mark): # type: (Any, Any) -> Any # See the specification for details. chunks = [] # type: List[Any] srp = self.reader.peek srf = self.reader.forward while True: # Instead of checking indentation, we check for document # separators. prefix = self.reader.prefix(3) if (prefix == '---' or prefix == '...') and srp(3) in _THE_END_SPACE_TAB: raise ScannerError( 'while scanning a quoted scalar', start_mark, 'found unexpected document separator', self.reader.get_mark(), ) while srp() in ' \t': srf() if srp() in '\r\n\x85\u2028\u2029': chunks.append(self.scan_line_break()) else: return chunks def scan_plain(self): # type: () -> Any # See the specification for details. # We add an additional restriction for the flow context: # plain scalars in the flow context cannot contain ',', ': ' and '?'. # We also keep track of the `allow_simple_key` flag here. # Indentation rules are loosed for the flow context. srp = self.reader.peek srf = self.reader.forward chunks = [] # type: List[Any] start_mark = self.reader.get_mark() end_mark = start_mark indent = self.indent + 1 # We allow zero indentation for scalars, but then we need to check for # document separators at the beginning of the line. # if indent == 0: # indent = 1 spaces = [] # type: List[Any] while True: length = 0 if srp() == '#': break while True: ch = srp(length) if ch == ':' and srp(length + 1) not in _THE_END_SPACE_TAB: pass elif ch == '?' and self.scanner_processing_version != (1, 1): pass elif ( ch in _THE_END_SPACE_TAB or ( not self.flow_level and ch == ':' and srp(length + 1) in _THE_END_SPACE_TAB ) or (self.flow_level and ch in ',:?[]{}') ): break length += 1 # It's not clear what we should do with ':' in the flow context. if ( self.flow_level and ch == ':' and srp(length + 1) not in '\0 \t\r\n\x85\u2028\u2029,[]{}' ): srf(length) raise ScannerError( 'while scanning a plain scalar', start_mark, "found unexpected ':'", self.reader.get_mark(), 'Please check ' 'http://pyyaml.org/wiki/YAMLColonInFlowContext ' 'for details.', ) if length == 0: break self.allow_simple_key = False chunks.extend(spaces) chunks.append(self.reader.prefix(length)) srf(length) end_mark = self.reader.get_mark() spaces = self.scan_plain_spaces(indent, start_mark) if ( not spaces or srp() == '#' or (not self.flow_level and self.reader.column < indent) ): break token = ScalarToken("".join(chunks), True, start_mark, end_mark) if spaces and spaces[0] == '\n': # Create a comment token to preserve the trailing line breaks. comment = CommentToken("".join(spaces) + '\n', start_mark, end_mark) token.add_post_comment(comment) return token def scan_plain_spaces(self, indent, start_mark): # type: (Any, Any) -> Any # See the specification for details. # The specification is really confusing about tabs in plain scalars. # We just forbid them completely. Do not use tabs in YAML! srp = self.reader.peek srf = self.reader.forward chunks = [] length = 0 while srp(length) in ' ': length += 1 whitespaces = self.reader.prefix(length) self.reader.forward(length) ch = srp() if ch in '\r\n\x85\u2028\u2029': line_break = self.scan_line_break() self.allow_simple_key = True prefix = self.reader.prefix(3) if (prefix == '---' or prefix == '...') and srp(3) in _THE_END_SPACE_TAB: return breaks = [] while srp() in ' \r\n\x85\u2028\u2029': if srp() == ' ': srf() else: breaks.append(self.scan_line_break()) prefix = self.reader.prefix(3) if (prefix == '---' or prefix == '...') and srp(3) in _THE_END_SPACE_TAB: return if line_break != '\n': chunks.append(line_break) elif not breaks: chunks.append(' ') chunks.extend(breaks) elif whitespaces: chunks.append(whitespaces) return chunks def scan_tag_handle(self, name, start_mark): # type: (Any, Any) -> Any # See the specification for details. # For some strange reasons, the specification does not allow '_' in # tag handles. I have allowed it anyway. srp = self.reader.peek ch = srp() if ch != '!': raise ScannerError( 'while scanning a %s' % (name,), start_mark, "expected '!', but found %r" % utf8(ch), self.reader.get_mark(), ) length = 1 ch = srp(length) if ch != ' ': while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' or ch in '-_': length += 1 ch = srp(length) if ch != '!': self.reader.forward(length) raise ScannerError( 'while scanning a %s' % (name,), start_mark, "expected '!', but found %r" % utf8(ch), self.reader.get_mark(), ) length += 1 value = self.reader.prefix(length) self.reader.forward(length) return value def scan_tag_uri(self, name, start_mark): # type: (Any, Any) -> Any # See the specification for details. # Note: we do not check if URI is well-formed. srp = self.reader.peek chunks = [] length = 0 ch = srp(length) while ( '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' or ch in "-;/?:@&=+$,_.!~*'()[]%" ): if ch == '%': chunks.append(self.reader.prefix(length)) self.reader.forward(length) length = 0 chunks.append(self.scan_uri_escapes(name, start_mark)) else: length += 1 ch = srp(length) if length != 0: chunks.append(self.reader.prefix(length)) self.reader.forward(length) length = 0 if not chunks: raise ScannerError( 'while parsing a %s' % (name,), start_mark, 'expected URI, but found %r' % utf8(ch), self.reader.get_mark(), ) return "".join(chunks) def scan_uri_escapes(self, name, start_mark): # type: (Any, Any) -> Any # See the specification for details. srp = self.reader.peek srf = self.reader.forward code_bytes = [] # type: List[Any] mark = self.reader.get_mark() while srp() == '%': srf() for k in range(2): if srp(k) not in '0123456789ABCDEFabcdef': raise ScannerError( 'while scanning a %s' % (name,), start_mark, 'expected URI escape sequence of 2 hexdecimal numbers,' ' but found %r' % utf8(srp(k)), self.reader.get_mark(), ) if PY3: code_bytes.append(int(self.reader.prefix(2), 16)) else: code_bytes.append(chr(int(self.reader.prefix(2), 16))) srf(2) try: if PY3: value = bytes(code_bytes).decode('utf-8') else: value = unicode(b"".join(code_bytes), 'utf-8') except UnicodeDecodeError as exc: raise ScannerError('while scanning a %s' % (name,), start_mark, str(exc), mark) return value def scan_line_break(self): # type: () -> Any # Transforms: # '\r\n' : '\n' # '\r' : '\n' # '\n' : '\n' # '\x85' : '\n' # '\u2028' : '\u2028' # '\u2029 : '\u2029' # default : '' ch = self.reader.peek() if ch in '\r\n\x85': if self.reader.prefix(2) == '\r\n': self.reader.forward(2) else: self.reader.forward() return '\n' elif ch in '\u2028\u2029': self.reader.forward() return ch return "" class RoundTripScanner(Scanner): def check_token(self, *choices): # type: (Any) -> bool # Check if the next token is one of the given types. while self.need_more_tokens(): self.fetch_more_tokens() self._gather_comments() if bool(self.tokens): if not choices: return True for choice in choices: if isinstance(self.tokens[0], choice): return True return False def peek_token(self): # type: () -> Any # Return the next token, but do not delete if from the queue. while self.need_more_tokens(): self.fetch_more_tokens() self._gather_comments() if bool(self.tokens): return self.tokens[0] return None def _gather_comments(self): # type: () -> Any """combine multiple comment lines""" comments = [] # type: List[Any] if not self.tokens: return comments if isinstance(self.tokens[0], CommentToken): comment = self.tokens.pop(0) self.tokens_taken += 1 comments.append(comment) while self.need_more_tokens(): self.fetch_more_tokens() if not self.tokens: return comments if isinstance(self.tokens[0], CommentToken): self.tokens_taken += 1 comment = self.tokens.pop(0) # print 'dropping2', comment comments.append(comment) if len(comments) >= 1: self.tokens[0].add_pre_comments(comments) # pull in post comment on e.g. ':' if not self.done and len(self.tokens) < 2: self.fetch_more_tokens() def get_token(self): # type: () -> Any # Return the next token. while self.need_more_tokens(): self.fetch_more_tokens() self._gather_comments() if bool(self.tokens): # nprint('tk', self.tokens) # only add post comment to single line tokens: # scalar, value token. FlowXEndToken, otherwise # hidden streamtokens could get them (leave them and they will be # pre comments for the next map/seq if ( len(self.tokens) > 1 and isinstance( self.tokens[0], (ScalarToken, ValueToken, FlowSequenceEndToken, FlowMappingEndToken), ) and isinstance(self.tokens[1], CommentToken) and self.tokens[0].end_mark.line == self.tokens[1].start_mark.line ): self.tokens_taken += 1 self.tokens[0].add_post_comment(self.tokens.pop(1)) self.tokens_taken += 1 return self.tokens.pop(0) return None def fetch_comment(self, comment): # type: (Any) -> None value, start_mark, end_mark = comment while value and value[-1] == ' ': # empty line within indented key context # no need to update end-mark, that is not used value = value[:-1] self.tokens.append(CommentToken(value, start_mark, end_mark)) # scanner def scan_to_next_token(self): # type: () -> Any # We ignore spaces, line breaks and comments. # If we find a line break in the block context, we set the flag # `allow_simple_key` on. # The byte order mark is stripped if it's the first character in the # stream. We do not yet support BOM inside the stream as the # specification requires. Any such mark will be considered as a part # of the document. # # TODO: We need to make tab handling rules more sane. A good rule is # Tabs cannot precede tokens # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END, # KEY(block), VALUE(block), BLOCK-ENTRY # So the checking code is # if : # self.allow_simple_keys = False # We also need to add the check for `allow_simple_keys == True` to # `unwind_indent` before issuing BLOCK-END. # Scanners for block, flow, and plain scalars need to be modified. srp = self.reader.peek srf = self.reader.forward if self.reader.index == 0 and srp() == '\uFEFF': srf() found = False while not found: while srp() == ' ': srf() ch = srp() if ch == '#': start_mark = self.reader.get_mark() comment = ch srf() while ch not in _THE_END: ch = srp() if ch == '\0': # don't gobble the end-of-stream character break comment += ch srf() # gather any blank lines following the comment too ch = self.scan_line_break() while len(ch) > 0: comment += ch ch = self.scan_line_break() end_mark = self.reader.get_mark() if not self.flow_level: self.allow_simple_key = True return comment, start_mark, end_mark if bool(self.scan_line_break()): start_mark = self.reader.get_mark() if not self.flow_level: self.allow_simple_key = True ch = srp() if ch == '\n': # empty toplevel lines start_mark = self.reader.get_mark() comment = "" while ch: ch = self.scan_line_break(empty_line=True) comment += ch if srp() == '#': # empty line followed by indented real comment comment = comment.rsplit('\n', 1)[0] + '\n' end_mark = self.reader.get_mark() return comment, start_mark, end_mark else: found = True return None def scan_line_break(self, empty_line=False): # type: (bool) -> Text # Transforms: # '\r\n' : '\n' # '\r' : '\n' # '\n' : '\n' # '\x85' : '\n' # '\u2028' : '\u2028' # '\u2029 : '\u2029' # default : '' ch = self.reader.peek() # type: Text if ch in '\r\n\x85': if self.reader.prefix(2) == '\r\n': self.reader.forward(2) else: self.reader.forward() return '\n' elif ch in '\u2028\u2029': self.reader.forward() return ch elif empty_line and ch in '\t ': self.reader.forward() return ch return "" def scan_block_scalar(self, style, rt=True): # type: (Any, Optional[bool]) -> Any return Scanner.scan_block_scalar(self, style, rt=rt) # try: # import psyco # psyco.bind(Scanner) # except ImportError: # pass ruamel.yaml-0.15.89/.ruamel/0000775000175100001440000000000013435603755016153 5ustar anthonusers00000000000000ruamel.yaml-0.15.89/.ruamel/__init__.py0000664000175100001440000000007713037504407020260 0ustar anthonusers00000000000000import pkg_resources pkg_resources.declare_namespace(__name__) ruamel.yaml-0.15.89/scalarfloat.py0000664000175100001440000001046613411244755017457 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals import sys from .compat import no_limit_int # NOQA from ruamel.yaml.anchor import Anchor if False: # MYPY from typing import Text, Any, Dict, List # NOQA __all__ = ['ScalarFloat', 'ExponentialFloat', 'ExponentialCapsFloat'] class ScalarFloat(float): def __new__(cls, *args, **kw): # type: (Any, Any, Any) -> Any width = kw.pop('width', None) # type: ignore prec = kw.pop('prec', None) # type: ignore m_sign = kw.pop('m_sign', None) # type: ignore m_lead0 = kw.pop('m_lead0', 0) # type: ignore exp = kw.pop('exp', None) # type: ignore e_width = kw.pop('e_width', None) # type: ignore e_sign = kw.pop('e_sign', None) # type: ignore underscore = kw.pop('underscore', None) # type: ignore anchor = kw.pop('anchor', None) # type: ignore v = float.__new__(cls, *args, **kw) # type: ignore v._width = width v._prec = prec v._m_sign = m_sign v._m_lead0 = m_lead0 v._exp = exp v._e_width = e_width v._e_sign = e_sign v._underscore = underscore if anchor is not None: v.yaml_set_anchor(anchor, always_dump=True) return v def __iadd__(self, a): # type: ignore # type: (Any) -> Any return float(self) + a x = type(self)(self + a) x._width = self._width x._underscore = self._underscore[:] if self._underscore is not None else None # NOQA return x def __ifloordiv__(self, a): # type: ignore # type: (Any) -> Any return float(self) // a x = type(self)(self // a) x._width = self._width x._underscore = self._underscore[:] if self._underscore is not None else None # NOQA return x def __imul__(self, a): # type: ignore # type: (Any) -> Any return float(self) * a x = type(self)(self * a) x._width = self._width x._underscore = self._underscore[:] if self._underscore is not None else None # NOQA x._prec = self._prec # check for others return x def __ipow__(self, a): # type: ignore # type: (Any) -> Any return float(self) ** a x = type(self)(self ** a) x._width = self._width x._underscore = self._underscore[:] if self._underscore is not None else None # NOQA return x def __isub__(self, a): # type: ignore # type: (Any) -> Any return float(self) - a x = type(self)(self - a) x._width = self._width x._underscore = self._underscore[:] if self._underscore is not None else None # NOQA return x @property def anchor(self): # type: () -> Any if not hasattr(self, Anchor.attrib): setattr(self, Anchor.attrib, Anchor()) return getattr(self, Anchor.attrib) def yaml_anchor(self, any=False): # type: (bool) -> Any if not hasattr(self, Anchor.attrib): return None if any or self.anchor.always_dump: return self.anchor return None def yaml_set_anchor(self, value, always_dump=False): # type: (Any, bool) -> None self.anchor.value = value self.anchor.always_dump = always_dump def dump(self, out=sys.stdout): # type: (Any) -> Any out.write( 'ScalarFloat({}| w:{}, p:{}, s:{}, lz:{}, _:{}|{}, w:{}, s:{})\n'.format( self, self._width, # type: ignore self._prec, # type: ignore self._m_sign, # type: ignore self._m_lead0, # type: ignore self._underscore, # type: ignore self._exp, # type: ignore self._e_width, # type: ignore self._e_sign, # type: ignore ) ) class ExponentialFloat(ScalarFloat): def __new__(cls, value, width=None, underscore=None): # type: (Any, Any, Any) -> Any return ScalarFloat.__new__(cls, value, width=width, underscore=underscore) class ExponentialCapsFloat(ScalarFloat): def __new__(cls, value, width=None, underscore=None): # type: (Any, Any, Any) -> Any return ScalarFloat.__new__(cls, value, width=width, underscore=underscore) ruamel.yaml-0.15.89/tokens.py0000664000175100001440000001556313373303256016471 0ustar anthonusers00000000000000# # header # coding: utf-8 from __future__ import unicode_literals if False: # MYPY from typing import Text, Any, Dict, Optional, List # NOQA from .error import StreamMark # NOQA SHOWLINES = True class Token(object): __slots__ = 'start_mark', 'end_mark', '_comment' def __init__(self, start_mark, end_mark): # type: (StreamMark, StreamMark) -> None self.start_mark = start_mark self.end_mark = end_mark def __repr__(self): # type: () -> Any # attributes = [key for key in self.__slots__ if not key.endswith('_mark') and # hasattr('self', key)] attributes = [key for key in self.__slots__ if not key.endswith('_mark')] attributes.sort() arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) for key in attributes]) if SHOWLINES: try: arguments += ', line: ' + str(self.start_mark.line) except: # NOQA pass try: arguments += ', comment: ' + str(self._comment) except: # NOQA pass return '{}({})'.format(self.__class__.__name__, arguments) def add_post_comment(self, comment): # type: (Any) -> None if not hasattr(self, '_comment'): self._comment = [None, None] self._comment[0] = comment def add_pre_comments(self, comments): # type: (Any) -> None if not hasattr(self, '_comment'): self._comment = [None, None] assert self._comment[1] is None self._comment[1] = comments def get_comment(self): # type: () -> Any return getattr(self, '_comment', None) @property def comment(self): # type: () -> Any return getattr(self, '_comment', None) def move_comment(self, target, empty=False): # type: (Any, bool) -> Any """move a comment from this token to target (normally next token) used to combine e.g. comments before a BlockEntryToken to the ScalarToken that follows it empty is a special for empty values -> comment after key """ c = self.comment if c is None: return # don't push beyond last element if isinstance(target, (StreamEndToken, DocumentStartToken)): return delattr(self, '_comment') tc = target.comment if not tc: # target comment, just insert # special for empty value in key: value issue 25 if empty: c = [c[0], c[1], None, None, c[0]] target._comment = c # nprint('mco2:', self, target, target.comment, empty) return self if c[0] and tc[0] or c[1] and tc[1]: raise NotImplementedError('overlap in comment %r %r' % (c, tc)) if c[0]: tc[0] = c[0] if c[1]: tc[1] = c[1] return self def split_comment(self): # type: () -> Any """ split the post part of a comment, and return it as comment to be added. Delete second part if [None, None] abc: # this goes to sequence # this goes to first element - first element """ comment = self.comment if comment is None or comment[0] is None: return None # nothing to do ret_val = [comment[0], None] if comment[1] is None: delattr(self, '_comment') return ret_val # class BOMToken(Token): # id = '' class DirectiveToken(Token): __slots__ = 'name', 'value' id = '' def __init__(self, name, value, start_mark, end_mark): # type: (Any, Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.name = name self.value = value class DocumentStartToken(Token): __slots__ = () id = '' class DocumentEndToken(Token): __slots__ = () id = '' class StreamStartToken(Token): __slots__ = ('encoding',) id = '' def __init__(self, start_mark=None, end_mark=None, encoding=None): # type: (Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.encoding = encoding class StreamEndToken(Token): __slots__ = () id = '' class BlockSequenceStartToken(Token): __slots__ = () id = '' class BlockMappingStartToken(Token): __slots__ = () id = '' class BlockEndToken(Token): __slots__ = () id = '' class FlowSequenceStartToken(Token): __slots__ = () id = '[' class FlowMappingStartToken(Token): __slots__ = () id = '{' class FlowSequenceEndToken(Token): __slots__ = () id = ']' class FlowMappingEndToken(Token): __slots__ = () id = '}' class KeyToken(Token): __slots__ = () id = '?' # def x__repr__(self): # return 'KeyToken({})'.format( # self.start_mark.buffer[self.start_mark.index:].split(None, 1)[0]) class ValueToken(Token): __slots__ = () id = ':' class BlockEntryToken(Token): __slots__ = () id = '-' class FlowEntryToken(Token): __slots__ = () id = ',' class AliasToken(Token): __slots__ = ('value',) id = '' def __init__(self, value, start_mark, end_mark): # type: (Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.value = value class AnchorToken(Token): __slots__ = ('value',) id = '' def __init__(self, value, start_mark, end_mark): # type: (Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.value = value class TagToken(Token): __slots__ = ('value',) id = '' def __init__(self, value, start_mark, end_mark): # type: (Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.value = value class ScalarToken(Token): __slots__ = 'value', 'plain', 'style' id = '' def __init__(self, value, plain, start_mark, end_mark, style=None): # type: (Any, Any, Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.value = value self.plain = plain self.style = style class CommentToken(Token): __slots__ = 'value', 'pre_done' id = '' def __init__(self, value, start_mark, end_mark): # type: (Any, Any, Any) -> None Token.__init__(self, start_mark, end_mark) self.value = value def reset(self): # type: () -> None if hasattr(self, 'pre_done'): delattr(self, 'pre_done') def __repr__(self): # type: () -> Any v = '{!r}'.format(self.value) if SHOWLINES: try: v += ', line: ' + str(self.start_mark.line) except: # NOQA pass return 'CommentToken({})'.format(v) ruamel.yaml-0.15.89/setup.cfg0000664000175100001440000000004613435603756016432 0ustar anthonusers00000000000000[egg_info] tag_build = tag_date = 0 ruamel.yaml-0.15.89/MANIFEST.in0000664000175100001440000000010413351205633016327 0ustar anthonusers00000000000000include README.rst LICENSE CHANGES setup.py recursive-include ext * ruamel.yaml-0.15.89/util.py0000664000175100001440000001367613411370200016130 0ustar anthonusers00000000000000# coding: utf-8 """ some helper functions that might be generally useful """ from __future__ import absolute_import, print_function from functools import partial import re from .compat import text_type, binary_type if False: # MYPY from typing import Any, Dict, Optional, List, Text # NOQA from .compat import StreamTextType # NOQA class LazyEval(object): """ Lightweight wrapper around lazily evaluated func(*args, **kwargs). func is only evaluated when any attribute of its return value is accessed. Every attribute access is passed through to the wrapped value. (This only excludes special cases like method-wrappers, e.g., __hash__.) The sole additional attribute is the lazy_self function which holds the return value (or, prior to evaluation, func and arguments), in its closure. """ def __init__(self, func, *args, **kwargs): # type: (Any, Any, Any) -> None def lazy_self(): # type: () -> Any return_value = func(*args, **kwargs) object.__setattr__(self, 'lazy_self', lambda: return_value) return return_value object.__setattr__(self, 'lazy_self', lazy_self) def __getattribute__(self, name): # type: (Any) -> Any lazy_self = object.__getattribute__(self, 'lazy_self') if name == 'lazy_self': return lazy_self return getattr(lazy_self(), name) def __setattr__(self, name, value): # type: (Any, Any) -> None setattr(self.lazy_self(), name, value) RegExp = partial(LazyEval, re.compile) # originally as comment # https://github.com/pre-commit/pre-commit/pull/211#issuecomment-186466605 # if you use this in your code, I suggest adding a test in your test suite # that check this routines output against a known piece of your YAML # before upgrades to this code break your round-tripped YAML def load_yaml_guess_indent(stream, **kw): # type: (StreamTextType, Any) -> Any """guess the indent and block sequence indent of yaml stream/string returns round_trip_loaded stream, indent level, block sequence indent - block sequence indent is the number of spaces before a dash relative to previous indent - if there are no block sequences, indent is taken from nested mappings, block sequence indent is unset (None) in that case """ from .main import round_trip_load # load a yaml file guess the indentation, if you use TABs ... def leading_spaces(l): # type: (Any) -> int idx = 0 while idx < len(l) and l[idx] == ' ': idx += 1 return idx if isinstance(stream, text_type): yaml_str = stream elif isinstance(stream, binary_type): yaml_str = stream.decode('utf-8') # most likely, but the Reader checks BOM for this else: yaml_str = stream.read() map_indent = None indent = None # default if not found for some reason block_seq_indent = None prev_line_key_only = None key_indent = 0 for line in yaml_str.splitlines(): rline = line.rstrip() lline = rline.lstrip() if lline.startswith('- '): l_s = leading_spaces(line) block_seq_indent = l_s - key_indent idx = l_s + 1 while line[idx] == ' ': # this will end as we rstripped idx += 1 if line[idx] == '#': # comment after - continue indent = idx - key_indent break if map_indent is None and prev_line_key_only is not None and rline: idx = 0 while line[idx] in ' -': idx += 1 if idx > prev_line_key_only: map_indent = idx - prev_line_key_only if rline.endswith(':'): key_indent = leading_spaces(line) idx = 0 while line[idx] == ' ': # this will end on ':' idx += 1 prev_line_key_only = idx continue prev_line_key_only = None if indent is None and map_indent is not None: indent = map_indent return round_trip_load(yaml_str, **kw), indent, block_seq_indent def configobj_walker(cfg): # type: (Any) -> Any """ walks over a ConfigObj (INI file with comments) generating corresponding YAML output (including comments """ from configobj import ConfigObj # type: ignore assert isinstance(cfg, ConfigObj) for c in cfg.initial_comment: if c.strip(): yield c for s in _walk_section(cfg): if s.strip(): yield s for c in cfg.final_comment: if c.strip(): yield c def _walk_section(s, level=0): # type: (Any, int) -> Any from configobj import Section assert isinstance(s, Section) indent = u' ' * level for name in s.scalars: for c in s.comments[name]: yield indent + c.strip() x = s[name] if u'\n' in x: i = indent + u' ' x = u'|\n' + i + x.strip().replace(u'\n', u'\n' + i) elif ':' in x: x = u"'" + x.replace(u"'", u"''") + u"'" line = u'{0}{1}: {2}'.format(indent, name, x) c = s.inline_comments[name] if c: line += u' ' + c yield line for name in s.sections: for c in s.comments[name]: yield indent + c.strip() line = u'{0}{1}:'.format(indent, name) c = s.inline_comments[name] if c: line += u' ' + c yield line for val in _walk_section(s[name], level=level + 1): yield val # def config_obj_2_rt_yaml(cfg): # from .comments import CommentedMap, CommentedSeq # from configobj import ConfigObj # assert isinstance(cfg, ConfigObj) # #for c in cfg.initial_comment: # # if c.strip(): # # pass # cm = CommentedMap() # for name in s.sections: # cm[name] = d = CommentedMap() # # # #for c in cfg.final_comment: # # if c.strip(): # # yield c # return cm ruamel.yaml-0.15.89/main.py0000664000175100001440000015044213421037210016072 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import, unicode_literals, print_function import sys import os import warnings import glob from importlib import import_module import ruamel.yaml from ruamel.yaml.error import UnsafeLoaderWarning, YAMLError # NOQA from ruamel.yaml.tokens import * # NOQA from ruamel.yaml.events import * # NOQA from ruamel.yaml.nodes import * # NOQA from ruamel.yaml.loader import BaseLoader, SafeLoader, Loader, RoundTripLoader # NOQA from ruamel.yaml.dumper import BaseDumper, SafeDumper, Dumper, RoundTripDumper # NOQA from ruamel.yaml.compat import StringIO, BytesIO, with_metaclass, PY3, nprint from ruamel.yaml.resolver import VersionedResolver, Resolver # NOQA from ruamel.yaml.representer import ( BaseRepresenter, SafeRepresenter, Representer, RoundTripRepresenter, ) from ruamel.yaml.constructor import ( BaseConstructor, SafeConstructor, Constructor, RoundTripConstructor, ) from ruamel.yaml.loader import Loader as UnsafeLoader if False: # MYPY from typing import List, Set, Dict, Union, Any, Callable # NOQA from ruamel.yaml.compat import StreamType, StreamTextType, VersionType # NOQA if PY3: from pathlib import Path else: Path = Any try: from _ruamel_yaml import CParser, CEmitter # type: ignore except: # NOQA CParser = CEmitter = None # import io enforce = object() # YAML is an acronym, i.e. spoken: rhymes with "camel". And thus a # subset of abbreviations, which should be all caps according to PEP8 class YAML(object): def __init__( self, _kw=enforce, typ=None, pure=False, output=None, plug_ins=None # input=None, ): # type: (Any, Optional[Text], Any, Any, Any) -> None """ _kw: not used, forces keyword arguments in 2.7 (in 3 you can do (*, safe_load=..) typ: 'rt'/None -> RoundTripLoader/RoundTripDumper, (default) 'safe' -> SafeLoader/SafeDumper, 'unsafe' -> normal/unsafe Loader/Dumper 'base' -> baseloader pure: if True only use Python modules input/output: needed to work as context manager plug_ins: a list of plug-in files """ if _kw is not enforce: raise TypeError( '{}.__init__() takes no positional argument but at least ' 'one was given ({!r})'.format(self.__class__.__name__, _kw) ) self.typ = 'rt' if typ is None else typ self.pure = pure # self._input = input self._output = output self._context_manager = None # type: Any self.plug_ins = [] # type: List[Any] for pu in ([] if plug_ins is None else plug_ins) + self.official_plug_ins(): file_name = pu.replace(os.sep, '.') self.plug_ins.append(import_module(file_name)) self.Resolver = ruamel.yaml.resolver.VersionedResolver # type: Any self.allow_unicode = True self.Reader = None # type: Any self.Scanner = None # type: Any self.Serializer = None # type: Any self.default_flow_style = None # type: Any if self.typ == 'rt': self.default_flow_style = False # no optimized rt-dumper yet self.Emitter = ruamel.yaml.emitter.Emitter # type: Any self.Serializer = ruamel.yaml.serializer.Serializer # type: Any self.Representer = ruamel.yaml.representer.RoundTripRepresenter # type: Any self.Scanner = ruamel.yaml.scanner.RoundTripScanner # type: Any # no optimized rt-parser yet self.Parser = ruamel.yaml.parser.RoundTripParser # type: Any self.Composer = ruamel.yaml.composer.Composer # type: Any self.Constructor = ruamel.yaml.constructor.RoundTripConstructor # type: Any elif self.typ == 'safe': self.Emitter = ( ruamel.yaml.emitter.Emitter if pure or CEmitter is None else CEmitter ) self.Representer = ruamel.yaml.representer.SafeRepresenter self.Parser = ruamel.yaml.parser.Parser if pure or CParser is None else CParser self.Composer = ruamel.yaml.composer.Composer self.Constructor = ruamel.yaml.constructor.SafeConstructor elif self.typ == 'base': self.Emitter = ruamel.yaml.emitter.Emitter self.Representer = ruamel.yaml.representer.BaseRepresenter self.Parser = ruamel.yaml.parser.Parser if pure or CParser is None else CParser self.Composer = ruamel.yaml.composer.Composer self.Constructor = ruamel.yaml.constructor.BaseConstructor elif self.typ == 'unsafe': self.Emitter = ( ruamel.yaml.emitter.Emitter if pure or CEmitter is None else CEmitter ) self.Representer = ruamel.yaml.representer.Representer self.Parser = ruamel.yaml.parser.Parser if pure or CParser is None else CParser self.Composer = ruamel.yaml.composer.Composer self.Constructor = ruamel.yaml.constructor.Constructor else: for module in self.plug_ins: if getattr(module, 'typ', None) == self.typ: module.init_typ(self) break else: raise NotImplementedError( 'typ "{}"not recognised (need to install plug-in?)'.format(self.typ) ) self.stream = None self.canonical = None self.old_indent = None self.width = None self.line_break = None self.map_indent = None self.sequence_indent = None self.sequence_dash_offset = 0 self.compact_seq_seq = None self.compact_seq_map = None self.sort_base_mapping_type_on_output = None # default: sort self.top_level_colon_align = None self.prefix_colon = None self.version = None self.preserve_quotes = None self.allow_duplicate_keys = False # duplicate keys in map, set self.encoding = 'utf-8' self.explicit_start = None self.explicit_end = None self.tags = None self.default_style = None self.top_level_block_style_scalar_no_indent_error_1_1 = False # [a, b: 1, c: {d: 2}] vs. [a, {b: 1}, {c: {d: 2}}] self.brace_single_entry_mapping_in_flow_sequence = False @property def reader(self): # type: () -> Any try: return self._reader # type: ignore except AttributeError: self._reader = self.Reader(None, loader=self) return self._reader @property def scanner(self): # type: () -> Any try: return self._scanner # type: ignore except AttributeError: self._scanner = self.Scanner(loader=self) return self._scanner @property def parser(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): if self.Parser is not CParser: setattr(self, attr, self.Parser(loader=self)) else: if getattr(self, '_stream', None) is None: # wait for the stream return None else: # if not hasattr(self._stream, 'read') and hasattr(self._stream, 'open'): # # pathlib.Path() instance # setattr(self, attr, CParser(self._stream)) # else: setattr(self, attr, CParser(self._stream)) # self._parser = self._composer = self # nprint('scanner', self.loader.scanner) return getattr(self, attr) @property def composer(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): setattr(self, attr, self.Composer(loader=self)) return getattr(self, attr) @property def constructor(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): cnst = self.Constructor(preserve_quotes=self.preserve_quotes, loader=self) cnst.allow_duplicate_keys = self.allow_duplicate_keys setattr(self, attr, cnst) return getattr(self, attr) @property def resolver(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): setattr(self, attr, self.Resolver(version=self.version, loader=self)) return getattr(self, attr) @property def emitter(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): if self.Emitter is not CEmitter: _emitter = self.Emitter( None, canonical=self.canonical, indent=self.old_indent, width=self.width, allow_unicode=self.allow_unicode, line_break=self.line_break, prefix_colon=self.prefix_colon, brace_single_entry_mapping_in_flow_sequence=self.brace_single_entry_mapping_in_flow_sequence, # NOQA dumper=self, ) setattr(self, attr, _emitter) if self.map_indent is not None: _emitter.best_map_indent = self.map_indent if self.sequence_indent is not None: _emitter.best_sequence_indent = self.sequence_indent if self.sequence_dash_offset is not None: _emitter.sequence_dash_offset = self.sequence_dash_offset # _emitter.block_seq_indent = self.sequence_dash_offset if self.compact_seq_seq is not None: _emitter.compact_seq_seq = self.compact_seq_seq if self.compact_seq_map is not None: _emitter.compact_seq_map = self.compact_seq_map else: if getattr(self, '_stream', None) is None: # wait for the stream return None return None return getattr(self, attr) @property def serializer(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): setattr( self, attr, self.Serializer( encoding=self.encoding, explicit_start=self.explicit_start, explicit_end=self.explicit_end, version=self.version, tags=self.tags, dumper=self, ), ) return getattr(self, attr) @property def representer(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): repres = self.Representer( default_style=self.default_style, default_flow_style=self.default_flow_style, dumper=self, ) if self.sort_base_mapping_type_on_output is not None: repres.sort_base_mapping_type_on_output = self.sort_base_mapping_type_on_output setattr(self, attr, repres) return getattr(self, attr) # separate output resolver? # def load(self, stream=None): # if self._context_manager: # if not self._input: # raise TypeError("Missing input stream while dumping from context manager") # for data in self._context_manager.load(): # yield data # return # if stream is None: # raise TypeError("Need a stream argument when not loading from context manager") # return self.load_one(stream) def load(self, stream): # type: (Union[Path, StreamTextType]) -> Any """ at this point you either have the non-pure Parser (which has its own reader and scanner) or you have the pure Parser. If the pure Parser is set, then set the Reader and Scanner, if not already set. If either the Scanner or Reader are set, you cannot use the non-pure Parser, so reset it to the pure parser and set the Reader resp. Scanner if necessary """ if not hasattr(stream, 'read') and hasattr(stream, 'open'): # pathlib.Path() instance with stream.open('rb') as fp: # type: ignore return self.load(fp) constructor, parser = self.get_constructor_parser(stream) try: return constructor.get_single_data() finally: parser.dispose() try: self._reader.reset_reader() except AttributeError: pass try: self._scanner.reset_scanner() except AttributeError: pass def load_all(self, stream, _kw=enforce): # , skip=None): # type: (Union[Path, StreamTextType], Any) -> Any if _kw is not enforce: raise TypeError( '{}.__init__() takes no positional argument but at least ' 'one was given ({!r})'.format(self.__class__.__name__, _kw) ) if not hasattr(stream, 'read') and hasattr(stream, 'open'): # pathlib.Path() instance with stream.open('r') as fp: # type: ignore for d in self.load_all(fp, _kw=enforce): yield d return # if skip is None: # skip = [] # elif isinstance(skip, int): # skip = [skip] constructor, parser = self.get_constructor_parser(stream) try: while constructor.check_data(): yield constructor.get_data() finally: parser.dispose() try: self._reader.reset_reader() except AttributeError: pass try: self._scanner.reset_scanner() except AttributeError: pass def get_constructor_parser(self, stream): # type: (StreamTextType) -> Any """ the old cyaml needs special setup, and therefore the stream """ if self.Parser is not CParser: if self.Reader is None: self.Reader = ruamel.yaml.reader.Reader if self.Scanner is None: self.Scanner = ruamel.yaml.scanner.Scanner self.reader.stream = stream else: if self.Reader is not None: if self.Scanner is None: self.Scanner = ruamel.yaml.scanner.Scanner self.Parser = ruamel.yaml.parser.Parser self.reader.stream = stream elif self.Scanner is not None: if self.Reader is None: self.Reader = ruamel.yaml.reader.Reader self.Parser = ruamel.yaml.parser.Parser self.reader.stream = stream else: # combined C level reader>scanner>parser # does some calls to the resolver, e.g. BaseResolver.descend_resolver # if you just initialise the CParser, to much of resolver.py # is actually used rslvr = self.Resolver # if rslvr is ruamel.yaml.resolver.VersionedResolver: # rslvr = ruamel.yaml.resolver.Resolver class XLoader(self.Parser, self.Constructor, rslvr): # type: ignore def __init__(selfx, stream, version=self.version, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None # NOQA CParser.__init__(selfx, stream) selfx._parser = selfx._composer = selfx self.Constructor.__init__(selfx, loader=selfx) selfx.allow_duplicate_keys = self.allow_duplicate_keys rslvr.__init__(selfx, version=version, loadumper=selfx) self._stream = stream loader = XLoader(stream) return loader, loader return self.constructor, self.parser def dump(self, data, stream=None, _kw=enforce, transform=None): # type: (Any, Union[Path, StreamType], Any, Any) -> Any if self._context_manager: if not self._output: raise TypeError('Missing output stream while dumping from context manager') if _kw is not enforce: raise TypeError( '{}.dump() takes one positional argument but at least ' 'two were given ({!r})'.format(self.__class__.__name__, _kw) ) if transform is not None: raise TypeError( '{}.dump() in the context manager cannot have transform keyword ' ''.format(self.__class__.__name__) ) self._context_manager.dump(data) else: # old style if stream is None: raise TypeError('Need a stream argument when not dumping from context manager') return self.dump_all([data], stream, _kw, transform=transform) def dump_all(self, documents, stream, _kw=enforce, transform=None): # type: (Any, Union[Path, StreamType], Any, Any) -> Any if self._context_manager: raise NotImplementedError if _kw is not enforce: raise TypeError( '{}.dump(_all) takes two positional argument but at least ' 'three were given ({!r})'.format(self.__class__.__name__, _kw) ) self._output = stream self._context_manager = YAMLContextManager(self, transform=transform) for data in documents: self._context_manager.dump(data) self._context_manager.teardown_output() self._output = None self._context_manager = None def Xdump_all(self, documents, stream, _kw=enforce, transform=None): # type: (Any, Union[Path, StreamType], Any, Any) -> Any """ Serialize a sequence of Python objects into a YAML stream. """ if not hasattr(stream, 'write') and hasattr(stream, 'open'): # pathlib.Path() instance with stream.open('w') as fp: return self.dump_all(documents, fp, _kw, transform=transform) if _kw is not enforce: raise TypeError( '{}.dump(_all) takes two positional argument but at least ' 'three were given ({!r})'.format(self.__class__.__name__, _kw) ) # The stream should have the methods `write` and possibly `flush`. if self.top_level_colon_align is True: tlca = max([len(str(x)) for x in documents[0]]) # type: Any else: tlca = self.top_level_colon_align if transform is not None: fstream = stream if self.encoding is None: stream = StringIO() else: stream = BytesIO() serializer, representer, emitter = self.get_serializer_representer_emitter( stream, tlca ) try: self.serializer.open() for data in documents: try: self.representer.represent(data) except AttributeError: # nprint(dir(dumper._representer)) raise self.serializer.close() finally: try: self.emitter.dispose() except AttributeError: raise # self.dumper.dispose() # cyaml delattr(self, '_serializer') delattr(self, '_emitter') if transform: val = stream.getvalue() if self.encoding: val = val.decode(self.encoding) if fstream is None: transform(val) else: fstream.write(transform(val)) return None def get_serializer_representer_emitter(self, stream, tlca): # type: (StreamType, Any) -> Any # we have only .Serializer to deal with (vs .Reader & .Scanner), much simpler if self.Emitter is not CEmitter: if self.Serializer is None: self.Serializer = ruamel.yaml.serializer.Serializer self.emitter.stream = stream self.emitter.top_level_colon_align = tlca return self.serializer, self.representer, self.emitter if self.Serializer is not None: # cannot set serializer with CEmitter self.Emitter = ruamel.yaml.emitter.Emitter self.emitter.stream = stream self.emitter.top_level_colon_align = tlca return self.serializer, self.representer, self.emitter # C routines rslvr = ( ruamel.yaml.resolver.BaseResolver if self.typ == 'base' else ruamel.yaml.resolver.Resolver ) class XDumper(CEmitter, self.Representer, rslvr): # type: ignore def __init__( selfx, stream, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (StreamType, Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> None # NOQA CEmitter.__init__( selfx, stream, canonical=canonical, indent=indent, width=width, encoding=encoding, allow_unicode=allow_unicode, line_break=line_break, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, ) selfx._emitter = selfx._serializer = selfx._representer = selfx self.Representer.__init__( selfx, default_style=default_style, default_flow_style=default_flow_style ) rslvr.__init__(selfx) self._stream = stream dumper = XDumper( stream, default_style=self.default_style, default_flow_style=self.default_flow_style, canonical=self.canonical, indent=self.old_indent, width=self.width, allow_unicode=self.allow_unicode, line_break=self.line_break, explicit_start=self.explicit_start, explicit_end=self.explicit_end, version=self.version, tags=self.tags, ) self._emitter = self._serializer = dumper return dumper, dumper, dumper # basic types def map(self, **kw): # type: (Any) -> Any if self.typ == 'rt': from ruamel.yaml.comments import CommentedMap return CommentedMap(**kw) else: return dict(**kw) def seq(self, *args): # type: (Any) -> Any if self.typ == 'rt': from ruamel.yaml.comments import CommentedSeq return CommentedSeq(*args) else: return list(*args) # helpers def official_plug_ins(self): # type: () -> Any bd = os.path.dirname(__file__) gpbd = os.path.dirname(os.path.dirname(bd)) res = [x.replace(gpbd, "")[1:-3] for x in glob.glob(bd + '/*/__plug_in__.py')] return res def register_class(self, cls): # type:(Any) -> Any """ register a class for dumping loading - if it has attribute yaml_tag use that to register, else use class name - if it has methods to_yaml/from_yaml use those to dump/load else dump attributes as mapping """ tag = getattr(cls, 'yaml_tag', '!' + cls.__name__) try: self.representer.add_representer(cls, cls.to_yaml) except AttributeError: def t_y(representer, data): # type: (Any, Any) -> Any return representer.represent_yaml_object( tag, data, cls, flow_style=representer.default_flow_style ) self.representer.add_representer(cls, t_y) try: self.constructor.add_constructor(tag, cls.from_yaml) except AttributeError: def f_y(constructor, node): # type: (Any, Any) -> Any return constructor.construct_yaml_object(node, cls) self.constructor.add_constructor(tag, f_y) return cls def parse(self, stream): # type: (StreamTextType) -> Any """ Parse a YAML stream and produce parsing events. """ _, parser = self.get_constructor_parser(stream) try: while parser.check_event(): yield parser.get_event() finally: parser.dispose() try: self._reader.reset_reader() except AttributeError: pass try: self._scanner.reset_scanner() except AttributeError: pass # ### context manager def __enter__(self): # type: () -> Any self._context_manager = YAMLContextManager(self) return self def __exit__(self, typ, value, traceback): # type: (Any, Any, Any) -> None if typ: nprint('typ', typ) self._context_manager.teardown_output() # self._context_manager.teardown_input() self._context_manager = None # ### backwards compatibility def _indent(self, mapping=None, sequence=None, offset=None): # type: (Any, Any, Any) -> None if mapping is not None: self.map_indent = mapping if sequence is not None: self.sequence_indent = sequence if offset is not None: self.sequence_dash_offset = offset @property def indent(self): # type: () -> Any return self._indent @indent.setter def indent(self, val): # type: (Any) -> None self.old_indent = val @property def block_seq_indent(self): # type: () -> Any return self.sequence_dash_offset @block_seq_indent.setter def block_seq_indent(self, val): # type: (Any) -> None self.sequence_dash_offset = val def compact(self, seq_seq=None, seq_map=None): # type: (Any, Any) -> None self.compact_seq_seq = seq_seq self.compact_seq_map = seq_map class YAMLContextManager(object): def __init__(self, yaml, transform=None): # type: (Any, Any) -> None # used to be: (Any, Optional[Callable]) -> None self._yaml = yaml self._output_inited = False self._output_path = None self._output = self._yaml._output self._transform = transform # self._input_inited = False # self._input = input # self._input_path = None # self._transform = yaml.transform # self._fstream = None if not hasattr(self._output, 'write') and hasattr(self._output, 'open'): # pathlib.Path() instance, open with the same mode self._output_path = self._output self._output = self._output_path.open('w') # if not hasattr(self._stream, 'write') and hasattr(stream, 'open'): # if not hasattr(self._input, 'read') and hasattr(self._input, 'open'): # # pathlib.Path() instance, open with the same mode # self._input_path = self._input # self._input = self._input_path.open('r') if self._transform is not None: self._fstream = self._output if self._yaml.encoding is None: self._output = StringIO() else: self._output = BytesIO() def teardown_output(self): # type: () -> None if self._output_inited: self._yaml.serializer.close() else: return try: self._yaml.emitter.dispose() except AttributeError: raise # self.dumper.dispose() # cyaml try: delattr(self._yaml, '_serializer') delattr(self._yaml, '_emitter') except AttributeError: raise if self._transform: val = self._output.getvalue() if self._yaml.encoding: val = val.decode(self._yaml.encoding) if self._fstream is None: self._transform(val) else: self._fstream.write(self._transform(val)) self._fstream.flush() self._output = self._fstream # maybe not necessary if self._output_path is not None: self._output.close() def init_output(self, first_data): # type: (Any) -> None if self._yaml.top_level_colon_align is True: tlca = max([len(str(x)) for x in first_data]) # type: Any else: tlca = self._yaml.top_level_colon_align self._yaml.get_serializer_representer_emitter(self._output, tlca) self._yaml.serializer.open() self._output_inited = True def dump(self, data): # type: (Any) -> None if not self._output_inited: self.init_output(data) try: self._yaml.representer.represent(data) except AttributeError: # nprint(dir(dumper._representer)) raise # def teardown_input(self): # pass # # def init_input(self): # # set the constructor and parser on YAML() instance # self._yaml.get_constructor_parser(stream) # # def load(self): # if not self._input_inited: # self.init_input() # try: # while self._yaml.constructor.check_data(): # yield self._yaml.constructor.get_data() # finally: # parser.dispose() # try: # self._reader.reset_reader() # type: ignore # except AttributeError: # pass # try: # self._scanner.reset_scanner() # type: ignore # except AttributeError: # pass def yaml_object(yml): # type: (Any) -> Any """ decorator for classes that needs to dump/load objects The tag for such objects is taken from the class attribute yaml_tag (or the class name in lowercase in case unavailable) If methods to_yaml and/or from_yaml are available, these are called for dumping resp. loading, default routines (dumping a mapping of the attributes) used otherwise. """ def yo_deco(cls): # type: (Any) -> Any tag = getattr(cls, 'yaml_tag', '!' + cls.__name__) try: yml.representer.add_representer(cls, cls.to_yaml) except AttributeError: def t_y(representer, data): # type: (Any, Any) -> Any return representer.represent_yaml_object( tag, data, cls, flow_style=representer.default_flow_style ) yml.representer.add_representer(cls, t_y) try: yml.constructor.add_constructor(tag, cls.from_yaml) except AttributeError: def f_y(constructor, node): # type: (Any, Any) -> Any return constructor.construct_yaml_object(node, cls) yml.constructor.add_constructor(tag, f_y) return cls return yo_deco ######################################################################################## def scan(stream, Loader=Loader): # type: (StreamTextType, Any) -> Any """ Scan a YAML stream and produce scanning tokens. """ loader = Loader(stream) try: while loader.scanner.check_token(): yield loader.scanner.get_token() finally: loader._parser.dispose() def parse(stream, Loader=Loader): # type: (StreamTextType, Any) -> Any """ Parse a YAML stream and produce parsing events. """ loader = Loader(stream) try: while loader._parser.check_event(): yield loader._parser.get_event() finally: loader._parser.dispose() def compose(stream, Loader=Loader): # type: (StreamTextType, Any) -> Any """ Parse the first YAML document in a stream and produce the corresponding representation tree. """ loader = Loader(stream) try: return loader.get_single_node() finally: loader.dispose() def compose_all(stream, Loader=Loader): # type: (StreamTextType, Any) -> Any """ Parse all YAML documents in a stream and produce corresponding representation trees. """ loader = Loader(stream) try: while loader.check_node(): yield loader._composer.get_node() finally: loader._parser.dispose() def load(stream, Loader=None, version=None, preserve_quotes=None): # type: (StreamTextType, Any, Optional[VersionType], Any) -> Any """ Parse the first YAML document in a stream and produce the corresponding Python object. """ if Loader is None: warnings.warn(UnsafeLoaderWarning.text, UnsafeLoaderWarning, stacklevel=2) Loader = UnsafeLoader loader = Loader(stream, version, preserve_quotes=preserve_quotes) try: return loader._constructor.get_single_data() finally: loader._parser.dispose() try: loader._reader.reset_reader() except AttributeError: pass try: loader._scanner.reset_scanner() except AttributeError: pass def load_all(stream, Loader=None, version=None, preserve_quotes=None): # type: (Optional[StreamTextType], Any, Optional[VersionType], Optional[bool]) -> Any # NOQA """ Parse all YAML documents in a stream and produce corresponding Python objects. """ if Loader is None: warnings.warn(UnsafeLoaderWarning.text, UnsafeLoaderWarning, stacklevel=2) Loader = UnsafeLoader loader = Loader(stream, version, preserve_quotes=preserve_quotes) try: while loader._constructor.check_data(): yield loader._constructor.get_data() finally: loader._parser.dispose() try: loader._reader.reset_reader() except AttributeError: pass try: loader._scanner.reset_scanner() except AttributeError: pass def safe_load(stream, version=None): # type: (StreamTextType, Optional[VersionType]) -> Any """ Parse the first YAML document in a stream and produce the corresponding Python object. Resolve only basic YAML tags. """ return load(stream, SafeLoader, version) def safe_load_all(stream, version=None): # type: (StreamTextType, Optional[VersionType]) -> Any """ Parse all YAML documents in a stream and produce corresponding Python objects. Resolve only basic YAML tags. """ return load_all(stream, SafeLoader, version) def round_trip_load(stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> Any """ Parse the first YAML document in a stream and produce the corresponding Python object. Resolve only basic YAML tags. """ return load(stream, RoundTripLoader, version, preserve_quotes=preserve_quotes) def round_trip_load_all(stream, version=None, preserve_quotes=None): # type: (StreamTextType, Optional[VersionType], Optional[bool]) -> Any """ Parse all YAML documents in a stream and produce corresponding Python objects. Resolve only basic YAML tags. """ return load_all(stream, RoundTripLoader, version, preserve_quotes=preserve_quotes) def emit( events, stream=None, Dumper=Dumper, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, ): # type: (Any, Optional[StreamType], Any, Optional[bool], Union[int, None], Optional[int], Optional[bool], Any) -> Any # NOQA """ Emit YAML parsing events into a stream. If stream is None, return the produced string instead. """ getvalue = None if stream is None: stream = StringIO() getvalue = stream.getvalue dumper = Dumper( stream, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, ) try: for event in events: dumper.emit(event) finally: try: dumper._emitter.dispose() except AttributeError: raise dumper.dispose() # cyaml if getvalue is not None: return getvalue() enc = None if PY3 else 'utf-8' def serialize_all( nodes, stream=None, Dumper=Dumper, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=enc, explicit_start=None, explicit_end=None, version=None, tags=None, ): # type: (Any, Optional[StreamType], Any, Any, Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Optional[VersionType], Any) -> Any # NOQA """ Serialize a sequence of representation trees into a YAML stream. If stream is None, return the produced string instead. """ getvalue = None if stream is None: if encoding is None: stream = StringIO() else: stream = BytesIO() getvalue = stream.getvalue dumper = Dumper( stream, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, encoding=encoding, version=version, tags=tags, explicit_start=explicit_start, explicit_end=explicit_end, ) try: dumper._serializer.open() for node in nodes: dumper.serialize(node) dumper._serializer.close() finally: try: dumper._emitter.dispose() except AttributeError: raise dumper.dispose() # cyaml if getvalue is not None: return getvalue() def serialize(node, stream=None, Dumper=Dumper, **kwds): # type: (Any, Optional[StreamType], Any, Any) -> Any """ Serialize a representation tree into a YAML stream. If stream is None, return the produced string instead. """ return serialize_all([node], stream, Dumper=Dumper, **kwds) def dump_all( documents, stream=None, Dumper=Dumper, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=enc, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (Any, Optional[StreamType], Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Any, Any, Any, Any, Any) -> Optional[str] # NOQA """ Serialize a sequence of Python objects into a YAML stream. If stream is None, return the produced string instead. """ getvalue = None if top_level_colon_align is True: top_level_colon_align = max([len(str(x)) for x in documents[0]]) if stream is None: if encoding is None: stream = StringIO() else: stream = BytesIO() getvalue = stream.getvalue dumper = Dumper( stream, default_style=default_style, default_flow_style=default_flow_style, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, block_seq_indent=block_seq_indent, top_level_colon_align=top_level_colon_align, prefix_colon=prefix_colon, ) try: dumper._serializer.open() for data in documents: try: dumper._representer.represent(data) except AttributeError: # nprint(dir(dumper._representer)) raise dumper._serializer.close() finally: try: dumper._emitter.dispose() except AttributeError: raise dumper.dispose() # cyaml if getvalue is not None: return getvalue() return None def dump( data, stream=None, Dumper=Dumper, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=enc, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, ): # type: (Any, Optional[StreamType], Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Optional[VersionType], Any, Any) -> Optional[str] # NOQA """ Serialize a Python object into a YAML stream. If stream is None, return the produced string instead. default_style ∈ None, '', '"', "'", '|', '>' """ return dump_all( [data], stream, Dumper=Dumper, default_style=default_style, default_flow_style=default_flow_style, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, block_seq_indent=block_seq_indent, ) def safe_dump_all(documents, stream=None, **kwds): # type: (Any, Optional[StreamType], Any) -> Optional[str] """ Serialize a sequence of Python objects into a YAML stream. Produce only basic YAML tags. If stream is None, return the produced string instead. """ return dump_all(documents, stream, Dumper=SafeDumper, **kwds) def safe_dump(data, stream=None, **kwds): # type: (Any, Optional[StreamType], Any) -> Optional[str] """ Serialize a Python object into a YAML stream. Produce only basic YAML tags. If stream is None, return the produced string instead. """ return dump_all([data], stream, Dumper=SafeDumper, **kwds) def round_trip_dump( data, stream=None, Dumper=RoundTripDumper, default_style=None, default_flow_style=None, canonical=None, indent=None, width=None, allow_unicode=None, line_break=None, encoding=enc, explicit_start=None, explicit_end=None, version=None, tags=None, block_seq_indent=None, top_level_colon_align=None, prefix_colon=None, ): # type: (Any, Optional[StreamType], Any, Any, Any, Optional[bool], Optional[int], Optional[int], Optional[bool], Any, Any, Optional[bool], Optional[bool], Optional[VersionType], Any, Any, Any, Any) -> Optional[str] # NOQA allow_unicode = True if allow_unicode is None else allow_unicode return dump_all( [data], stream, Dumper=Dumper, default_style=default_style, default_flow_style=default_flow_style, canonical=canonical, indent=indent, width=width, allow_unicode=allow_unicode, line_break=line_break, encoding=encoding, explicit_start=explicit_start, explicit_end=explicit_end, version=version, tags=tags, block_seq_indent=block_seq_indent, top_level_colon_align=top_level_colon_align, prefix_colon=prefix_colon, ) # Loader/Dumper are no longer composites, to get to the associated # Resolver()/Representer(), etc., you need to instantiate the class def add_implicit_resolver( tag, regexp, first=None, Loader=None, Dumper=None, resolver=Resolver ): # type: (Any, Any, Any, Any, Any, Any) -> None """ Add an implicit scalar detector. If an implicit scalar value matches the given regexp, the corresponding tag is assigned to the scalar. first is a sequence of possible initial characters or None. """ if Loader is None and Dumper is None: resolver.add_implicit_resolver(tag, regexp, first) return if Loader: if hasattr(Loader, 'add_implicit_resolver'): Loader.add_implicit_resolver(tag, regexp, first) elif issubclass( Loader, (BaseLoader, SafeLoader, ruamel.yaml.loader.Loader, RoundTripLoader) ): Resolver.add_implicit_resolver(tag, regexp, first) else: raise NotImplementedError if Dumper: if hasattr(Dumper, 'add_implicit_resolver'): Dumper.add_implicit_resolver(tag, regexp, first) elif issubclass( Dumper, (BaseDumper, SafeDumper, ruamel.yaml.dumper.Dumper, RoundTripDumper) ): Resolver.add_implicit_resolver(tag, regexp, first) else: raise NotImplementedError # this code currently not tested def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=None, resolver=Resolver): # type: (Any, Any, Any, Any, Any, Any) -> None """ Add a path based resolver for the given tag. A path is a list of keys that forms a path to a node in the representation tree. Keys can be string values, integers, or None. """ if Loader is None and Dumper is None: resolver.add_path_resolver(tag, path, kind) return if Loader: if hasattr(Loader, 'add_path_resolver'): Loader.add_path_resolver(tag, path, kind) elif issubclass( Loader, (BaseLoader, SafeLoader, ruamel.yaml.loader.Loader, RoundTripLoader) ): Resolver.add_path_resolver(tag, path, kind) else: raise NotImplementedError if Dumper: if hasattr(Dumper, 'add_path_resolver'): Dumper.add_path_resolver(tag, path, kind) elif issubclass( Dumper, (BaseDumper, SafeDumper, ruamel.yaml.dumper.Dumper, RoundTripDumper) ): Resolver.add_path_resolver(tag, path, kind) else: raise NotImplementedError def add_constructor(tag, object_constructor, Loader=None, constructor=Constructor): # type: (Any, Any, Any, Any) -> None """ Add an object constructor for the given tag. object_onstructor is a function that accepts a Loader instance and a node object and produces the corresponding Python object. """ if Loader is None: constructor.add_constructor(tag, object_constructor) else: if hasattr(Loader, 'add_constructor'): Loader.add_constructor(tag, object_constructor) return if issubclass(Loader, BaseLoader): BaseConstructor.add_constructor(tag, object_constructor) elif issubclass(Loader, SafeLoader): SafeConstructor.add_constructor(tag, object_constructor) elif issubclass(Loader, Loader): Constructor.add_constructor(tag, object_constructor) elif issubclass(Loader, RoundTripLoader): RoundTripConstructor.add_constructor(tag, object_constructor) else: raise NotImplementedError def add_multi_constructor(tag_prefix, multi_constructor, Loader=None, constructor=Constructor): # type: (Any, Any, Any, Any) -> None """ Add a multi-constructor for the given tag prefix. Multi-constructor is called for a node if its tag starts with tag_prefix. Multi-constructor accepts a Loader instance, a tag suffix, and a node object and produces the corresponding Python object. """ if Loader is None: constructor.add_multi_constructor(tag_prefix, multi_constructor) else: if False and hasattr(Loader, 'add_multi_constructor'): Loader.add_multi_constructor(tag_prefix, constructor) return if issubclass(Loader, BaseLoader): BaseConstructor.add_multi_constructor(tag_prefix, multi_constructor) elif issubclass(Loader, SafeLoader): SafeConstructor.add_multi_constructor(tag_prefix, multi_constructor) elif issubclass(Loader, ruamel.yaml.loader.Loader): Constructor.add_multi_constructor(tag_prefix, multi_constructor) elif issubclass(Loader, RoundTripLoader): RoundTripConstructor.add_multi_constructor(tag_prefix, multi_constructor) else: raise NotImplementedError def add_representer(data_type, object_representer, Dumper=None, representer=Representer): # type: (Any, Any, Any, Any) -> None """ Add a representer for the given type. object_representer is a function accepting a Dumper instance and an instance of the given data type and producing the corresponding representation node. """ if Dumper is None: representer.add_representer(data_type, object_representer) else: if hasattr(Dumper, 'add_representer'): Dumper.add_representer(data_type, object_representer) return if issubclass(Dumper, BaseDumper): BaseRepresenter.add_representer(data_type, object_representer) elif issubclass(Dumper, SafeDumper): SafeRepresenter.add_representer(data_type, object_representer) elif issubclass(Dumper, Dumper): Representer.add_representer(data_type, object_representer) elif issubclass(Dumper, RoundTripDumper): RoundTripRepresenter.add_representer(data_type, object_representer) else: raise NotImplementedError # this code currently not tested def add_multi_representer(data_type, multi_representer, Dumper=None, representer=Representer): # type: (Any, Any, Any, Any) -> None """ Add a representer for the given type. multi_representer is a function accepting a Dumper instance and an instance of the given data type or subtype and producing the corresponding representation node. """ if Dumper is None: representer.add_multi_representer(data_type, multi_representer) else: if hasattr(Dumper, 'add_multi_representer'): Dumper.add_multi_representer(data_type, multi_representer) return if issubclass(Dumper, BaseDumper): BaseRepresenter.add_multi_representer(data_type, multi_representer) elif issubclass(Dumper, SafeDumper): SafeRepresenter.add_multi_representer(data_type, multi_representer) elif issubclass(Dumper, Dumper): Representer.add_multi_representer(data_type, multi_representer) elif issubclass(Dumper, RoundTripDumper): RoundTripRepresenter.add_multi_representer(data_type, multi_representer) else: raise NotImplementedError class YAMLObjectMetaclass(type): """ The metaclass for YAMLObject. """ def __init__(cls, name, bases, kwds): # type: (Any, Any, Any) -> None super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds) if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None: cls.yaml_constructor.add_constructor(cls.yaml_tag, cls.from_yaml) # type: ignore cls.yaml_representer.add_representer(cls, cls.to_yaml) # type: ignore class YAMLObject(with_metaclass(YAMLObjectMetaclass)): # type: ignore """ An object that can dump itself to a YAML stream and load itself from a YAML stream. """ __slots__ = () # no direct instantiation, so allow immutable subclasses yaml_constructor = Constructor yaml_representer = Representer yaml_tag = None # type: Any yaml_flow_style = None # type: Any @classmethod def from_yaml(cls, constructor, node): # type: (Any, Any) -> Any """ Convert a representation node to a Python object. """ return constructor.construct_yaml_object(node, cls) @classmethod def to_yaml(cls, representer, data): # type: (Any, Any) -> Any """ Convert a Python object to a representation node. """ return representer.represent_yaml_object( cls.yaml_tag, data, cls, flow_style=cls.yaml_flow_style )