| |
| import yaml |
| |
| def get_version_string(): |
| cdef const char *value |
| value = yaml_get_version_string() |
| 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 |
| |
| 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 |
| 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: |
| 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) |
| self.stream_name = u'<unicode string>' |
| self.unicode_source = 1 |
| else: |
| self.stream_name = u'<byte string>' |
| if PyBytes_CheckExact(stream) == 0: |
| raise TypeError(u"a string or stream input is required") |
| self.stream = stream |
| yaml_parser_set_input_string(&self.parser, PyBytes_AS_Yaml_STRING(stream), PyBytes_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: |
| 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: |
| context = PyUnicode_FromString(self.parser.context) |
| 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) |
| 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_FromYamlString(token.data.tag_directive.handle) |
| prefix = PyUnicode_FromYamlString(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_FromYamlString(token.data.alias.value) |
| return AliasToken(value, start_mark, end_mark) |
| elif token.type == YAML_ANCHOR_TOKEN: |
| value = PyUnicode_FromYamlString(token.data.anchor.value) |
| return AnchorToken(value, start_mark, end_mark) |
| elif token.type == YAML_TAG_TOKEN: |
| handle = PyUnicode_FromYamlString(token.data.tag.handle) |
| suffix = PyUnicode_FromYamlString(token.data.tag.suffix) |
| if not handle: |
| handle = None |
| return TagToken((handle, suffix), start_mark, end_mark) |
| elif token.type == YAML_SCALAR_TOKEN: |
| value = PyUnicode_DecodeUTF8(<char *>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: |
| 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_FromYamlString(tag_directive.handle) |
| prefix = PyUnicode_FromYamlString(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_FromYamlString(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_FromYamlString(event.data.scalar.anchor) |
| tag = None |
| if event.data.scalar.tag != NULL: |
| tag = PyUnicode_FromYamlString(event.data.scalar.tag) |
| value = PyUnicode_DecodeUTF8(<char *>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_FromYamlString(event.data.sequence_start.anchor) |
| tag = None |
| if event.data.sequence_start.tag != NULL: |
| tag = PyUnicode_FromYamlString(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_FromYamlString(event.data.mapping_start.anchor) |
| tag = None |
| if event.data.mapping_start.tag != NULL: |
| tag = PyUnicode_FromYamlString(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: |
| 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) |
| 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_FromYamlString(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) |
| 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_FromYamlString(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_FromYamlString(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_FromYamlString(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) |
| raise ComposerError(u"found duplicate anchor; first occurrence", |
| self.anchors[anchor].start_mark, u"second occurrence", mark) |
| self.descend_resolver(parent, index) |
| if self.parsed_event.type == YAML_SCALAR_EVENT: |
| node = self._compose_scalar_node(anchor) |
| elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: |
| node = self._compose_sequence_node(anchor) |
| elif self.parsed_event.type == YAML_MAPPING_START_EVENT: |
| node = self._compose_mapping_node(anchor) |
| self.ascend_resolver() |
| return node |
| |
| cdef _compose_scalar_node(self, object anchor): |
| start_mark = Mark(self.stream_name, |
| self.parsed_event.start_mark.index, |
| self.parsed_event.start_mark.line, |
| self.parsed_event.start_mark.column, |
| None, None) |
| end_mark = Mark(self.stream_name, |
| self.parsed_event.end_mark.index, |
| self.parsed_event.end_mark.line, |
| self.parsed_event.end_mark.column, |
| None, None) |
| value = PyUnicode_DecodeUTF8(<char *>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_FromYamlString(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_FromYamlString(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_FromYamlString(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, unsigned 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 PyBytes_CheckExact(value) == 0: |
| raise TypeError(u"a string value is expected") |
| parser.stream_cache = value |
| parser.stream_cache_pos = 0 |
| parser.stream_cache_len = PyBytes_GET_SIZE(value) |
| if (parser.stream_cache_len - parser.stream_cache_pos) < <int>size: |
| size = parser.stream_cache_len - parser.stream_cache_pos |
| if size > 0: |
| memcpy(buffer, PyBytes_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 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: |
| problem = PyUnicode_FromString(self.emitter.problem) |
| return EmitterError(problem) |
| 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 yaml_char_t *anchor |
| cdef yaml_char_t *tag |
| cdef yaml_char_t *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: |
| 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 PyBytes_CheckExact(handle): |
| raise TypeError(u"tag handle must be a string") |
| tag_directives_end.handle = PyBytes_AS_Yaml_STRING(handle) |
| if PyUnicode_CheckExact(prefix): |
| prefix = PyUnicode_AsUTF8String(prefix) |
| cache.append(prefix) |
| if not PyBytes_CheckExact(prefix): |
| raise TypeError(u"tag prefix must be a string") |
| tag_directives_end.prefix = PyBytes_AS_Yaml_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 PyBytes_CheckExact(anchor_object): |
| raise TypeError(u"anchor must be a string") |
| anchor = PyBytes_AS_Yaml_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 PyBytes_CheckExact(anchor_object): |
| raise TypeError(u"anchor must be a string") |
| anchor = PyBytes_AS_Yaml_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 PyBytes_CheckExact(tag_object): |
| raise TypeError(u"tag must be a string") |
| tag = PyBytes_AS_Yaml_STRING(tag_object) |
| value_object = event_object.value |
| if PyUnicode_CheckExact(value_object): |
| value_object = PyUnicode_AsUTF8String(value_object) |
| if not PyBytes_CheckExact(value_object): |
| raise TypeError(u"value must be a string") |
| value = PyBytes_AS_Yaml_STRING(value_object) |
| length = PyBytes_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 PyBytes_CheckExact(anchor_object): |
| raise TypeError(u"anchor must be a string") |
| anchor = PyBytes_AS_Yaml_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 PyBytes_CheckExact(tag_object): |
| raise TypeError(u"tag must be a string") |
| tag = PyBytes_AS_Yaml_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 PyBytes_CheckExact(anchor_object): |
| raise TypeError(u"anchor must be a string") |
| anchor = PyBytes_AS_Yaml_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 PyBytes_CheckExact(tag_object): |
| raise TypeError(u"tag must be a string") |
| tag = PyBytes_AS_Yaml_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: |
| 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: |
| raise SerializerError(u"serializer is closed") |
| else: |
| raise SerializerError(u"serializer is already opened") |
| |
| def close(self): |
| cdef yaml_event_t event |
| if self.closed == -1: |
| 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: |
| raise SerializerError(u"serializer is not opened") |
| elif self.closed == 1: |
| 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: |
| 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 PyBytes_CheckExact(handle): |
| raise TypeError(u"tag handle must be a string") |
| tag_directives_end.handle = PyBytes_AS_Yaml_STRING(handle) |
| if PyUnicode_CheckExact(prefix): |
| prefix = PyUnicode_AsUTF8String(prefix) |
| cache.append(prefix) |
| if not PyBytes_CheckExact(prefix): |
| raise TypeError(u"tag prefix must be a string") |
| tag_directives_end.prefix = PyBytes_AS_Yaml_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 yaml_char_t *anchor |
| cdef yaml_char_t *tag |
| cdef yaml_char_t *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 PyBytes_CheckExact(anchor_object): |
| raise TypeError(u"anchor must be a string") |
| anchor = PyBytes_AS_Yaml_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 PyBytes_CheckExact(tag_object): |
| raise TypeError(u"tag must be a string") |
| tag = PyBytes_AS_Yaml_STRING(tag_object) |
| value_object = node.value |
| if PyUnicode_CheckExact(value_object): |
| value_object = PyUnicode_AsUTF8String(value_object) |
| if not PyBytes_CheckExact(value_object): |
| raise TypeError(u"value must be a string") |
| value = PyBytes_AS_Yaml_STRING(value_object) |
| length = PyBytes_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 PyBytes_CheckExact(tag_object): |
| raise TypeError(u"tag must be a string") |
| tag = PyBytes_AS_Yaml_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 PyBytes_CheckExact(tag_object): |
| raise TypeError(u"tag must be a string") |
| tag = PyBytes_AS_Yaml_STRING(tag_object) |
| mapping_style = YAML_BLOCK_MAPPING_STYLE |
| if node.flow_style: |
| mapping_style = YAML_FLOW_MAPPING_STYLE |
| if yaml_mapping_start_event_initialize(&event, anchor, tag, |
| implicit, mapping_style) == 0: |
| raise MemoryError |
| if yaml_emitter_emit(&self.emitter, &event) == 0: |
| error = self._emitter_error() |
| raise error |
| for item_key, item_value in node.value: |
| self._serialize_node(item_key, node, None) |
| self._serialize_node(item_value, node, item_key) |
| yaml_mapping_end_event_initialize(&event) |
| if yaml_emitter_emit(&self.emitter, &event) == 0: |
| error = self._emitter_error() |
| raise error |
| self.ascend_resolver() |
| return 1 |
| |
| cdef int output_handler(void *data, unsigned char *bufferu, size_t size) except 0: |
| cdef CEmitter emitter |
| cdef char *buffer |
| buffer = <char *>bufferu |
| emitter = <CEmitter>data |
| if emitter.dump_unicode == 0: |
| value = PyBytes_FromStringAndSize(buffer, size) |
| else: |
| value = PyUnicode_DecodeUTF8(buffer, size, 'strict') |
| emitter.stream.write(value) |
| return 1 |
| |
