yaml_parser_t

Vocabulary

yaml.ffi

Definition

USING: alien.c-types classes.struct ;

IN: yaml.ffi

STRUCT: yaml_parser_t
    { error yaml_error_type_t } { problem c-string }
    { problem_offset size_t initial: 0 }
    { problem_value int initial: 0 } {
        problem_mark yaml_mark_t initial:
        S{ yaml_mark_t { index 0 } { line 0 } { column 0 } }
    } { context c-string } {
        context_mark yaml_mark_t initial:
        S{ yaml_mark_t { index 0 } { line 0 } { column 0 } }
    } { read_handler yaml_read_handler_t* }
    { read_handler_data void* } {
        input yaml_parser_input initial: S{ yaml_parser_input
            { string
                S{ string_yaml_parser_input
                    { start f }
                    { end f }
                    { current f }
                }
            }
            { file f }
        }
    } { eof int initial: 0 } {
        buffer yaml_parser_buffer initial: S{ yaml_parser_buffer
            { start f }
            { end f }
            { pointer f }
            { last f }
        }
    } { unread size_t initial: 0 } {
        raw_buffer yaml_parser_raw_buffer initial: S{
        yaml_parser_raw_buffer
            { start f }
            { end f }
            { pointer f }
            { last f }
        }
    } { encoding yaml_encoding_t } { offset size_t initial: 0 } 
    {
        mark yaml_mark_t initial:
        S{ yaml_mark_t { index 0 } { line 0 } { column 0 } }
    } { stream_start_produced int initial: 0 }
    { stream_end_produced int initial: 0 }
    { flow_level int initial: 0 } {
        tokens yaml_parser_tokens initial: S{ yaml_parser_tokens
            { start f }
            { end f }
            { head f }
            { tail f }
        }
    } { tokens_parsed size_t initial: 0 }
    { token_available int initial: 0 } {
        indents yaml_parser_indents initial:
        S{ yaml_parser_indents { start f } { end f } { top f } }
    } { indent int initial: 0 }
    { simple_key_allowed int initial: 0 } {
        simple_keys yaml_parser_simple_keys initial: S{
        yaml_parser_simple_keys
            { start f }
            { end f }
            { top f }
        }
    } {
        states yaml_parser_states initial:
        S{ yaml_parser_states { start f } { end f } { top f } }
    } { state yaml_parser_state_t } {
        marks yaml_parser_marks initial:
        S{ yaml_parser_marks { start f } { end f } { top f } }
    } {
        tag_directives yaml_parser_tag_directives initial: S{
        yaml_parser_tag_directives
            { start f }
            { end f }
            { top f }
        }
    } {
        aliases yaml_parser_aliases initial:
        S{ yaml_parser_aliases { start f } { end f } { top f } }
    } { document yaml_document_t* } ;

Methods

USING: classes.struct classes.struct.private kernel yaml.ffi ;

M: yaml_parser_t clone
    clone-underlying \ yaml_parser_t memory>struct ; inline


USING: accessors classes.struct combinators.smart yaml.ffi ;

M: yaml_parser_t struct-slot-values
    {
        [ error>> ]
        [ problem>> ]
        [ problem_offset>> ]
        [ problem_value>> ]
        [ problem_mark>> ]
        [ context>> ]
        [ context_mark>> ]
        [ read_handler>> ]
        [ read_handler_data>> ]
        [ input>> ]
        [ eof>> ]
        [ buffer>> ]
        [ unread>> ]
        [ raw_buffer>> ]
        [ encoding>> ]
        [ offset>> ]
        [ mark>> ]
        [ stream_start_produced>> ]
        [ stream_end_produced>> ]
        [ flow_level>> ]
        [ tokens>> ]
        [ tokens_parsed>> ]
        [ token_available>> ]
        [ indents>> ]
        [ indent>> ]
        [ simple_key_allowed>> ]
        [ simple_keys>> ]
        [ states>> ]
        [ state>> ]
        [ marks>> ]
        [ tag_directives>> ]
        [ aliases>> ]
        [ document>> ]
    } cleave>array ; inline