ruamel.yaml-0.15.34/0000775000175100001440000000000013157452567014602 5ustar anthonusers00000000000000ruamel.yaml-0.15.34/scalarstring.py0000664000175100001440000000421213120661020017617 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals from ruamel.yaml.compat import text_type if False: # MYPY from typing import Text, Any, Dict, List # NOQA __all__ = ["ScalarString", "PreservedScalarString", "SingleQuotedScalarString", "DoubleQuotedScalarString"] class ScalarString(text_type): __slots__ = () def __new__(cls, *args, **kw): # type: (Any, Any) -> Any return text_type.__new__(cls, *args, **kw) # type: ignore def replace(self, old, new, maxreplace=-1): # type: (Any, Any, int) -> Any return type(self)((text_type.replace(self, old, new, maxreplace))) class PreservedScalarString(ScalarString): __slots__ = () style = "|" def __new__(cls, value): # type: (Text) -> Any return ScalarString.__new__(cls, value) class SingleQuotedScalarString(ScalarString): __slots__ = () style = "'" def __new__(cls, value): # type: (Text) -> Any return ScalarString.__new__(cls, value) class DoubleQuotedScalarString(ScalarString): __slots__ = () style = '"' def __new__(cls, value): # type: (Text) -> Any return ScalarString.__new__(cls, value) def preserve_literal(s): # type: (Text) -> Text return PreservedScalarString(s.replace('\r\n', '\n').replace('\r', '\n')) def walk_tree(base): # type: (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 """ from ruamel.yaml.compat import string_types if isinstance(base, dict): for k in base: v = base[k] # type: Text if isinstance(v, string_types) and '\n' in v: base[k] = preserve_literal(v) else: walk_tree(v) elif isinstance(base, list): for idx, elem in enumerate(base): if isinstance(elem, string_types) and '\n' in elem: # type: ignore base[idx] = preserve_literal(elem) # type: ignore else: walk_tree(elem) ruamel.yaml-0.15.34/constructor.py0000644000175100001440000016743713152175206017544 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division import collections import datetime import base64 import binascii import re import sys import types import warnings 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, version_tnf) from ruamel.yaml.comments import * # NOQA from ruamel.yaml.comments import (CommentedMap, CommentedOrderedMap, CommentedSet, CommentedKeySeq, CommentedSeq, TaggedScalar) from ruamel.yaml.scalarstring import * # NOQA from ruamel.yaml.scalarstring import (PreservedScalarString, SingleQuotedScalarString, DoubleQuotedScalarString, ScalarString) from ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt from ruamel.yaml.scalarfloat import ScalarFloat from ruamel.yaml.timestamp import TimeStamp if False: # MYPY from typing import Any, Dict, List, Set, Generator # NOQA __all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor', 'ConstructorError', 'RoundTripConstructor'] 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: (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.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 # type: ignore try: return self.loader._composer # type: ignore except AttributeError: print('slt', type(self)) print('slc', self.loader._composer) # type: ignore print(dir(self)) raise @property def resolver(self): # type: () -> Any if hasattr(self.loader, 'typ'): return self.loader.resolver # type: ignore return self.loader._resolver # type: ignore 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: 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 # type: ignore elif isinstance(node, SequenceNode): constructor = self.__class__.construct_sequence # type: ignore elif isinstance(node, MappingNode): constructor = self.__class__.construct_mapping # type: ignore 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) # type: ignore if self.deep_construct: for dummy in generator: # type: ignore 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 = {} 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 = {} # 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, collections.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, collections.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: self.check_mapping_key(node, key_node, mapping, key, value) 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) -> None if key in mapping: if not self.allow_duplicate_keys: args = [ "while constructing a mapping", node.start_mark, 'found duplicate key "{}" with value "{}" ' '(original value: "{}")'.format( key, value, mapping.get(key)), key_node.start_mark, """ To suppress this check see: http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys """, """\ Duplicate keys will become and 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': 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, 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 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 = re.compile( 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 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 = [] # type: List[Any] yield data data.extend(self.construct_sequence(node)) def construct_yaml_map(self, node): # type: (Any) -> Any data = {} # 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: module_name, object_name = name.rsplit('.', 1) else: module_name = builtins_module object_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] if not hasattr(module, object_name): raise ConstructorError( "while constructing a Python object", mark, "cannot find %r in the module %r" % (utf8(object_name), module.__name__), mark) return getattr(module, object_name) 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) 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): return PreservedScalarString(node.value) elif bool(self._preserve_quotes) and isinstance(node.value, text_type): if node.style == "'": return SingleQuotedScalarString(node.value) if node.style == '"': return DoubleQuotedScalarString(node.value) 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, # type: ignore underscore=underscore) 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) 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, # type: ignore underscore=underscore) 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), # type: ignore 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, # type: ignore underscore=underscore) 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 '+-' # print('sf', width, prec, m_sign, exp, e_width, e_sign) return ScalarFloat(sign * float(value_s), # type: ignore width=width, prec=prec, m_sign=m_sign, m_lead0=lead0, exp=exp, e_width=e_width, e_sign=e_sign) 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), # type: ignore width=width, prec=prec, m_sign=m_sign, m_lead0=lead0) 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 = [] index = 0 while index < len(node.value): key_node, value_node = node.value[index] if key_node.tag == u'tag:yaml.org,2002:merge': 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=None, 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]) # type: ignore if len(node.comment) > 2: maptyp.yaml_end_comment_extend(node.comment[2], clear=True) # type: ignore 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, collections.Hashable): if isinstance(key, list): key_a = CommentedKeySeq(key) if key_node.flow_style is True: key_a.fa.set_flow_style() elif key_node.flow_style is False: key_a.fa.set_block_style() key = key_a # 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, collections.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) 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) # type: ignore key_node.comment = None if key_node.comment: maptyp._yaml_add_comment(key_node.comment, key=key) # type: ignore if value_node.comment: maptyp._yaml_add_comment(value_node.comment, value=key) # type: ignore maptyp._yaml_set_kv_line_col( # type: ignore key, [key_node.start_mark.line, key_node.start_mark.column, value_node.start_mark.line, value_node.start_mark.column]) maptyp[key] = value # type: ignore 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) # type: ignore 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, collections.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, collections.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_mapping_key(node, key_node, typ, key, value) 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.flow_style is True: data.fa.set_flow_style() elif node.flow_style is False: data.fa.set_block_style() if node.comment: data._yaml_add_comment(node.comment) yield data data.extend(self.construct_rt_sequence(node, data)) def construct_yaml_map(self, node): # type: (Any) -> Any 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() yield data self.construct_mapping(node, data) 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 self.construct_mapping(node, data) return elif isinstance(node, ScalarNode): data = TaggedScalar() data.value = self.construct_scalar(node) data.style = node.style data.yaml_set_tag(node.tag) yield data return except: 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 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.34/compat.py0000664000175100001440000001137513142547771016442 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function # partially from package six by Benjamin Peterson import sys import os import types if False: # MYPY from typing import Any, Dict, Optional, List, Union, BinaryIO, IO, Text, Tuple # NOQA _DEFAULT_YAML_VERSION = (1, 2) try: from ruamel.ordereddict import ordereddict except: 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: 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 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 if False: # MYPY # StreamType = Union[BinaryIO, IO[str], IO[unicode], StringIO] StreamType = Union[BinaryIO, IO[str], StringIO] StreamTextType = Union[Text, StreamType] VersionType = Union[List[int], str, Tuple[int, int]] if PY3: builtins_module = 'builtins' else: builtins_module = '__builtin__' 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: Union[None, 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): print(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 def nprint(*args, **kw): # type: (Any, Any) -> None if bool(dbg): print(*args, **kw) # 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'\xD7FF': return True if (u'\xE000' <= ch <= u'\xFFFD') and ch != u'\xFEFF': # excl. byte order mark return True if u'\x10000' <= ch <= u'\x10FFFF': 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 ruamel.yaml-0.15.34/PKG-INFO0000664000175100001440000003401513157452567015702 0ustar anthonusers00000000000000Metadata-Version: 1.1 Name: ruamel.yaml Version: 0.15.34 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. 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 infomormation 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 ChangeLog ========= .. should insert NEXT: at the beginning of line for next key 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.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Programming Language :: Python :: Implementation :: Jython Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Processing :: Markup ruamel.yaml-0.15.34/CHANGES0000664000175100001440000004673313157452247015605 0ustar anthonusers00000000000000[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.34/emitter.py0000644000175100001440000016025413152176270016620 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 from ruamel.yaml.compat import utf8, text_type, PY2, nprint, dbg, DBG_EVENT, \ check_anchorname_char if False: # MYPY from typing import Any, Dict, List, Union, Text, Tuple # 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): DEFAULT_TAG_PREFIXES = { u'!': u'!', u'tag:yaml.org,2002:': u'!!', } 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, dumper=None): # type: (StreamType, Any, int, int, bool, Any, int, bool, Any, Any) -> None 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: Union[None, 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: Union[None, int] # Flow level. self.flow_level = 0 # 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.no_newline = None # type: Union[None, 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 # 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 # type: ignore return self.dumper._serializer # type: ignore except AttributeError: return self # cyaml 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, 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)): self.process_anchor(u'&') self.process_tag() if isinstance(self.event, ScalarEvent): self.expect_scalar() elif isinstance(self.event, SequenceStartEvent): 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): self.indention = False self.no_newline = True 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() 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_level += 1 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() self.flow_level -= 1 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) else: 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() self.flow_level -= 1 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): # type: () -> None ind = self.indents.seq_flow_align(self.best_sequence_indent, self.column) self.write_indicator(u' ' * ind + u'{', True, whitespace=True) self.flow_level += 1 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() self.flow_level -= 1 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) 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() self.flow_level -= 1 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 mapping self.write_post_comment(self.event) 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 indentless = (self.mapping_context and not self.indention) 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 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]: 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 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): # sequence keys if self.event.style == '?': self.write_indicator(u'?', True, indention=True) self.states.append(self.expect_block_mapping_simple_value) self.expect_node(mapping=True, simple_key=True) 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 == u'') 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, 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) -> None if self.event.anchor is None: self.prepared_anchor = None return 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 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() 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) 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 u''.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 = u''.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 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 hints = u'' if text: if text[0] in u' \n\x85\u2028\u2029': hints += text_type(self.best_sequence_indent) if text[-1] not in u'\n\x85\u2028\u2029': hints += u'-' elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029': hints += u'+' return hints def write_folded(self, text): # type: (Any) -> None hints = self.determine_block_hints(text) self.write_indicator(u'>' + hints, True) if hints[-1:] == 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': 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': data = text[start:end] self.column += len(data) 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') spaces = (ch == u' ') end += 1 def write_literal(self, text): # type: (Any) -> None hints = self.determine_block_hints(text) self.write_indicator(u'|' + hints, True) if hints[-1:] == 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 and (not self.root_context or self.requested_indent): 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: print(repr(data)) 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): # type: (Any) -> None value = comment.value # print('{:02d} {:02d} {!r}'.format(self.column, comment.start_mark.column, value)) if value[-1] == '\n': value = value[:-1] try: # get original column position col = comment.start_mark.column if col < self.column + 1: ValueError except ValueError: col = self.column + 1 # print('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 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) if isinstance(event, start_events): comment.pre_done = True except TypeError: print('eventtt', 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.34/scalarint.py0000664000175100001440000000577513140151720017125 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals if False: # MYPY from typing import Text, Any, Dict, List # NOQA __all__ = ["ScalarInt", "BinaryInt", "OctalInt", "HexInt", "HexCapsInt"] from .compat import no_limit_int # NOQA 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 v = no_limit_int.__new__(cls, *args, **kw) # type: ignore v._width = width v._underscore = underscore return v def __iadd__(self, a): # type: ignore # type: (Any) -> Any x = type(self)(self + a) x._width = self._width # type: ignore x._underscore = 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 = 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 = 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 = 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 = self._underscore[:] if self._underscore is not None else None # type: ignore # NOQA return x class BinaryInt(ScalarInt): def __new__(cls, value, width=None, underscore=None): # type: (Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore) class OctalInt(ScalarInt): def __new__(cls, value, width=None, underscore=None): # type: (Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore) # 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): # type: (Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore) class HexCapsInt(ScalarInt): """uses upper case (A-F)""" def __new__(cls, value, width=None, underscore=None): # type: (Any, Any, Any) -> Any return ScalarInt.__new__(cls, value, width=width, underscore=underscore) ruamel.yaml-0.15.34/composer.py0000644000175100001440000001776313146573373017014 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import from __future__ import print_function import warnings from ruamel.yaml.error import MarkedYAMLError, ReusedAnchorWarning from ruamel.yaml.compat import utf8 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 # type: ignore return self.loader._parser # type: ignore @property def resolver(self): # type: () -> Any # assert self.loader._resolver is not None if hasattr(self.loader, 'typ'): self.loader.resolver # type: ignore return self.loader._resolver # type: ignore 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) 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: print('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.34/events.py0000664000175100001440000000722513076065701016454 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', def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None, flow_style=None, comment=None): # type: (Any, Any, Any, Any, Any, Any, Any) -> None NodeEvent.__init__(self, anchor, start_mark, end_mark, comment) self.tag = tag self.implicit = implicit self.flow_style = flow_style 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.34/setup.py0000664000175100001440000010330113157452246016304 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 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, ): open_kw = dict() else: open_kw = dict(encoding='utf-8') if sys.version_info < (2, 7) or platform.python_implementation() == 'Jython': class Set(): pass 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. """ _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, 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(u'_package_data'): if 'dict(' in line: parsing = 'python' lines.append(u'dict(\n') elif line.endswith(u'= {\n'): parsing = 'python' lines.append(u'{\n') else: raise NotImplementedError continue if not parsing: continue if parsing == 'python': if line.startswith(u')') or line.startswith(u'}'): lines.append(line) try: data = literal_eval(u''.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(u"{0:{1}}: {2}".format(index, w, line).encode('utf-8'), end=u'') if index == e.lineno - 1: print(u"{0:{1}} {2}^--- {3}".format( u' ', w, u' ' * 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 that start with "_" or ".", or contain a setup.py/tox.ini (indicating a subpackage) """ 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 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): 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] 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 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 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'] @property def author_email(self): return self._pkg_data['author_email'] @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'] @property def status(self): # αβ status = self._pkg_data.get('status', u'β').lower() if status in [u'α', u'alpha']: return (3, 'Alpha') elif status in [u'β', u'beta']: return (4, 'Beta') elif u'stable' in status.lower(): return (5, 'Production/Stable') raise NotImplementedError @property def classifiers(self): return [ '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') if not df: return {} return {self.full_package_name: df} @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')], ) if 'test' not in target: # no test just hope it works 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: print('compile error:', file_name) continue except LinkError: print('libyaml link error', file_name) continue self._ext_modules.append(ext) except Exception as e: # NOQA print('Exception:', e) pass finally: shutil.rmtree(tmp_dir) return self._ext_modules 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 file_name = 'setup.cfg' if os.path.exists(file_name): # add it if not in there? return 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: 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.split, 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, ) 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 dump_kw in sys.argv: sys.argv.remove(dump_kw) try: with open('README.rst') as fp: kw['long_description'] = fp.read() except: pass if nsp.wheel(kw, setup): 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) with InMemoryZipFile(full_name) as imz: imz.delete_from_zip_file(nsp.full_package_name + '.*.pth') break main() ruamel.yaml-0.15.34/representer.py0000644000175100001440000012754013157451360017507 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.scalarstring import (PreservedScalarString, SingleQuotedScalarString, DoubleQuotedScalarString) from ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt from ruamel.yaml.scalarfloat import ScalarFloat 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 # NOQA __all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', 'RepresenterError', 'RoundTripRepresenter'] 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: Union[None, int] @property def serializer(self): # type: () -> Any try: if hasattr(self.dumper, 'typ'): return self.dumper.serializer # type: ignore return self.dumper._serializer # type: ignore 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): # type: (Any, Any, Any) -> Any if style is None: style = self.default_style node = ScalarNode(tag, value, style=style) 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()) 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): # type: (Any) -> Any try: value = self.dumper.boolean_representation[bool(data)] # type: ignore except AttributeError: if data: value = u'true' else: value = u'false' return self.represent_scalar(u'tag:yaml.org,2002:bool', value) 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 name = u'%s.%s' % (data.__module__, data.__name__) return self.represent_scalar(u'tag:yaml.org,2002:python/name:' + name, u'') def represent_module(self, data): # type: (Any) -> Any return self.represent_scalar( u'tag:yaml.org,2002:python/module:' + data.__name__, u'') 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 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) from ruamel.yaml.comments import (CommentedMap, CommentedOrderedMap, CommentedSeq, CommentedKeySeq, 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 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', u'') def represent_preserved_scalarstring(self, data): # type: (Any) -> Any tag = None style = '|' 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) def represent_single_quoted_scalarstring(self, data): # type: (Any) -> Any tag = None style = "'" 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) def represent_double_quoted_scalarstring(self, data): # type: (Any) -> Any tag = None style = '"' 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) def insert_underscore(self, prefix, s, underscore): # type: (Any, Any, Any) -> Any if underscore is None: return self.represent_scalar(u'tag:yaml.org,2002:int', prefix + s) 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) 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') return self.insert_underscore('', s, data._underscore) 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') return self.insert_underscore('0b', s, data._underscore) 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') return self.insert_underscore('0o', s, data._underscore) 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') return self.insert_underscore('0x', s, data._underscore) 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') return self.insert_underscore('0x', s, data._underscore) def represent_scalar_float(self, data): # type: (Any) -> Any """ this is way more complicated """ value = None 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) 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 u'', abs(int(data))) elif data._exp is None: # no exponent, "normal" dot prec = data._prec if prec < 1: prec = 1 # print('dw2', data._width, prec) ms = data._m_sign if data._m_sign else u'' # -1 for the dot value = u'{}{:0{}.{}f}'.format(ms, abs(data), data._width - len(ms), data._width - prec - 1) while len(value) < data._width: value += u'0' else: # exponent m, es = u'{:{}e}'.format(data, data._width).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 u'' if data._prec < 0: # mantissa without dot if m2 != u'0': e -= len(m2) else: m2 = u'' 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) 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) node_item.comment = 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 self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style 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) 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, [])] if bool(merge_list): items = mapping.non_merged_items() else: items = mapping.items() for item_key, item_value in items: 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 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(0, (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_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): try: tag = data.tag.value except AttributeError: tag = None return self.represent_scalar(tag, data.value, style=data.style) RoundTripRepresenter.add_representer(type(None), RoundTripRepresenter.represent_none) RoundTripRepresenter.add_representer( PreservedScalarString, RoundTripRepresenter.represent_preserved_scalarstring) RoundTripRepresenter.add_representer( SingleQuotedScalarString, RoundTripRepresenter.represent_single_quoted_scalarstring) RoundTripRepresenter.add_representer( DoubleQuotedScalarString, RoundTripRepresenter.represent_double_quoted_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(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.34/__init__.py0000664000175100001440000000475113157452266016716 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, 34), __version__='0.15.34', 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='#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.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', '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', windows_wheels=True, read_the_docs='yaml', many_linux='libyaml-devel', supported=[(2, 7), (3, 3)], # minimum tox=dict( env='*p', deps='ruamel.std.pathlib', fl8excl='_test/lib', ), rtfd=47359, ) # 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.34/LICENSE0000664000175100001440000000214113157452246015577 0ustar anthonusers00000000000000 The MIT License (MIT) Copyright (c) 2014-2017 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.34/parser.py0000664000175100001440000007704313146551004016443 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 # 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'): self.loader.scanner return self.loader._scanner @property def resolver(self): # type: () -> Any if hasattr(self.loader, 'typ'): 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): end_mark = self.scanner.peek_token().end_mark event = MappingStartEvent( anchor, tag, implicit, start_mark, end_mark, flow_style=True) 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), u'', 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 # print('>>>> tk', type(self), next_token, getattr(next_token, 'comment', None)) 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 # pt = self.scanner.peek_token() # print('pt', pt) 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: comment = self.scanner.peek_token().comment 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), u'', 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.34/cyaml.py0000664000175100001440000001424713141537312016252 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 # 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, VersionType, 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, VersionType, 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, VersionType, 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, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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 # type: ignore 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, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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.34/reader.py0000664000175100001440000002224513133364047016410 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 import re from ruamel.yaml.error import YAMLError, FileMark, StringMark, YAMLStreamError from ruamel.yaml.compat import text_type, binary_type, PY3 if False: # MYPY from typing import Any, Dict, Optional, List, Union, Text # 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: (StreamTextType, 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 = u'' self.pointer = 0 self.raw_buffer = None # type: Any self.raw_decode = None self.encoding = None # type: Union[None, 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' 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(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 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) # 4 if 32 bit unicode supported, 2 e.g. on MacOS (issue 56) try: NON_PRINTABLE = re.compile( u'[^\x09\x0A\x0D\x20-\x7E\x85' u'\xA0-\uD7FF' u'\uE000-\uFFFD' u'\U00010000-\U0010FFFF' u']' ) UNICODE_SIZE = 4 except: NON_PRINTABLE = re.compile( u'[^\x09\x0A\x0D\x20-\x7E\x85' u'\xA0-\uD7FF' u'\uE000-\uFFFD' u']' ) UNICODE_SIZE = 2 def check_printable(self, data): # type: (Any) -> None match = self.NON_PRINTABLE.search(data) if bool(match): character = match.group() position = self.index + (len(self.buffer) - self.pointer) + match.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 += u'\0' self.raw_buffer = None break def update_raw(self, size=None): # type: (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.34/error.py0000664000175100001440000002045213141535773016302 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) # type: ignore 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) # type: ignore lines.append(note) if self.warn is not None and self.warn: warn = textwrap.dedent(self.warn) # type: ignore 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) # type: ignore lines.append(note) if self.warn is not None and self.warn: warn = textwrap.dedent(self.warn) # type: ignore lines.append(warn) return '\n'.join(lines) ruamel.yaml-0.15.34/timestamp.py0000664000175100001440000000144513076065362017154 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals import datetime import copy 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.34/README.rst0000664000175100001440000002533513157452247016274 0ustar anthonusers00000000000000 ruamel.yaml =========== ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python. 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 infomormation 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 ChangeLog ========= .. should insert NEXT: at the beginning of line for next key 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.34/configobjwalker.py0000664000175100001440000000052613076065072020314 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.34/dumper.py0000664000175100001440000001450113113253336016432 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 # 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, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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: (Any, StreamType, Any, Any, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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: (Any, StreamType, Any, Any, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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: (Any, StreamType, Any, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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.34/nodes.py0000644000175100001440000000666513146542335016266 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function 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): # type: (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 = None 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): print('{}{}(tag={!r}, value={!r})'.format( ' ' * indent, self.__class__.__name__, self.tag, self.value)) if self.comment: print(' {}comment: {})'.format( ' ' * indent, self.comment)) return print('{}{}(tag={!r})'.format( ' ' * indent, self.__class__.__name__, self.tag)) if self.comment: print(' {}comment: {})'.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: print('Node value type?', 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): # type: (Any, Any, Any, Any, Any, Any) -> None Node.__init__(self, tag, value, start_mark, end_mark, comment=comment) self.style = style class CollectionNode(Node): __slots__ = 'flow_style', 'anchor', 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.34/ext/0000775000175100001440000000000013157452567015402 5ustar anthonusers00000000000000ruamel.yaml-0.15.34/ext/_ruamel_yaml.pxd0000664000175100001440000002165013037504357020561 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.34/ext/dumper.c0000664000175100001440000002347413037504357017044 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_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(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.34/ext/_ruamel_yaml.h0000664000175100001440000000073413037504357020215 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.34/ext/_ruamel_yaml.pyx0000664000175100001440000017643113070654661020617 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.34/ext/loader.c0000664000175100001440000002717113070654661017015 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, INITIAL_STACK_SIZE)) 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, INITIAL_STACK_SIZE)) 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, INITIAL_STACK_SIZE)) 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, INITIAL_STACK_SIZE)) 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.34/ext/_ruamel_yaml.c0000664000175100001440000431136713070654661020224 0ustar anthonusers00000000000000/* Generated by Cython 0.23.2 */ #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 < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else #define CYTHON_ABI "0_23_2" #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 #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_CPYTHON 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif #if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 #define CYTHON_USE_PYLONG_INTERNALS 1 #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 > 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_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) #else #define CYTHON_PEP393_ENABLED 0 #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_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])) #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 #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 #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_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #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 #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #else #define __Pyx_PyType_AsAsync(obj) NULL #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 #define __Pyx_void_to_None(void_result) (void_result, Py_INCREF(Py_None), Py_None) #ifndef CYTHON_INLINE #if 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 PY_MAJOR_VERSION >= 3 #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 #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 */ #ifdef PYREX_WITHOUT_ASSERTIONS #define CYTHON_WITHOUT_ASSERTIONS #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_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif typedef struct {PyObject **p; 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 (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (_MSC_VER) && defined (_M_X64) #define __Pyx_sst_abs(value) _abs64(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 char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE 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_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((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) #if PY_MAJOR_VERSION < 3 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); } #else #define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen #endif #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_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_COMPILING_IN_CPYTHON #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 && __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 PyObject *__pyx_m; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; 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", }; /*--- 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) --- */ #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) #if CYTHON_COMPILING_IN_CPYTHON 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 static PyObject *__Pyx_GetBuiltinName(PyObject *name); 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); static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #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 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); 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)); } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); #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 static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); #if CYTHON_COMPILING_IN_CPYTHON 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 #if CYTHON_COMPILING_IN_CPYTHON #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 static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); #include static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif #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 CYTHON_INLINE 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); static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); static CYTHON_INLINE int __Pyx_IterFinish(void); static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); static int __Pyx_SetVtable(PyObject *dict, void *vtable); static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); typedef struct { int code_line; PyCodeObject* code_object; } __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); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); static int __Pyx_check_binary_version(void); 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*/ #define __Pyx_MODULE_NAME "_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 char __pyx_k__3[] = "?"; static char __pyx_k__6[] = ""; static char __pyx_k__7[] = "'"; static char __pyx_k__8[] = "\""; static char __pyx_k__9[] = "|"; static char __pyx_k_TAG[] = "TAG"; static char __pyx_k__10[] = ">"; static char __pyx_k__17[] = "\r"; static char __pyx_k__18[] = "\n"; static char __pyx_k__19[] = "\r\n"; static char __pyx_k_tag[] = "tag"; static char __pyx_k_YAML[] = "YAML"; static char __pyx_k_file[] = ""; static char __pyx_k_line[] = "line"; static char __pyx_k_main[] = "__main__"; static char __pyx_k_name[] = "name"; static char __pyx_k_read[] = "read"; static char __pyx_k_tags[] = "tags"; static char __pyx_k_test[] = "__test__"; static char __pyx_k_class[] = "__class__"; static char __pyx_k_index[] = "index"; static char __pyx_k_major[] = "major"; static char __pyx_k_minor[] = "minor"; static char __pyx_k_patch[] = "patch"; static char __pyx_k_style[] = "style"; static char __pyx_k_utf_8[] = "utf-8"; static char __pyx_k_value[] = "value"; static char __pyx_k_width[] = "width"; static char __pyx_k_write[] = "write"; static char __pyx_k_anchor[] = "anchor"; static char __pyx_k_buffer[] = "buffer"; static char __pyx_k_column[] = "column"; static char __pyx_k_id_03d[] = "id%03d"; static char __pyx_k_import[] = "__import__"; static char __pyx_k_indent[] = "indent"; static char __pyx_k_stream[] = "stream"; static char __pyx_k_strict[] = "strict"; static char __pyx_k_pointer[] = "pointer"; static char __pyx_k_resolve[] = "resolve"; static char __pyx_k_version[] = "version"; static char __pyx_k_KeyToken[] = "KeyToken"; static char __pyx_k_TagToken[] = "TagToken"; static char __pyx_k_encoding[] = "encoding"; static char __pyx_k_end_mark[] = "end_mark"; static char __pyx_k_explicit[] = "explicit"; static char __pyx_k_implicit[] = "implicit"; static char __pyx_k_TypeError[] = "TypeError"; static char __pyx_k_YAMLError[] = "YAMLError"; static char __pyx_k_canonical[] = "canonical"; static char __pyx_k_utf_16_be[] = "utf-16-be"; static char __pyx_k_utf_16_le[] = "utf-16-le"; static char __pyx_k_AliasEvent[] = "AliasEvent"; static char __pyx_k_AliasToken[] = "AliasToken"; static char __pyx_k_ScalarNode[] = "ScalarNode"; static char __pyx_k_ValueError[] = "ValueError"; static char __pyx_k_ValueToken[] = "ValueToken"; static char __pyx_k_flow_style[] = "flow_style"; static char __pyx_k_line_break[] = "line_break"; static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static char __pyx_k_start_mark[] = "start_mark"; static char __pyx_k_AnchorToken[] = "AnchorToken"; static char __pyx_k_MappingNode[] = "MappingNode"; static char __pyx_k_MemoryError[] = "MemoryError"; static char __pyx_k_ParserError[] = "ParserError"; static char __pyx_k_ReaderError[] = "ReaderError"; static char __pyx_k_ScalarEvent[] = "ScalarEvent"; static char __pyx_k_ScalarToken[] = "ScalarToken"; static char __pyx_k_byte_string[] = ""; static char __pyx_k_get_version[] = "get_version"; static char __pyx_k_ruamel_yaml[] = "_ruamel_yaml"; static char __pyx_k_EmitterError[] = "EmitterError"; static char __pyx_k_ScannerError[] = "ScannerError"; static char __pyx_k_SequenceNode[] = "SequenceNode"; static char __pyx_k_explicit_end[] = "explicit_end"; static char __pyx_k_BlockEndToken[] = "BlockEndToken"; static char __pyx_k_ComposerError[] = "ComposerError"; static char __pyx_k_allow_unicode[] = "allow_unicode"; static char __pyx_k_too_many_tags[] = "too many tags"; static char __pyx_k_AttributeError[] = "AttributeError"; static char __pyx_k_DirectiveToken[] = "DirectiveToken"; static char __pyx_k_FlowEntryToken[] = "FlowEntryToken"; static char __pyx_k_StreamEndEvent[] = "StreamEndEvent"; static char __pyx_k_StreamEndToken[] = "StreamEndToken"; static char __pyx_k_explicit_start[] = "explicit_start"; static char __pyx_k_unicode_string[] = ""; static char __pyx_k_BlockEntryToken[] = "BlockEntryToken"; static char __pyx_k_MappingEndEvent[] = "MappingEndEvent"; static char __pyx_k_SerializerError[] = "SerializerError"; static char __pyx_k_ascend_resolver[] = "ascend_resolver"; static char __pyx_k_invalid_event_s[] = "invalid event %s"; static char __pyx_k_no_parser_error[] = "no parser error"; static char __pyx_k_ConstructorError[] = "ConstructorError"; static char __pyx_k_DocumentEndEvent[] = "DocumentEndEvent"; static char __pyx_k_DocumentEndToken[] = "DocumentEndToken"; static char __pyx_k_RepresenterError[] = "RepresenterError"; static char __pyx_k_SequenceEndEvent[] = "SequenceEndEvent"; static char __pyx_k_StreamStartEvent[] = "StreamStartEvent"; static char __pyx_k_StreamStartToken[] = "StreamStartToken"; static char __pyx_k_descend_resolver[] = "descend_resolver"; static char __pyx_k_no_emitter_error[] = "no emitter error"; static char __pyx_k_second_occurrence[] = "second occurrence"; static char __pyx_k_MappingStartEvent[] = "MappingStartEvent"; static char __pyx_k_ruamel_yaml_error[] = "ruamel.yaml.error"; static char __pyx_k_ruamel_yaml_nodes[] = "ruamel.yaml.nodes"; static char __pyx_k_DocumentStartEvent[] = "DocumentStartEvent"; static char __pyx_k_DocumentStartToken[] = "DocumentStartToken"; static char __pyx_k_SequenceStartEvent[] = "SequenceStartEvent"; static char __pyx_k_get_version_string[] = "get_version_string"; static char __pyx_k_ruamel_yaml_events[] = "ruamel.yaml.events"; static char __pyx_k_ruamel_yaml_parser[] = "ruamel.yaml.parser"; static char __pyx_k_ruamel_yaml_reader[] = "ruamel.yaml.reader"; static char __pyx_k_ruamel_yaml_tokens[] = "ruamel.yaml.tokens"; static char __pyx_k_unknown_event_type[] = "unknown event type"; static char __pyx_k_unknown_token_type[] = "unknown token type"; static char __pyx_k_FlowMappingEndToken[] = "FlowMappingEndToken"; static char __pyx_k_ruamel_yaml_emitter[] = "ruamel.yaml.emitter"; static char __pyx_k_ruamel_yaml_scanner[] = "ruamel.yaml.scanner"; static char __pyx_k_FlowSequenceEndToken[] = "FlowSequenceEndToken"; static char __pyx_k_in_s_line_d_column_d[] = " in \"%s\", line %d, column %d"; static char __pyx_k_ruamel_yaml_composer[] = "ruamel.yaml.composer"; static char __pyx_k_serializer_is_closed[] = "serializer is closed"; static char __pyx_k_tag_must_be_a_string[] = "tag must be a string"; static char __pyx_k_FlowMappingStartToken[] = "FlowMappingStartToken"; static char __pyx_k_found_undefined_alias[] = "found undefined alias"; static char __pyx_k_BlockMappingStartToken[] = "BlockMappingStartToken"; static char __pyx_k_FlowSequenceStartToken[] = "FlowSequenceStartToken"; static char __pyx_k_ruamel_yaml_serializer[] = "ruamel.yaml.serializer"; static char __pyx_k_value_must_be_a_string[] = "value must be a string"; static char __pyx_k_BlockSequenceStartToken[] = "BlockSequenceStartToken"; static char __pyx_k_anchor_must_be_a_string[] = "anchor must be a string"; static char __pyx_k_ruamel_yaml_constructor[] = "ruamel.yaml.constructor"; static char __pyx_k_ruamel_yaml_representer[] = "ruamel.yaml.representer"; static char __pyx_k_serializer_is_not_opened[] = "serializer is not opened"; static char __pyx_k_a_string_value_is_expected[] = "a string value is expected"; static char __pyx_k_but_found_another_document[] = "but found another document"; static char __pyx_k_tag_handle_must_be_a_string[] = "tag handle must be a string"; static char __pyx_k_tag_prefix_must_be_a_string[] = "tag prefix must be a string"; static char __pyx_k_serializer_is_already_opened[] = "serializer is already opened"; static char __pyx_k_home_avdndata_hg_ruamel_eu_src[] = "/home/avdndata/hg/ruamel.eu/src/site-packages/ruamel/yaml/ext/_ruamel_yaml.pyx"; static char __pyx_k_a_string_or_stream_input_is_requ[] = "a string or stream input is required"; static char __pyx_k_expected_a_single_document_in_th[] = "expected a single document in the stream"; static char __pyx_k_found_duplicate_anchor_first_occ[] = "found duplicate anchor; first occurrence"; 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_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_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__17; static PyObject *__pyx_kp_s__18; static PyObject *__pyx_kp_s__19; 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_column; static PyObject *__pyx_n_s_descend_resolver; 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_kp_s_home_avdndata_hg_ruamel_eu_src; 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_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_pointer; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_read; 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_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_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_start_mark; static PyObject *__pyx_n_s_stream; 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_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 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 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_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_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__20; static PyObject *__pyx_tuple__21; 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__74; static PyObject *__pyx_codeobj__73; static PyObject *__pyx_codeobj__75; /* "_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 7; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_minor); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_patch); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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); case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); 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; 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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } 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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } 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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } 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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } 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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_line = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_line == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_column = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_column == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 71; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __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; } /* "_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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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); 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_filename = __pyx_f[0]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __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_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_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __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_L11_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 = 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_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __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_L11_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_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __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_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_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L15_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_L22_try_end; __pyx_L15_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 = 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_filename = __pyx_f[0]; __pyx_lineno = 276; __pyx_clineno = __LINE__; goto __pyx_L17_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_L25; } /* "_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_L25:; __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_L16_exception_handled; } goto __pyx_L17_except_error; __pyx_L17_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_L16_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_L22_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_L14; } /* "_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_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __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_L27; } /* "_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_L27:; /* "_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_L26; } /* "_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_L28; } /* "_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_L28:; } __pyx_L26:; /* "_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_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 302; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 302; __pyx_clineno = __LINE__; goto __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_L14:; /* "_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 = PyDict_New(); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 307; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_9 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = PyUnicode_FromString(__pyx_v_self->parser.problem); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_7 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __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":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_SCANNER_ERROR: 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_filename = __pyx_f[0]; __pyx_lineno = 332; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 334; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 331; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 331; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 338; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 336; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 336; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 347; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_7 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_5 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 355; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 355; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 357; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 357; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 381; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 386; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 386; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 394; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 409; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 409; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 409; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 413; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 417; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 423; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 423; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 423; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 425; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 425; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 425; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 429; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 429; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 429; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 433; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 433; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 433; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 435; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 435; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 435; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 445; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 445; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 445; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 454; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __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, __pyx_k_strict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 459; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_plain); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(5+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 492; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 497; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 503; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 503; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 515; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 516; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 517; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 529; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 530; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_6; yaml_tag_directive_t *__pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 539; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 542; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 543; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 541; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 541; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 567; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __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 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 570; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 573; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 574; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 575; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 578; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_8 = PyTuple_New(5+__pyx_t_6); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 583; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_explicit); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 583; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_2 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 583; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 583; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 586; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_8 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 586; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 586; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 590; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __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, __pyx_k_strict); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_quoted_implicit); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_8 = PyTuple_New(7+__pyx_t_6); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 619; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(6+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 639; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_2 = PyTuple_New(6+__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 656; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 656; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 658; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 658; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 690; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 703; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 706; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 712; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 716; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_7 = 1; } } __pyx_t_8 = PyTuple_New(4+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __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_kp_s_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_kp_s_expected_a_single_document_in_th); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_kp_s_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __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_8, 2+__pyx_t_7, __pyx_kp_s_but_found_another_document); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_7, ((PyObject *)__pyx_v_mark)); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 718; __pyx_clineno = __LINE__; goto __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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_document, __pyx_n_s_start_mark); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 719; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_7 = 1; } } __pyx_t_3 = PyTuple_New(4+__pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 718; __pyx_clineno = __LINE__; goto __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_7, __pyx_kp_u_expected_a_single_document_in_th); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_t_8); __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_7, __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_7, ((PyObject *)__pyx_v_mark)); __pyx_t_8 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 718; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 718; __pyx_clineno = __LINE__; goto __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_8); __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 724; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 725; __pyx_clineno = __LINE__; goto __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 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 727; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 733; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 734; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 736; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 737; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 738; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 741; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_8 = 1; } } __pyx_t_3 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 741; __pyx_clineno = __LINE__; goto __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_8, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_8, 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_8, __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_8, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 741; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 741; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 743; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_8 = 1; } } __pyx_t_5 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 743; __pyx_clineno = __LINE__; goto __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_8, Py_None); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_8, 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_8, __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_8, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 743; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 743; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 745; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 749; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 757; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 760; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 764; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 765; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 765; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_9 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 764; __pyx_clineno = __LINE__; goto __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_kp_s_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_kp_s_found_duplicate_anchor_first_occ); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_kp_s_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_kp_s_second_occurrence); __Pyx_GIVEREF(__pyx_kp_s_second_occurrence); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_s_second_occurrence); __Pyx_INCREF(((PyObject *)__pyx_v_mark)); __Pyx_GIVEREF(((PyObject *)__pyx_v_mark)); PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, ((PyObject *)__pyx_v_mark)); __pyx_t_6 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 764; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 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_filename = __pyx_f[0]; __pyx_lineno = 764; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __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_9 = PyObject_GetItem(__pyx_v_self->anchors, __pyx_v_anchor); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_start_mark); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } __pyx_t_7 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __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_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_8, __pyx_kp_u_found_duplicate_anchor_first_occ); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __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_8, __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_8, ((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_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_8 = 1; } } __pyx_t_6 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __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_8, __pyx_v_parent); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_8, __pyx_v_index); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 773; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 775; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 776; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && 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_filename = __pyx_f[0]; __pyx_lineno = 776; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 776; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __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_9); __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; Py_ssize_t __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 781; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 782; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 788; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 785; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 785; __pyx_clineno = __LINE__; goto __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, __pyx_k_strict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_plain_implicit); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_quoted_implicit); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON && 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; } } __pyx_t_3 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 815; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; __pyx_t_9 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_8 = PyTuple_New(5+__pyx_t_9); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 815; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 815; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 817; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 824; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 825; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_1 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 845; __pyx_clineno = __LINE__; goto __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_10 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_10 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __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_10 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_10 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 854; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 856; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 863; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 865; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 862; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 862; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 873; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 873; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_implicit); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 873; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 873; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 873; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 881; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = NULL; __pyx_t_8 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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; } } __pyx_t_1 = PyTuple_New(5+__pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __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_10 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_10 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __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_11 = __Pyx_PyList_Append(__pyx_v_value, __pyx_t_3); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __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_10 = ((struct __pyx_vtabstruct_12_ruamel_yaml_CParser *)__pyx_v_self->__pyx_vtab)->_parse_next_event(__pyx_v_self); if (unlikely(__pyx_t_10 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 902; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 904; __pyx_clineno = __LINE__; goto __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; } /* "_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 911; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_size); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 911; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && 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_filename = __pyx_f[0]; __pyx_lineno = 911; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 911; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 911; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 913; __pyx_clineno = __LINE__; goto __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__15, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __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__16, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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); case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); 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; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_canonical); if (value) { values[1] = value; kw_args--; } } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_indent); if (value) { values[2] = value; kw_args--; } } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_width); if (value) { values[3] = value; kw_args--; } } case 4: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_unicode); if (value) { values[4] = value; kw_args--; } } case 5: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_line_break); if (value) { values[5] = value; kw_args--; } } case 6: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encoding); if (value) { values[6] = value; kw_args--; } } case 7: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_explicit_start); if (value) { values[7] = value; kw_args--; } } case 8: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_explicit_end); if (value) { values[8] = value; kw_args--; } } case 9: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_version); if (value) { values[9] = value; kw_args--; } } 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_filename = __pyx_f[0]; __pyx_lineno = 952; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); 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_filename = __pyx_f[0]; __pyx_lineno = 952; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 956; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __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 = PyObject_HasAttr(__pyx_v_stream, __pyx_n_u_encoding); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 963; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 967; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 970; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 972; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __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__17, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 976; __pyx_clineno = __LINE__; goto __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__18, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 978; __pyx_clineno = __LINE__; goto __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__19, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 983; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __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 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __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 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 1006; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && 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_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __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__20, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __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__21, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1013; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1013; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1039; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1054; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1054; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __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__22, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __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__23, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1062; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1064; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = PyObject_GetItem(__pyx_t_1, __pyx_v_handle); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1064; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1066; __pyx_clineno = __LINE__; goto __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 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1067; __pyx_clineno = __LINE__; goto __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__24, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1070; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1070; __pyx_clineno = __LINE__; goto __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__25, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1072; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1072; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __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 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1076; __pyx_clineno = __LINE__; goto __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__26, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1079; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1079; __pyx_clineno = __LINE__; goto __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__27, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1085; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1085; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1089; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1090; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1092; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1092; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1095; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1097; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1099; __pyx_clineno = __LINE__; goto __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__28, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __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__29, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1104; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1104; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1107; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1108; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __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__30, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1116; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1116; __pyx_clineno = __LINE__; goto __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__31, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1118; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1118; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1121; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1124; __pyx_clineno = __LINE__; goto __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__32, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1127; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1127; __pyx_clineno = __LINE__; goto __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__33, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1129; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1129; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1131; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1133; __pyx_clineno = __LINE__; goto __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__34, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1136; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1136; __pyx_clineno = __LINE__; goto __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__35, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1138; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1138; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1143; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1144; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1144; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1144; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1145; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1145; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1145; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1146; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1148; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1148; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1150; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1150; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1152; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1152; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1154; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1154; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1158; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1159; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1161; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1164; __pyx_clineno = __LINE__; goto __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__36, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1167; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1167; __pyx_clineno = __LINE__; goto __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__37, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1169; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1169; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1172; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1175; __pyx_clineno = __LINE__; goto __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__38, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1178; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1178; __pyx_clineno = __LINE__; goto __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__39, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1180; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1180; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1183; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1183; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1186; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1190; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1191; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1193; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1196; __pyx_clineno = __LINE__; goto __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__40, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1199; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1199; __pyx_clineno = __LINE__; goto __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__41, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1201; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1201; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1204; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1207; __pyx_clineno = __LINE__; goto __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__42, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __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__43, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1212; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1212; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1218; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1222; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1223; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1225; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1229; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1229; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1229; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1229; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1231; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1231; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1231; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1236; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1237; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1238; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1239; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 -1: /* "_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_filename = __pyx_f[0]; __pyx_lineno = 1245; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1245; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1247; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1247; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1256; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1257; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1258; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1262; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1262; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1264; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1264; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1269; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1269; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1269; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 -1: /* "_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_filename = __pyx_f[0]; __pyx_lineno = 1275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1275; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1275; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1277; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1277; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1277; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1280; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1281; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1282; __pyx_clineno = __LINE__; goto __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 -1: /* "_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_filename = __pyx_f[0]; __pyx_lineno = 1294; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1294; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1294; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1296; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1296; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1296; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1299; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1299; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1299; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1301; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1301; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1301; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1304; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1305; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1305; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1306; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1306; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1310; __pyx_clineno = __LINE__; goto __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 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1311; __pyx_clineno = __LINE__; goto __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__54, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __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__55, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1315; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1315; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1319; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1321; __pyx_clineno = __LINE__; goto __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 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1322; __pyx_clineno = __LINE__; goto __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__56, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1325; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1325; __pyx_clineno = __LINE__; goto __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__57, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1327; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1327; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1330; __pyx_clineno = __LINE__; goto __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 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1331; __pyx_clineno = __LINE__; goto __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__58, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1334; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1334; __pyx_clineno = __LINE__; goto __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__59, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1336; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1336; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1342; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1343; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1344; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1345; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1346; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1347; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1349; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1350; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1351; __pyx_clineno = __LINE__; goto __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 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1352; __pyx_clineno = __LINE__; goto __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 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1353; __pyx_clineno = __LINE__; goto __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 *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 1357; __pyx_clineno = __LINE__; goto __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1358; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1360; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1360; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1360; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1362; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1363; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1364; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_COMPILING_IN_CPYTHON __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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_CPYTHON 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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON 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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1368; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1369; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1370; __pyx_clineno = __LINE__; goto __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; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *(*__pyx_t_11)(PyObject *); PyObject *(*__pyx_t_12)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1386; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1390; __pyx_clineno = __LINE__; goto __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__60, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1393; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1393; __pyx_clineno = __LINE__; goto __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__61, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1399; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1400; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1401; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1402; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1404; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1405; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1406; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1406; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_v_parent); __Pyx_GIVEREF(__pyx_v_parent); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_parent); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_index); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1406; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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_filename = __pyx_f[0]; __pyx_lineno = 1407; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1410; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_7 = 1; } } __pyx_t_10 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_t_6); __Pyx_INCREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_7, __pyx_tuple__62); __pyx_t_8 = 0; __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 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_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_ScalarNode); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_node, __pyx_n_s_value); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(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_7 = 1; } } __pyx_t_9 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __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_10); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_7, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_7, __pyx_t_6); __Pyx_INCREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_7, __pyx_tuple__63); __pyx_t_10 = 0; __pyx_t_6 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 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_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1418; __pyx_clineno = __LINE__; goto __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__64, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1421; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1421; __pyx_clineno = __LINE__; goto __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__65, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1423; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1423; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1427; __pyx_clineno = __LINE__; goto __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__66, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __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__67, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1432; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1432; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1435; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1441; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1441; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1443; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1443; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1447; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1448; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1449; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1450; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1451; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1453; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_SequenceNode); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); __pyx_t_10 = NULL; } __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_6); __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, Py_True); __pyx_t_9 = 0; __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1454; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1459; __pyx_clineno = __LINE__; goto __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__68, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __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__69, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1464; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1467; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1467; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1471; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1472; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1473; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1474; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __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_7 = 0; __pyx_t_11 = NULL; } else { __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __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_7 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_5); __pyx_t_7++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_5); __pyx_t_7++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1476; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1477; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1477; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1480; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1481; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1482; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1483; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1485; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_MappingNode); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && 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_7 = 1; } } __pyx_t_10 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_t_6); __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_7, Py_True); __pyx_t_8 = 0; __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 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_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __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__70, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __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__71, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1496; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1496; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1503; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1504; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1505; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1506; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __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_7 = 0; __pyx_t_11 = NULL; } else { __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __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_7 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_5); __pyx_t_7++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_5); __pyx_t_7++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __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_CPYTHON 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_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_10 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __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_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_12 = Py_TYPE(__pyx_t_8)->tp_iternext; index = 0; __pyx_t_10 = __pyx_t_12(__pyx_t_8); if (unlikely(!__pyx_t_10)) goto __pyx_L52_unpacking_failed; __Pyx_GOTREF(__pyx_t_10); index = 1; __pyx_t_6 = __pyx_t_12(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L52_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_8), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L53_unpacking_done; __pyx_L52_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_L53_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_item_key, __pyx_t_10); __pyx_t_10 = 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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1508; __pyx_clineno = __LINE__; goto __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 == 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1511; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1512; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1513; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && 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_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __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_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __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; } /* "_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_filename = __pyx_f[0]; __pyx_lineno = 1521; __pyx_clineno = __LINE__; goto __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, __pyx_k_strict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && 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_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __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; } 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 PY_VERSION_HEX >= 0x030400a1 if (unlikely(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}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_12_ruamel_yaml_Mark[] = { {(char *)"name", __pyx_getprop_12_ruamel_yaml_4Mark_name, 0, 0, 0}, {(char *)"index", __pyx_getprop_12_ruamel_yaml_4Mark_index, 0, 0, 0}, {(char *)"line", __pyx_getprop_12_ruamel_yaml_4Mark_line, 0, 0, 0}, {(char *)"column", __pyx_getprop_12_ruamel_yaml_4Mark_column, 0, 0, 0}, {(char *)"buffer", __pyx_getprop_12_ruamel_yaml_4Mark_buffer, 0, 0, 0}, {(char *)"pointer", __pyx_getprop_12_ruamel_yaml_4Mark_pointer, 0, 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 PY_VERSION_HEX >= 0x030400a1 if (unlikely(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}, {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 PY_VERSION_HEX >= 0x030400a1 if (unlikely(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}, {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 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif "_ruamel_yaml", 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ 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_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_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__17, __pyx_k__17, sizeof(__pyx_k__17), 0, 0, 1, 0}, {&__pyx_kp_s__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 1, 0}, {&__pyx_kp_s__19, __pyx_k__19, sizeof(__pyx_k__19), 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_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_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_kp_s_home_avdndata_hg_ruamel_eu_src, __pyx_k_home_avdndata_hg_ruamel_eu_src, sizeof(__pyx_k_home_avdndata_hg_ruamel_eu_src), 0, 0, 1, 0}, {&__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_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_pointer, __pyx_k_pointer, sizeof(__pyx_k_pointer), 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_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_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_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_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_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_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_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 355; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 302; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 355; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 357; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 656; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 658; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "_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__15 = PyTuple_Pack(1, __pyx_kp_s_a_string_value_is_expected); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "_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__16 = PyTuple_Pack(1, __pyx_kp_u_a_string_value_is_expected); if (unlikely(!__pyx_tuple__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "_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__20 = PyTuple_Pack(1, __pyx_kp_s_no_emitter_error); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); /* "_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__21 = PyTuple_Pack(1, __pyx_kp_u_no_emitter_error); if (unlikely(!__pyx_tuple__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1013; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "_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__22 = PyTuple_Pack(1, __pyx_kp_s_too_many_tags); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "_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__23 = PyTuple_Pack(1, __pyx_kp_u_too_many_tags); if (unlikely(!__pyx_tuple__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "_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__24 = PyTuple_Pack(1, __pyx_kp_s_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1070; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "_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__25 = PyTuple_Pack(1, __pyx_kp_u_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1072; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "_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__26 = PyTuple_Pack(1, __pyx_kp_s_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1079; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); /* "_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__27 = PyTuple_Pack(1, __pyx_kp_u_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); /* "_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__28 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__28)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); /* "_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__29 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); /* "_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__30 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1116; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "_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__31 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1118; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "_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__32 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1127; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); /* "_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__33 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1129; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); /* "_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__34 = PyTuple_Pack(1, __pyx_kp_s_value_must_be_a_string); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1136; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "_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__35 = PyTuple_Pack(1, __pyx_kp_u_value_must_be_a_string); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1138; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); /* "_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__36 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__36)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1167; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); /* "_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__37 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__37)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__37); __Pyx_GIVEREF(__pyx_tuple__37); /* "_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__38 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1178; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "_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__39 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__39)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1180; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__39); __Pyx_GIVEREF(__pyx_tuple__39); /* "_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__40 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__40)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1199; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); /* "_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__41 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__41)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1201; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); /* "_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__42 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__42)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); /* "_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__43 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__43)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1212; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "_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__44 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_closed); if (unlikely(!__pyx_tuple__44)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); /* "_ruamel_yaml.pyx":1264 * raise SerializerError("serializer is closed") * else: * raise SerializerError(u"serializer is closed") # <<<<<<<<<<<<<< * else: * if PY_MAJOR_VERSION < 3: */ __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_closed); if (unlikely(!__pyx_tuple__45)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); /* "_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__46 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_already_opened); if (unlikely(!__pyx_tuple__46)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); /* "_ruamel_yaml.pyx":1269 * raise SerializerError("serializer is already opened") * else: * raise SerializerError(u"serializer is already opened") # <<<<<<<<<<<<<< * * def close(self): */ __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_already_opened); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); /* "_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__48 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_not_opened); if (unlikely(!__pyx_tuple__48)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); /* "_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__49 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_not_opened); if (unlikely(!__pyx_tuple__49)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1277; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__49); __Pyx_GIVEREF(__pyx_tuple__49); /* "_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__50 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_not_opened); if (unlikely(!__pyx_tuple__50)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__50); __Pyx_GIVEREF(__pyx_tuple__50); /* "_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__51 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_not_opened); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); /* "_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__52 = PyTuple_Pack(1, __pyx_kp_s_serializer_is_closed); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); /* "_ruamel_yaml.pyx":1301 * raise SerializerError("serializer is closed") * else: * raise SerializerError(u"serializer is closed") # <<<<<<<<<<<<<< * cache = [] * version_directive = NULL */ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_serializer_is_closed); if (unlikely(!__pyx_tuple__53)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "_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__54 = PyTuple_Pack(1, __pyx_kp_s_too_many_tags); if (unlikely(!__pyx_tuple__54)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); /* "_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__55 = PyTuple_Pack(1, __pyx_kp_u_too_many_tags); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1315; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "_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__56 = PyTuple_Pack(1, __pyx_kp_s_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1325; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "_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__57 = PyTuple_Pack(1, __pyx_kp_u_tag_handle_must_be_a_string); if (unlikely(!__pyx_tuple__57)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1327; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); /* "_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__58 = PyTuple_Pack(1, __pyx_kp_s_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__58)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1334; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); /* "_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__59 = PyTuple_Pack(1, __pyx_kp_u_tag_prefix_must_be_a_string); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1336; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); /* "_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__60 = PyTuple_Pack(1, __pyx_kp_s_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__60); __Pyx_GIVEREF(__pyx_tuple__60); /* "_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__61 = PyTuple_Pack(1, __pyx_kp_u_anchor_must_be_a_string); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); /* "_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__62 = PyTuple_Pack(2, Py_True, Py_False); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); /* "_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__63 = PyTuple_Pack(2, Py_False, Py_True); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); /* "_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__64 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1421; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); /* "_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__65 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__65)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1423; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); /* "_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__66 = PyTuple_Pack(1, __pyx_kp_s_value_must_be_a_string); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); /* "_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__67 = PyTuple_Pack(1, __pyx_kp_u_value_must_be_a_string); if (unlikely(!__pyx_tuple__67)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1432; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); /* "_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__68 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); /* "_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__69 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__69)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1464; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); /* "_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__70 = PyTuple_Pack(1, __pyx_kp_s_tag_must_be_a_string); if (unlikely(!__pyx_tuple__70)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); /* "_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__71 = PyTuple_Pack(1, __pyx_kp_u_tag_must_be_a_string); if (unlikely(!__pyx_tuple__71)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1496; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); /* "_ruamel_yaml.pyx":3 * * * def get_version_string(): # <<<<<<<<<<<<<< * cdef char *value * value = yaml_get_version_string() */ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_n_s_value); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_avdndata_hg_ruamel_eu_src, __pyx_n_s_get_version_string, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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__74 = PyTuple_Pack(3, __pyx_n_s_major, __pyx_n_s_minor, __pyx_n_s_patch); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); __pyx_codeobj__75 = (PyObject*)__Pyx_PyCode_New(0, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__74, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_avdndata_hg_ruamel_eu_src, __pyx_n_s_get_version, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__75)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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) #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #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_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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 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_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main__ruamel_yaml) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (!PyDict_GetItemString(modules, "_ruamel_yaml")) { if (unlikely(PyDict_SetItemString(modules, "_ruamel_yaml", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 246; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 246; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "CParser", (PyObject *)&__pyx_type_12_ruamel_yaml_CParser) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "CEmitter", (PyObject *)&__pyx_type_12_ruamel_yaml_CEmitter) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_version_string, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_version, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_YAMLError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ReaderError, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScannerError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 20; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 20; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 20; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ParserError, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 20; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 21; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 21; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 21; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ComposerError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 21; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ConstructorError, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 23; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 23; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 23; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_EmitterError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 23; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SerializerError, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 25; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 25; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 25; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_RepresenterError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 25; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamStartToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamEndToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DirectiveToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentStartToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentEndToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockSequenceStartToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockMappingStartToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockEndToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowSequenceStartToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowMappingStartToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowSequenceEndToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowMappingEndToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ValueToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_BlockEntryToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FlowEntryToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AliasToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AnchorToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_TagToken, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarToken, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamStartEvent, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 49; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 49; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 49; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_StreamEndEvent, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 49; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentStartEvent, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DocumentEndEvent, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AliasEvent, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarEvent, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SequenceStartEvent, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SequenceEndEvent, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MappingStartEvent, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MappingEndEvent, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 59; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 59; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 59; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarNode, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 59; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SequenceNode, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 61; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 61; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 61; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_MappingNode, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 61; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __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 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __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", __pyx_clineno, __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 PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif } /* --- Runtime support code --- */ #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 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; } 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); } 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 } 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; } static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else PyErr_GetExcInfo(type, value, tb); #endif } static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); 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; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(type, value, tb); #endif } static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { PyObject *local_type, *local_value, *local_tb; #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); 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_COMPILING_IN_CPYTHON 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_COMPILING_IN_CPYTHON 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; 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; } #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 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); 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); #else PyErr_Restore(type, value, tb); #endif } static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(type, value, tb); #endif } #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { 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_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 PY_VERSION_HEX >= 0x03030000 if (cause) { #else if (cause && cause != Py_None) { #endif 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 = PyThreadState_GET(); 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 static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON 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; } static CYTHON_INLINE 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_CheckExact(key)) && 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; } #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 #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) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject* args = PyTuple_Pack(1, arg); return (likely(args)) ? __Pyx_PyObject_Call(func, args, NULL) : NULL; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_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 static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_COMPILING_IN_CPYTHON #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); } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); r = d; Py_INCREF(d); } return r; bad: return NULL; } 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 = 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 } 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; } 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 } static CYTHON_INLINE 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_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, 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_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, 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_COMPILING_IN_CPYTHON 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)) PyErr_Clear(); else return NULL; } } 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)); } 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); } 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"); } static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(exc_type == PyExc_StopIteration) || 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 } 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; } 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; } 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_VERSION_HEX < 0x03030000 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, '.')) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(1); 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, 1); #endif if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_VERSION_HEX < 0x03030000 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_VERSION_HEX < 0x03030000 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } 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; } 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); } #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; 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( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = py_line; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #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;\ } #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #endif 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) | digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | 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) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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)) } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } } 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) 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) | digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) -(((((int)digits[1]) << PyLong_SHIFT) | 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) | digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | 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) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) -(((((((int)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) -(((((((((int)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0])); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) } } { #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_Int(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_Int(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; } 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); } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } 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); } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } 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) | digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | 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) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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)) } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } } 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) 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) | digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) -(((((long)digits[1]) << PyLong_SHIFT) | 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) | digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | 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) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) -(((((((long)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) -(((((((((long)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0])); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) } } { #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_Int(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_Int(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; } 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; } 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; ++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 char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if CYTHON_COMPILING_IN_CPYTHON && (__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)) { #if PY_VERSION_HEX < 0x03030000 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 if (__Pyx_PyUnicode_READY(o) == -1) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (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 } 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 CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { PyNumberMethods *m; const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(x) || PyLong_Check(x)) #else if (PyLong_Check(x)) #endif return __Pyx_NewRef(x); m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = PyNumber_Int(x); } else if (m && m->nb_long) { name = "long"; res = PyNumber_Long(x); } #else if (m && m->nb_int) { name = "int"; res = PyNumber_Long(x); } #endif if (res) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check(res) && !PyLong_Check(res)) { #else if (!PyLong_Check(res)) { #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", name, name, Py_TYPE(res)->tp_name); Py_DECREF(res); return NULL; } } 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) | digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | digits[2]) << PyLong_SHIFT) | digits[1]) << PyLong_SHIFT) | 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.34/ext/api.c0000664000175100001440000010714113116447664016320 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_realloc(*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, yaml_char_t **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 = 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)) goto error; if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE)) goto error; if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE)) goto error; if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE)) goto error; if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE)) goto error; if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE)) 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 = 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 = 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, INITIAL_STACK_SIZE)) goto error; if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE)) goto error; if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE)) goto error; if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE)) 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 = 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 = 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(sizeof(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, INITIAL_STACK_SIZE)) 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, INITIAL_STACK_SIZE)) goto error; if (version_directive) { version_directive_copy = yaml_malloc(sizeof(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, INITIAL_STACK_SIZE)) 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, INITIAL_STACK_SIZE)) 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, INITIAL_STACK_SIZE)) 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.34/ext/yaml.h0000664000175100001440000015173613135155253016516 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. */ #ifdef _WIN32 #define YAML_DECLARE_STATIC 1 # 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-SEQUENCE-END 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 falce. */ #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; /** * 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. */ struct { /** The number of references. */ int references; /** The anchor id. */ int anchor; /** If the node has been emitted? */ int serialized; } *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 destoys its content after * it is emitted. The document object is destroyedeven 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.34/ext/writer.c0000664000175100001440000000771313116707006017054 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.34/ext/config.h0000664000175100001440000000434013116447433017010 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.34/ext/reader.c0000664000175100001440000004043713116707305017004 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 >= PTRDIFF_MAX) return yaml_parser_set_reader_error(parser, "input is too long", PTRDIFF_MAX, -1); return 1; } ruamel.yaml-0.15.34/ext/parser.c0000664000175100001440000013020613116707335017033 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, INITIAL_STACK_SIZE)) 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) { yaml_parser_set_parser_error(parser, "found incompatible YAML document", token->start_mark); goto error; } version_directive = yaml_malloc(sizeof(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); } 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.34/ext/emitter.c0000664000175100001440000020024713116707505017212 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, 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. */ static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter, yaml_event_t *event, int first) { 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)) 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, 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(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) { 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, 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 (!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]; 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.34/ext/scanner.c0000664000175100001440000027777113116706660017213 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 # ']' * BLOCK-SEQUENCE-START # '{' * BLOCK-SEQUENCE-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 nessesary 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 '\\': *(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; 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.34/ext/yaml_private.h0000664000175100001440000007150313116707225020242 0ustar anthonusers00000000000000 #include "config.h" #include "yaml.h" #include #include #include #ifndef _MSC_VER #include #else #ifdef _WIN64 #define PTRDIFF_MAX _I64_MAX #else #define PTRDIFF_MAX INT_MAX #endif #endif /* * 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 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,size) \ (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \ ((stack).top = (stack).start, \ (stack).end = (stack).start+(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) \ (((queue).start = 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)) ruamel.yaml-0.15.34/resolver.py0000664000175100001440000004154613143642437017017 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import import re if False: # MYPY from typing import Any, Dict, List, Union # 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 * # NOQA __all__ = ['BaseResolver', 'Resolver', 'VersionedResolver'] # 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', re.compile(u'''^(?:true|True|TRUE|false|False|FALSE)$''', re.X), list(u'tTfF')), ([(1, 1)], u'tag:yaml.org,2002:bool', re.compile(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', re.compile(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', re.compile(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', re.compile(u'''^(?:[-+]?0b[0-1_]+ |[-+]?0o?[0-7_]+ |[-+]?(?:0|[1-9][0-9_]*) |[-+]?0x[0-9a-fA-F_]+)$''', re.X), list(u'-+0123456789')), ([(1, 1)], u'tag:yaml.org,2002:int', re.compile(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', re.compile(u'^(?:<<)$'), [u'<']), ([(1, 2), (1, 1)], u'tag:yaml.org,2002:null', re.compile(u'''^(?: ~ |null|Null|NULL | )$''', re.X), [u'~', u'n', u'N', u'']), ([(1, 2), (1, 1)], u'tag:yaml.org,2002:timestamp', re.compile(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', re.compile(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', re.compile(u'^(?:!|&|\\*)$'), list(u'!&*')), ] 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 # type: ignore 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 # print('xx2', self) # sys.exit(0) 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 == u'': resolvers = self.yaml_implicit_resolvers.get(u'', []) 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 Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:bool', re.compile(u'''^(?:yes|Yes|YES|no|No|NO |true|True|TRUE|false|False|FALSE |on|On|ON|off|Off|OFF)$''', re.X), list(u'yYnNtTfFoO')) Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:float', re.compile(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_]* |[-+]?\\.(?:inf|Inf|INF) |\\.(?:nan|NaN|NAN))$''', re.X), list(u'-+0123456789.')) Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:int', re.compile(u'''^(?:[-+]?0b[0-1_]+ |[-+]?0o?[0-7_]+ |[-+]?(?:0|[1-9][0-9_]*) |[-+]?0x[0-9a-fA-F_]+ |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), list(u'-+0123456789')) Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:merge', re.compile(u'^(?:<<)$'), [u'<']) Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:null', re.compile(u'''^(?: ~ |null|Null|NULL | )$''', re.X), [u'~', u'n', u'N', u'']) Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:timestamp', re.compile(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')) Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:value', re.compile(u'^(?:=)$'), [u'=']) # The following resolver is only for documentation purposes. It cannot work # because plain scalars cannot start with '!', '&', or '*'. Resolver.add_implicit_resolver_base( u'tag:yaml.org,2002:yaml', re.compile(u'^(?:!|&|\\*)$'), list(u'!&*')) 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): # type: (VersionType, Any) -> None 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: (Union[VersionType, None]) -> 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 == u'': resolvers = self.versioned_resolver.get(u'', []) 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: if hasattr(self.loadumper, 'typ'): version = self.loadumper.version # type: ignore else: version = self.loadumper._serializer.use_version # type: ignore # dumping if version is None: version = self._loader_version if version is None: version = _DEFAULT_YAML_VERSION return version ruamel.yaml-0.15.34/ruamel.yaml.egg-info/0000775000175100001440000000000013157452567020522 5ustar anthonusers00000000000000ruamel.yaml-0.15.34/ruamel.yaml.egg-info/namespace_packages.txt0000664000175100001440000000000713157452567025052 0ustar anthonusers00000000000000ruamel ruamel.yaml-0.15.34/ruamel.yaml.egg-info/SOURCES.txt0000664000175100001440000000155413157452567022413 0ustar anthonusers00000000000000CHANGES LICENSE MANIFEST.in README.rst setup.py ./LICENSE ./__init__.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 ./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.34/ruamel.yaml.egg-info/PKG-INFO0000664000175100001440000003401513157452567021622 0ustar anthonusers00000000000000Metadata-Version: 1.1 Name: ruamel.yaml Version: 0.15.34 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. 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 infomormation 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 ChangeLog ========= .. should insert NEXT: at the beginning of line for next key 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.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Programming Language :: Python :: Implementation :: Jython Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Processing :: Markup ruamel.yaml-0.15.34/ruamel.yaml.egg-info/top_level.txt0000664000175100001440000000002413157452567023250 0ustar anthonusers00000000000000_ruamel_yaml ruamel ruamel.yaml-0.15.34/ruamel.yaml.egg-info/requires.txt0000664000175100001440000000021113157452565023112 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.34/ruamel.yaml.egg-info/dependency_links.txt0000664000175100001440000000000113157452567024570 0ustar anthonusers00000000000000 ruamel.yaml-0.15.34/serializer.py0000644000175100001440000001740613146542335017322 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import import re from ruamel.yaml.error import YAMLError from ruamel.yaml.compat import nprint, DBG_NODE, dbg, string_types 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 # 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 = re.compile(u'id(?!000$)\\d{3,}') def __init__(self, encoding=None, explicit_start=None, explicit_end=None, version=None, tags=None, dumper=None): # type: (Any, bool, bool, VersionType, Any, Any) -> None 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: Union[None, bool] self._templated_id = None @property def emitter(self): # type: () -> Any if hasattr(self.dumper, 'typ'): return self.dumper.emitter # type: ignore return self.dumper._emitter # type: ignore @property def resolver(self): # type: () -> Any if hasattr(self.dumper, 'typ'): self.dumper.resolver # type: ignore return self.dumper._resolver # type: ignore 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: 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: 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)) 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.34/loader.py0000664000175100001440000000545213143642722016415 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 # 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, VersionType, 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, VersionType, 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, VersionType, 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, VersionType, 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.34/comments.py0000644000175100001440000007250313151721216016766 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 collections import MutableSet, Sized, Set from ruamel.yaml.compat import ordereddict, PY2, string_types from ruamel.yaml.scalarstring import ScalarString if False: # MYPY from typing import Any, Dict, Optional, List, Union # NOQA __all__ = ["CommentedSeq", "CommentedKeySeq", "CommentedMap", "CommentedOrderedMap", "CommentedSet", 'comment_attrib', 'merge_attrib'] comment_attrib = '_yaml_comment' format_attrib = '_yaml_format' line_col_attrib = '_yaml_line_col' anchor_attrib = '_yaml_anchor' 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: Union[None, 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 Anchor(object): __slots__ = 'value', 'always_dump', attrib = anchor_attrib def __init__(self): # type: () -> None self.value = None self.always_dump = False 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 l = self.ca._items.setdefault(key, [None, None, None, None]) if clear or l[1] is None: if comment[1] is not None: assert isinstance(comment[1], list) l[1] = comment[1] else: l[1].extend(comment[0]) l[0] = comment[0] def yaml_value_comment_extend(self, key, comment, clear=False): # type: (Any, Any, bool) -> None l = self.ca._items.setdefault(key, [None, None, None, None]) if clear or l[3] is None: if comment[1] is not None: assert isinstance(comment[1], list) l[3] = comment[1] else: l[3].extend(comment[0]) l[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: column = self._yaml_get_column(key) 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 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)) 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(list, CommentedBase): __slots__ = Comment.attrib, 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 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 pop(self, idx=None): # type: (Any) -> Any res = list.pop(self, idx) # type: ignore 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) return res 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 __setitem__(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) class CommentedKeySeq(tuple, CommentedBase): """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) done = [] # type: List[Any] # list of processed merge items, kept for masking for merged in getattr(self._mapping, merge_attrib, []): for x in merged[1]: if self._mapping._unmerged_contains(x): continue for y in done: if x in y: break else: count += 1 done.append(merged[1]) return count def __repr__(self): # type: () -> str return '{0.__class__.__name__}({0._mapping!r})'.format(self) class CommentedMapKeysView(CommentedMapView, Set): __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: yield x class CommentedMapItemsView(CommentedMapView, Set): __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: yield self._mapping[key] class CommentedMap(ordereddict, CommentedBase): __slots__ = Comment.attrib, 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 row_idx, k1 in enumerate(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: (Any) -> None try: ordereddict.update(self, vals) 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) 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) def _unmerged_contains(self, key): # type: (Any) -> Any if ordereddict.__contains__(self, key): return True return None def __contains__(self, key): # type: (Any) -> bool if ordereddict.__contains__(self, key): return True # this will only work once the mapping/dict is built to completion for merged in getattr(self, merge_attrib, []): if key in merged[1]: return True return False def get(self, key, default=None): # type: (Any, Any) -> Any try: return self.__getitem__(key) except: return default def __repr__(self): # type: () -> Any if not hasattr(self, merge_attrib): return ordereddict.__repr__(self) return 'ordereddict(' + repr(list(self._items())) + ')' def non_merged_items(self): # type: () -> Any for x in ordereddict.__iter__(self): yield x, ordereddict.__getitem__(self, x) def __delitem__(self, key): # type: (Any) -> None found = True for merged in getattr(self, merge_attrib, []): try: del merged[1][key] found = True except KeyError: pass try: ordereddict.__delitem__(self, key) except KeyError: if not found: raise def __iter__(self): # type: () -> Any for x in ordereddict.__iter__(self): yield x done = [] # type: List[Any] # list of processed merge items, kept for masking for merged in getattr(self, merge_attrib, []): for x in merged[1]: if ordereddict.__contains__(self, x): continue for y in done: if x in y: break else: yield x done.append(merged[1]) def _keys(self): # type: () -> Any for x in ordereddict.__iter__(self): yield x done = [] # type: List[Any] # list of processed merge items, kept for masking for merged in getattr(self, merge_attrib, []): for x in merged[1]: if ordereddict.__contains__(self, x): continue for y in done: if x in y: break else: yield x done.append(merged[1]) 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) def _values(self): # type: () -> Any for x in ordereddict.__iter__(self): yield ordereddict.__getitem__(self, x) done = [] # type: List[Any] # list of processed merge items, kept for masking for merged in getattr(self, merge_attrib, []): for x in merged[1]: if ordereddict.__contains__(self, x): continue for y in done: if x in y: break else: yield ordereddict.__getitem__(merged[1], x) done.append(merged[1]) if PY2: 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) done = [] # type: List[Any] # list of processed merge items, kept for masking for merged in getattr(self, merge_attrib, []): for x, v in merged[1].items(): if ordereddict.__contains__(self, x): continue for y in done: if x in y: break else: yield x, v # ordereddict.__getitem__(merged[1], x) done.append(merged[1]) 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 add_yaml_merge(self, value): # type: (Any) -> None self.merge.extend(value) 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 class CommentedOrderedMap(CommentedMap): __slots__ = Comment.attrib, class CommentedSet(MutableSet, CommentedMap): __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 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 __str__(self): return self.value def dump_comments(d, name='', sep='.', out=sys.stdout): # type: (Any, str, str, Any) -> None """ recurisively dump domments all but the toplevel preceded by the path in dotted form x.0.a """ if isinstance(d, dict) and hasattr(d, 'ca'): if name: print(name) print(d.ca, file=out) # 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: print(name) print(d.ca, file=out) # 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.34/scanner.py0000664000175100001440000020624513144402743016601 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 = u'\0\r\n\x85\u2028\u2029' _THE_END_SPACE_TAB = u'\0 \t\r\n\x85\u2028\u2029' _SPACE_TAB = u' \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 def reset_scanner(self): # type: () -> None # Had we reached the end of the stream? self.done = False # The number of unclosed '{' and '['. `flow_level == 0` means block # context. self.flow_level = 0 # 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 if hasattr(self.loader, 'typ'): self.loader.reader # type: ignore return self.loader._reader # type: ignore @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 == u'\0': return self.fetch_stream_end() # Is it a directive? if ch == u'%' and self.check_directive(): return self.fetch_directive() # Is it the document start? if ch == u'-' and self.check_document_start(): return self.fetch_document_start() # Is it the document end? if ch == u'.' 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 == u'[': return self.fetch_flow_sequence_start() # Is it the flow mapping start indicator? if ch == u'{': return self.fetch_flow_mapping_start() # Is it the flow sequence end indicator? if ch == u']': return self.fetch_flow_sequence_end() # Is it the flow mapping end indicator? if ch == u'}': return self.fetch_flow_mapping_end() # Is it the flow entry indicator? if ch == u',': return self.fetch_flow_entry() # Is it the block entry indicator? if ch == u'-' and self.check_block_entry(): return self.fetch_block_entry() # Is it the key indicator? if ch == u'?' and self.check_key(): return self.fetch_key() # Is it the value indicator? if ch == u':' and self.check_value(): return self.fetch_value() # Is it an alias? if ch == u'*': return self.fetch_alias() # Is it an anchor? if ch == u'&': return self.fetch_anchor() # Is it a tag? if ch == u'!': return self.fetch_tag() # Is it a literal scalar? if ch == u'|' and not self.flow_level: return self.fetch_literal() # Is it a folded scalar? if ch == u'>' and not self.flow_level: return self.fetch_folded() # Is it a single quoted scalar? if ch == u'\'': return self.fetch_single() # Is it a double quoted scalar? if ch == u'\"': 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) def fetch_flow_mapping_start(self): # type: () -> None self.fetch_flow_collection_start(FlowMappingStartToken) def fetch_flow_collection_start(self, TokenClass): # type: (Any) -> None # '[' and '{' may start a simple key. self.save_possible_simple_key() # Increase the flow level. self.flow_level += 1 # 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. self.flow_level -= 1 # 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) == u'---' \ 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) == u'...' \ 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) and self.reader.peek(1) in '\'"{[]}': 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. ch = self.reader.peek() if self.scanner_processing_version == (1, 1): return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' or \ (self.reader.peek(1) not in _THE_END_SPACE_TAB and (ch == u'-' or (not self.flow_level and ch in u'?:'))) # YAML 1.2 if ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`': # ################### ^ ??? return True ch1 = self.reader.peek(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 (self.reader.peek(1) not in _THE_END_SPACE_TAB and (ch == u'-' or (not self.flow_level and ch in u'?:'))) # 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. if self.reader.index == 0 and self.reader.peek() == u'\uFEFF': self.reader.forward() found = False while not found: while self.reader.peek() == u' ': self.reader.forward() if self.reader.peek() == u'#': while self.reader.peek() not in _THE_END: self.reader.forward() 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. start_mark = self.reader.get_mark() self.reader.forward() name = self.scan_directive_name(start_mark) value = None if name == u'YAML': value = self.scan_yaml_directive_value(start_mark) end_mark = self.reader.get_mark() elif name == u'TAG': value = self.scan_tag_directive_value(start_mark) end_mark = self.reader.get_mark() else: end_mark = self.reader.get_mark() while self.reader.peek() not in _THE_END: self.reader.forward() 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 ch = self.reader.peek(length) while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ or ch in u'-_:.': length += 1 ch = self.reader.peek(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 = self.reader.peek() if ch not in u'\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. while self.reader.peek() == u' ': self.reader.forward() major = self.scan_yaml_directive_number(start_mark) if self.reader.peek() != '.': raise ScannerError( "while scanning a directive", start_mark, "expected a digit or '.', but found %r" % utf8(self.reader.peek()), self.reader.get_mark()) self.reader.forward() minor = self.scan_yaml_directive_number(start_mark) if self.reader.peek() not in u'\0 \r\n\x85\u2028\u2029': raise ScannerError( "while scanning a directive", start_mark, "expected a digit or ' ', but found %r" % utf8(self.reader.peek()), self.reader.get_mark()) return (major, minor) def scan_yaml_directive_number(self, start_mark): # type: (Any) -> Any # See the specification for details. ch = self.reader.peek() if not (u'0' <= ch <= u'9'): raise ScannerError( "while scanning a directive", start_mark, "expected a digit, but found %r" % utf8(ch), self.reader.get_mark()) length = 0 while u'0' <= self.reader.peek(length) <= u'9': length += 1 value = int(self.reader.prefix(length)) self.reader.forward(length) return value def scan_tag_directive_value(self, start_mark): # type: (Any) -> Any # See the specification for details. while self.reader.peek() == u' ': self.reader.forward() handle = self.scan_tag_directive_handle(start_mark) while self.reader.peek() == u' ': self.reader.forward() 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 != u' ': 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 u'\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. while self.reader.peek() == u' ': self.reader.forward() if self.reader.peek() == u'#': while self.reader.peek() not in _THE_END: self.reader.forward() ch = self.reader.peek() 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. start_mark = self.reader.get_mark() indicator = self.reader.peek() if indicator == u'*': name = 'alias' else: name = 'anchor' self.reader.forward() length = 0 ch = self.reader.peek(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 = self.reader.peek(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 = self.reader.peek() # no need to peek, ch is already set # assert ch1 == ch if ch not in u'\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. start_mark = self.reader.get_mark() ch = self.reader.peek(1) if ch == u'<': handle = None self.reader.forward(2) suffix = self.scan_tag_uri('tag', start_mark) if self.reader.peek() != u'>': raise ScannerError( "while parsing a tag", start_mark, "expected '>', but found %r" % utf8(self.reader.peek()), self.reader.get_mark()) self.reader.forward() elif ch in _THE_END_SPACE_TAB: handle = None suffix = u'!' self.reader.forward() else: length = 1 use_handle = False while ch not in u'\0 \r\n\x85\u2028\u2029': if ch == u'!': use_handle = True break length += 1 ch = self.reader.peek(length) handle = u'!' if use_handle: handle = self.scan_tag_handle('tag', start_mark) else: handle = u'!' self.reader.forward() suffix = self.scan_tag_uri('tag', start_mark) ch = self.reader.peek() if ch not in u'\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): # type: (Any) -> Any # See the specification for details. 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) 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 = u'' # Scan the inner part of the block scalar. while self.reader.column == indent and self.reader.peek() != u'\0': chunks.extend(breaks) leading_non_space = self.reader.peek() not in u' \t' length = 0 while self.reader.peek(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 self.reader.peek() != u'\0': # Unfortunately, folding rules are ambiguous. # # This is the folding according to the specification: if folded and line_break == u'\n' \ and leading_non_space and self.reader.peek() not in u' \t': if not breaks: chunks.append(u' ') 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 self.reader.peek() 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(u''.join(chunks), False, start_mark, end_mark, style) if len(trailing) > 0: # print('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. chomping = None increment = None ch = self.reader.peek() if ch in u'+-': if ch == '+': chomping = True else: chomping = False self.reader.forward() ch = self.reader.peek() if ch in u'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 u'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 = self.reader.peek() if ch in u'+-': if ch == '+': chomping = True else: chomping = False self.reader.forward() ch = self.reader.peek() if ch not in u'\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. while self.reader.peek() == u' ': self.reader.forward() if self.reader.peek() == u'#': while self.reader.peek() not in _THE_END: self.reader.forward() ch = self.reader.peek() 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() def scan_block_scalar_indentation(self): # type: () -> Any # See the specification for details. chunks = [] max_indent = 0 end_mark = self.reader.get_mark() while self.reader.peek() in u' \r\n\x85\u2028\u2029': if self.reader.peek() != u' ': chunks.append(self.scan_line_break()) end_mark = self.reader.get_mark() else: self.reader.forward() 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 = [] end_mark = self.reader.get_mark() while self.reader.column < indent and self.reader.peek() == u' ': self.reader.forward() while self.reader.peek() in u'\r\n\x85\u2028\u2029': chunks.append(self.scan_line_break()) end_mark = self.reader.get_mark() while self.reader.column < indent and self.reader.peek() == u' ': self.reader.forward() 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 chunks = [] # type: List[Any] start_mark = self.reader.get_mark() quote = self.reader.peek() self.reader.forward() chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) while self.reader.peek() != 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(u''.join(chunks), False, start_mark, end_mark, style) ESCAPE_REPLACEMENTS = { u'0': u'\0', u'a': u'\x07', u'b': u'\x08', u't': u'\x09', u'\t': u'\x09', u'n': u'\x0A', u'v': u'\x0B', u'f': u'\x0C', u'r': u'\x0D', u'e': u'\x1B', u' ': u'\x20', u'\"': u'\"', u'/': u'/', # as per http://www.json.org/ u'\\': u'\\', u'N': u'\x85', u'_': u'\xA0', u'L': u'\u2028', u'P': u'\u2029', } ESCAPE_CODES = { u'x': 2, u'u': 4, u'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] while True: length = 0 while self.reader.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': length += 1 if length != 0: chunks.append(self.reader.prefix(length)) self.reader.forward(length) ch = self.reader.peek() if not double and ch == u'\'' and self.reader.peek(1) == u'\'': chunks.append(u'\'') self.reader.forward(2) elif (double and ch == u'\'') or (not double and ch in u'\"\\'): chunks.append(ch) self.reader.forward() elif double and ch == u'\\': self.reader.forward() ch = self.reader.peek() if ch in self.ESCAPE_REPLACEMENTS: chunks.append(self.ESCAPE_REPLACEMENTS[ch]) self.reader.forward() elif ch in self.ESCAPE_CODES: length = self.ESCAPE_CODES[ch] self.reader.forward() for k in range(length): if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': raise ScannerError( "while scanning a double-quoted scalar", start_mark, "expected escape sequence of %d hexdecimal " "numbers, but found %r" % (length, utf8(self.reader.peek(k))), self.reader.get_mark()) code = int(self.reader.prefix(length), 16) chunks.append(unichr(code)) self.reader.forward(length) elif ch in u'\r\n\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. chunks = [] length = 0 while self.reader.peek(length) in u' \t': length += 1 whitespaces = self.reader.prefix(length) self.reader.forward(length) ch = self.reader.peek() if ch == u'\0': raise ScannerError( "while scanning a quoted scalar", start_mark, "found unexpected end of stream", self.reader.get_mark()) elif ch in u'\r\n\x85\u2028\u2029': line_break = self.scan_line_break() breaks = self.scan_flow_scalar_breaks(double, start_mark) if line_break != u'\n': chunks.append(line_break) elif not breaks: chunks.append(u' ') 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] while True: # Instead of checking indentation, we check for document # separators. prefix = self.reader.prefix(3) if (prefix == u'---' or prefix == u'...') \ and self.reader.peek(3) in _THE_END_SPACE_TAB: raise ScannerError("while scanning a quoted scalar", start_mark, "found unexpected document separator", self.reader.get_mark()) while self.reader.peek() in u' \t': self.reader.forward() if self.reader.peek() in u'\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. 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 self.reader.peek() == u'#': break while True: ch = self.reader.peek(length) if (ch == u':' and self.reader.peek(length + 1) not in _THE_END_SPACE_TAB): pass elif (ch == u'?' and self.scanner_processing_version != (1, 1)): pass elif (ch in _THE_END_SPACE_TAB or (not self.flow_level and ch == u':' and self.reader.peek(length + 1) in _THE_END_SPACE_TAB) or (self.flow_level and ch in u',:?[]{}')): break length += 1 # It's not clear what we should do with ':' in the flow context. if (self.flow_level and ch == u':' and self.reader.peek(length + 1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): self.reader.forward(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)) self.reader.forward(length) end_mark = self.reader.get_mark() spaces = self.scan_plain_spaces(indent, start_mark) if not spaces or self.reader.peek() == u'#' \ or (not self.flow_level and self.reader.column < indent): break token = ScalarToken(u''.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! chunks = [] length = 0 while self.reader.peek(length) in u' ': length += 1 whitespaces = self.reader.prefix(length) self.reader.forward(length) ch = self.reader.peek() if ch in u'\r\n\x85\u2028\u2029': line_break = self.scan_line_break() self.allow_simple_key = True prefix = self.reader.prefix(3) if (prefix == u'---' or prefix == u'...') \ and self.reader.peek(3) in _THE_END_SPACE_TAB: return breaks = [] while self.reader.peek() in u' \r\n\x85\u2028\u2029': if self.reader.peek() == ' ': self.reader.forward() else: breaks.append(self.scan_line_break()) prefix = self.reader.prefix(3) if (prefix == u'---' or prefix == u'...') \ and self.reader.peek(3) in _THE_END_SPACE_TAB: return if line_break != u'\n': chunks.append(line_break) elif not breaks: chunks.append(u' ') 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. ch = self.reader.peek() if ch != u'!': raise ScannerError("while scanning a %s" % name, start_mark, "expected '!', but found %r" % utf8(ch), self.reader.get_mark()) length = 1 ch = self.reader.peek(length) if ch != u' ': while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' \ or u'a' <= ch <= u'z' \ or ch in u'-_': length += 1 ch = self.reader.peek(length) if ch != u'!': 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. chunks = [] length = 0 ch = self.reader.peek(length) while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ or ch in u'-;/?:@&=+$,_.!~*\'()[]%': if ch == u'%': 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 = self.reader.peek(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 u''.join(chunks) def scan_uri_escapes(self, name, start_mark): # type: (Any, Any) -> Any # See the specification for details. code_bytes = [] # type: List[Any] mark = self.reader.get_mark() while self.reader.peek() == u'%': self.reader.forward() for k in range(2): if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': raise ScannerError( "while scanning a %s" % name, start_mark, "expected URI escape sequence of 2 hexdecimal numbers," " but found %r" % utf8(self.reader.peek(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))) self.reader.forward(2) try: if PY3: value = bytes(code_bytes).decode('utf-8') else: value = unicode(''.join(code_bytes), 'utf-8') # type: ignore 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 u'\r\n\x85': if self.reader.prefix(2) == u'\r\n': self.reader.forward(2) else: self.reader.forward() return u'\n' elif ch in u'\u2028\u2029': self.reader.forward() return ch return u'' 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] == u' ': # 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. if self.reader.index == 0 and self.reader.peek() == u'\uFEFF': self.reader.forward() found = False while not found: while self.reader.peek() == u' ': self.reader.forward() ch = self.reader.peek() if ch == u'#': start_mark = self.reader.get_mark() comment = ch self.reader.forward() while ch not in _THE_END: ch = self.reader.peek() if ch == u'\0': # don't gobble the end-of-stream character break comment += ch self.reader.forward() # 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 = self.reader.peek() 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 self.reader.peek() == '#': # 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 u'\r\n\x85': if self.reader.prefix(2) == u'\r\n': self.reader.forward(2) else: self.reader.forward() return u'\n' elif ch in u'\u2028\u2029': self.reader.forward() return ch elif empty_line and ch in '\t ': self.reader.forward() return ch return u'' # try: # import psyco # psyco.bind(Scanner) # except ImportError: # pass ruamel.yaml-0.15.34/.ruamel/0000775000175100001440000000000013157452567016145 5ustar anthonusers00000000000000ruamel.yaml-0.15.34/.ruamel/__init__.py0000664000175100001440000000007713037504407020246 0ustar anthonusers00000000000000import pkg_resources pkg_resources.declare_namespace(__name__) ruamel.yaml-0.15.34/scalarfloat.py0000664000175100001440000000700113146576251017440 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import print_function, absolute_import, division, unicode_literals import sys from .compat import no_limit_int # NOQA 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 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 return v def __iadd__(self, a): # type: ignore # type: (Any) -> Any return float(self) + a x = type(self)(self + a) x._width = self._width # type: ignore x._underscore = self._underscore[:] if self._underscore is not None else None # type: ignore # 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 # type: ignore x._underscore = self._underscore[:] if self._underscore is not None else None # type: ignore # 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 # type: ignore x._underscore = self._underscore[:] if self._underscore is not None else None # type: ignore # 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 # type: ignore x._underscore = self._underscore[:] if self._underscore is not None else None # type: ignore # 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 # type: ignore x._underscore = self._underscore[:] if self._underscore is not None else None # type: ignore # NOQA return x def dump(self, out=sys.stdout): # type: (Any) -> Any print('ScalarFloat({}| w:{}, p:{}, s:{}, lz:{}|{}, w:{}, s:{})'.format( self, self._width, self._prec, self._m_sign, self._m_lead0, # type: ignore self._exp, self._e_width, self._e_sign), file=out) # 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.34/tokens.py0000664000175100001440000001522213144576200016444 0ustar anthonusers00000000000000# # header # coding: utf-8 if False: # MYPY from typing import Any, Dict, Optional, List # NOQA SHOWLINES = True class Token(object): __slots__ = 'start_mark', 'end_mark', '_comment', def __init__(self, start_mark, end_mark): # type: (Any, Any) -> 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 = u', '.join([u'%s=%r' % (key, getattr(self, key)) for key in attributes]) if SHOWLINES: try: arguments += u', line: ' + str(self.start_mark.line) except: pass return u'{}({})'.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): 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 = u'{!r}'.format(self.value) if SHOWLINES: try: v += u', line: ' + str(self.start_mark.line) except: pass return 'CommentToken({})'.format(v) ruamel.yaml-0.15.34/setup.cfg0000664000175100001440000000004613157452567016423 0ustar anthonusers00000000000000[egg_info] tag_build = tag_date = 0 ruamel.yaml-0.15.34/MANIFEST.in0000664000175100001440000000010413037504357016323 0ustar anthonusers00000000000000include README.rst LICENSE CHANGES setup.py recursive-include ext * ruamel.yaml-0.15.34/util.py0000664000175100001440000001127013133364047016117 0ustar anthonusers00000000000000# coding: utf-8 """ some helper functions that might be generally useful """ from __future__ import absolute_import, print_function from .compat import text_type, binary_type if False: # MYPY from typing import Any, Dict, Optional, List, Text # NOQA from .compat import StreamTextType # NOQA # 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.34/main.py0000644000175100001440000012703213157451335016073 0ustar anthonusers00000000000000# coding: utf-8 from __future__ import absolute_import, unicode_literals import sys import os import warnings import glob from importlib import import_module import ruamel.yaml from ruamel.yaml.error import * # 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 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 # NOQA from ruamel.yaml.compat import StreamType, StreamTextType, VersionType # NOQA try: from _ruamel_yaml import CParser, CEmitter # type: ignore except: 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, plug_ins=None): # type: (Any, 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 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.plug_ins = [] # type: List[Any] for pu in ([] if plug_ins is None else plug_ins) + self.official_plug_ins(): file_name = pu.replace('/', '.') 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.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 @property def reader(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): setattr(self, attr, self.Reader(None, loader=self)) return getattr(self, attr) @property def scanner(self): # type: () -> Any attr = '_' + sys._getframe().f_code.co_name if not hasattr(self, attr): setattr(self, attr, self.Scanner(loader=self)) return getattr(self, attr) @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 # print('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, 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 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): setattr(self, attr, self.Representer( default_style=self.default_style, default_flow_style=self.default_flow_style, dumper=self)) return getattr(self, attr) # separate output resolver? def load(self, stream): # type: (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('r') 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() # type: ignore except AttributeError: pass try: self._scanner.reset_scanner() # type: ignore except AttributeError: pass def load_all(self, stream, _kw=enforce): # , skip=None): # type: (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 raise StopIteration() # 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() # type: ignore except AttributeError: pass try: self._scanner.reset_scanner() # type: ignore 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=None, preserve_quotes=None): # type: (StreamTextType, VersionType, bool) -> None 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, loadumper=selfx) self._stream = stream loader = XLoader(stream) return loader, loader return self.constructor, self.parser def dump(self, data, stream, _kw=enforce, transform=None): # type: (Any, StreamType, Any, Any) -> Any return self.dump_all([data], stream, _kw, transform=transform) def dump_all(self, documents, stream, _kw=enforce, transform=None): # type: (Any, 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: # type: ignore 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: # print(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() # type: ignore if self.encoding: val = val.decode(self.encoding) 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, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, 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) -> None """ 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) # ### 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 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, 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() # type: ignore finally: loader._parser.dispose() # type: ignore def load_all(stream, Loader=None, version=None, preserve_quotes=None): # type: (StreamTextType, Any, VersionType, bool) -> Any """ 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(): # type: ignore yield loader._constructor.get_data() # type: ignore finally: loader._parser.dispose() # type: ignore def safe_load(stream, version=None): # type: (StreamTextType, 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, 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, VersionType, 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, VersionType, 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, StreamType, Any, bool, Union[int, None], int, bool, Any) -> Any """ 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, StreamType, Any, Any, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, bool], 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, 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, StreamType, Any, Any, Any, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, bool], Any, Any, Any, Any, Any) -> Union[None, 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: # print(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, StreamType, Any, Any, Any, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, bool], VersionType, Any, Any) -> Union[None, 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, StreamType, Any) -> Union[None, 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, StreamType, Any) -> Union[None, 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, StreamType, Any, Any, Any, bool, Union[None, int], Union[None, int], bool, Any, Any, Union[None, bool], Union[None, bool], VersionType, Any, Any, Any, Any) -> Union[None, 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)