import yaml

def get_version_string():

    return yaml_get_version_string()

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 int index

    cdef readonly int line

    cdef readonly int column

    cdef readonly buffer

    cdef readonly pointer

    def __init__(self, object name, int index, int line, int column,

            object buffer, object pointer):

        self.name = name

        self.index = index

        self.line = line

        self.column = column

        self.buffer = buffer

        self.pointer = pointer

    def get_snippet(self):

        return None

    def __str__(self):

        where = "  in \"%s\", line %d, column %d"   \

                % (self.name, self.line+1, self.column+1)

        return where

#class YAMLError(Exception):

#    pass

#

#class MarkedYAMLError(YAMLError):

#

#    def __init__(self, context=None, context_mark=None,

#            problem=None, problem_mark=None, note=None):

#        self.context = context

#        self.context_mark = context_mark

#        self.problem = problem

#        self.problem_mark = problem_mark

#        self.note = note

#

#    def __str__(self):

#        lines = []

#        if self.context is not None:

#            lines.append(self.context)

#        if self.context_mark is not None  \

#            and (self.problem is None or self.problem_mark is None

#                    or self.context_mark.name != self.problem_mark.name

#                    or self.context_mark.line != self.problem_mark.line

#                    or self.context_mark.column != self.problem_mark.column):

#            lines.append(str(self.context_mark))

#        if self.problem is not None:

#            lines.append(self.problem)

#        if self.problem_mark is not None:

#            lines.append(str(self.problem_mark))

#        if self.note is not None:

#            lines.append(self.note)

#        return '\n'.join(lines)

#

#class ReaderError(YAMLError):

#

#    def __init__(self, name, position, character, encoding, reason):

#        self.name = name

#        self.character = character

#        self.position = position

#        self.encoding = encoding

#        self.reason = reason

#

#    def __str__(self):

#        if isinstance(self.character, str):

#            return "'%s' codec can't decode byte #x%02x: %s\n"  \

#                    "  in \"%s\", position %d"    \

#                    % (self.encoding, ord(self.character), self.reason,

#                            self.name, self.position)

#        else:

#            return "unacceptable character #x%04x: %s\n"    \

#                    "  in \"%s\", position %d"    \

#                    % (ord(self.character), self.reason,

#                            self.name, self.position)

#

#class ScannerError(MarkedYAMLError):

#    pass

#

#class ParserError(MarkedYAMLError):

#    pass

#

#class EmitterError(YAMLError):

#    pass

#

#cdef class Token:

#    cdef readonly Mark start_mark

#    cdef readonly Mark end_mark

#    def __init__(self, Mark start_mark, Mark end_mark):

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#

#cdef class StreamStartToken(Token):

#    cdef readonly object encoding

#    def __init__(self, Mark start_mark, Mark end_mark, encoding):

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#        self.encoding = encoding

#

#cdef class StreamEndToken(Token):

#    pass

#

#cdef class DirectiveToken(Token):

#    cdef readonly object name

#    cdef readonly object value

#    def __init__(self, name, value, Mark start_mark, Mark end_mark):

#        self.name = name

#        self.value = value

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#

#cdef class DocumentStartToken(Token):

#    pass

#

#cdef class DocumentEndToken(Token):

#    pass

#

#cdef class BlockSequenceStartToken(Token):

#    pass

#

#cdef class BlockMappingStartToken(Token):

#    pass

#

#cdef class BlockEndToken(Token):

#    pass

#

#cdef class FlowSequenceStartToken(Token):

#    pass

#

#cdef class FlowMappingStartToken(Token):

#    pass

#

#cdef class FlowSequenceEndToken(Token):

#    pass

#

#cdef class FlowMappingEndToken(Token):

#    pass

#

#cdef class KeyToken(Token):

#    pass

#

#cdef class ValueToken(Token):

#    pass

#

#cdef class BlockEntryToken(Token):

#    pass

#

#cdef class FlowEntryToken(Token):

#    pass

#

#cdef class AliasToken(Token):

#    cdef readonly object value

