diff options
author | Mikhail Borisov <borisov.mikhail@gmail.com> | 2022-02-10 16:45:39 +0300 |
---|---|---|
committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:45:39 +0300 |
commit | a6a92afe03e02795227d2641b49819b687f088f8 (patch) | |
tree | f6984a1d27d5a7ec88a6fdd6e20cd5b7693b6ece /contrib/python/PyYAML/py2/yaml/_yaml.pyx | |
parent | c6dc8b8bd530985bc4cce0137e9a5de32f1087cb (diff) | |
download | ydb-a6a92afe03e02795227d2641b49819b687f088f8.tar.gz |
Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.
Diffstat (limited to 'contrib/python/PyYAML/py2/yaml/_yaml.pyx')
-rw-r--r-- | contrib/python/PyYAML/py2/yaml/_yaml.pyx | 2976 |
1 files changed, 1488 insertions, 1488 deletions
diff --git a/contrib/python/PyYAML/py2/yaml/_yaml.pyx b/contrib/python/PyYAML/py2/yaml/_yaml.pyx index ff4efe80b5..efdb347aff 100644 --- a/contrib/python/PyYAML/py2/yaml/_yaml.pyx +++ b/contrib/python/PyYAML/py2/yaml/_yaml.pyx @@ -1,1527 +1,1527 @@ - -import yaml - -def get_version_string(): + +import yaml + +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 -YAMLError = yaml.error.YAMLError -ReaderError = yaml.reader.ReaderError -ScannerError = yaml.scanner.ScannerError -ParserError = yaml.parser.ParserError -ComposerError = yaml.composer.ComposerError -ConstructorError = yaml.constructor.ConstructorError -EmitterError = yaml.emitter.EmitterError -SerializerError = yaml.serializer.SerializerError -RepresenterError = yaml.representer.RepresenterError - -StreamStartToken = yaml.tokens.StreamStartToken -StreamEndToken = yaml.tokens.StreamEndToken -DirectiveToken = yaml.tokens.DirectiveToken -DocumentStartToken = yaml.tokens.DocumentStartToken -DocumentEndToken = yaml.tokens.DocumentEndToken -BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken -BlockMappingStartToken = yaml.tokens.BlockMappingStartToken -BlockEndToken = yaml.tokens.BlockEndToken -FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken -FlowMappingStartToken = yaml.tokens.FlowMappingStartToken -FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken -FlowMappingEndToken = yaml.tokens.FlowMappingEndToken -KeyToken = yaml.tokens.KeyToken -ValueToken = yaml.tokens.ValueToken -BlockEntryToken = yaml.tokens.BlockEntryToken -FlowEntryToken = yaml.tokens.FlowEntryToken -AliasToken = yaml.tokens.AliasToken -AnchorToken = yaml.tokens.AnchorToken -TagToken = yaml.tokens.TagToken -ScalarToken = yaml.tokens.ScalarToken - -StreamStartEvent = yaml.events.StreamStartEvent -StreamEndEvent = yaml.events.StreamEndEvent -DocumentStartEvent = yaml.events.DocumentStartEvent -DocumentEndEvent = yaml.events.DocumentEndEvent -AliasEvent = yaml.events.AliasEvent -ScalarEvent = yaml.events.ScalarEvent -SequenceStartEvent = yaml.events.SequenceStartEvent -SequenceEndEvent = yaml.events.SequenceEndEvent -MappingStartEvent = yaml.events.MappingStartEvent -MappingEndEvent = yaml.events.MappingEndEvent - -ScalarNode = yaml.nodes.ScalarNode -SequenceNode = yaml.nodes.SequenceNode -MappingNode = yaml.nodes.MappingNode - -cdef class Mark: - cdef readonly object name + 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 +YAMLError = yaml.error.YAMLError +ReaderError = yaml.reader.ReaderError +ScannerError = yaml.scanner.ScannerError +ParserError = yaml.parser.ParserError +ComposerError = yaml.composer.ComposerError +ConstructorError = yaml.constructor.ConstructorError +EmitterError = yaml.emitter.EmitterError +SerializerError = yaml.serializer.SerializerError +RepresenterError = yaml.representer.RepresenterError + +StreamStartToken = yaml.tokens.StreamStartToken +StreamEndToken = yaml.tokens.StreamEndToken +DirectiveToken = yaml.tokens.DirectiveToken +DocumentStartToken = yaml.tokens.DocumentStartToken +DocumentEndToken = yaml.tokens.DocumentEndToken +BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken +BlockMappingStartToken = yaml.tokens.BlockMappingStartToken +BlockEndToken = yaml.tokens.BlockEndToken +FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken +FlowMappingStartToken = yaml.tokens.FlowMappingStartToken +FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken +FlowMappingEndToken = yaml.tokens.FlowMappingEndToken +KeyToken = yaml.tokens.KeyToken +ValueToken = yaml.tokens.ValueToken +BlockEntryToken = yaml.tokens.BlockEntryToken +FlowEntryToken = yaml.tokens.FlowEntryToken +AliasToken = yaml.tokens.AliasToken +AnchorToken = yaml.tokens.AnchorToken +TagToken = yaml.tokens.TagToken +ScalarToken = yaml.tokens.ScalarToken + +StreamStartEvent = yaml.events.StreamStartEvent +StreamEndEvent = yaml.events.StreamEndEvent +DocumentStartEvent = yaml.events.DocumentStartEvent +DocumentEndEvent = yaml.events.DocumentEndEvent +AliasEvent = yaml.events.AliasEvent +ScalarEvent = yaml.events.ScalarEvent +SequenceStartEvent = yaml.events.SequenceStartEvent +SequenceEndEvent = yaml.events.SequenceEndEvent +MappingStartEvent = yaml.events.MappingStartEvent +MappingEndEvent = yaml.events.MappingEndEvent + +ScalarNode = yaml.nodes.ScalarNode +SequenceNode = yaml.nodes.SequenceNode +MappingNode = yaml.nodes.MappingNode + +cdef class Mark: + cdef readonly object name cdef readonly size_t index cdef readonly size_t line cdef readonly size_t column - cdef readonly buffer - cdef readonly pointer - + cdef readonly buffer + cdef readonly pointer + def __init__(self, object name, size_t index, size_t line, size_t 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 + 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 = '<file>' - else: - self.stream_name = u'<file>' - self.stream_cache = None - self.stream_cache_len = 0 - self.stream_cache_pos = 0 - yaml_parser_set_input(&self.parser, input_handler, <void *>self) - else: - if PyUnicode_CheckExact(stream) != 0: - stream = PyUnicode_AsUTF8String(stream) - if PY_MAJOR_VERSION < 3: - self.stream_name = '<unicode string>' - else: - self.stream_name = u'<unicode string>' - self.unicode_source = 1 - else: - if PY_MAJOR_VERSION < 3: - self.stream_name = '<byte string>' - else: - self.stream_name = u'<byte string>' - 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 + 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 = '<file>' + else: + self.stream_name = u'<file>' + self.stream_cache = None + self.stream_cache_len = 0 + self.stream_cache_pos = 0 + yaml_parser_set_input(&self.parser, input_handler, <void *>self) + else: + if PyUnicode_CheckExact(stream) != 0: + stream = PyUnicode_AsUTF8String(stream) + if PY_MAJOR_VERSION < 3: + self.stream_name = '<unicode string>' + else: + self.stream_name = u'<unicode string>' + self.unicode_source = 1 + else: + if PY_MAJOR_VERSION < 3: + self.stream_name = '<byte string>' + else: + self.stream_name = u'<byte string>' + 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: + 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: + 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: + 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: + 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) + 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: + 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: + 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) + 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 - + 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, size_t size, size_t *read) except 0: - cdef CParser parser - parser = <CParser>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: + cdef CParser parser + parser = <CParser>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 + + 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, <void *>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") + 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") + 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) + 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 + 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 + 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 + 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") + 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") + 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: + 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 + 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 + 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 + 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 - + 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, size_t size) except 0: - cdef CEmitter emitter - emitter = <CEmitter>data - if emitter.dump_unicode == 0: + cdef CEmitter emitter + emitter = <CEmitter>data + if emitter.dump_unicode == 0: value = PyString_FromStringAndSize(buffer, size) - else: + else: value = PyUnicode_DecodeUTF8(buffer, size, 'strict') - emitter.stream.write(value) - return 1 - + emitter.stream.write(value) + return 1 + |