#    def __init__(self, value, Mark start_mark, Mark end_mark):

#        self.value = value

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#

#cdef class AnchorToken(Token):

#    cdef readonly object value

#    def __init__(self, value, Mark start_mark, Mark end_mark):

#        self.value = value

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#

#cdef class TagToken(Token):

#    cdef readonly object value

#    def __init__(self, value, Mark start_mark, Mark end_mark):

#        self.value = value

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#

#cdef class ScalarToken(Token):

#    cdef readonly object value

#    cdef readonly object plain

#    cdef readonly object style

#    def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None):

#        self.value = value

#        self.plain = plain

#        self.start_mark = start_mark

#        self.end_mark = end_mark

#        self.style = style

cdef class CParser:

    cdef yaml_parser_t parser

    cdef yaml_event_t parsed_event

    cdef object stream

    cdef object stream_name

    cdef object current_token

    cdef object current_event

    cdef object anchors

    def __init__(self, stream):

        if yaml_parser_initialize(&self.parser) == 0:

            raise MemoryError

        self.parsed_event.type = YAML_NO_EVENT

        if hasattr(stream, 'read'):

            self.stream = stream

            try:

                self.stream_name = stream.name

            except AttributeError:

                self.stream_name = '<file>'

            yaml_parser_set_input(&self.parser, input_handler, <void *>self)

        else:

            if PyUnicode_CheckExact(stream) != 0:

                stream = PyUnicode_AsUTF8String(stream)

                self.stream_name = '<unicode string>'

            else:

                self.stream_name = '<string>'

            if PyString_CheckExact(stream) == 0:

                raise TypeError("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)

    cdef object _parser_error(self):

        if self.parser.error == YAML_MEMORY_ERROR:

            raise MemoryError

        elif self.parser.error == YAML_READER_ERROR:

            raise ReaderError(self.stream_name, self.parser.problem_offset,

                    self.parser.problem_value, '?', 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)

            if self.parser.error == YAML_SCANNER_ERROR:

                if self.parser.context != NULL:

                    return ScannerError(self.parser.context, context_mark,

                            self.parser.problem, problem_mark)

                else:

                    return ScannerError(None, None,

                            self.parser.problem, problem_mark)

            else:

                if self.parser.context != NULL:

                    return ParserError(self.parser.context, context_mark,

                            self.parser.problem, problem_mark)

                else:

                    return ParserError(None, None,

                            self.parser.problem, problem_mark)

        raise ValueError("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:

                encoding = "utf-8"

            elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING:

                encoding = "utf-16-le"

            elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING:

                encoding = "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("YAML",

                    (token.data.version_directive.major,

                        token.data.version_directive.minor),

                    start_mark, end_mark)

        elif token.type == YAML_TAG_DIRECTIVE_TOKEN:

            return DirectiveToken("TAG",

                    (token.data.tag_directive.handle,

                        token.data.tag_directive.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_DecodeUTF8(token.data.alias.value,

                    strlen(token.data.alias.value), 'strict')

            return AliasToken(value, start_mark, end_mark)

        elif token.type == YAML_ANCHOR_TOKEN:

            value = PyUnicode_DecodeUTF8(token.data.anchor.value,

                    strlen(token.data.anchor.value), 'strict')

            return AnchorToken(value, start_mark, end_mark)

        elif token.type == YAML_TAG_TOKEN:

            handle = PyUnicode_DecodeUTF8(token.data.tag.handle,

                    strlen(token.data.tag.handle), 'strict')

            suffix = PyUnicode_DecodeUTF8(token.data.tag.suffix,

                    strlen(token.data.tag.suffix), 'strict')

            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 = ''

            elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE:

                style = '\''

            elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE:

                style = '"'

            elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE:

                style = '|'

            elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:

                style = '>'

            return ScalarToken(value, plain,

                    start_mark, end_mark, style)

        else:

            raise ValueError("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:

                encoding = "utf-8"

            elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING:

                encoding = "utf-16-le"

            elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING:

                encoding = "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 = {}