packages feed

YamlReference (empty) → 0.1

raw patch · 1337 files changed

+9036/−0 lines, 1337 filesdep +HUnitdep +basedep +dlistbuild-type:Customsetup-changed

Dependencies added: HUnit, base, dlist, regex-compat

Files

+ Setup.hs view
@@ -0,0 +1,7 @@+import Distribution.Simple+import System.Cmd+main = defaultMainWithHooks $ defaultUserHooks { runTests = run, preClean = clean }+    where run _ _ _ _ = system $ "dist/build/yaml2yeast-test/yaml2yeast-test tests"+          clean _ _ = do+            system $ "rm -f tests/*.error"+            return (Nothing, [])
+ Text/Yaml/Reference.bnf view
@@ -0,0 +1,697 @@+-- ** Spec productions+--+-- These are copied directly from the spec, with the addition of the occasional+-- decision point and commitment.++c_printable = '\x9'+            / '\xA'+            / '\xD'+            / ('\x20', '\x7E')+            / '\x85'+            / ('\xA0', '\xD7FF')+            / ('\xE000', '\xFFFD')+            / ('\x10000', '\x10FFFF')++c_byte_order_mark = '\xFEFF' & detect_utf_encoding++-- Indicators:++c_sequence_entry = indicator '-'+c_mapping_key    = indicator '?'+c_mapping_value  = indicator ':'+c_collect_entry  = indicator ','+c_sequence_start = indicator '['+c_sequence_end   = indicator ']'+c_mapping_start  = indicator '{'+c_mapping_end    = indicator '}'+c_comment        = indicator '#'+c_anchor         = indicator '&'+c_alias          = indicator '*'+c_tag            = indicator '!'+c_literal        = indicator '|'+c_folded         = indicator '>'+c_single_quote   = indicator '\''+c_double_quote   = indicator '"'+c_directive      = indicator '%'+c_reserved       = indicator ( '@' /  '`' )++c_indicator = c_sequence_entry+            / c_mapping_key+            / c_mapping_value+            / c_collect_entry+            / c_sequence_start+            / c_sequence_end+            / c_mapping_start+            / c_mapping_end+            / c_comment+            / c_anchor+            / c_alias+            / c_tag+            / c_literal+            / c_folded+            / c_single_quote+            / c_double_quote+            / c_directive+            / c_reserved++c_flow_indicator = c_collect_entry+                 / c_sequence_start / c_sequence_end+                 / c_mapping_start  / c_mapping_end++-- Line breaks:++b_line_feed           = '\xA'+b_carriage_return     = '\xD'+b_next_line           = '\x85'+b_line_separator      = '\x2028'+b_paragraph_separator = '\x2029'++b_char = b_line_feed+       / b_carriage_return+       / b_next_line+       / b_line_separator+       / b_paragraph_separator++b_specific = ( b_line_separator / b_paragraph_separator )+           & nextLine++b_generic = ( b_carriage_return & b_line_feed+            / b_carriage_return+            / b_line_feed+            / b_next_line )+          & nextLine++b_as_line_feed    = token LineFeed b_generic+b_normalized      = b_as_line_feed / token Break b_specific+b_ignored_generic = token Continue b_generic+b_ignored_any     = b_ignored_generic / token Continue b_specific++-- Chars:++nb_char = c_printable - b_char+s_space = '\x20'+s_tab   = '\x9'+s_white = s_space / s_tab+ns_char = nb_char - s_white++ns_dec_digit    = ('\x30', '\x39')+ns_hex_digit    = ns_dec_digit / ('\x41', '\x46') / ('\x61', '\x66')+ns_ascii_letter = ('\x41', '\x5A') / ('\x61', '\x7A')+ns_word_char    = ns_dec_digit / ns_ascii_letter / '-'++ns_uri_char = "escape"+            ^ ( ns_word_char+              / '%' ! "escape" & ns_hex_digit & ns_hex_digit+              / ';' / '/' / '?' / ':' / '@' / '&'  / '=' / '+' / '$' / ','+              / '_' / '.' / '!' / '~' / '*' / '\'' / '(' / ')' / '[' / ']' )+ns_tag_char = ns_uri_char - c_tag++-- Escape:++c_escape = indicator '\\'++ns_esc_null                = meta '0'+ns_esc_bell                = meta 'a'+ns_esc_backspace           = meta 'b'+ns_esc_horizontal_tab      = meta ( 't' / '\x9' )+ns_esc_line_feed           = meta 'n'+ns_esc_vertical_tab        = meta 'v'+ns_esc_form_feed           = meta 'f'+ns_esc_carriage_return     = meta 'r'+ns_esc_escape              = meta 'e'+ns_esc_space               = meta '\x20'+ns_esc_double_quote        = meta '"'+ns_esc_backslash           = meta '\\'+ns_esc_next_line           = meta 'N'+ns_esc_non_breaking_space  = meta '_'+ns_esc_line_separator      = meta 'L'+ns_esc_paragraph_separator = meta 'P'+ns_esc_8_bit               = indicator 'x' ! "escaped" & meta ( ns_hex_digit % 2 )+ns_esc_16_bit              = indicator 'u' ! "escaped" & meta ( ns_hex_digit % 4 )+ns_esc_32_bit              = indicator 'U' ! "escaped" & meta ( ns_hex_digit % 8 )++ns_esc_char = nest BeginEscape+            & c_escape ! "escape"+            & "escaped"+            ^ ( ns_esc_null+              / ns_esc_bell+              / ns_esc_backspace+              / ns_esc_horizontal_tab+              / ns_esc_line_feed+              / ns_esc_vertical_tab+              / ns_esc_form_feed+              / ns_esc_carriage_return+              / ns_esc_escape+              / ns_esc_space+              / ns_esc_double_quote+              / ns_esc_backslash+              / ns_esc_next_line+              / ns_esc_non_breaking_space+              / ns_esc_line_separator+              / ns_esc_paragraph_separator+              / ns_esc_8_bit+              / ns_esc_16_bit+              / ns_esc_32_bit )+            & nest EndEscape++-- Spaces:++s_indent    n      = token Indent ( s_space % n )+s_indent_lt n      = token Indent ( s_space <% n )+s_indent_le n      = token Indent ( s_space <% (n .+ 1) )+s_separate_in_line = token White ( s_white +) / sol++-- Empty lines++s_ignored_prefix n s = case s of+                            Plain   -> s_ignored_prefix_flow n+                            Double  -> s_ignored_prefix_flow n+                            Single  -> s_ignored_prefix_flow n+                            Literal -> s_ignored_prefix_block n+                            Folded  -> s_ignored_prefix_block n++s_ignored_prefix_flow  n = s_indent n & ( s_separate_in_line ?)+s_ignored_prefix_block n = s_indent n++l_empty n s = ( s_ignored_prefix n s / s_indent_lt n ) & b_normalized++-- Comments: TODO++c_nb_comment_text = nest BeginComment+                  & c_comment & meta ( nb_char *)+                  & nest EndComment++s_b_comment  = ( s_separate_in_line & ( c_nb_comment_text ?) ?) & b_ignored_any+s_l_comments = ( s_b_comment / sol ) & ( l_comment *)+l_comment    = s_separate_in_line & ( c_nb_comment_text ?) & b_ignored_any++-- Folding:++b_l_folded_specific n s = token Break b_specific & ( l_empty n s *)+b_l_folded_as_space     = token LineFold b_generic+b_l_folded_trimmed  n s = b_ignored_generic & ( l_empty n s +)+b_l_folded_any      n s = b_l_folded_specific n s / b_l_folded_trimmed n s / b_l_folded_as_space+s_l_flow_folded     n   = ( s_separate_in_line ?) & b_l_folded_any n Plain++-- Directives:++l_directive = nest BeginDirective+            & c_directive+            & "directive" ^ ( ns_yaml_directive / ns_tag_directive / ns_reserved_directive )+            & nest EndDirective+            & s_l_comments++ns_reserved_directive  = ns_directive_name & ( s_separate_in_line & ns_directive_parameter *)+ns_directive_name      = meta ( ns_char +)+ns_directive_parameter = meta ( ns_char +)++-- Yaml directive:++ns_yaml_directive = meta [ 'Y', 'A', 'M', 'L' ] ! "directive"+                  & s_separate_in_line & ns_yaml_version+ns_yaml_version   = meta ( ( ns_dec_digit +) & '.' & ( ns_dec_digit +) )++-- Tag directive:++ns_tag_directive = meta [ 'T', 'A', 'G' ] ! "directive"+                 & s_separate_in_line & c_tag_handle+                 & s_separate_in_line & ns_tag_prefix++c_tag_handle = c_named_tag_handle+             / c_secondary_tag_handle+             / c_primary_tag_handle++c_primary_tag_handle   = nest BeginHandle+                       & c_tag+                       & nest EndHandle+c_secondary_tag_handle = nest BeginHandle+                       & c_tag & c_tag+                       & nest EndHandle+c_named_tag_handle     = nest BeginHandle+                       & c_tag & meta ( ns_word_char +) & c_tag+                       & nest EndHandle++ns_tag_prefix = nest BeginTag+              & ( c_ns_local_tag_prefix / ns_global_tag_prefix )+              & nest EndTag++c_ns_local_tag_prefix = c_tag & meta ( ns_uri_char *)+ns_global_tag_prefix  = meta ( ns_tag_char & ( ns_uri_char *) )++-- Properties:++c_ns_properties = nest BeginProperties+                & c_ns_property & ( s_separate_in_line & c_ns_property *)+                & nest EndProperties+c_ns_property   = c_ns_anchor_property / c_ns_tag_property++-- Tag:++c_ns_tag_property = nest BeginTag+                  & ( c_verbatim_tag / c_ns_shorthand_tag / c_non_specific_tag )+                  & nest EndTag++c_verbatim_tag     = c_tag & indicator '<' & meta ( ns_uri_char +) & indicator '>'+c_ns_shorthand_tag = c_named_tag_handle & meta ( ns_uri_char +)+                   / c_secondary_tag_handle & meta ( ns_uri_char +)+                   / c_primary_tag_handle & meta ( ns_tag_char +)+c_non_specific_tag = c_tag++-- Anchor:++c_ns_anchor_property = nest BeginAnchor+                     & c_anchor & ns_anchor_name+                     & nest EndAnchor++ns_anchor_char = ns_char - c_flow_indicator+ns_anchor_name = meta ( ns_anchor_char +)++-- Double:++nb_double_char = "escape" ^ ( ns_esc_char / nb_char - c_escape - c_double_quote )+ns_double_char = nb_double_char - s_white++c_double_quoted n c = nest BeginScalar+                    & c_double_quote ! "node" & text ( nb_double_text n c ) & c_double_quote+                    & nest EndScalar++nb_double_text n c = case c of+                          FlowOut -> s_double_multi n+                          FlowIn  -> s_double_multi n+                          FlowKey -> ( nb_double_char *)++s_double_multi   n = ( s_ns_double_chars *)+                   & ( s_ns_double_next n *)+                   & ( s_white *)+s_ns_double_chars  = ( s_white *) & ns_double_char+s_ns_double_next n = s_l_double_any n+                   & s_ignored_prefix n Double+                   & ( ns_double_char & ( s_ns_double_chars *) ?)+s_l_double_any   n = "escape" ^ ( s_b_double_escaped / s_l_flow_folded n )+s_b_double_escaped = ( s_white *)+                   & nest BeginEscape+                   & c_escape ! "escape"+                   & b_ignored_any+                   & nest EndEscape++-- Single:++c_quoted_quote = nest BeginEscape+               & c_single_quote ! "escape" & meta '\''+               & nest EndEscape+nb_single_char = "escape" ^ ( c_quoted_quote / nb_char - c_single_quote )+ns_single_char = nb_single_char - s_white++c_single_quoted n c = nest BeginScalar+                    & c_single_quote & text ( nb_single_text n c ) & c_single_quote+                    & nest EndScalar++nb_single_text n c = case c of+                          FlowOut -> s_single_multi n+                          FlowIn  -> s_single_multi n+                          FlowKey -> ( nb_single_char *)++s_ns_single_chars  = ( s_white *) & ns_single_char+s_single_multi   n = ( s_ns_single_chars *)+                   & ( s_ns_single_next n *)+                   & ( s_white *)+s_ns_single_next n = s_l_flow_folded n+                   & s_ignored_prefix n Double+                   & ( ns_single_char & ( s_ns_single_chars *) ?)++-- Plain:++ns_plain_safe c = case c of+                       FlowOut -> ns_plain_safe_out+                       FlowIn  -> ns_plain_safe_in+                       FlowKey -> ns_plain_safe_in++ns_plain_safe_out = ns_char - c_mapping_value - c_comment+ns_plain_safe_in  = ns_plain_safe_out - c_flow_indicator+ns_plain_char c   = ( ':' +) & ( '#' / ns_plain_safe c ) & ( '#' *)+                  / ns_plain_safe c & ( '#' *)+nb_plain_char c   = s_white / ns_plain_char c+ns_plain_first c  = ( '-' / '?' / ':' ) & ( ( '#' +) / ns_plain_char c )+                  / ns_plain_char c - c_indicator++ns_plain n c = nest BeginScalar+             & text (case c of+                          FlowOut -> ns_plain_multi n c+                          FlowIn  -> ns_plain_multi n c+                          FlowKey -> ns_plain_single c)+             & nest EndScalar++ns_plain_single   c = ns_plain_first c ! "node" & ( s_ns_plain_chars c *)+s_ns_plain_chars  c = ( s_white *) & ns_plain_char c+ns_plain_multi  n c = ns_plain_single c & ( s_ns_plain_next n c *)+s_ns_plain_next n c = s_l_flow_folded n+                    & s_ignored_prefix n Plain+                    & ns_plain_char c+                    & ( s_ns_plain_chars c *)++-- Separation: TODO++s_separate_in_flow n c = case c of+                              FlowOut  -> s_separate_lines n+                              FlowIn   -> s_separate_lines n+                              FlowKey  -> s_separate_in_line++s_separate_lines n = s_l_comments & s_ignored_prefix_flow n+                   / s_separate_in_line++-- Flow collection:++in_flow c = case c of+                 FlowOut -> FlowIn+                 FlowIn  -> FlowIn+                 FlowKey -> FlowKey++-- Flow sequence:++c_flow_sequence n c = nest BeginSequence+                    & c_sequence_start ! "node"+                    & ( s_separate_in_flow n c ?)+                    & ( ns_s_flow_seq_entries n (in_flow c) ?)+                    & c_sequence_end+                    & nest EndSequence++ns_s_flow_seq_entries n c = ns_flow_seq_entry n c+                          & ( s_separate_in_flow n c ?)+                          & ( c_collect_entry+                            & ( s_separate_in_flow n c ?)+                            & ( ns_s_flow_seq_entries n c ?) ?)++ns_flow_seq_entry n c = "pair" ^ ( ns_flow_map_single_pair n c / "node" ^ ns_flow_node n c )++-- Flow mapping:++c_flow_mapping n c = nest BeginMapping+                   & c_mapping_start ! "node"+                   & ( s_separate_in_flow n c ?)+                   & ( ns_s_flow_map_entries n (in_flow c) ?)+                   & c_mapping_end+                   & nest EndMapping++ns_s_flow_map_entries n c = ns_flow_map_entry n c+                          & ( s_separate_in_flow n c ?)+                          & ( c_collect_entry+                            & ( s_separate_in_flow n c ?)+                            & ( ns_s_flow_map_entries n c ?) ?)++ns_flow_map_entry n c = nest BeginPair+                      & "pair"+                      ^ ( c_mapping_key ! "pair" & s_ns_flow_map_explicit_entry n c+                        / ns_flow_map_implicit_entry n c )+                      & nest EndPair++s_ns_flow_map_explicit_entry n c = "entry"+                                 ^ ( s_ns_flow_map_explicit_json n c+                                   / s_ns_flow_map_explicit_yaml n c+                                   / s_ns_flow_map_explicit_empty n c+                                   / e_node & e_node )+s_ns_flow_map_explicit_json  n c = s_separate_in_flow n c+                                 & ( "node" ^ c_flow_json_node n c ) ! "entry"+                                 & ( ( s_separate_in_flow n c ?) & c_ns_flow_map_adjacent_value n c+                                   / e_node )+s_ns_flow_map_explicit_yaml  n c = s_separate_in_flow n c+                                 & ( "node" ^ ns_flow_yaml_node n c ) ! "entry"+                                 & ( ( s_separate_in_flow n c ?) & c_ns_flow_map_separate_value n c+                                   / e_node )+s_ns_flow_map_explicit_empty n c = s_separate_in_flow n c & e_node & c_ns_flow_map_separate_value n c++c_ns_flow_map_separate_value n c = c_mapping_value ! "pair"+                                 & ( s_separate_in_flow n c & ns_flow_node n c+                                   / e_node )+c_ns_flow_map_adjacent_value n c = c_mapping_value ! "pair"+                                 & ( ( s_separate_in_flow n c ?) & ns_flow_node n c+                                   / e_node )++ns_flow_map_implicit_entry  n c = c_ns_flow_map_implicit_json n c+                                / ns_flow_map_implicit_yaml n c+                                / ns_flow_map_implicit_empty n c+c_ns_flow_map_implicit_json n c = c_s_simple_json_key  & ( c_ns_flow_map_adjacent_value n c / e_node )+ns_flow_map_implicit_yaml   n c = ns_s_simple_yaml_key & ( c_ns_flow_map_separate_value n c / e_node )+ns_flow_map_implicit_empty  n c = e_node & c_ns_flow_map_separate_value n c++c_s_simple_json_key  = ( "node" ^ ( c_flow_json_node  na FlowKey ) & ( s_separate_in_line ?) ) `limitedTo` 1024+ns_s_simple_yaml_key = ( "node" ^ ( ns_flow_yaml_node na FlowKey ) & ( s_separate_in_line ?) ) `limitedTo` 1024++ns_flow_map_single_pair   n c = nest BeginMapping+                              & nest BeginPair+                              & ( c_mapping_key ! "pair" & s_ns_flow_map_explicit_entry n c+                                / ns_flow_map_single_entry n c )+                              & nest EndPair+                              & nest EndMapping+ns_flow_map_single_entry  n c = "entry"+                              ^ ( c_ns_flow_map_single_json n c+                                / ns_flow_map_single_yaml n c+                                / ns_flow_map_implicit_empty n c )+c_ns_flow_map_single_json n c = c_s_simple_json_key  & c_ns_flow_map_adjacent_value n c+ns_flow_map_single_yaml   n c = ns_s_simple_yaml_key & c_ns_flow_map_separate_value n c++-- Alias:++c_ns_alias = nest BeginAlias+           & c_alias ! "node" & ns_anchor_name+           & nest EndAlias++-- Empty:++e_scalar = nest BeginScalar & nest EndScalar+e_node   = nest BeginNode & e_scalar & nest EndNode++-- Flow node:++ns_flow_content      n c = c_flow_json_content n c+                         / ns_flow_yaml_content n c+c_flow_json_content  n c = c_flow_sequence n c+                         / c_flow_mapping n c+                         / c_single_quoted n c+                         / c_double_quoted n c+ns_flow_yaml_content n c = ns_plain n c++c_flow_json_node   n c = nest BeginNode+                       & ( c_ns_properties & s_separate_in_line ?)+                       & c_flow_json_content n c+                       & nest EndNode+ns_flow_yaml_node  n c = nest BeginNode+                       & ( c_ns_alias+                         / ( c_ns_properties+                           & ( s_separate_in_line & ns_flow_yaml_content n c+                             / e_scalar ) )+                         / ns_flow_yaml_content n c )+                       & nest EndNode+ns_flow_node       n c = nest BeginNode+                       & ( c_ns_alias+                         / ( c_ns_properties+                           & ( s_separate_in_line & ns_flow_content n c+                             / e_scalar ) )+                         / ns_flow_content n c )+                       & nest EndNode++-- Block scalar:++c_indentation_indicator n = indicator ( ns_dec_digit - '0' ) & asInteger+                          / detect_scalar_indentation n++detect_scalar_indentation n = peek $ ( nb_char *)+                                   & ( b_ignored_any & ( l_empty n Literal *) ?)+                                   & count_spaces (-n)++count_spaces n  = (s_space & count_spaces (n .+ 1))+                / result (max 1 n)++c_style_indicator s = case s of+                           Literal -> indicator '|'+                           Folded  -> indicator '>'++c_chomping_indicator = indicator '-' & result Strip+                     / indicator '+' ! "header" & result Keep+                     / result Clip++c_b__block_header n s = c_style_indicator s ! "node"+                      & "header"+                      ^ ( do t <- c_chomping_indicator+                             m <- c_indentation_indicator n+                             ( s_white / b_char ) ?! "header"+                             s_b_comment+                             result (m, t)+                        / do m <- c_indentation_indicator n+                             t <- c_chomping_indicator+                             s_b_comment+                             result (m, t) )++-- Chomping:++b_chomped_last t = case t of+                        Strip -> nest EndScalar & b_ignored_any+                        Clip  -> b_normalized & nest EndScalar+                        Keep  -> b_normalized++l_chomped_empty n t = case t of+                           Strip -> l_strip_empty n+                           Clip  -> l_strip_empty n+                           Keep  -> l_keep_empty n++l_strip_empty n = ( s_indent_le n & b_ignored_any *)+                & ( l_trail_comments n ?)+l_keep_empty  n = ( s_indent_le n & b_normalized *)+                & nest EndScalar+                & ( l_trail_comments n ?)++l_trail_comments n = s_indent_lt n & c_nb_comment_text & b_ignored_any+                   & ( l_comment *)++-- Literal:++c_l__literal n = do nest BeginScalar+                    (m, t) <- c_b__block_header n Literal+                    text ( l_literal_content (n .+ m) t )++l_nb_literal_chars n   = ( l_empty n Literal *) & s_indent n & ( nb_char +)+b_l_literal_next   n   = b_normalized & l_nb_literal_chars n+l_literal_content  n t = ( l_nb_literal_chars n & ( b_l_literal_next n *) & b_chomped_last t ?)+                       & l_chomped_empty n t++-- Folded:++c_l__folded n = do nest BeginScalar+                   (m, t) <- c_b__block_header n Folded+                   text ( l_folded_content (n .+ m) t )++s_nb_folded_text  n = s_indent n & ns_char ! "fold" & ( nb_char *)+l_nb_folded_lines n = s_nb_folded_text n+                    & ( b_l_folded_any n Folded & s_nb_folded_text n *)++l_nb_start_with_folded n = ( l_empty n Folded *)+                         & l_nb_folded_lines n+                         & "fold" ^ ( b_normalized & l_nb_start_with_spaced n ?)++s_nb_spaced_text  n = s_indent n & s_white ! "fold" & ( nb_char *)+b_l_spaced        n = b_normalized & ( l_empty n Folded *)+l_nb_spaced_lines n = s_nb_spaced_text n+                    & ( b_l_spaced n & s_nb_spaced_text n *)++l_nb_start_with_spaced n = ( l_empty n Folded *)+                         & l_nb_spaced_lines n+                         & "fold" ^ ( b_normalized & l_nb_start_with_folded n ?)++l_nb_start_with_any n   = "fold" ^ ( l_nb_start_with_folded n / l_nb_start_with_spaced n )+l_folded_content    n t = ( l_nb_start_with_any n & b_chomped_last t ?)+                        & l_chomped_empty n t++-- Block sequence:++seq_spaces n c = case c of+                      BlockOut -> n+                      BlockIn  -> n .- 1++l__block_sequence n = do m  <- detect_collection_indentation n+                         (   nest BeginSequence+                           & ( s_indent (n .+ m) & c_l_block_seq_entry (n .+ m) +)+                           & nest EndSequence )++detect_collection_indentation n = peek $ ( l_comment* ) & count_spaces (-n)++c_l_block_seq_entry n = c_sequence_entry ! "node" & s_l__block_indented n BlockOut++s_l__block_indented n c = do m <- detect_inline_indentation+                             (   s_indent m+                               & "node"+                               ^ ( ns_l_in_line_sequence (n .+ 1 .+ m)+                                 / ns_l_in_line_mapping (n .+ 1 .+ m) ) )+                        / s_l__block_node n c+                        / e_node & s_l_comments++detect_inline_indentation = peek $ count_spaces 0++ns_l_in_line_sequence n = nest BeginNode+                        & nest BeginSequence+                        & c_l_block_seq_entry n+                        & ( s_indent n & c_l_block_seq_entry n *)+                        & nest EndSequence+                        & nest EndNode++-- Block mapping:++l__block_mapping n = do m <- detect_collection_indentation n+                        (   nest BeginMapping+                          & ( s_indent (n .+ m) & ns_l_block_map_entry (n .+ m) +)+                          & nest EndMapping )++ns_l_block_map_entry n = nest BeginPair+                       & ( c_l_block_map_explicit_entry n+                         / ns_l_block_map_implicit_entry n )+                       & nest EndPair++c_l_block_map_explicit_entry n = c_l_block_map_explicit_key n+                               & ( l_block_map_explicit_value n / e_node )+c_l_block_map_explicit_key   n = c_mapping_key ! "node" & s_l__block_indented n BlockIn+l_block_map_explicit_value   n = s_indent n & c_mapping_value & s_l__block_indented n BlockIn++ns_l_block_map_implicit_entry n = ns_s_block_map_implicit_key & c_l_block_map_implicit_value n+                                / e_node & c_l_block_map_implicit_value n+ns_s_block_map_implicit_key     = c_s_simple_json_key / ns_s_simple_yaml_key+c_l_block_map_implicit_value n  = c_mapping_value ! "node"+                                & ( s_l__block_node n BlockIn+                                  / e_node & s_l_comments )++ns_l_in_line_mapping n = nest BeginNode+                       & nest BeginMapping+                       & ns_l_block_map_entry n+                       & ( s_indent n & ns_l_block_map_entry n *)+                       & nest EndMapping+                       & nest EndNode++-- Block node:++s_l__block_node     n c = s_l__block_in_block n c+                        / s_l__flow_in_block n+s_l__flow_in_block  n   = s_separate_in_line & ns_flow_node (n .+ 1) FlowOut & s_l_comments+s_l__block_in_block n c = nest BeginNode+                        & ( s_separate_in_line & c_ns_properties ?)+                        & s_l__block_content n c+                        & nest EndNode+s_l__block_content  n c = s_separate_in_line & c_l__literal n+                        / s_separate_in_line & c_l__folded n+                        / s_l_comments & l__block_sequence (seq_spaces n c)+                        / s_l_comments & l__block_mapping n++-- Document:++c_document_start  = token DocumentStart [ '-', '-', '-' ]++c_document_end    = token DocumentEnd [ '.', '.', '.' ]++l_document_prefix = ( c_byte_order_mark ?) & ( l_comment *)++l_document_suffix = c_document_end & s_l_comments++l_forbidden = sol+            & ( c_document_start / c_document_end )+            & ( b_char / s_white / eof )++l_implicit_document = nest BeginDocument+                    & s_l__block_node (-1) BlockOut `forbidding` l_forbidden+                    & nest EndDocument++l_explicit_document =  nest BeginDocument+                    & ( l_directive ! "doc" *)+                    & c_document_start ! "doc"+                    & "node" ^ ( l_implicit_document / e_node & s_l_comments )+                    & nest EndDocument++e_no_document = empty++-- Stream:++l_yaml_stream = nest BeginStream+              & l_documents+              & ( l_document_suffix & l_documents *)+              & nest EndStream++l_documents = l_leading_document & ( l_following_document *)++l_leading_document = l_document_prefix & "doc" ^ ( l_explicit_document / "node" ^ ( l_implicit_document / e_no_document ) )++l_following_document = l_document_prefix & "doc" ^ ( l_explicit_document / e_no_document )
+ Text/Yaml/Reference.hs view
@@ -0,0 +1,1774 @@+-- #ignore-exports+-------------------------------------------------------------------------------+-- |+-- Module      :  Text.Yaml.Reference+-- Copyright   :  (c) Oren Ben-Kiki 2007+-- License     :  LGPL+-- +-- Maintainer  :  yaml-oren@ben-kiki.org+-- Stability   :  alpha+-- Portability :  portable+--+-- Implementation of the YAML syntax as defined in <http://www.yaml.org>.+-- Actually this file contains the parsing framework and includes (using CPP)+-- the actual productions from @Reference.bnf@.+--+-- The parsing framework is fully streaming (generates output tokens+-- \"immediately\"), but has a memory leak (actually retention) which causes it+-- to blow up on \"large\" files. To debug this with minimal syntax productions+-- use the @debug_leak@ production (@yes "#" | yaml2yeast -p debug-leak@).+-------------------------------------------------------------------------------++module Text.Yaml.Reference+  (+    -- Basic parsing:+    Code,+    Token,+    Tokenizer,+    yaml,+    -- For testing:+    Context,+    Style,+    Chomp,+    tokenizer,+    tokenizerWithN,+    tokenizerWithC,+    tokenizerWithS,+    tokenizerWithT,+    tokenizerWithNC,+    tokenizerWithNS,+    tokenizerWithNT,+    tokenizerNames,+    showTokens+  )+where++import           Control.Monad+import qualified Data.ByteString.Lazy.Char8 as C+import           Data.Char+import qualified Data.DList as D+import qualified Data.Map as Map+import           Text.Regex+import           Debug.Trace+import qualified Prelude+import           Prelude hiding ((/), (*), (+), (-), (^))++-- * Generic operators+--+-- ** Numeric operators+--+-- We rename the four numerical operators @+@ @-@ @*@ @\/@ to start with @.@+-- (@.+@, @.-@, @.*@, @.\/@). This allows us to use the originals for BNF+-- notation (we also hijack the @^@ operator). This is not a generally+-- recommended practice. It is justified in this case since we have very little+-- arithmetic operations, and a lot of BNF rules which this makes extremely+-- readable.++infixl 6 .++-- | \".+\" is the numeric addition (we use \"+\" for postfix \"one or more\").+(.+) = (Prelude.+)++infixl 6 .-+-- | \".-\" is the numeric subtraction (we use \"-\" for infix \"and not\").+(.-) = (Prelude.-)++infixl 7 .*+-- | \".*\" is the numeric multiplication (we use \"*\" for postfix \"zero or+-- more\").+(.*) = (Prelude.*)++infixl 7 ./+-- | \"./\" is the numeric division (we use \"/\" for infix \"or\").+(./) = (Prelude./)++-- ** Record field access+--+-- We also define @|>@ for record access for increased readability.++infixl 9 |>+-- | @record |> field@ is the same as @field record@,  but is more readable.+(|>) :: record -> (record -> value) -> value+record |> field = field record++-- * UTF decoding+--+-- This really should be factored out to the standard libraries. Since it isn't+-- there, we get to tailor it exactly to our needs. We use lazy byte strings as+-- input, which should give reasonable I\/O performance when reading large+-- files. The output is a normal 'Char' list which is easy to work with and+-- should be efficient enough as long as the 'Parser' does its job right.++-- | Recognized Unicode encodings. UTF-32 isn't required by YAML parsers.+data Encoding = UTF8    -- ^ UTF-8 encoding (or ASCII)+              | UTF16LE -- ^ UTF-16 little endian+              | UTF16BE -- ^ UTF-16 big endian+    deriving Show++-- | @decode bytes@ automatically detects the 'Encoding' used and converts the+-- /bytes/ to Unicode characters.+decode :: C.ByteString -> (Encoding, [Char])+decode text = (encoding, undoEncoding encoding text)+  where encoding = detectEncoding $ C.unpack $ C.take 2 text++-- | @detectEncoding text@ examines the first few chars (bytes) of the /text/+-- to deduce the Unicode encoding used according to the YAML spec.+detectEncoding :: [Char] -> Encoding+detectEncoding text =+  case text of+    '\xFF':'\xFE':_ -> UTF16LE+    '\xFE':'\xFF':_ -> UTF16BE+    _               -> UTF8++-- | @undoEncoding encoding bytes@ converts a /bytes/ stream to Unicode+-- characters according to the /encoding/.+undoEncoding :: Encoding -> C.ByteString -> [Char]+undoEncoding encoding bytes =+  case encoding of+    UTF8    -> undoUTF8 bytes+    UTF16LE -> combinePairs $ undoUTF16LE bytes+    UTF16BE -> combinePairs $ undoUTF16BE bytes++-- ** UTF-16 decoding++-- | @combinePairs chars@ converts each pair of UTF-16 surrogate characters to a+-- single Unicode character.+combinePairs :: [Char] -> [Char]+combinePairs []                          = []+combinePairs (lead:rest)+  | '\xD800' <= lead && lead <= '\xDBFF' = combineLead lead rest+  | '\xDC00' <= lead && lead <= '\xDFFF' = error "UTF-16 contains trail surrogate without lead surrogate"+  | otherwise                            = lead:(combinePairs rest)++-- | @combineLead lead rest@ combines the /lead/ surrogate with the head of the+-- /rest/ of the input chars, assumed to be a /trail/ surrogate, and continues+-- combining surrogate pairs.+combineLead :: Char -> [Char] -> [Char]+combineLead lead []                        = error "UTF-16 contains lead surrogate as final character"+combineLead lead (trail:rest)+  | '\xDC00' <= trail && trail <= '\xDFFF' = (combineSurrogates lead trail):combinePairs rest+  | otherwise                              = error "UTF-16 contains lead surrogate without trail surrogate"++-- | @surrogateOffset@ is copied from the Unicode FAQs.+surrogateOffset :: Int+surrogateOffset = 0x10000 .- (0xD800 .* 1024) .- 0xDC00++-- | @combineSurrogates lead trail@ combines two UTF-16 surrogates into a single+-- Unicode character.+combineSurrogates :: Char -> Char -> Char+combineSurrogates lead trail = chr $ (ord lead) .* 1024 .+ (ord trail) .+ surrogateOffset++-- | @hasFewerThan bytes n@ checks whether there are fewer than /n/ /bytes/+-- left to read.+hasFewerThan :: Int -> C.ByteString -> Bool+hasFewerThan n bytes+  | n == 1 = C.null bytes+  | n > 1  = C.null bytes || hasFewerThan (n .- 1) (C.tail bytes)++-- | @undoUTF18LE bytes@ decoded a UTF-16-LE /bytes/ stream to Unicode chars.+undoUTF16LE :: C.ByteString -> [Char]+undoUTF16LE bytes+  | C.null bytes = []+  | hasFewerThan 2 bytes = error "UTF-16-LE input contains odd number of bytes"+  | otherwise = let low = C.head bytes+                    bytes' = C.tail bytes+                    high = C.head bytes'+                    rest = C.tail bytes'+                in (chr $ (ord high) .* 256 .+ (ord low)):(undoUTF16LE rest)++-- | @undoUTF18BE bytes@ decoded a UTF-16-BE /bytes/ stream to Unicode chars.+undoUTF16BE :: C.ByteString -> [Char]+undoUTF16BE bytes+  | C.null bytes = []+  | hasFewerThan 2 bytes = error "UTF-16-BE input contains odd number of bytes"+  | otherwise = let high = C.head bytes+                    bytes' = C.tail bytes+                    low = C.head bytes'+                    rest = C.tail bytes'+                in (chr $ (ord high) .* 256 .+ (ord low)):(undoUTF16BE rest)++-- ** UTF-8 decoding++-- | @undoUTF8 bytes@ decoded a UTF-8 /bytes/ stream to Unicode chars.+undoUTF8 :: C.ByteString -> [Char]+undoUTF8 bytes+  | C.null bytes = []+  | otherwise = let first = C.head bytes+                    rest = C.tail bytes+                in case () of+                      _ | first < '\x80' -> first:(undoUTF8 rest)+                        | first < '\xC0' -> error "UTF-8 input contains invalid first byte"+                        | first < '\xE0' -> decodeTwoUTF8 first rest+                        | first < '\xF0' -> decodeThreeUTF8 first rest+                        | first < '\xF8' -> decodeFourUTF8 first rest+                        | otherwise      -> error "UTF-8 input contains invalid first byte"++-- | @decodeTwoUTF8 first bytes@ decodes a two-byte UTF-8 character, where the+-- /first/ byte is already available and the second is the head of the /bytes/,+-- and then continues to undo the UTF-8 encoding.+decodeTwoUTF8 :: Char -> C.ByteString -> [Char]+decodeTwoUTF8 first bytes+  | C.null bytes = error "UTF-8 double byte char is missing second byte at eof"+  | otherwise = let second = C.head bytes+                    rest = C.tail bytes+                in case () of+                      _ | second < '\x80' || '\xBF' < second -> error "UTF-8 double byte char has invalid second byte"+                        | otherwise                          -> (combineTwoUTF8 first second):(undoUTF8 rest)++-- | @combineTwoUTF8 first second@ combines the /first/ and /second/ bytes of a+-- two-byte UTF-8 char into a single Unicode char.+combineTwoUTF8 :: Char -> Char -> Char+combineTwoUTF8 first second = chr(((ord first) .- 0xC0) .* 64+                               .+ ((ord second) .- 0x80))++-- | @decodeThreeUTF8 first bytes@ decodes a three-byte UTF-8 character, where+-- the /first/ byte is already available and the second and third are the head+-- of the /bytes/, and then continues to undo the UTF-8 encoding.+decodeThreeUTF8 :: Char -> C.ByteString -> [Char]+decodeThreeUTF8 first bytes+  | hasFewerThan 2 bytes = error "UTF-8 triple byte char is missing bytes at eof"+  | otherwise = let second = C.head bytes+                    bytes' = C.tail bytes+                    third = C.head bytes'+                    rest = C.tail bytes'+                in case () of+                      _ | second < '\x80' || '\xBF' < second -> error "UTF-8 triple byte char has invalid second byte"+                        | third < '\x80' || '\xBF' < third   -> error "UTF-8 triple byte char has invalid third byte"+                        | otherwise                          -> (combineThreeUTF8 first second third):(undoUTF8 rest)++-- | @combineThreeUTF8 first second@ combines the /first/, /second/ and /third/+-- bytes of a three-byte UTF-8 char into a single Unicode char.+combineThreeUTF8 :: Char -> Char -> Char -> Char+combineThreeUTF8 first second third = chr(((ord first) .- 0xE0) .* 4096+                                       .+ ((ord second) .- 0x80) .* 64+                                       .+ ((ord third)  .- 0x80))++-- | @decodeFourUTF8 first bytes@ decodes a four-byte UTF-8 character, where the+-- /first/ byte is already available and the second, third and fourth are the+-- head of the /bytes/, and then continues to undo the UTF-8 encoding.+decodeFourUTF8 :: Char -> C.ByteString -> [Char]+decodeFourUTF8 first bytes+  | hasFewerThan 3 bytes = error "UTF-8 quad byte char is missing bytes at eof"+  | otherwise = let second = C.head bytes+                    bytes' = C.tail bytes+                    third = C.head bytes'+                    bytes'' = C.tail bytes'+                    fourth = C.head bytes''+                    rest = C.tail bytes''+                in case () of+                      _ | second < '\x80' || '\xBF' < second -> error "UTF-8 quad byte char has invalid second byte"+                        | third < '\x80' || '\xBF' < third   -> error "UTF-8 quad byte char has invalid third byte"+                        | third < '\x80' || '\xBF' < third   -> error "UTF-8 quad byte char has invalid fourth byte"+                        | otherwise                          -> (combineFourUTF8 first second third fourth):(undoUTF8 rest)++-- | @combineFourUTF8 first second@ combines the /first/, /second/ and /third/+-- bytes of a three-byte UTF-8 char into a single Unicode char.+combineFourUTF8 :: Char -> Char -> Char -> Char -> Char+combineFourUTF8 first second third fourth = chr(((ord first)  .- 0xF0) .* 262144+                                             .+ ((ord second) .- 0x80) .* 4096+                                             .+ ((ord third)  .- 0x80) .* 64+                                             .+ ((ord fourth) .- 0x80))++-- * Result tokens+--+-- The parsing result is a stream of tokens rather than a parse tree. The idea+-- is to convert the YAML input into \"byte codes\". These byte codes are+-- intended to be written into a byte codes file (or more likely a UNIX pipe)+-- for further processing.++-- | 'Token' codes.+data Code = Bom             -- ^ BOM, contains \"@TF8@\", \"@TF16LE@\" or \"@TF16BE@\".+          | Text            -- ^ Content text characters.+          | Meta            -- ^ Non-content (meta) text characters.+          | Break           -- ^ Line break preserved in content.+          | Continue        -- ^ Separation line break.+          | LineFeed        -- ^ Line break normalized to content line feed.+          | LineFold        -- ^ Line break folded to content space.+          | Indicator       -- ^ Character indicating structure.+          | White           -- ^ Separation white space.+          | Indent          -- ^ Indentation spaces.+          | DocumentStart   -- ^ Document start marker.+          | DocumentEnd     -- ^ Document end marker.+          | BeginEscape     -- ^ Begins escape sequence.+          | EndEscape       -- ^ Ends escape sequence.+          | BeginComment    -- ^ Begins comment.+          | EndComment      -- ^ Ends comment.+          | BeginDirective  -- ^ Begins directive.+          | EndDirective    -- ^ Ends directive.+          | BeginTag        -- ^ Begins tag.+          | EndTag          -- ^ Ends tag.+          | BeginHandle     -- ^ Begins tag handle.+          | EndHandle       -- ^ Ends tag handle.+          | BeginAnchor     -- ^ Begins anchor.+          | EndAnchor       -- ^ Ends anchor.+          | BeginProperties -- ^ Begins node properties.+          | EndProperties   -- ^ Ends node properties.+          | BeginAlias      -- ^ Begins alias.+          | EndAlias        -- ^ Ends alias.+          | BeginScalar     -- ^ Begins scalar content.+          | EndScalar       -- ^ Ends scalar content.+          | BeginSequence   -- ^ Begins sequence content.+          | EndSequence     -- ^ Ends sequence content.+          | BeginMapping    -- ^ Begins mapping content.+          | EndMapping      -- ^ Ends mapping content.+          | BeginPair       -- ^ Begins mapping key:value pair.+          | EndPair         -- ^ Ends mapping key:value pair.+          | BeginNode       -- ^ Begins complete node.+          | EndNode         -- ^ Ends complete node.+          | BeginDocument   -- ^ Begins document.+          | EndDocument     -- ^ Ends document.+          | BeginStream     -- ^ Begins YAML stream.+          | EndStream       -- ^ Ends YAML stream.+          | Error           -- ^ Parsing error at this point.+          -- For testing:.+          | Test            -- ^ Test characters otherwise unassigned.+          | Detected        -- ^ Detected parameter.+  deriving Eq++-- | @show code@ converts a 'Code' to the one-character YEAST token code char.+-- The list of byte codes is also documented in the @yaml2yeast@ program.+instance Show Code where+  show code = case code of+                   Bom             -> "U"+                   Text            -> "T"+                   Meta            -> "t"+                   Break           -> "B"+                   Continue        -> "b"+                   LineFeed        -> "L"+                   LineFold        -> "l"+                   Indicator       -> "I"+                   White           -> "w"+                   Indent          -> "i"+                   DocumentStart   -> "K"+                   DocumentEnd     -> "k"+                   BeginEscape     -> "E"+                   EndEscape       -> "e"+                   BeginComment    -> "C"+                   EndComment      -> "c"+                   BeginDirective  -> "D"+                   EndDirective    -> "d"+                   BeginTag        -> "G"+                   EndTag          -> "g"+                   BeginHandle     -> "H"+                   EndHandle       -> "h"+                   BeginAnchor     -> "A"+                   EndAnchor       -> "a"+                   BeginProperties -> "P"+                   EndProperties   -> "p"+                   BeginAlias      -> "R"+                   EndAlias        -> "r"+                   BeginScalar     -> "S"+                   EndScalar       -> "s"+                   BeginSequence   -> "Q"+                   EndSequence     -> "q"+                   BeginMapping    -> "M"+                   EndMapping      -> "m"+                   BeginNode       -> "N"+                   EndNode         -> "n"+                   BeginPair       -> "X"+                   EndPair         -> "x"+                   BeginDocument   -> "O"+                   EndDocument     -> "o"+                   BeginStream     -> "Y"+                   EndStream       -> "y"+                   Error           -> "!"+                   Test            -> "?"+                   Detected        -> "$"++-- | Parsed token.+data Token = Token {+    tCode :: Code,        -- ^ Specific token 'Code'.+    tText :: Maybe String -- ^ Contained input chars, if any.+  }++-- | @show token@ converts a 'Token' to a single YEAST line.+instance Show Token where+  show token = case token|>tText of+                    Nothing     -> (show $ token|>tCode) ++ "\n"+                    Just string -> (show $ token|>tCode) ++ (escapeString string) ++ "\n"++-- | @escapeString string@ escapes all the non-ASCII characters in the+-- /string/, as well as escaping the \"@\\@\" character, using the \"@\\xXX@\",+-- \"@\\uXXXX@\" and \"@\\UXXXXXXXX@\" escape sequences.+escapeString :: String -> String+escapeString []                                   = []+escapeString (first:rest)+  | ' ' <= first && first /= '\\' && first <= '~' = first:(escapeString rest)+  | first <= '\xFF'                               = "\\x" ++ (toHex 2 $ ord first) ++ (escapeString rest)+  | '\xFF' < first && first <= '\xFFFF'           = "\\u" ++ (toHex 4 $ ord first) ++ (escapeString rest)+  | otherwise                                     = "\\U" ++ (toHex 8 $ ord first) ++ (escapeString rest)++-- | @toHex digits int@ converts the /int/ to the specified number of+-- hexadecimal /digits/.+toHex :: Int -> Int -> String+toHex digits int+  | digits > 1  = (toHex (digits .- 1) (int `div` 16)) ++ [intToDigit $ int `mod` 16]+  | digits == 1 = [intToDigit int]++-- | @showTokens tokens@ converts a list of /tokens/ to a multi-line YEAST+-- text.+showTokens :: [Token] -> String+showTokens tokens = foldr (\ token text -> (show token) ++ text) "" tokens++-- * Parsing framework+--+-- Haskell has no shortage of parsing frameworks. We use our own because:+--+--  * Most available frameworks are inappropriate because of their focus on+--    building a parse tree, and completing all of it before any of it is+--    accessible to the caller. We return a stream of tokens, and would like+--    its head to be accessible as soon as possible to allow for streaming. To+--    do this we use a difference list (not a 'DList' - we use a \"real\"+--    difference list building on Haskell's lazy evaluation nature).+--+--  * Haskell makes it so easy to roll your own parsing framework. We need some+--    specialized machinery (limited lookahead, forbidden patterns). It is+--    possible to build these on top of existing frameworks but the end result+--    isn't much shorter than rolling our own.+--+-- Since we roll our own framework we don't bother with making it generalized,+-- so we maintain a single 'State' type rather than having a generic one that+-- contains a polymorphic \"UserState\" field etc.++-- | A 'Parser' is basically a function computing a /result/, while at the same+-- time accumulating a list of 'Token'. A result of @Nothing@ indicates+-- failure.+data Parser result = Parser (State -> (State, Maybe result))++-- A 'Pattern' is a parser that doesn't have an (interesting) result.+type Pattern = Parser ()++-- ** Parsing state++-- | The internal parser state. We don't bother with parameterising it with a+-- \"UserState\", we just bundle the generic and specific fields together (not+-- that it is that easy to draw the line - is @sLine@ generic or specific?).+-- Note that using 'DList' for @sTokens@ allows us to consume tokens as they+-- are generated, instead of waiting for the whole parsing process to complete.+-- Likewise for @sCommits@, which allows us to commit to a partially generated+-- tokens stream before it is fully generated.+data State = State {+    -- Fields that never change, or only change for nested parsers:+    sName         :: String,         -- ^ The input name for error messages.+    sEncoding     :: Encoding,       -- ^ The input UTF encoding.+    sDecision     :: String,         -- ^ Current decision name.+    sLimit        :: Int,            -- ^ Lookahead characters limit.+    sForbidden    :: Maybe Pattern,  -- ^ Pattern we must not enter into.+    sIsPeek       :: Bool,           -- ^ Disables token generation.+    -- Fields that get collected by consecutive parsers, then merged:+    sTokens       :: D.DList Token,  -- ^ Tokens collected from input.+    sCommits      :: D.DList String, -- ^ Committments collected while parsing.+    -- Fields that are incrementally modified by consecutive parsers:+    sConsumed     :: Bool,           -- ^ Consumed character markers.+    sChars        :: D.DList Char,   -- ^ Characters collected for a token.+    sMessage      :: Maybe String,   -- ^ If an error occurred.+    sLine         :: Int,            -- ^ Builds on YAML's line break definition.+    sColumn       :: Int,            -- ^ Actually character number - we hate tabs.+    sCode         :: Code,           -- ^ Of token we are collecting chars for.+    sLast         :: Char,           -- ^ Last matched character.+    sInput        :: [Char]          -- ^ The input decoded characters.+  }++-- Showing a 'State' is only used in debugging. Note that forcing certain+-- members (@sTokens@, @sCommits@) may disable streaming.+instance Show State where+  show state = "Name: " ++ (show $ state|>sName)+--          ++ ", Encoding: " ++ (show / state|>sEncoding)+            ++ ", Decision: " ++ (show $ state|>sDecision)+--          ++ ", Limit: " ++ (show / state|>sLimit)+--          ++ ", IsPeek: " ++ (show / state|>sIsPeek)+--          ++ ", Tokens:\n" ++ (showTokens / D.toList / state|>sTokens) ++ "...\n"+--          ++ ", Commits: " ++ (show / D.toList / state|>sCommits)+--          ++ ", Consumed: >>>" ++ (show / state|>sConsumed) ++ "<<<"+--          ++ ", Chars: >>>" ++ (D.toList / state|>sChars) ++ "<<<"+            ++ ", Message: " ++ (show $ state|>sMessage)+            ++ ", Line: " ++ (show $ state|>sLine)+            ++ ", Column: " ++ (show $ state|>sColumn)+            ++ ", Code: " ++ (show $ state|>sCode)+            ++ ", Last: >>>" ++ (show $ state|>sLast) ++ "<<<"+--          ++ ", Input: >>>" ++ (show / state|>sInput) ++ "<<<"++-- | @initialState name input@ returns an initial 'State' for parsing the+-- /input/ (with /name/ for error messages).+initialState :: String -> C.ByteString -> State+initialState name input = let (encoding, decoded) = decode input+                          in State { sName         = name,+                                     sEncoding     = encoding,+                                     sDecision     = "n/a",+                                     sLimit        = -1,+                                     sForbidden    = Nothing,+                                     sIsPeek       = False,+                                     sTokens       = D.empty,+                                     sCommits      = D.empty,+                                     sConsumed     = False,+                                     sChars        = D.empty,+                                     sMessage      = Nothing,+                                     sLine         = 1,+                                     sColumn       = 0,+                                     sCode         = Test,+                                     sLast         = ' ',+                                     sInput        = decoded }++-- *** Setters+--+-- We need setter functions instead of using @{ sXxx = value }@ because the+-- nice syntax causes the old state to be fully evaluated, killing the+-- streaming (lazy) functionality we need. Generating the setters by hand was+-- tedious, there's surely a way to do this using Template Haskell or DrIFT or+-- some such. Life is too short.++-- | @setDecision name state@ sets the @sDecision@ field to /decision/.+setDecision :: String -> State -> State+setDecision decision state = State { sName         = state|>sName,+                                     sEncoding     = state|>sEncoding,+                                     sDecision     = decision,+                                     sLimit        = state|>sLimit,+                                     sForbidden    = state|>sForbidden,+                                     sIsPeek       = state|>sIsPeek,+                                     sTokens       = state|>sTokens,+                                     sCommits      = state|>sCommits,+                                     sConsumed     = state|>sConsumed,+                                     sChars        = state|>sChars,+                                     sMessage      = state|>sMessage,+                                     sLine         = state|>sLine,+                                     sColumn       = state|>sColumn,+                                     sCode         = state|>sCode,+                                     sLast         = state|>sLast,+                                     sInput        = state|>sInput }++-- | @setLimit limit state@ sets the @sLimit@ field to /limit/.+setLimit :: Int -> State -> State+setLimit limit state = State { sName         = state|>sName,+                               sEncoding     = state|>sEncoding,+                               sDecision     = state|>sDecision,+                               sLimit        = limit,+                               sForbidden    = state|>sForbidden,+                               sIsPeek       = state|>sIsPeek,+                               sTokens       = state|>sTokens,+                               sCommits      = state|>sCommits,+                               sConsumed     = state|>sConsumed,+                               sChars        = state|>sChars,+                               sMessage      = state|>sMessage,+                               sLine         = state|>sLine,+                               sColumn       = state|>sColumn,+                               sCode         = state|>sCode,+                               sLast         = state|>sLast,+                               sInput        = state|>sInput }++-- | @setForbidden forbidden state@ sets the @sForbidden@ field to /forbidden/.+setForbidden :: Maybe Pattern -> State -> State+setForbidden forbidden state = State { sName         = state|>sName,+                                       sEncoding     = state|>sEncoding,+                                       sDecision     = state|>sDecision,+                                       sLimit        = state|>sLimit,+                                       sForbidden    = forbidden,+                                       sIsPeek       = state|>sIsPeek,+                                       sTokens       = state|>sTokens,+                                       sCommits      = state|>sCommits,+                                       sConsumed     = state|>sConsumed,+                                       sChars        = state|>sChars,+                                       sMessage      = state|>sMessage,+                                       sLine         = state|>sLine,+                                       sColumn       = state|>sColumn,+                                       sCode         = state|>sCode,+                                       sLast         = state|>sLast,+                                       sInput        = state|>sInput }++-- | @setIsPeek isPeek state@ sets the @sIsPeek@ field to /isPeek/.+setIsPeek :: Bool -> State -> State+setIsPeek isPeek state = State { sName         = state|>sName,+                                 sEncoding     = state|>sEncoding,+                                 sDecision     = state|>sDecision,+                                 sLimit        = state|>sLimit,+                                 sForbidden    = state|>sForbidden,+                                 sIsPeek       = isPeek,+                                 sTokens       = state|>sTokens,+                                 sCommits      = state|>sCommits,+                                 sConsumed     = state|>sConsumed,+                                 sChars        = state|>sChars,+                                 sMessage      = state|>sMessage,+                                 sLine         = state|>sLine,+                                 sColumn       = state|>sColumn,+                                 sCode         = state|>sCode,+                                 sLast         = state|>sLast,+                                 sInput        = state|>sInput }++-- | @setTokens tokens state@ sets the @sTokens@ field to /tokens/.+setTokens :: D.DList Token -> State -> State+setTokens tokens state = State { sName         = state|>sName,+                                 sEncoding     = state|>sEncoding,+                                 sDecision     = state|>sDecision,+                                 sLimit        = state|>sLimit,+                                 sForbidden    = state|>sForbidden,+                                 sIsPeek       = state|>sIsPeek,+                                 sTokens       = tokens,+                                 sCommits      = state|>sCommits,+                                 sConsumed     = state|>sConsumed,+                                 sChars        = state|>sChars,+                                 sMessage      = state|>sMessage,+                                 sLine         = state|>sLine,+                                 sColumn       = state|>sColumn,+                                 sCode         = state|>sCode,+                                 sLast         = state|>sLast,+                                 sInput        = state|>sInput }++-- | @setCommits commits state@ sets the @sCommits@ field to /commits/.+setCommits :: D.DList String -> State -> State+setCommits commits state = State { sName         = state|>sName,+                                   sEncoding     = state|>sEncoding,+                                   sDecision     = state|>sDecision,+                                   sLimit        = state|>sLimit,+                                   sForbidden    = state|>sForbidden,+                                   sIsPeek       = state|>sIsPeek,+                                   sTokens       = state|>sTokens,+                                   sCommits      = commits,+                                   sConsumed     = state|>sConsumed,+                                   sChars        = state|>sChars,+                                   sMessage      = state|>sMessage,+                                   sLine         = state|>sLine,+                                   sColumn       = state|>sColumn,+                                   sCode         = state|>sCode,+                                   sLast         = state|>sLast,+                                   sInput        = state|>sInput }++-- | @setChars chars state@ sets the @sChars@ field to /chars/.+setChars :: D.DList Char -> State -> State+setChars chars state = State { sName         = state|>sName,+                               sEncoding     = state|>sEncoding,+                               sDecision     = state|>sDecision,+                               sLimit        = state|>sLimit,+                               sForbidden    = state|>sForbidden,+                               sIsPeek       = state|>sIsPeek,+                               sTokens       = state|>sTokens,+                               sCommits      = state|>sCommits,+                               sConsumed     = state|>sConsumed,+                               sChars        = chars,+                               sMessage      = state|>sMessage,+                               sLine         = state|>sLine,+                               sColumn       = state|>sColumn,+                               sCode         = state|>sCode,+                               sLast         = state|>sLast,+                               sInput        = state|>sInput }++-- | @setConsumed consumed state@ sets the @sConsumed@ field to /consumed/.+setConsumed :: Bool -> State -> State+setConsumed consumed state = State { sName         = state|>sName,+                                     sEncoding     = state|>sEncoding,+                                     sDecision     = state|>sDecision,+                                     sLimit        = state|>sLimit,+                                     sForbidden    = state|>sForbidden,+                                     sIsPeek       = state|>sIsPeek,+                                     sTokens       = state|>sTokens,+                                     sCommits      = state|>sCommits,+                                     sConsumed     = consumed,+                                     sChars        = state|>sChars,+                                     sMessage      = state|>sMessage,+                                     sLine         = state|>sLine,+                                     sColumn       = state|>sColumn,+                                     sCode         = state|>sCode,+                                     sLast         = state|>sLast,+                                     sInput        = state|>sInput }++-- | @setMessage message state@ sets the @sMessage@ field to /message/.+setMessage :: Maybe String -> State -> State+setMessage message state = State { sName         = state|>sName,+                                   sEncoding     = state|>sEncoding,+                                   sDecision     = state|>sDecision,+                                   sLimit        = state|>sLimit,+                                   sForbidden    = state|>sForbidden,+                                   sIsPeek       = state|>sIsPeek,+                                   sTokens       = state|>sTokens,+                                   sCommits      = state|>sCommits,+                                   sConsumed     = state|>sConsumed,+                                   sChars        = state|>sChars,+                                   sMessage      = message,+                                   sLine         = state|>sLine,+                                   sColumn       = state|>sColumn,+                                   sCode         = state|>sCode,+                                   sLast         = state|>sLast,+                                   sInput        = state|>sInput }++-- | @setLine line state@ sets the @sLine@ field to /line/.+setLine :: Int -> State -> State+setLine line state = State { sName         = state|>sName,+                             sEncoding     = state|>sEncoding,+                             sDecision     = state|>sDecision,+                             sLimit        = state|>sLimit,+                             sForbidden    = state|>sForbidden,+                             sIsPeek       = state|>sIsPeek,+                             sTokens       = state|>sTokens,+                             sCommits      = state|>sCommits,+                             sConsumed     = state|>sConsumed,+                             sChars        = state|>sChars,+                             sMessage      = state|>sMessage,+                             sLine         = line,+                             sColumn       = state|>sColumn,+                             sCode         = state|>sCode,+                             sLast         = state|>sLast,+                             sInput        = state|>sInput }++-- | @setColumn line state@ sets the @sColumn@ field to /line/.+setColumn :: Int -> State -> State+setColumn column state = State { sName         = state|>sName,+                                 sEncoding     = state|>sEncoding,+                                 sDecision     = state|>sDecision,+                                 sLimit        = state|>sLimit,+                                 sForbidden    = state|>sForbidden,+                                 sIsPeek       = state|>sIsPeek,+                                 sTokens       = state|>sTokens,+                                 sCommits      = state|>sCommits,+                                 sConsumed     = state|>sConsumed,+                                 sChars        = state|>sChars,+                                 sMessage      = state|>sMessage,+                                 sLine         = state|>sLine,+                                 sColumn       = column,+                                 sCode         = state|>sCode,+                                 sLast         = state|>sLast,+                                 sInput        = state|>sInput }++-- | @setCode code state@ sets the @sCode@ field to /code/.+setCode :: Code -> State -> State+setCode code state = State { sName         = state|>sName,+                             sEncoding     = state|>sEncoding,+                             sDecision     = state|>sDecision,+                             sLimit        = state|>sLimit,+                             sForbidden    = state|>sForbidden,+                             sIsPeek       = state|>sIsPeek,+                             sTokens       = state|>sTokens,+                             sCommits      = state|>sCommits,+                             sConsumed     = state|>sConsumed,+                             sChars        = state|>sChars,+                             sMessage      = state|>sMessage,+                             sLine         = state|>sLine,+                             sColumn       = state|>sColumn,+                             sCode         = code,+                             sLast         = state|>sLast,+                             sInput        = state|>sInput }++-- | @setLast last state@ sets the @sLast@ field to /last/.+setLast :: Char -> State -> State+setLast last state = State { sName         = state|>sName,+                             sEncoding     = state|>sEncoding,+                             sDecision     = state|>sDecision,+                             sLimit        = state|>sLimit,+                             sForbidden    = state|>sForbidden,+                             sIsPeek       = state|>sIsPeek,+                             sTokens       = state|>sTokens,+                             sCommits      = state|>sCommits,+                             sConsumed     = state|>sConsumed,+                             sChars        = state|>sChars,+                             sMessage      = state|>sMessage,+                             sLine         = state|>sLine,+                             sColumn       = state|>sColumn,+                             sCode         = state|>sCode,+                             sLast         = last,+                             sInput        = state|>sInput }++-- | @setInput input state@ sets the @sInput@ field to /input/.+setInput :: [Char] -> State -> State+setInput input state = State { sName         = state|>sName,+                               sEncoding     = state|>sEncoding,+                               sDecision     = state|>sDecision,+                               sLimit        = state|>sLimit,+                               sForbidden    = state|>sForbidden,+                               sIsPeek       = state|>sIsPeek,+                               sTokens       = state|>sTokens,+                               sCommits      = state|>sCommits,+                               sConsumed     = state|>sConsumed,+                               sChars        = state|>sChars,+                               sMessage      = state|>sMessage,+                               sLine         = state|>sLine,+                               sColumn       = state|>sColumn,+                               sCode         = state|>sCode,+                               sLast         = state|>sLast,+                               sInput        = input }++-- ** Implicit parsers+--+-- It is tedious to have to wrap each expected character (or character range)+-- in an explicit 'Parse' constructor. We let Haskell do that for us using a+-- 'Match' class.++-- | @Match parameter result@ specifies that we can convert the /parameter/ to+-- a 'Parser' returning the /result/.+class Match parameter result | parameter -> result where+    match :: parameter -> Parser result++-- | @parse parser state@ applies the actual /parser/ match function to a+-- /state/.+parse :: (Match match result) => match -> State -> (State, Maybe result)+parse parser state = let Parser parser' = match parser+                     in parser' state++-- | We don't need to convert a 'Parser', it already is one.+instance Match (Parser result) result where+    match = id++-- | We convert 'Char' to a parser for a character (that returns nothing).+instance Match Char () where+    match code = nextIf (== code)++-- | We convert a 'Char' tuple to a parser for a character range (that returns+-- nothing).+instance Match (Char, Char) () where+    match (low, high) = nextIf (\ code -> low <= code && code <= high)++-- | We convert 'String' to a parser for a sequence of characters (that returns+-- nothing).+instance Match String () where+    match "" = empty+    match (first:rest) = match first & match rest++-- ** Parsing Monad++-- | Allow using the @do@ notation for our parsers, which makes for short and+-- sweet @do@ syntax when we want to examine the results (we typically don't).+--+-- We don't use the 'Monad' @fail@ method because we need access to the 'State'+-- on failure.+--+-- @return result@ does just that - return a /result/.+--+-- @left >>= right@ applies the /left/ parser, and if it didn't fail+-- applies the /right/ one (well, the one /right/ returns). To achieve+-- streaming, we need to construct the final state manually, \"regardless\" of+-- the result of the right parser, and append the collected tokens and+-- commitments from the left and right parser. This allows our caller to+-- start consuming tokens from the left parser before the right parser is+-- done.+--+-- This code seems to hang on to the old states for too long a time, causing+-- memory usage to grow up when creating long parser chains (e.g. using @*@).+instance Monad Parser where++  return result = Parser (\ state -> (state, Just result))++  left >>= right =+    Parser (\ originalState -> let (leftState, leftResult) = parse left originalState+                                   leftTokens = leftState|>sTokens+                                   leftCommits = leftState|>sCommits+                                   leftConsumed = leftState|>sConsumed+                                   leftState' = setTokens D.empty+                                              $ setCommits D.empty +                                              $ setConsumed False+                                              $ leftState+                                   (rightState, rightResult) = case leftResult of+                                                                    Nothing    -> (leftState', Nothing)+                                                                    Just value -> parse (right value) leftState'+                                   rightTokens = rightState|>sTokens+                                   rightCommits = rightState|>sCommits+                                   rightConsumed = rightState|>sConsumed+                                   finalState = setTokens (D.append leftTokens rightTokens)+                                              $ setCommits (D.append leftCommits rightCommits)+                                              $ setConsumed (leftConsumed || rightConsumed)+                                              $ rightState+                               in (finalState, rightResult))++-- ** Parsing operators+--+-- Here we reap the benefits of renaming the numerical operators. Note that in+-- our specific case, we use the 'MonadPlus' to combine the results of+-- different parsers. Typically, parsing frameworks simply use the last result,+-- or leave the task of combining them to the rules themselves (using @do@+-- notation).+--+-- Operator precedence, in decreasing strength:+--+-- @repeated % n@, @repeated <% n@, @match - rejected@, @match ! decision@,+-- @match ?! decision@ are the strongest binding, and don't mix.+--+-- @match - first - second@ is @(match - first) - second@.+--+-- @first & second & third@ is @first & (second & third)@. Note that @first -+-- rejected & second@ is @(first - rejected) & second@, etc. d@ is @a & (b - c)+-- & d@.+--+-- @match \/ alternative \/ otherwise@ is @match \/ (alternative \/+-- otherwise)@. Note that @first & second \/ third@ is @(first & second) \/+-- third@.+--+-- @( match *)@, @(match +)@, @(match ?)@ are the weakest and require the+-- @()@.++infix  3 %+infix  3 <%+infix  3 ^+infix  3 !+infix  3 ?!+infixl 3 -+infixr 2 &+infixr 1 /+infix 0 ?+infix 0 *+infix 0 +++-- | @parser % n@ repeats /parser/ exactly /n/ times.+(%) :: (Match match result) => match -> Int -> Pattern+parser % n+  | n <= 0 = empty+  | n > 0  = parser & parser % n .- 1++-- | @decision ^ (option \/ option \/ ...)@ provides a /decision/ name to the+-- choice about to be made, to allow to @commit@ to it.+(^) :: (Match match result) => String -> match -> Parser result+decision ^ parser = decide decision parser++-- | @parser ! decision@ commits to /decision/ after successfully matching the+-- /parser/.+(!) :: (Match match result) => match -> String -> Pattern+parser ! decision = parser & commit decision++-- | @parser ?! decision@ commits to /decision/ if the current position matches+-- /parser/, without consuming any characters.+(?!) :: (Match match result) => match -> String -> Pattern+parser ?! decision = peek parser & commit decision++-- | @parser <% n@ matches fewer than /n/ occurrences of /parser/.+(<%) :: (Match match result) => match -> Int -> Pattern+parser <% n+  | n < 1 = failed "Fewer than 0 repetitions"+  | n == 1 = reject parser Nothing+  | n > 1  = parser & parser <% n .- 1 / empty++-- | @parser - rejected@ matches /parser/, except if /rejected/ matches at this+-- point.+(-) :: (Match match1 result1, Match match2 result2) => match1 -> match2 -> Parser result1+parser - rejected = reject rejected Nothing & parser++-- | @before & after@ parses /before/ and, if it succeeds, parses /after/. This+-- basically invokes the monad's @>>=@ method.+(&) :: (Match match1 result1, Match match2 result2) => match1 -> match2 -> Parser result2+before & after = (match before) >> (match after)++-- | @first \/ second@ tries to parse /first/, and failing that parses /second/,+-- unless /first/ has committed in which case is fails immediately. To achieve+-- streaming, we need to construct the final state manually, passing the+-- commitments through \"regardless\" of the results of either parsers. This+-- allows our caller to start consuming tokens from a committed option before+-- it is done parsing.+--+-- This code seems to hang on to the old states for too long a time, causing+-- memory usage to grow up when creating long parser chains (e.g. using @*@).+(/) :: (Match match1 result, Match match2 result) => match1 -> match2 -> Parser result+first / second =+  Parser (\ originalState ->+           let decision = originalState|>sDecision+               originalTokens = originalState|>sTokens+               originalCommits = originalState|>sCommits+               originalConsumed = originalState|>sConsumed+               nestState = setDecision "n/a"+                         $ setTokens D.empty+                         $ setCommits D.empty+                         $ setConsumed False+                         $ originalState+               (firstState, firstResult) = parse first nestState+               (firstIsCommitted, firstCommits) = commitStatus "n/a" decision $ D.toList $ firstState|>sCommits+               (chosenState, chosenResult, chosenCommits) =+                 if firstIsCommitted+                    then (firstState, firstResult, firstCommits)+                    else case firstResult of+                              Just _  -> (firstState, firstResult, firstCommits)+                              Nothing -> let (secondState, secondResult) = parse second nestState+                                             secondCommits = snd $ commitStatus "n/a" decision $ D.toList $ secondState|>sCommits+                                         in  (secondState, secondResult, secondCommits)+               chosenTokens = chosenState|>sTokens+               chosenConsumed = chosenState|>sConsumed+               finalState = setTokens (D.append originalTokens chosenTokens)+                          $ setCommits (D.append originalCommits chosenCommits)+                          $ setConsumed (originalConsumed || chosenConsumed)+                          $ setDecision decision+                          $ chosenState+           in (finalState, chosenResult))+  where commitStatus :: String -> String -> [String] -> (Bool, D.DList String)+        commitStatus prev decision []                             = (False, D.empty)+        commitStatus prev decision (name:rest) | name == decision = (True, snd $ commitStatus prev decision rest)+                                               | name == prev     = (True, snd $ commitStatus prev decision rest)+                                               | otherwise        = (True, D.cons name $ snd $ commitStatus name decision rest)++-- | @(parser ?)@ (optional) tries to match /parser/, otherwise does nothing.+(?) :: (Match match result) => match -> Pattern+(?) parser = non_empty parser & empty / empty++-- | @(parser *)@ matches zero or more occurrences of /parser/.+(*) :: (Match match result) => match -> Pattern+(*) parser = "*" ^ ( non_empty parser ! "*" & (parser *) / empty )++-- | @(parser +)@ matches one or more occurrences of /parser/.+(+) :: (Match match result) => match -> Pattern+(+) parser = non_empty parser & (parser *)++-- ** Basic parsers++-- | @traced name parser@ traces all invocations to the parser. Is only used when+-- debugging.+traced :: (Match match result, Show result) => String -> match -> Parser result+traced name parser = Parser (\ state -> trace_reply name (parse parser (trace_call name state)))++-- | @trace_call name state@ traces the /state/ at the start of the call to /name/.+trace_call :: String -> State -> State+trace_call name state = trace ("Call " ++ name ++ " with " ++ (show state)) state++-- | @trace_call name reply@ traces the /reply/ from calling /name/.+trace_reply :: Show result => String -> (State, Maybe result) -> (State, Maybe result)+trace_reply name reply@(state, result) =+  case result of+       Nothing    -> trace ("Fail " ++ name ++ " with " ++ (show state)) reply+       Just value -> trace ("Done " ++ name ++ " with " ++ (show state)) reply++-- | @reject rejected name@ fails if /rejected/ matches at this point, and does+-- nothing otherwise. If /name/ is provided, it is used in the error message,+-- otherwise the messages uses the current character.+reject :: (Match match result) => match -> Maybe String -> Pattern+reject rejected name =+  Parser (\ state -> let (_, result) = parse rejected $ setIsPeek True state+                         parser' = case (result, name) of+                                        (Nothing, _)        -> empty+                                        (Just _, Nothing)   -> consumeNextIf (const False)+                                        (Just _, Just text) -> failed $ "Unexpected " ++ text+                     in parse parser' state)++-- | @peek parser@ succeeds if /parser/ matches at this point, but does not+-- consume any input.+peek :: (Match match result) => match -> Parser result+peek parser = Parser (\ state -> let (_, result) = parse parser $ setIsPeek True state+                                 in case result of+                                         Nothing -> (setFailed "Peek failed" state, Nothing)+                                         Just _  -> (state, result))++-- | @non_empty parser@ matches the same as /parser/ as long as it consumes some+-- characters.+non_empty :: (Match match result) => match -> Parser result+non_empty parser =+  Parser (\ originalState -> let nestState = setConsumed False originalState+                                 (parseState, parseResult) = parse parser nestState+                             in case (parseState|>sConsumed, parseResult) of+                                     (True,   _)       -> (parseState, parseResult)+                                     (False,  Nothing) -> (parseState, parseResult)+                                     (False,  Just _)  -> (setFailed "Parser does not consume characters" originalState, Nothing))++-- | @empty@ always matches without consuming any input.+empty :: Pattern+empty = return ()++-- | @setFailed state message@ sets the @sMessage@ field to the error /message/.+setFailed :: String -> State -> State+setFailed message state = setMessage (Just $ state|>sName+                                          ++ ": line " ++ (show $ state|>sLine)+                                          ++ ": column " ++ (show $ state|>sColumn)+                                          ++ ": " ++ message)+                                     state++-- | @failed message@ fails parsing with the specified /message/. Note this is+-- not the 'Monad' @fail@ method, which we do not use.+failed :: String -> Parser result+failed message = Parser (\ state -> (setFailed message state, Nothing))++-- | @eof@ matches the end of the input.+eof :: Pattern+eof = Parser (\ state -> if state|>sInput     == []+                            then (state, Just ())+                            else (setFailed "Expected end of input" state, Nothing))++-- | @sol@ matches the start of a line.+sol :: Pattern+sol = Parser (\ state -> if state|>sColumn == 0+                            then (state, Just ())+                            else (setFailed "Expected start of line" state, Nothing))++-- ** State manipulation pseudo-parsers++-- | @incrLine@ increments @sLine@ counter resets @sColumn@.+nextLine :: Pattern+nextLine = Parser (\ state -> (setLine (state|>sLine .+ 1)+                             $ setColumn 0+                             $ state,+                               Just ()))++-- | @with setField getField value parser@ invokes the specified /parser/ with+-- the value of the specified field set to /value/ for the duration of the+-- invocation, using the /setField/ and /getField/ functions to manipulate it.+with :: (value -> State -> State) -> (State -> value) -> value -> Parser result -> Parser result+with setField getField value parser =+  Parser (\ originalState -> let originalValue = getField originalState+                                 withState = setField value originalState+                                 (parseState, parseResult) = parse parser withState+                                 finalState = setField originalValue parseState+                             in (finalState, parseResult))++-- | @decide name (a / b / ...)@ names the contained decision point so it can be+-- addressed by later @commit@ calls.+decide :: (Match match result) => String -> match -> Parser result+decide decision parser = with setDecision sDecision decision $ match parser++-- | @commit name@ commits the parser to all the decisions up to the most recent+-- containing decision with the specified /name/. This makes all tokens+-- generated in this parsing path immediately available to the caller.+commit :: String -> Pattern+commit name = Parser (\ state -> (setCommits (D.snoc (state|>sCommits) name) state, Just ()))++-- | @parser ``forbidding`` pattern@ parses the specified /parser/ ensuring+-- that it does not contain anything matching the /forbidden/ parser.+forbidding :: (Match match1 result1, Match match2 result2) => match1 -> match2 -> Parser result1+forbidding parser forbidden = with setForbidden sForbidden (Just $ forbidden & empty) (match parser)++-- | @parser ``limitedTo`` limit@ parses the specified /parser/+-- ensuring that it does not consume more than the /limit/ input chars.+limitedTo :: (Match match result) => match -> Int -> Parser result+limitedTo parser limit = with setLimit sLimit limit (match parser)++-- ** Consuming input characters++-- | @consumeNextIf test@ consumes and returns the next character if it satisfies+-- the /test/.+consumeNextIf :: (Char -> Bool) -> Pattern+consumeNextIf test = +  Parser (\ state -> case state|>sInput of+                          (char:rest) | test char -> (setInput rest+                                                    $ setLast char+                                                    $ setColumn (state|>sColumn .+ 1)+                                                    $ setChars (D.snoc (state|>sChars) char)+                                                    $ setConsumed True+                                                    $ state,+                                                      Just ())+                                      | otherwise -> (setFailed ("Unexpected '" ++ [char] ++ "'") state, Nothing)+                          []                      -> (setFailed "Unexpected end of input" state, Nothing))++-- | @limitedNextIf test@ fails if the 'State' lookahead limit is reached.+-- Otherwise it consumes and returns the specified input char if it satisfies+-- /test/.+limitedNextIf :: (Char -> Bool) -> Pattern+limitedNextIf test =+  Parser (\ state -> case state|>sLimit of+                          -1    -> parse (consumeNextIf test) state+                          0     -> (setFailed "Lookahead limit reached" state, Nothing)+                          limit -> parse (consumeNextIf test) $ setLimit (limit .- 1) state)++-- | @nextIf test@ fails if the current position matches the 'State' forbidden+-- pattern or if the 'State' lookahead limit is reached. Otherwise it consumes+-- (and buffers) the next input char if it satisfies /test/.+nextIf :: (Char -> Bool) -> Pattern+nextIf test =+  Parser (\ state -> case state|>sForbidden of+                          Nothing     -> parse (limitedNextIf test) state+                          Just parser -> let (_, result) = parse parser $ setIsPeek True+                                                                        $ setForbidden Nothing+                                                                        $ state+                                         in case result of+                                                 Nothing -> parse (limitedNextIf test) state+                                                 Just _  -> (setFailed "Forbidden pattern detected" state, Nothing))++-- ** Producing tokens++-- | @finishToken@ places all collected text into a new token and begins a new+-- one, or does nothing if there are no collected characters.+finishToken :: Pattern+finishToken =+  Parser (\ state -> let chars = D.toList $ state|>sChars+                         token = Token { tCode = state|>sCode, tText = Just chars }+                     in if state|>sIsPeek || chars == ""+                           then (state, Just ())+                           else (setTokens (D.snoc (state|>sTokens) token)+                               $ setChars D.empty+                               $ state,+                                 Just ()))++-- | @wrap parser@ invokes the /parser/, ensures any unclaimed input characters+-- are wrapped into a token (only happens when testing productions), ensures no+-- input is left unparsed, and returns the parser's result.+wrap :: (Match match result) => match -> Parser result+wrap parser = do result <- match parser+                 finishToken & eof+                 return result++-- | @consume parser@ invokes the /parser/ and then consumes all remaining+-- unparsed input characters.+consume :: (Match match result) => match -> Parser result+consume parser = do result <- match parser+                    finishToken & clear_input+                    return result+                 where clear_input = Parser (\ state -> (setInput [] state, Just ()))++-- | @token code parser@ places all text matched by /parser/ into a 'Token' with+-- the specified /code/ (unless it is empty). Note it collects the text even if+-- there is an error.+token :: (Match match result) => Code -> match -> Pattern+token code parser = finishToken & with setCode sCode code (parser & finishToken)++-- | @fake code text@ creates a token with the specified /code/ and \"fake\"+-- /text/ characters.+fake :: Code -> String -> Pattern+fake code text =+  Parser (\ state -> if state|>sIsPeek+                        then (state, Just())+                        else let token = Token { tCode = code, tText = Just text }+                             in (setTokens (D.snoc (state|>sTokens) token) state, Just ()))++-- | @meta parser@ collects the text matched by the specified /parser/ into a+-- | @Meta@ token.+meta :: (Match match result) => match -> Pattern+meta parser = token Meta parser++-- | @indicator code@ collects the text matched by the specified /parser/ into an+-- @Indicator@ token.+indicator :: (Match match result) => match -> Pattern+indicator parser = token Indicator $ parser++-- | @text parser@  collects the text matched by the specified /parser/ into a+-- @Text@ token.+text :: (Match match result) => match -> Pattern+text parser = token Text parser++-- | @nest code@ returns an empty token with the specified begin\/end /code/ to+-- signal nesting.+nest :: Code -> Pattern+nest code =+  Parser (\ state -> if state|>sIsPeek+                        then (state, Just())+                        else let (state', _) = parse finishToken state+                                 token = Token { tCode = code, tText = Nothing }+                             in (setTokens (D.snoc (state'|>sTokens) token) state', Just ()))++-- * Production parameters++-- | Production context.+data Context = BlockOut     -- ^ Outside block mapping.+             | BlockIn      -- ^ Inside block mapping.+             | FlowOut      -- ^ Outside flow collection.+             | FlowIn       -- ^ Inside flow collection.+             | FlowKey      -- ^ Inside flow key.++-- | @show context@ converts a 'Context' to a 'String'.+instance Show Context where+  show context = case context of+                      BlockOut -> "block-out"+                      BlockIn  -> "block-in"+                      FlowOut  -> "flow-out"+                      FlowIn   -> "flow-in"+                      FlowKey  -> "flow-key"++-- | @read context@ converts a 'String' to a 'Context'. We trust our callers to+-- convert any @-@ characters into @_@ to allow the built-in @lex@ function to+-- handle the names as single identifiers.+instance Read Context where+  readsPrec _ text = [ ((r word), tail) | (word, tail) <- lex text ]+    where r word = case word of+                        "block_out" -> BlockOut+                        "block_in"  -> BlockIn+                        "flow_out"  -> FlowOut+                        "flow_in"   -> FlowIn+                        "flow_key"  -> FlowKey+                        _           -> error $ "unknown context: " ++ word++-- | Scalar style.+data Style = Plain   -- ^ Plain scalar.+           | Double  -- ^ Double quoted.+           | Single  -- ^ Single quoted.+           | Literal -- ^ Literal block.+           | Folded  -- ^ Folded block.++-- | @show style@ converts a 'Style' to a 'String'.+instance Show Style where+  show style = case style of+                    Plain   -> "plain"+                    Double  -> "double"+                    Single  -> "single"+                    Literal -> "literal"+                    Folded  -> "folded"++-- | @read style@ converts a 'String' to a 'Style'.+instance Read Style where+  readsPrec _ text = [ ((r word), tail) | (word, tail) <- lex text ]+    where r word = case word of+                        "plain"   -> Plain+                        "double"  -> Double+                        "single"  -> Single+                        "literal" -> Literal+                        "folded"  -> Folded+                        _         -> error $ "unknown style: " ++ word++-- | Chomp method.+data Chomp = Strip -- ^ Remove all trailing line breaks.+           | Clip  -- ^ Keep first trailing line break.+           | Keep  -- ^ Keep all trailing line breaks.++-- | @show chomp@ converts a 'Chomp' to a 'String'.+instance Show Chomp where+  show chomp = case chomp of+                    Strip -> "strip"+                    Clip  -> "clip"+                    Keep  -> "keep"++-- | @read chomp@ converts a 'String' to a 'Chomp'.+instance Read Chomp where+  readsPrec _ text = [ ((r word), tail) | (word, tail) <- lex text ]+    where r word = case word of+                        "strip" -> Strip+                        "clip"  -> Clip+                        "keep"  -> Keep+                        _       -> error $ "unknown chomp: " ++ word++-- * Tokenizers+--+-- We encapsulate the 'Parser' inside a 'Tokenizer'. This allows us to hide the+-- implementation details from our callers.++-- | 'Tokenizer' converts a (named) input text into a list of 'Token'. Errors+-- are reported as tokens.+type Tokenizer = String -> C.ByteString -> [Token]++-- | @patternTokenizer pattern@ converts the /pattern/ to a simple 'Tokenizer'.+-- Note how using difference lists we can tuck the error token at the end of+-- the result without preventing the streaming.+patternTokenizer :: Pattern -> Tokenizer+patternTokenizer pattern name input =+  let (state, result) = parse (wrap pattern) (initialState name input)+      last = case result of+                  Just _  -> D.empty+                  Nothing -> D.singleton Token { tCode = Error, tText = state|>sMessage }+      bugs = commitBugs $ D.toList $ state|>sCommits+      errors = D.append bugs last+  in D.toList $ D.append (state|>sTokens) errors++-- | @parserTokenizer what parser@ converts the /parser/ returning /what/ to a+-- simple 'Tokenizer' (only used for tests). Note how using difference lists we+-- can tuck the result or error token at the end of the result without+-- preventing the streaming.+parserTokenizer :: (Show result, Match match result) => String -> match -> Tokenizer+parserTokenizer what parser name input =+  let (state, result) = parse (wrap parser) (initialState name input)+      last = case result of+                  Just value -> Token { tCode = Detected, tText = Just $ what ++ "=" ++ (show value) }+                  Nothing    -> Token { tCode = Error, tText = state|>sMessage }+      bugs = commitBugs $ D.toList $ state|>sCommits+      errors = D.snoc bugs last+  in D.toList $ D.append (state|>sTokens) errors++-- | @commitBugs commits@ converts any @commit@ calls made outside the decision+-- they refer to into an error token. No such calls should exists outside+-- tests.+commitBugs :: [String] -> D.DList Token+commitBugs [] = D.empty+commitBugs (decision:rest) =+  D.cons Token { tCode = Error, tText = Just $ "Commit to '" ++ decision ++ "' was made outside it" }+       $ commitBugs rest++-- | @yaml name input@ converts the Unicode /input/ (called /name/ in error+-- messages) to a list of 'Token' according to the YAML spec. This is it!+yaml :: Tokenizer+yaml = patternTokenizer l_yaml_stream++-- CPP LINES CAUSE HADDOCK TO BARF --+#ifdef REAL_CPP+-- This is how non-ancient C pre-processor do it.+#define STR(X) #X+#else+-- This only works in GHC's simplistic GHC (and ancient C pre-processors).+#define STR(X) "X"+#endif+-- These allow us to avoid repeating the parser names.+#define PAT(PATTERN) pat STR(PATTERN) PATTERN+#define PAR(PARSER)  par STR(PARSER)  PARSER+#define PAC(PARSER)  pac STR(PARSER)  PARSER+-- CPP LINES CAUSE HADDOCK TO BARF --++-- | @pName name@ converts a parser name to the \"proper\" spec name.+pName :: String -> String+pName name = regexSub questionRegex "?"+           $ regexSub minusRegex "-"+           $ regexSub plusRegex "+" name+           where regexSub regex value text = subRegex regex text value+                 questionRegex = mkRegex "'"+                 minusRegex = mkRegex "_"+                 plusRegex = mkRegex "__"++-- | @tokenizers@ returns a mapping from a production name to a production+-- tokenizer.+tokenizers :: Map.Map String Tokenizer+tokenizers = PAR(c_chomping_indicator) "t"+           $ PAC(detect_inline_indentation) "m"+           $ PAT(debug_leak)+           $ PAT(b_as_line_feed)+           $ PAT(b_carriage_return)+           $ PAT(b_char)+           $ PAT(b_generic)+           $ PAT(b_ignored_any)+           $ PAT(b_ignored_generic)+           $ PAT(b_l_folded_as_space)+           $ PAT(b_line_feed)+           $ PAT(b_line_separator)+           $ PAT(b_next_line)+           $ PAT(b_normalized)+           $ PAT(b_paragraph_separator)+           $ PAT(b_specific)+           $ PAT(c_alias)+           $ PAT(c_anchor)+           $ PAT(c_byte_order_mark)+           $ PAT(c_collect_entry)+           $ PAT(c_comment)+           $ PAT(c_directive)+           $ PAT(c_document_end)+           $ PAT(c_document_start)+           $ PAT(c_double_quote)+           $ PAT(c_escape)+           $ PAT(c_flow_indicator)+           $ PAT(c_folded)+           $ PAT(c_indicator)+           $ PAT(c_literal)+           $ PAT(c_mapping_end)+           $ PAT(c_mapping_key)+           $ PAT(c_mapping_start)+           $ PAT(c_mapping_value)+           $ PAT(c_named_tag_handle)+           $ PAT(c_nb_comment_text)+           $ PAT(c_non_specific_tag)+           $ PAT(c_ns_alias)+           $ PAT(c_ns_anchor_property)+           $ PAT(c_ns_local_tag_prefix)+           $ PAT(c_ns_properties)+           $ PAT(c_ns_property)+           $ PAT(c_ns_shorthand_tag)+           $ PAT(c_ns_tag_property)+           $ PAT(c_primary_tag_handle)+           $ PAT(c_printable)+           $ PAT(c_quoted_quote)+           $ PAT(c_reserved)+           $ PAT(c_secondary_tag_handle)+           $ PAT(c_sequence_end)+           $ PAT(c_sequence_entry)+           $ PAT(c_sequence_start)+           $ PAT(c_single_quote)+           $ PAT(c_s_simple_json_key)+           $ PAT(c_tag)+           $ PAT(c_tag_handle)+           $ PAT(c_verbatim_tag)+           $ PAT(e_node)+           $ PAT(e_no_document)+           $ PAT(e_scalar)+           $ PAT(l_comment)+           $ PAT(l_directive)+           $ PAT(l_document_prefix)+           $ PAT(l_documents)+           $ PAT(l_document_suffix)+           $ PAT(l_explicit_document)+           $ PAT(l_following_document)+           $ PAT(l_forbidden)+           $ PAT(l_implicit_document)+           $ PAT(l_leading_document)+           $ PAT(l_yaml_stream)+           $ PAT(nb_char)+           $ PAT(nb_double_char)+           $ PAT(nb_single_char)+           $ PAT(ns_anchor_char)+           $ PAT(ns_anchor_name)+           $ PAT(ns_ascii_letter)+           $ PAT(ns_char)+           $ PAT(ns_dec_digit)+           $ PAT(ns_directive_name)+           $ PAT(ns_directive_parameter)+           $ PAT(ns_double_char)+           $ PAT(ns_esc_16_bit)+           $ PAT(ns_esc_32_bit)+           $ PAT(ns_esc_8_bit)+           $ PAT(ns_esc_backslash)+           $ PAT(ns_esc_backspace)+           $ PAT(ns_esc_bell)+           $ PAT(ns_esc_carriage_return)+           $ PAT(ns_esc_char)+           $ PAT(ns_esc_double_quote)+           $ PAT(ns_esc_escape)+           $ PAT(ns_esc_form_feed)+           $ PAT(ns_esc_horizontal_tab)+           $ PAT(ns_esc_line_feed)+           $ PAT(ns_esc_line_separator)+           $ PAT(ns_esc_next_line)+           $ PAT(ns_esc_non_breaking_space)+           $ PAT(ns_esc_null)+           $ PAT(ns_esc_paragraph_separator)+           $ PAT(ns_esc_space)+           $ PAT(ns_esc_vertical_tab)+           $ PAT(ns_global_tag_prefix)+           $ PAT(ns_hex_digit)+           $ PAT(ns_plain_safe_in)+           $ PAT(ns_plain_safe_out)+           $ PAT(ns_reserved_directive)+           $ PAT(ns_s_block_map_implicit_key)+           $ PAT(ns_single_char)+           $ PAT(ns_s_simple_yaml_key)+           $ PAT(ns_tag_char)+           $ PAT(ns_tag_directive)+           $ PAT(ns_tag_prefix)+           $ PAT(ns_uri_char)+           $ PAT(ns_word_char)+           $ PAT(ns_yaml_directive)+           $ PAT(ns_yaml_version)+           $ PAT(s_b_comment)+           $ PAT(s_b_double_escaped)+           $ PAT(s_l_comments)+           $ PAT(s_ns_double_chars)+           $ PAT(s_ns_single_chars)+           $ PAT(s_separate_in_line)+           $ PAT(s_space)+           $ PAT(s_tab)+           $ PAT(s_white)+           $ Map.empty+  where pat name pattern     = Map.insert (pName name) $ patternTokenizer     (match pattern)+        par name parser what = Map.insert (pName name) $ parserTokenizer what (match parser)+        pac name parser what = Map.insert (pName name) $ parserTokenizer what (consume parser)++-- | @tokenizer name@ converts the production with the specified /name/ to a+-- simple 'Tokenizer', or @Nothing@ if it isn't known.+tokenizer :: String -> (Maybe Tokenizer)+tokenizer name = Map.lookup name tokenizers++-- | @tokenizersWithN@ returns a mapping from a production name to a production+-- tokenizer (that takes an /n/ argument).+tokenizersWithN :: Map.Map String (Int -> Tokenizer)+tokenizersWithN = PAR(c_indentation_indicator) "m"+                $ PAR(count_spaces) "m"+                $ PAC(detect_collection_indentation) "m"+                $ PAC(detect_scalar_indentation) "m"+                $ PAT(b_l_literal_next)+                $ PAT(b_l_spaced)+                $ PAT(c_l_block_map_explicit_entry)+                $ PAT(c_l_block_map_explicit_key)+                $ PAT(c_l_block_map_implicit_value)+                $ PAT(c_l_block_seq_entry)+                $ PAT(c_l__folded)+                $ PAT(c_l__literal)+                $ PAT(l_block_map_explicit_value)+                $ PAT(l__block_mapping)+                $ PAT(l__block_sequence)+                $ PAT(l_keep_empty)+                $ PAT(l_nb_folded_lines)+                $ PAT(l_nb_literal_chars)+                $ PAT(l_nb_spaced_lines)+                $ PAT(l_nb_start_with_any)+                $ PAT(l_nb_start_with_folded)+                $ PAT(l_nb_start_with_spaced)+                $ PAT(l_strip_empty)+                $ PAT(l_trail_comments)+                $ PAT(ns_l_block_map_entry)+                $ PAT(ns_l_block_map_implicit_entry)+                $ PAT(ns_l_in_line_mapping)+                $ PAT(ns_l_in_line_sequence)+                $ PAT(s_double_multi)+                $ PAT(s_ignored_prefix_block)+                $ PAT(s_ignored_prefix_flow)+                $ PAT(s_indent)+                $ PAT(s_indent_le)+                $ PAT(s_indent_lt)+                $ PAT(s_l_double_any)+                $ PAT(s_l_flow_folded)+                $ PAT(s_l__flow_in_block)+                $ PAT(s_nb_folded_text)+                $ PAT(s_nb_spaced_text)+                $ PAT(s_ns_double_next)+                $ PAT(s_ns_single_next)+                $ PAT(s_separate_lines)+                $ PAT(s_single_multi)+                $ Map.empty+  where pat name pattern     = Map.insert (pName name) (\ n -> patternTokenizer     (match   $ pattern n))+        par name parser what = Map.insert (pName name) (\ n -> parserTokenizer what (match   $ parser  n))+        pac name parser what = Map.insert (pName name) (\ n -> parserTokenizer what (consume $ parser  n))++-- | @tokenizerWithN name n@ converts the production (that requires an /n/+-- argument) with the specified /name/ to a simple 'Tokenizer', or @Nothing@ if+-- it isn't known.+tokenizerWithN :: String -> Int -> Maybe Tokenizer+tokenizerWithN name n =+  case Map.lookup name tokenizersWithN of+    Just tokenizer -> Just $ tokenizer n+    Nothing        -> Nothing++-- | @tokenizersWithC@ returns a mapping from a production name to a production+-- tokenizer (that takes a /c/ argument).+tokenizersWithC :: Map.Map String (Context -> Tokenizer)+tokenizersWithC = PAT(nb_plain_char)+                $ PAT(ns_plain_char)+                $ PAT(ns_plain_first)+                $ PAT(ns_plain_safe)+                $ PAT(ns_plain_single)+                $ PAT(s_ns_plain_chars)+                $ Map.empty+  where pat name pattern = Map.insert (pName name) (\ c -> patternTokenizer (match $ pattern c))++-- | @tokenizerWithC name c@ converts the production (that requires a /c/+-- argument) with the specified /name/ to a simple 'Tokenizer', or @Nothing@ if+-- it isn't known.+tokenizerWithC :: String -> Context -> Maybe Tokenizer+tokenizerWithC name c =+  case Map.lookup name tokenizersWithC of+    Just tokenizer -> Just $ tokenizer c+    Nothing        -> Nothing++-- | @tokenizersWithS@ returns a mapping from a production name to a production+-- tokenizer (that takes a /s/ argument).+tokenizersWithS :: Map.Map String (Style -> Tokenizer)+tokenizersWithS = PAT(c_style_indicator)+                $ Map.empty+  where pat name pattern = Map.insert (pName name) (\ s -> patternTokenizer (match $ pattern s))++-- | @tokenizerWithS name s@ converts the production (that requires an /s/+-- argument) with the specified /name/ to a simple 'Tokenizer', or @Nothing@ if+-- it isn't known.+tokenizerWithS :: String -> Style -> Maybe Tokenizer+tokenizerWithS name s =+  case Map.lookup name tokenizersWithS of+    Just tokenizer -> Just $ tokenizer s+    Nothing        -> Nothing++-- | @tokenizersWithT@ returns a mapping from a production name to a production+-- tokenizer (that takes a /t/ argument).+tokenizersWithT :: Map.Map String (Chomp -> Tokenizer)+tokenizersWithT = PAT(b_chomped_last)+                $ Map.empty+  where pat name pattern = Map.insert (pName name) (\ t -> patternTokenizer (match $ pattern t))++-- | @tokenizerWithT name t@ converts the production (that requires an /t/+-- argument) with the specified /name/ to a simple 'Tokenizer', or @Nothing@ if+-- it isn't known.+tokenizerWithT :: String -> Chomp -> Maybe Tokenizer+tokenizerWithT name t = +  case Map.lookup name tokenizersWithT of+    Just tokenizer -> Just $ tokenizer t+    Nothing        -> Nothing++-- | @tokenizersWithNC@ returns a mapping from a production name to a+-- production tokenizer (that requires /n/ and /c/ arguments).+tokenizersWithNC :: Map.Map String (Int -> Context -> Tokenizer)+tokenizersWithNC = PAT(c_double_quoted)+                 $ PAT(c_flow_json_content)+                 $ PAT(c_flow_json_node)+                 $ PAT(c_flow_mapping)+                 $ PAT(c_flow_sequence)+                 $ PAT(c_ns_flow_map_adjacent_value)+                 $ PAT(c_ns_flow_map_implicit_json)+                 $ PAT(c_ns_flow_map_separate_value)+                 $ PAT(c_ns_flow_map_single_json)+                 $ PAT(c_single_quoted)+                 $ PAT(nb_double_text)+                 $ PAT(nb_single_text)+                 $ PAT(ns_flow_content)+                 $ PAT(ns_flow_map_entry)+                 $ PAT(ns_flow_map_implicit_empty)+                 $ PAT(ns_flow_map_implicit_entry)+                 $ PAT(ns_flow_map_implicit_yaml)+                 $ PAT(ns_flow_map_single_entry)+                 $ PAT(ns_flow_map_single_pair)+                 $ PAT(ns_flow_map_single_yaml)+                 $ PAT(ns_flow_node)+                 $ PAT(ns_flow_seq_entry)+                 $ PAT(ns_flow_yaml_content)+                 $ PAT(ns_flow_yaml_node)+                 $ PAT(ns_plain)+                 $ PAT(ns_plain_multi)+                 $ PAT(ns_s_flow_map_entries)+                 $ PAT(ns_s_flow_seq_entries)+                 $ PAT(s_l__block_content)+                 $ PAT(s_l__block_in_block)+                 $ PAT(s_l__block_indented)+                 $ PAT(s_l__block_node)+                 $ PAT(s_ns_flow_map_explicit_empty)+                 $ PAT(s_ns_flow_map_explicit_entry)+                 $ PAT(s_ns_flow_map_explicit_json)+                 $ PAT(s_ns_flow_map_explicit_yaml)+                 $ PAT(s_ns_plain_next)+                 $ PAT(s_separate_in_flow)+                 $ Map.empty+  where pat name pattern = Map.insert (pName name) (\ n c -> patternTokenizer (match $ pattern n c))++-- | @tokenizerWithNC name n c@ converts the production (that requires /n/ and+-- /c/ arguments) with the specified /name/ to a simple 'Tokenizer', or+-- @Nothing@ if it isn't known.+tokenizerWithNC :: String -> Int -> Context -> Maybe Tokenizer+tokenizerWithNC name n c =+  case Map.lookup name tokenizersWithNC of+    Just tokenizer -> Just $ tokenizer n c+    Nothing        -> Nothing++-- | @tokenizersWithNS@ returns a mapping from a production name to a production+-- tokenizer (that requires /n/ and /s/ arguments).+tokenizersWithNS :: Map.Map String (Int -> Style -> Tokenizer)+tokenizersWithNS = PAR(c_b__block_header) "(m,t)"+                 $ PAT(b_l_folded_any)+                 $ PAT(b_l_folded_specific)+                 $ PAT(b_l_folded_trimmed)+                 $ PAT(l_empty)+                 $ PAT(s_ignored_prefix)+                 $ Map.empty+  where pat name pattern     = Map.insert (pName name) (\ n s -> patternTokenizer     (match $ pattern n s))+        par name parser what = Map.insert (pName name) (\ n s -> parserTokenizer what (match $ parser  n s))++-- | @tokenizerWithNS name n s@ converts the production (that requires /n/ and+-- /s/ arguments) with the specified /name/ to a simple 'Tokenizer', or+-- @Nothing@ if it isn't known.+tokenizerWithNS :: String -> Int -> Style -> Maybe Tokenizer+tokenizerWithNS name n s =+  case Map.lookup name tokenizersWithNS of+    Just tokenizer -> Just $ tokenizer n s+    Nothing        -> Nothing++-- | @tokenizersWithNT@ returns a mapping from a production name to a+-- production tokenizer (that requires /n/ and /t/ arguments).+tokenizersWithNT :: Map.Map String (Int -> Chomp -> Tokenizer)+tokenizersWithNT = PAT(l_chomped_empty)+                 $ PAT(l_folded_content)+                 $ PAT(l_literal_content)+                 $ Map.empty+  where pat name pattern = Map.insert (pName name) (\ n t -> patternTokenizer (match $ pattern n t))++-- | @tokenizerWithNT name n t@ converts the production (that requires /n/ and+-- /t/ arguments) with the specified /name/ to a simple 'Tokenizer', or+-- @Nothing@ if it isn't known.+tokenizerWithNT :: String -> Int -> Chomp -> Maybe Tokenizer+tokenizerWithNT name n t =+  case Map.lookup name tokenizersWithNT of+    Just tokenizer -> Just $ tokenizer n t+    Nothing        -> Nothing++-- | @tokenizerNames@ returns the list of all productions (tokenizers).+tokenizerNames :: [String]+tokenizerNames = (Map.keys tokenizers)+              ++ (Map.keys tokenizersWithN)+              ++ (Map.keys tokenizersWithC)+              ++ (Map.keys tokenizersWithS)+              ++ (Map.keys tokenizersWithT)+              ++ (Map.keys tokenizersWithNC)+              ++ (Map.keys tokenizersWithNS)+              ++ (Map.keys tokenizersWithNT)++-- * Productions++-- ** BNF compatibility helpers++-- | @detect_utf_encoding@ doesn't actually detect the encoding, we just call it+-- this way to make the productions compatible with the spec. Instead it simply+-- reports the encoding (which was already detected when we started parsing).+detect_utf_encoding = Parser (\ state -> let text = case state|>sEncoding of+                                                         UTF8    -> "TF8"+                                                         UTF16LE -> "TF16LE"+                                                         UTF16BE -> "TF16BE"+                                         in parse (fake Bom text) $ setChars D.empty+                                                                  $ setColumn (state|>sColumn .- 1)+                                                                  $ state)++-- | @na@ is the \"non-applicable\" indentation value. We use Haskell's laziness+-- to verify it really is never used.+na :: Int+na = error "Accessing non-applicable indentation"++-- | @asInteger@ returns the last consumed character, which is assumed to be a+-- decimal digit, as an integer.+asInteger :: Parser Int+asInteger = Parser (\ state -> (state, Just $ ord (state|>sLast) .- 48))++-- | @result value@ is the same as /return value/ except that we give the+-- Haskell type deduction the additional boost it needs to figure out this is+-- wrapped in a 'Parser'.+result :: result -> Parser result+result = return++-- CPP LINES CAUSE HADDOCK TO BARF --+#include "Reference.bnf"+-- CPP LINES CAUSE HADDOCK TO BARF --++debug_leak = ( c_comment & b_line_feed *)
+ YamlReference.cabal view
@@ -0,0 +1,1167 @@+Name:            YamlReference+Version:         0.1+License:         LGPL+License-File:    lgpl.txt+Copyright:       Oren Ben-Kiki 2007+Author:          Oren Ben-Kiki+Maintainer:      yaml-oren@ben-kiki.org+Stability:       alpha+Homepage:        www.ben-kiki.org/oren/YamlReference+Package-Url:     www.ben-kiki.org/oren/YamlReference/YamlReference-0.1.tar.gz+Synopsis:        YAML reference implementation+Description:     This package contains \"the\" reference YAML syntax parser+                 ("Text.Yaml.Reference"), generated directly from the YAML+                 specifications, as well as sample program (@yaml2yeast@) that+                 allows accessing it from the command line, converting YAML+                 files to YEAST tokens. This is intended to be more of an+                 \"executable specification\" for YAML rather than an actual+                 basis for YAML tool chains. That said, it is possible to build+                 interesting tools on top of it, such as the @yeast2html@ YAML+                 syntax visualizer (contained in this package), pretty+                 printers, etc. This is a streaming parser that will+                 \"immediately\" begin to generate output, but it has a memoy+                 leak (actually, retention) problem that prevents it from being+                 applied to \"large\" files. To debug this with minimal syntax+                 productions use @yes "#" | yaml2yeast -p debug-leak@.+Build-Depends:   base >= 2.0, HUnit >= 1.1, regex-compat >= 0.71, dlist >= 0.2+Exposed-Modules: Text.Yaml.Reference+Extensions:      CPP, MultiParamTypeClasses+Data-Files:      Text/Yaml/Reference.bnf yeast2html yaml2yeast.css+                 tests/debug-leak.input tests/debug-leak.output+                 tests/b-as-line-feed.input tests/b-as-line-feed.output+                 tests/b-carriage-return.input tests/b-carriage-return.output+                 tests/b-char.cr.input tests/b-char.cr.output+                 tests/b-char.invalid.input tests/b-char.invalid.output+                 tests/b-char.lf.input tests/b-char.lf.output+                 tests/b-char.ls.input tests/b-char.ls.output+                 tests/b-char.nl.input tests/b-char.nl.output+                 tests/b-char.ps.input tests/b-char.ps.output+                 tests/b-chomped-last.t=clip.input+                 tests/b-chomped-last.t=clip.invalid.input+                 tests/b-chomped-last.t=clip.invalid.output+                 tests/b-chomped-last.t=clip.output+                 tests/b-chomped-last.t=keep.input+                 tests/b-chomped-last.t=keep.output+                 tests/b-chomped-last.t=strip.input+                 tests/b-chomped-last.t=strip.output tests/b-generic.cr.input+                 tests/b-generic.crlf.input tests/b-generic.crlf.output+                 tests/b-generic.cr.output tests/b-generic.invalid.input+                 tests/b-generic.invalid.output tests/b-generic.lf.input+                 tests/b-generic.lf.output tests/b-generic.nl.input+                 tests/b-generic.nl.output tests/b-ignored-any.invalid.input+                 tests/b-ignored-any.invalid.output+                 tests/b-ignored-any.lf.input tests/b-ignored-any.lf.output+                 tests/b-ignored-any.ls.input tests/b-ignored-any.ls.output+                 tests/b-ignored-generic.input tests/b-ignored-generic.output+                 tests/b-l-folded-any.n=4.s=plain.as-space.input+                 tests/b-l-folded-any.n=4.s=plain.as-space.output+                 tests/b-l-folded-any.n=4.s=plain.invalid.input+                 tests/b-l-folded-any.n=4.s=plain.invalid.output+                 tests/b-l-folded-any.n=4.s=plain.specific.input+                 tests/b-l-folded-any.n=4.s=plain.specific.output+                 tests/b-l-folded-any.n=4.s=plain.trimmed.input+                 tests/b-l-folded-any.n=4.s=plain.trimmed.output+                 tests/b-l-folded-as-space.input+                 tests/b-l-folded-as-space.invalid.input+                 tests/b-l-folded-as-space.invalid.output+                 tests/b-l-folded-as-space.output+                 tests/b-l-folded-specific.n=4.s=plain.invalid.input+                 tests/b-l-folded-specific.n=4.s=plain.invalid.output+                 tests/b-l-folded-specific.n=4.s=plain.ls.input+                 tests/b-l-folded-specific.n=4.s=plain.ls-lf-ls.input+                 tests/b-l-folded-specific.n=4.s=plain.ls-lf-ls.output+                 tests/b-l-folded-specific.n=4.s=plain.ls.output+                 tests/b-l-folded-trimmed.n=4.s=plain.invalid.input+                 tests/b-l-folded-trimmed.n=4.s=plain.invalid.output+                 tests/b-l-folded-trimmed.n=4.s=plain.lf-ls-lf.input+                 tests/b-l-folded-trimmed.n=4.s=plain.lf-ls-lf.output+                 tests/b-line-feed.input tests/b-line-feed.output+                 tests/b-line-separator.input tests/b-line-separator.output+                 tests/b-l-literal-next.n=4.input+                 tests/b-l-literal-next.n=4.invalid.input+                 tests/b-l-literal-next.n=4.invalid.output+                 tests/b-l-literal-next.n=4.output tests/b-l-spaced.n=4.input+                 tests/b-l-spaced.n=4.invalid.input+                 tests/b-l-spaced.n=4.invalid.output+                 tests/b-l-spaced.n=4.output tests/b-next-line.input+                 tests/b-next-line.output tests/b-normalized.invalid.input+                 tests/b-normalized.invalid.output tests/b-normalized.lf.input+                 tests/b-normalized.lf.output tests/b-normalized.ls.input+                 tests/b-normalized.ls.output tests/b-paragraph-separator.input+                 tests/b-paragraph-separator.output+                 tests/b-specific.invalid.input tests/b-specific.invalid.output+                 tests/b-specific.ls.input tests/b-specific.ls.output+                 tests/b-specific.ps.input tests/b-specific.ps.output+                 tests/c-alias.input tests/c-alias.output tests/c-anchor.input+                 tests/c-anchor.output+                 tests/c-b+block-header.n=2.s=folded.i.input+                 tests/c-b+block-header.n=2.s=folded.im.input+                 tests/c-b+block-header.n=2.s=folded.im.output+                 tests/c-b+block-header.n=2.s=folded.imt.input+                 tests/c-b+block-header.n=2.s=folded.imt.output+                 tests/c-b+block-header.n=2.s=folded.invalid.input+                 tests/c-b+block-header.n=2.s=folded.invalid.output+                 tests/c-b+block-header.n=2.s=folded.i.output+                 tests/c-b+block-header.n=2.s=folded.it.input+                 tests/c-b+block-header.n=2.s=folded.itm.input+                 tests/c-b+block-header.n=2.s=folded.itm.output+                 tests/c-b+block-header.n=2.s=folded.it.output+                 tests/c-byte-order-mark.invalid.input+                 tests/c-byte-order-mark.invalid.output+                 tests/c-byte-order-mark.utf16be.input+                 tests/c-byte-order-mark.utf16be.output+                 tests/c-byte-order-mark.utf16le.input+                 tests/c-byte-order-mark.utf16le.output+                 tests/c-byte-order-mark.utf8.input+                 tests/c-byte-order-mark.utf8.output+                 tests/c-chomping-indicator.empty.input+                 tests/c-chomping-indicator.empty.output+                 tests/c-chomping-indicator.hyphen.input+                 tests/c-chomping-indicator.hyphen.output+                 tests/c-chomping-indicator.invalid.input+                 tests/c-chomping-indicator.invalid.output+                 tests/c-chomping-indicator.plus.input+                 tests/c-chomping-indicator.plus.output+                 tests/c-collect-entry.input tests/c-collect-entry.output+                 tests/c-comment.input tests/c-comment.output+                 tests/c-directive.input tests/c-directive.output+                 tests/c-document-end.input tests/c-document-end.invalid.input+                 tests/c-document-end.invalid.output+                 tests/c-document-end.output tests/c-document-start.input+                 tests/c-document-start.invalid.input+                 tests/c-document-start.invalid.output+                 tests/c-document-start.output+                 tests/c-double-quoted.n=4.c=flow-out.input+                 tests/c-double-quoted.n=4.c=flow-out.invalid.input+                 tests/c-double-quoted.n=4.c=flow-out.invalid.output+                 tests/c-double-quoted.n=4.c=flow-out.output+                 tests/c-double-quote.input tests/c-double-quote.output+                 tests/c-escape.input tests/c-escape.invalid.input+                 tests/c-escape.invalid.output tests/c-escape.output+                 tests/c-flow-indicator.collect-entry.input+                 tests/c-flow-indicator.collect-entry.output+                 tests/c-flow-indicator.invalid.input+                 tests/c-flow-indicator.invalid.output+                 tests/c-flow-indicator.mapping-end.input+                 tests/c-flow-indicator.mapping-end.output+                 tests/c-flow-indicator.mapping-start.input+                 tests/c-flow-indicator.mapping-start.output+                 tests/c-flow-indicator.sequence-end.input+                 tests/c-flow-indicator.sequence-end.output+                 tests/c-flow-indicator.sequence-start.input+                 tests/c-flow-indicator.sequence-start.output+                 tests/c-flow-json-content.n=4.c=flow-in.double.input+                 tests/c-flow-json-content.n=4.c=flow-in.double.output+                 tests/c-flow-json-content.n=4.c=flow-in.invalid.input+                 tests/c-flow-json-content.n=4.c=flow-in.invalid.output+                 tests/c-flow-json-content.n=4.c=flow-in.mapping.input+                 tests/c-flow-json-content.n=4.c=flow-in.mapping.output+                 tests/c-flow-json-content.n=4.c=flow-in.sequence.input+                 tests/c-flow-json-content.n=4.c=flow-in.sequence.output+                 tests/c-flow-json-node.n=4.c=flow-in.invalid.input+                 tests/c-flow-json-node.n=4.c=flow-in.invalid.output+                 tests/c-flow-json-node.n=4.c=flow-in.tagged.input+                 tests/c-flow-json-node.n=4.c=flow-in.tagged.output+                 tests/c-flow-json-node.n=4.c=flow-in.untagged.input+                 tests/c-flow-json-node.n=4.c=flow-in.untagged.output+                 tests/c-flow-mapping.n=4.c=flow-in.compact.input+                 tests/c-flow-mapping.n=4.c=flow-in.compact.output+                 tests/c-flow-mapping.n=4.c=flow-in.invalid.input+                 tests/c-flow-mapping.n=4.c=flow-in.invalid.output+                 tests/c-flow-mapping.n=4.c=flow-in.spaced.input+                 tests/c-flow-mapping.n=4.c=flow-in.spaced.output+                 tests/c-flow-sequence.n=4.c=flow-in.compact.input+                 tests/c-flow-sequence.n=4.c=flow-in.compact.output+                 tests/c-flow-sequence.n=4.c=flow-in.invalid.input+                 tests/c-flow-sequence.n=4.c=flow-in.invalid.output+                 tests/c-flow-sequence.n=4.c=flow-in.spaced.input+                 tests/c-flow-sequence.n=4.c=flow-in.spaced.output+                 tests/c-folded.input tests/c-folded.output+                 tests/c-indentation-indicator.n=0.input+                 tests/c-indentation-indicator.n=0.invalid.input+                 tests/c-indentation-indicator.n=0.invalid.output+                 tests/c-indentation-indicator.n=0.output+                 tests/c-indicator.alias.input tests/c-indicator.alias.output+                 tests/c-indicator.anchor.input tests/c-indicator.anchor.output+                 tests/c-indicator.collect-entry.input+                 tests/c-indicator.collect-entry.output+                 tests/c-indicator.comment.input+                 tests/c-indicator.comment.output+                 tests/c-indicator.directive.input+                 tests/c-indicator.directive.output+                 tests/c-indicator.double-quote.input+                 tests/c-indicator.double-quote.output+                 tests/c-indicator.folded.input tests/c-indicator.folded.output+                 tests/c-indicator.invalid.input+                 tests/c-indicator.invalid.output+                 tests/c-indicator.literal.input+                 tests/c-indicator.literal.output+                 tests/c-indicator.mapping-end.input+                 tests/c-indicator.mapping-end.output+                 tests/c-indicator.mapping-key.input+                 tests/c-indicator.mapping-key.output+                 tests/c-indicator.mapping-start.input+                 tests/c-indicator.mapping-start.output+                 tests/c-indicator.mapping-value.input+                 tests/c-indicator.mapping-value.output+                 tests/c-indicator.reserved.at.input+                 tests/c-indicator.reserved.at.output+                 tests/c-indicator.reserved.backtick.input+                 tests/c-indicator.reserved.backtick.output+                 tests/c-indicator.sequence-end.input+                 tests/c-indicator.sequence-end.output+                 tests/c-indicator.sequence-entry.input+                 tests/c-indicator.sequence-entry.output+                 tests/c-indicator.sequence-start.input+                 tests/c-indicator.sequence-start.output+                 tests/c-indicator.single-quote.input+                 tests/c-indicator.single-quote.output+                 tests/c-indicator.tag.input tests/c-indicator.tag.output+                 tests/c-l-block-map-explicit-entry.n=2.input+                 tests/c-l-block-map-explicit-entry.n=2.invalid.input+                 tests/c-l-block-map-explicit-entry.n=2.invalid.output+                 tests/c-l-block-map-explicit-entry.n=2.output+                 tests/c-l-block-map-explicit-key.n=2.input+                 tests/c-l-block-map-explicit-key.n=2.invalid.input+                 tests/c-l-block-map-explicit-key.n=2.invalid.output+                 tests/c-l-block-map-explicit-key.n=2.output+                 tests/c-l-block-map-implicit-value.n=2.empty.input+                 tests/c-l-block-map-implicit-value.n=2.empty.output+                 tests/c-l-block-map-implicit-value.n=2.invalid.input+                 tests/c-l-block-map-implicit-value.n=2.invalid.output+                 tests/c-l-block-map-implicit-value.n=2.plain.input+                 tests/c-l-block-map-implicit-value.n=2.plain.output+                 tests/c-l-block-seq-entry.n=2.input+                 tests/c-l-block-seq-entry.n=2.invalid.input+                 tests/c-l-block-seq-entry.n=2.invalid.output+                 tests/c-l-block-seq-entry.n=2.output+                 tests/c-l+folded.n=2.indent.input+                 tests/c-l+folded.n=2.indent.output+                 tests/c-l+folded.n=2.invalid.input+                 tests/c-l+folded.n=2.invalid.output+                 tests/c-l+folded.n=2.simple.input+                 tests/c-l+folded.n=2.simple.output tests/c-literal.input+                 tests/c-literal.output tests/c-l+literal.n=2.invalid.input+                 tests/c-l+literal.n=2.invalid.output+                 tests/c-l+literal.n=2.simple.input+                 tests/c-l+literal.n=2.simple.output+                 tests/c-l+literal.n=2.strip-indent.input+                 tests/c-l+literal.n=2.strip-indent.output+                 tests/c-l+literal.n=2.strip.input+                 tests/c-l+literal.n=2.strip.output tests/c-mapping-end.input+                 tests/c-mapping-end.output tests/c-mapping-key.input+                 tests/c-mapping-key.output tests/c-mapping-start.input+                 tests/c-mapping-start.output tests/c-mapping-value.input+                 tests/c-mapping-value.output tests/c-named-tag-handle.input+                 tests/c-named-tag-handle.invalid.input+                 tests/c-named-tag-handle.invalid.output+                 tests/c-named-tag-handle.output+                 tests/c-nb-comment-text.comment.input+                 tests/c-nb-comment-text.comment.output+                 tests/c-nb-comment-text.comment-text.input+                 tests/c-nb-comment-text.comment-text.output+                 tests/c-nb-comment-text.invalid.input+                 tests/c-nb-comment-text.invalid.output+                 tests/c-non-specific-tag.input+                 tests/c-non-specific-tag.invalid.input+                 tests/c-non-specific-tag.invalid.output+                 tests/c-non-specific-tag.output tests/c-ns-alias.input+                 tests/c-ns-alias.invalid.input tests/c-ns-alias.invalid.output+                 tests/c-ns-alias.output tests/c-ns-anchor-property.input+                 tests/c-ns-anchor-property.invalid.input+                 tests/c-ns-anchor-property.invalid.output+                 tests/c-ns-anchor-property.output+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.compact.input+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.compact.output+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.empty.input+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.empty.output+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.invalid.input+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.invalid.output+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.spaced.input+                 tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.spaced.output+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.compact.input+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.compact.output+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.empty.input+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.empty.output+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.invalid.input+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.invalid.output+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.spaced.input+                 tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.spaced.output+                 tests/c-ns-flow-map-separate-value.n=4.c=flow-in.empty.input+                 tests/c-ns-flow-map-separate-value.n=4.c=flow-in.empty.output+                 tests/c-ns-flow-map-separate-value.n=4.c=flow-in.invalid.input+                 tests/c-ns-flow-map-separate-value.n=4.c=flow-in.invalid.output+                 tests/c-ns-flow-map-separate-value.n=4.c=flow-in.value.input+                 tests/c-ns-flow-map-separate-value.n=4.c=flow-in.value.output+                 tests/c-ns-flow-map-single-json.n=4.c=flow-in.input+                 tests/c-ns-flow-map-single-json.n=4.c=flow-in.invalid.input+                 tests/c-ns-flow-map-single-json.n=4.c=flow-in.invalid.output+                 tests/c-ns-flow-map-single-json.n=4.c=flow-in.output+                 tests/c-ns-local-tag-prefix.input+                 tests/c-ns-local-tag-prefix.invalid.input+                 tests/c-ns-local-tag-prefix.invalid.output+                 tests/c-ns-local-tag-prefix.output tests/c-ns-properties.input+                 tests/c-ns-properties.invalid.input+                 tests/c-ns-properties.invalid.output+                 tests/c-ns-properties.output tests/c-ns-property.anchor.input+                 tests/c-ns-property.anchor.output+                 tests/c-ns-property.invalid.input+                 tests/c-ns-property.invalid.output+                 tests/c-ns-property.tag.input tests/c-ns-property.tag.output+                 tests/c-ns-shorthand-tag.invalid.input+                 tests/c-ns-shorthand-tag.invalid.output+                 tests/c-ns-shorthand-tag.named.input+                 tests/c-ns-shorthand-tag.named.output+                 tests/c-ns-shorthand-tag.primary.input+                 tests/c-ns-shorthand-tag.primary.output+                 tests/c-ns-shorthand-tag.secondary.input+                 tests/c-ns-shorthand-tag.secondary.output+                 tests/c-ns-tag-property.invalid.input+                 tests/c-ns-tag-property.invalid.output+                 tests/c-ns-tag-property.non-specific.input+                 tests/c-ns-tag-property.non-specific.output+                 tests/c-ns-tag-property.shorthand.input+                 tests/c-ns-tag-property.shorthand.output+                 tests/c-ns-tag-property.verbatim.input+                 tests/c-ns-tag-property.verbatim.output+                 tests/count-spaces.n=0.0.input tests/count-spaces.n=0.0.output+                 tests/count-spaces.n=0.1.input tests/count-spaces.n=0.1.output+                 tests/count-spaces.n=0.2.input tests/count-spaces.n=0.2.output+                 tests/count-spaces.n=-1.0.input tests/count-spaces.n=1.0.input+                 tests/count-spaces.n=-1.0.output+                 tests/count-spaces.n=1.0.output+                 tests/count-spaces.n=-1.1.input tests/count-spaces.n=1.1.input+                 tests/count-spaces.n=-1.1.output+                 tests/count-spaces.n=1.1.output+                 tests/count-spaces.n=-1.2.input tests/count-spaces.n=1.2.input+                 tests/count-spaces.n=-1.2.output+                 tests/count-spaces.n=1.2.output+                 tests/c-primary-tag-handle.input+                 tests/c-primary-tag-handle.invalid.input+                 tests/c-primary-tag-handle.invalid.output+                 tests/c-primary-tag-handle.output+                 tests/c-printable.10000.input tests/c-printable.10000.output+                 tests/c-printable.10ffff.input tests/c-printable.10ffff.output+                 tests/c-printable.cr.input tests/c-printable.cr.output+                 tests/c-printable.d7ff.input tests/c-printable.d7ff.output+                 tests/c-printable.e000.input tests/c-printable.e000.output+                 tests/c-printable.fffd.input tests/c-printable.fffd.output+                 tests/c-printable.invalid.input+                 tests/c-printable.invalid.output tests/c-printable.lf.input+                 tests/c-printable.lf.output tests/c-printable.nbsp.input+                 tests/c-printable.nbsp.output tests/c-printable.nel.input+                 tests/c-printable.nel.output tests/c-printable.sp.input+                 tests/c-printable.sp.output tests/c-printable.tab.input+                 tests/c-printable.tab.output tests/c-printable.tilde.input+                 tests/c-printable.tilde.output tests/c-quoted-quote.input+                 tests/c-quoted-quote.invalid.input+                 tests/c-quoted-quote.invalid.output+                 tests/c-quoted-quote.output tests/c-reserved.at.input+                 tests/c-reserved.at.output tests/c-reserved.backtick.input+                 tests/c-reserved.backtick.output+                 tests/c-secondary-tag-handle.input+                 tests/c-secondary-tag-handle.invalid.input+                 tests/c-secondary-tag-handle.invalid.output+                 tests/c-secondary-tag-handle.output tests/c-sequence-end.input+                 tests/c-sequence-end.output tests/c-sequence-entry.input+                 tests/c-sequence-entry.output tests/c-sequence-start.input+                 tests/c-sequence-start.output+                 tests/c-single-quoted.n=4.c=flow-out.input+                 tests/c-single-quoted.n=4.c=flow-out.invalid.input+                 tests/c-single-quoted.n=4.c=flow-out.invalid.output+                 tests/c-single-quoted.n=4.c=flow-out.output+                 tests/c-single-quote.input tests/c-single-quote.output+                 tests/c-s-simple-json-key.just.input+                 tests/c-s-simple-json-key.just.output+                 tests/c-s-simple-json-key.long.input+                 tests/c-s-simple-json-key.long.output+                 tests/c-s-simple-json-key.short.input+                 tests/c-s-simple-json-key.short.output+                 tests/c-style-indicator.s=folded.input+                 tests/c-style-indicator.s=folded.output+                 tests/c-style-indicator.s=literal.input+                 tests/c-style-indicator.s=literal.invalid.input+                 tests/c-style-indicator.s=literal.invalid.output+                 tests/c-style-indicator.s=literal.output+                 tests/c-tag-handle.invalid.input+                 tests/c-tag-handle.invalid.output+                 tests/c-tag-handle.named.input tests/c-tag-handle.named.output+                 tests/c-tag-handle.primary.input+                 tests/c-tag-handle.primary.output+                 tests/c-tag-handle.secondary.input+                 tests/c-tag-handle.secondary.output tests/c-tag.input+                 tests/c-tag.output tests/c-verbatim-tag.input+                 tests/c-verbatim-tag.invalid.input+                 tests/c-verbatim-tag.invalid.output+                 tests/c-verbatim-tag.output+                 tests/detect-collection-indentation.n=1.input+                 tests/detect-collection-indentation.n=1.output+                 tests/detect-inline-indentation.input+                 tests/detect-inline-indentation.output+                 tests/detect-scalar-indentation.n=2.input+                 tests/detect-scalar-indentation.n=2.output tests/e-node.input+                 tests/e-node.output tests/e-no-document.input+                 tests/e-no-document.output tests/e-scalar.input+                 tests/e-scalar.output+                 tests/l-block-map-explicit-value.n=2.input+                 tests/l-block-map-explicit-value.n=2.invalid.input+                 tests/l-block-map-explicit-value.n=2.invalid.output+                 tests/l-block-map-explicit-value.n=2.output+                 tests/l+block-mapping.n=1.input+                 tests/l+block-mapping.n=1.output+                 tests/l+block-mapping.n=2.invalid.input+                 tests/l+block-mapping.n=2.invalid.output+                 tests/l+block-sequence.n=1.input+                 tests/l+block-sequence.n=1.output+                 tests/l+block-sequence.n=2.invalid.input+                 tests/l+block-sequence.n=2.invalid.output+                 tests/l-chomped-empty.n=4.t=clip.input+                 tests/l-chomped-empty.n=4.t=clip.output+                 tests/l-chomped-empty.n=4.t=keep.input+                 tests/l-chomped-empty.n=4.t=keep.output+                 tests/l-chomped-empty.n=4.t=strip.input+                 tests/l-chomped-empty.n=4.t=strip.output+                 tests/l-comment.empty.input tests/l-comment.empty.output+                 tests/l-comment.invalid.input tests/l-comment.invalid.output+                 tests/l-comment.spaces-comment.input+                 tests/l-comment.spaces-comment.output+                 tests/l-directive.invalid.input+                 tests/l-directive.invalid.output+                 tests/l-directive.reserved.input+                 tests/l-directive.reserved.output tests/l-directive.tag.input+                 tests/l-directive.tag.invalid.input+                 tests/l-directive.tag.invalid.output+                 tests/l-directive.tag.output tests/l-directive.yaml.input+                 tests/l-directive.yaml.invalid.input+                 tests/l-directive.yaml.invalid.output+                 tests/l-directive.yaml.output+                 tests/l-document-prefix.bom-comment.input+                 tests/l-document-prefix.bom-comment.output+                 tests/l-document-prefix.bom.input+                 tests/l-document-prefix.bom.output+                 tests/l-document-prefix.comment.input+                 tests/l-document-prefix.comment.output+                 tests/l-document-prefix.empty.input+                 tests/l-document-prefix.empty.output+                 tests/l-document-prefix.invalid.input+                 tests/l-document-prefix.invalid.output+                 tests/l-documents.explicit.input+                 tests/l-documents.explicit.output+                 tests/l-documents.implicit.input+                 tests/l-documents.implicit.output+                 tests/l-document-suffix.input+                 tests/l-document-suffix.invalid.input+                 tests/l-document-suffix.invalid.output+                 tests/l-document-suffix.output+                 tests/l-empty.n=4.s=literal.indent.input+                 tests/l-empty.n=4.s=literal.indent-lt.input+                 tests/l-empty.n=4.s=literal.indent-lt.output+                 tests/l-empty.n=4.s=literal.indent.output+                 tests/l-empty.n=4.s=literal.indent-sp.invalid.input+                 tests/l-empty.n=4.s=literal.indent-sp.invalid.output+                 tests/l-empty.n=4.s=plain.indent.input+                 tests/l-empty.n=4.s=plain.indent-lt.input+                 tests/l-empty.n=4.s=plain.indent-lt.output+                 tests/l-empty.n=4.s=plain.indent.output+                 tests/l-empty.n=4.s=plain.indent-sp.input+                 tests/l-empty.n=4.s=plain.indent-sp.output+                 tests/l-explicit-document.invalid.input+                 tests/l-explicit-document.invalid.output+                 tests/l-explicit-document.literal.input+                 tests/l-explicit-document.literal.output+                 tests/l-explicit-document.plain.input+                 tests/l-explicit-document.plain.output+                 tests/l-folded-content.n=4.t=strip.input+                 tests/l-folded-content.n=4.t=strip.invalid.input+                 tests/l-folded-content.n=4.t=strip.invalid.output+                 tests/l-folded-content.n=4.t=strip.output+                 tests/l-following-document.empty.input+                 tests/l-following-document.empty.output+                 tests/l-following-document.explicit.input+                 tests/l-following-document.explicit.output+                 tests/l-following-document.invalid.input+                 tests/l-following-document.invalid.output+                 tests/l-forbidden.end-space.input+                 tests/l-forbidden.end-space.output+                 tests/l-forbidden.invalid.input+                 tests/l-forbidden.invalid.output tests/l-forbidden.start.input+                 tests/l-forbidden.start-lf.input+                 tests/l-forbidden.start-lf.output+                 tests/l-forbidden.start.output+                 tests/l-implicit-document.invalid.input+                 tests/l-implicit-document.invalid.output+                 tests/l-implicit-document.literal.input+                 tests/l-implicit-document.literal.output+                 tests/l-implicit-document.plain.input+                 tests/l-implicit-document.plain.output+                 tests/l-keep-empty.n=4.0.input tests/l-keep-empty.n=4.0.output+                 tests/l-keep-empty.n=4.1.input tests/l-keep-empty.n=4.1.output+                 tests/l-leading-document.empty.input+                 tests/l-leading-document.empty.output+                 tests/l-leading-document.explicit.input+                 tests/l-leading-document.explicit.output+                 tests/l-leading-document.implicit.input+                 tests/l-leading-document.implicit.output+                 tests/l-literal-content.n=4.t=strip.input+                 tests/l-literal-content.n=4.t=strip.invalid.input+                 tests/l-literal-content.n=4.t=strip.invalid.output+                 tests/l-literal-content.n=4.t=strip.output+                 tests/l-nb-folded-lines.n=4.input+                 tests/l-nb-folded-lines.n=4.invalid.input+                 tests/l-nb-folded-lines.n=4.invalid.output+                 tests/l-nb-folded-lines.n=4.output+                 tests/l-nb-literal-chars.n=4.input+                 tests/l-nb-literal-chars.n=4.invalid.input+                 tests/l-nb-literal-chars.n=4.invalid.output+                 tests/l-nb-literal-chars.n=4.output+                 tests/l-nb-spaced-lines.n=4.input+                 tests/l-nb-spaced-lines.n=4.invalid.input+                 tests/l-nb-spaced-lines.n=4.invalid.output+                 tests/l-nb-spaced-lines.n=4.output+                 tests/l-nb-start-with-any.n=4.folded.input+                 tests/l-nb-start-with-any.n=4.folded.output+                 tests/l-nb-start-with-any.n=4.invalid.input+                 tests/l-nb-start-with-any.n=4.invalid.output+                 tests/l-nb-start-with-any.n=4.spaced.input+                 tests/l-nb-start-with-any.n=4.spaced.output+                 tests/l-nb-start-with-folded.n=4.input+                 tests/l-nb-start-with-folded.n=4.invalid.input+                 tests/l-nb-start-with-folded.n=4.invalid.output+                 tests/l-nb-start-with-folded.n=4.output+                 tests/l-nb-start-with-spaced.n=4.input+                 tests/l-nb-start-with-spaced.n=4.invalid.input+                 tests/l-nb-start-with-spaced.n=4.invalid.output+                 tests/l-nb-start-with-spaced.n=4.output+                 tests/l-strip-empty.n=4.0.input+                 tests/l-strip-empty.n=4.0.output+                 tests/l-strip-empty.n=4.1.input+                 tests/l-strip-empty.n=4.1.output+                 tests/l-trail-comments.n=4.1.input+                 tests/l-trail-comments.n=4.1.output+                 tests/l-trail-comments.n=4.2.input+                 tests/l-trail-comments.n=4.2.output+                 tests/l-trail-comments.n=4.3.input+                 tests/l-trail-comments.n=4.3.output+                 tests/l-trail-comments.n=4.invalid.input+                 tests/l-trail-comments.n=4.invalid.output+                 tests/l-yaml-stream.empty.input+                 tests/l-yaml-stream.empty.output+                 tests/l-yaml-stream.explicit.input+                 tests/l-yaml-stream.explicit.output+                 tests/l-yaml-stream.implicit.input+                 tests/l-yaml-stream.implicit.output tests/nb-char.input+                 tests/nb-char.invalid.input tests/nb-char.invalid.output+                 tests/nb-char.output tests/nb-double-char.a.input+                 tests/nb-double-char.a.output+                 tests/nb-double-char.backslash.invalid.input+                 tests/nb-double-char.backslash.invalid.output+                 tests/nb-double-char.double-quote.invalid.input+                 tests/nb-double-char.double-quote.invalid.output+                 tests/nb-double-char.escaped.input+                 tests/nb-double-char.escaped.output+                 tests/nb-double-text.n=4.c=flow-key.input+                 tests/nb-double-text.n=4.c=flow-key.invalid.input+                 tests/nb-double-text.n=4.c=flow-key.invalid.output+                 tests/nb-double-text.n=4.c=flow-key.output+                 tests/nb-double-text.n=4.c=flow-out.input+                 tests/nb-double-text.n=4.c=flow-out.output+                 tests/nb-plain-char.c=flow-in.invalid.input+                 tests/nb-plain-char.c=flow-in.invalid.output+                 tests/nb-plain-char.c=flow-in.space.input+                 tests/nb-plain-char.c=flow-in.space.output+                 tests/nb-plain-char.c=flow-out.a.input+                 tests/nb-plain-char.c=flow-out.a.output+                 tests/nb-plain-char.c=flow-out.comma.input+                 tests/nb-plain-char.c=flow-out.comma.output+                 tests/nb-single-char.escaped.input+                 tests/nb-single-char.escaped.output+                 tests/nb-single-char.invalid.input+                 tests/nb-single-char.invalid.output+                 tests/nb-single-text.n=4.c=flow-key.input+                 tests/nb-single-text.n=4.c=flow-key.output+                 tests/nb-single-text.n=4.c=flow-out.input+                 tests/nb-single-text.n=4.c=flow-out.invalid.input+                 tests/nb-single-text.n=4.c=flow-out.invalid.output+                 tests/nb-single-text.n=4.c=flow-out.output+                 tests/ns-anchor-char.input tests/ns-anchor-char.invalid.input+                 tests/ns-anchor-char.invalid.output+                 tests/ns-anchor-char.output tests/ns-anchor-name.input+                 tests/ns-anchor-name.invalid.input+                 tests/ns-anchor-name.invalid.output+                 tests/ns-anchor-name.output tests/ns-ascii-letter.a.input+                 tests/ns-ascii-letter.a.output+                 tests/ns-ascii-letter.invalid.input+                 tests/ns-ascii-letter.invalid.output+                 tests/ns-ascii-letter.Z.input tests/ns-ascii-letter.Z.output+                 tests/ns-char.input tests/ns-char.invalid.input+                 tests/ns-char.invalid.output tests/ns-char.output+                 tests/ns-dec-digit.0.input tests/ns-dec-digit.0.output+                 tests/ns-dec-digit.1.input tests/ns-dec-digit.1.output+                 tests/ns-dec-digit.2.input tests/ns-dec-digit.2.output+                 tests/ns-dec-digit.3.input tests/ns-dec-digit.3.output+                 tests/ns-dec-digit.4.input tests/ns-dec-digit.4.output+                 tests/ns-dec-digit.5.input tests/ns-dec-digit.5.output+                 tests/ns-dec-digit.6.input tests/ns-dec-digit.6.output+                 tests/ns-dec-digit.7.input tests/ns-dec-digit.7.output+                 tests/ns-dec-digit.8.input tests/ns-dec-digit.8.output+                 tests/ns-dec-digit.9.input tests/ns-dec-digit.9.output+                 tests/ns-dec-digit.invalid.input+                 tests/ns-dec-digit.invalid.output+                 tests/ns-directive-name.input+                 tests/ns-directive-name.invalid.input+                 tests/ns-directive-name.invalid.output+                 tests/ns-directive-name.output+                 tests/ns-directive-parameter.input+                 tests/ns-directive-parameter.invalid.input+                 tests/ns-directive-parameter.invalid.output+                 tests/ns-directive-parameter.output tests/ns-double-char.input+                 tests/ns-double-char.invalid.input+                 tests/ns-double-char.invalid.output+                 tests/ns-double-char.output tests/ns-esc-16-bit.input+                 tests/ns-esc-16-bit.output tests/ns-esc-32-bit.input+                 tests/ns-esc-32-bit.output tests/ns-esc-8-bit.input+                 tests/ns-esc-8-bit.output tests/ns-esc-backslash.input+                 tests/ns-esc-backslash.output tests/ns-esc-backspace.input+                 tests/ns-esc-backspace.output tests/ns-esc-bell.input+                 tests/ns-esc-bell.output tests/ns-esc-carriage-return.input+                 tests/ns-esc-carriage-return.output+                 tests/ns-esc-char.16-bit.input tests/ns-esc-char.16-bit.output+                 tests/ns-esc-char.32-bit.input tests/ns-esc-char.32-bit.output+                 tests/ns-esc-char.8-bit.input tests/ns-esc-char.8-bit.output+                 tests/ns-esc-char.backslash.input+                 tests/ns-esc-char.backslash.output+                 tests/ns-esc-char.bell.input tests/ns-esc-char.bell.output+                 tests/ns-esc-char.bs.input tests/ns-esc-char.bs.output+                 tests/ns-esc-char.cr.input tests/ns-esc-char.cr.output+                 tests/ns-esc-char.double-quote.input+                 tests/ns-esc-char.double-quote.output+                 tests/ns-esc-char.esc.input tests/ns-esc-char.esc.output+                 tests/ns-esc-char.ff.input tests/ns-esc-char.ff.output+                 tests/ns-esc-char.lf.input tests/ns-esc-char.lf.output+                 tests/ns-esc-char.ls.input tests/ns-esc-char.ls.output+                 tests/ns-esc-char.nbsp.input tests/ns-esc-char.nbsp.output+                 tests/ns-esc-char.nl.input tests/ns-esc-char.nl.output+                 tests/ns-esc-char.null.input tests/ns-esc-char.null.output+                 tests/ns-esc-char.ps.input tests/ns-esc-char.ps.output+                 tests/ns-esc-char.sp.input tests/ns-esc-char.sp.output+                 tests/ns-esc-char.tab.input tests/ns-esc-char.tab.output+                 tests/ns-esc-char.vt.input tests/ns-esc-char.vt.output+                 tests/ns-esc-double-quote.input+                 tests/ns-esc-double-quote.output tests/ns-esc-escape.input+                 tests/ns-esc-escape.output tests/ns-esc-form-feed.input+                 tests/ns-esc-form-feed.output+                 tests/ns-esc-horizontal-tab.tab.input+                 tests/ns-esc-horizontal-tab.tab.output+                 tests/ns-esc-horizontal-tab.t.input+                 tests/ns-esc-horizontal-tab.t.output+                 tests/ns-esc-line-feed.input tests/ns-esc-line-feed.output+                 tests/ns-esc-line-separator.input+                 tests/ns-esc-line-separator.output+                 tests/ns-esc-next-line.input tests/ns-esc-next-line.output+                 tests/ns-esc-non-breaking-space.input+                 tests/ns-esc-non-breaking-space.output tests/ns-esc-null.input+                 tests/ns-esc-null.output+                 tests/ns-esc-paragraph-separator.input+                 tests/ns-esc-paragraph-separator.output+                 tests/ns-esc-space.input tests/ns-esc-space.output+                 tests/ns-esc-vertical-tab.input+                 tests/ns-esc-vertical-tab.output+                 tests/ns-flow-content.n=4.c=flow-in.invalid.input+                 tests/ns-flow-content.n=4.c=flow-in.invalid.output+                 tests/ns-flow-content.n=4.c=flow-in.json.input+                 tests/ns-flow-content.n=4.c=flow-in.json.output+                 tests/ns-flow-content.n=4.c=flow-in.yaml.input+                 tests/ns-flow-content.n=4.c=flow-in.yaml.output+                 tests/ns-flow-map-entry.n=4.c=flow-in.explicit.input+                 tests/ns-flow-map-entry.n=4.c=flow-in.explicit.output+                 tests/ns-flow-map-entry.n=4.c=flow-in.implicit.input+                 tests/ns-flow-map-entry.n=4.c=flow-in.implicit.output+                 tests/ns-flow-map-entry.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-entry.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-implicit-empty.n=4.c=flow-in.input+                 tests/ns-flow-map-implicit-empty.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-implicit-empty.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-implicit-empty.n=4.c=flow-in.output+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.empty.input+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.empty.output+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.json.input+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.json.output+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.yaml.input+                 tests/ns-flow-map-implicit-entry.n=4.c=flow-in.yaml.output+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.compact.input+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.compact.output+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.empty.input+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.empty.output+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.spaced.input+                 tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.spaced.output+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.empty.input+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.empty.output+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.json.input+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.json.output+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.yaml.input+                 tests/ns-flow-map-single-entry.n=4.c=flow-in.yaml.output+                 tests/ns-flow-map-single-pair.n=4.c=flow-in.explicit.input+                 tests/ns-flow-map-single-pair.n=4.c=flow-in.explicit.output+                 tests/ns-flow-map-single-pair.n=4.c=flow-in.implicit.input+                 tests/ns-flow-map-single-pair.n=4.c=flow-in.implicit.output+                 tests/ns-flow-map-single-pair.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-single-pair.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-single-yaml.n=4.c=flow-in.input+                 tests/ns-flow-map-single-yaml.n=4.c=flow-in.invalid.input+                 tests/ns-flow-map-single-yaml.n=4.c=flow-in.invalid.output+                 tests/ns-flow-map-single-yaml.n=4.c=flow-in.output+                 tests/ns-flow-node.n=4.c=flow-in.alias.input+                 tests/ns-flow-node.n=4.c=flow-in.alias.output+                 tests/ns-flow-node.n=4.c=flow-in.invalid.input+                 tests/ns-flow-node.n=4.c=flow-in.invalid.output+                 tests/ns-flow-node.n=4.c=flow-in.tagged.input+                 tests/ns-flow-node.n=4.c=flow-in.tagged.output+                 tests/ns-flow-node.n=4.c=flow-in.tag.input+                 tests/ns-flow-node.n=4.c=flow-in.tag.output+                 tests/ns-flow-node.n=4.c=flow-in.untagged.input+                 tests/ns-flow-node.n=4.c=flow-in.untagged.output+                 tests/ns-flow-seq-entry.n=4.c=flow-in.invalid.input+                 tests/ns-flow-seq-entry.n=4.c=flow-in.invalid.output+                 tests/ns-flow-seq-entry.n=4.c=flow-in.node.input+                 tests/ns-flow-seq-entry.n=4.c=flow-in.node.output+                 tests/ns-flow-seq-entry.n=4.c=flow-in.pair.input+                 tests/ns-flow-seq-entry.n=4.c=flow-in.pair.output+                 tests/ns-flow-yaml-content.n=4.c=flow-in.input+                 tests/ns-flow-yaml-content.n=4.c=flow-in.invalid.input+                 tests/ns-flow-yaml-content.n=4.c=flow-in.invalid.output+                 tests/ns-flow-yaml-content.n=4.c=flow-in.output+                 tests/ns-flow-yaml-node.n=4.c=flow-in.alias.input+                 tests/ns-flow-yaml-node.n=4.c=flow-in.alias.output+                 tests/ns-flow-yaml-node.n=4.c=flow-in.invalid.input+                 tests/ns-flow-yaml-node.n=4.c=flow-in.invalid.output+                 tests/ns-flow-yaml-node.n=4.c=flow-in.tagged.input+                 tests/ns-flow-yaml-node.n=4.c=flow-in.tagged.output+                 tests/ns-flow-yaml-node.n=4.c=flow-in.tag.input+                 tests/ns-flow-yaml-node.n=4.c=flow-in.tag.output+                 tests/ns-flow-yaml-node.n=4.c=flow-in.untagged.input+                 tests/ns-flow-yaml-node.n=4.c=flow-in.untagged.output+                 tests/ns-global-tag-prefix.input+                 tests/ns-global-tag-prefix.invalid.input+                 tests/ns-global-tag-prefix.invalid.output+                 tests/ns-global-tag-prefix.output tests/ns-hex-digit.6.input+                 tests/ns-hex-digit.6.output tests/ns-hex-digit.a.input+                 tests/ns-hex-digit.a.output tests/ns-hex-digit.B.input+                 tests/ns-hex-digit.B.output tests/ns-hex-digit.c.input+                 tests/ns-hex-digit.c.output tests/ns-hex-digit.D.input+                 tests/ns-hex-digit.D.output tests/ns-hex-digit.e.input+                 tests/ns-hex-digit.e.output tests/ns-hex-digit.F.input+                 tests/ns-hex-digit.F.output tests/ns-hex-digit.invalid.input+                 tests/ns-hex-digit.invalid.output+                 tests/ns-l-block-map-entry.n=2.explicit.input+                 tests/ns-l-block-map-entry.n=2.explicit.output+                 tests/ns-l-block-map-entry.n=2.implicit.input+                 tests/ns-l-block-map-entry.n=2.implicit.output+                 tests/ns-l-block-map-entry.n=2.invalid.input+                 tests/ns-l-block-map-entry.n=2.invalid.output+                 tests/ns-l-block-map-implicit-entry.n=2.empty.input+                 tests/ns-l-block-map-implicit-entry.n=2.empty.output+                 tests/ns-l-block-map-implicit-entry.n=2.invalid.input+                 tests/ns-l-block-map-implicit-entry.n=2.invalid.output+                 tests/ns-l-block-map-implicit-entry.n=2.non-empty.input+                 tests/ns-l-block-map-implicit-entry.n=2.non-empty.output+                 tests/ns-l-in-line-mapping.n=2.input+                 tests/ns-l-in-line-mapping.n=2.invalid.input+                 tests/ns-l-in-line-mapping.n=2.invalid.output+                 tests/ns-l-in-line-mapping.n=2.output+                 tests/ns-l-in-line-sequence.n=3.input+                 tests/ns-l-in-line-sequence.n=3.invalid.input+                 tests/ns-l-in-line-sequence.n=3.invalid.output+                 tests/ns-l-in-line-sequence.n=3.output+                 tests/ns-plain-char.c=flow-in.acc.input+                 tests/ns-plain-char.c=flow-in.acc.output+                 tests/ns-plain-char.c=flow-in.ac.input+                 tests/ns-plain-char.c=flow-in.ac.output+                 tests/ns-plain-char.c=flow-in.a.input+                 tests/ns-plain-char.c=flow-in.a.output+                 tests/ns-plain-char.c=flow-in.c.input+                 tests/ns-plain-char.c=flow-in.c.output+                 tests/ns-plain-char.c=flow-in.ma.input+                 tests/ns-plain-char.c=flow-in.ma.output+                 tests/ns-plain-char.c=flow-in.mc.input+                 tests/ns-plain-char.c=flow-in.mc.output+                 tests/ns-plain-char.c=flow-in.m.input+                 tests/ns-plain-char.c=flow-in.mmcc.input+                 tests/ns-plain-char.c=flow-in.mmcc.output+                 tests/ns-plain-char.c=flow-in.mms.input+                 tests/ns-plain-char.c=flow-in.mms.output+                 tests/ns-plain-char.c=flow-in.m.output+                 tests/ns-plain-char.c=flow-in.s.input+                 tests/ns-plain-char.c=flow-in.s.output+                 tests/ns-plain-first.c=flow-in.a.input+                 tests/ns-plain-first.c=flow-in.a.output+                 tests/ns-plain-first.c=flow-in.c.input+                 tests/ns-plain-first.c=flow-in.c.output+                 tests/ns-plain-first.c=flow-in.da.input+                 tests/ns-plain-first.c=flow-in.da.output+                 tests/ns-plain-first.c=flow-in.dc.input+                 tests/ns-plain-first.c=flow-in.dc.output+                 tests/ns-plain-first.c=flow-in.d.input+                 tests/ns-plain-first.c=flow-in.d.output+                 tests/ns-plain-first.c=flow-in.ds.input+                 tests/ns-plain-first.c=flow-in.ds.output+                 tests/ns-plain-first.c=flow-in.ia.input+                 tests/ns-plain-first.c=flow-in.ia.output+                 tests/ns-plain-first.c=flow-in.i.input+                 tests/ns-plain-first.c=flow-in.i.output+                 tests/ns-plain-first.c=flow-in.ka.input+                 tests/ns-plain-first.c=flow-in.ka.output+                 tests/ns-plain-first.c=flow-in.kc.input+                 tests/ns-plain-first.c=flow-in.kc.output+                 tests/ns-plain-first.c=flow-in.k.input+                 tests/ns-plain-first.c=flow-in.k.output+                 tests/ns-plain-first.c=flow-in.ks.input+                 tests/ns-plain-first.c=flow-in.ks.output+                 tests/ns-plain-first.c=flow-in.m.input+                 tests/ns-plain-first.c=flow-in.m.output+                 tests/ns-plain-first.c=flow-in.s.input+                 tests/ns-plain-first.c=flow-in.s.output+                 tests/ns-plain-first.c=flow-in.va.input+                 tests/ns-plain-first.c=flow-in.va.output+                 tests/ns-plain-first.c=flow-in.vc.input+                 tests/ns-plain-first.c=flow-in.vc.output+                 tests/ns-plain-first.c=flow-in.v.input+                 tests/ns-plain-first.c=flow-in.v.output+                 tests/ns-plain-first.c=flow-in.vs.input+                 tests/ns-plain-first.c=flow-in.vs.output+                 tests/ns-plain-first.c=flow-out.m.input+                 tests/ns-plain-first.c=flow-out.m.output+                 tests/ns-plain-multi.n=4.c=flow-in.input+                 tests/ns-plain-multi.n=4.c=flow-in.invalid.input+                 tests/ns-plain-multi.n=4.c=flow-in.invalid.output+                 tests/ns-plain-multi.n=4.c=flow-in.output+                 tests/ns-plain.n=4.c=flow-in.input+                 tests/ns-plain.n=4.c=flow-in.output+                 tests/ns-plain.n=4.c=flow-key.input+                 tests/ns-plain.n=4.c=flow-key.invalid.input+                 tests/ns-plain.n=4.c=flow-key.invalid.output+                 tests/ns-plain.n=4.c=flow-key.output+                 tests/ns-plain-safe.c=flow-in.mapping-start.input+                 tests/ns-plain-safe.c=flow-in.mapping-start.output+                 tests/ns-plain-safe.c=flow-in.v.input+                 tests/ns-plain-safe.c=flow-in.v.output+                 tests/ns-plain-safe.c=flow-out.a.input+                 tests/ns-plain-safe.c=flow-out.a.output+                 tests/ns-plain-safe.c=flow-out.c.input+                 tests/ns-plain-safe.c=flow-out.c.output+                 tests/ns-plain-safe.c=flow-out.mapping-start.input+                 tests/ns-plain-safe.c=flow-out.mapping-start.output+                 tests/ns-plain-safe-in.a.input tests/ns-plain-safe-in.a.output+                 tests/ns-plain-safe-in.c.input tests/ns-plain-safe-in.c.output+                 tests/ns-plain-safe-in.mapping-start.input+                 tests/ns-plain-safe-in.mapping-start.output+                 tests/ns-plain-safe-in.v.input tests/ns-plain-safe-in.v.output+                 tests/ns-plain-safe-out.a.input+                 tests/ns-plain-safe-out.a.output+                 tests/ns-plain-safe-out.c.input+                 tests/ns-plain-safe-out.c.output+                 tests/ns-plain-safe-out.mapping-start.input+                 tests/ns-plain-safe-out.mapping-start.output+                 tests/ns-plain-safe-out.v.input+                 tests/ns-plain-safe-out.v.output+                 tests/ns-plain-single.c=flow-key.invalid.input+                 tests/ns-plain-single.c=flow-key.invalid.output+                 tests/ns-plain-single.c=flow-out.input+                 tests/ns-plain-single.c=flow-out.output+                 tests/ns-reserved-directive.input+                 tests/ns-reserved-directive.invalid.input+                 tests/ns-reserved-directive.invalid.output+                 tests/ns-reserved-directive.output+                 tests/ns-s-block-map-implicit-key.invalid.input+                 tests/ns-s-block-map-implicit-key.invalid.output+                 tests/ns-s-block-map-implicit-key.json.input+                 tests/ns-s-block-map-implicit-key.json.output+                 tests/ns-s-block-map-implicit-key.yaml.input+                 tests/ns-s-block-map-implicit-key.yaml.output+                 tests/ns-s-flow-map-entries.n=4.c=flow-in.invalid.input+                 tests/ns-s-flow-map-entries.n=4.c=flow-in.invalid.output+                 tests/ns-s-flow-map-entries.n=4.c=flow-in.multi.input+                 tests/ns-s-flow-map-entries.n=4.c=flow-in.multi.output+                 tests/ns-s-flow-map-entries.n=4.c=flow-in.single.input+                 tests/ns-s-flow-map-entries.n=4.c=flow-in.single.output+                 tests/ns-s-flow-seq-entries.n=4.c=flow-in.invalid.input+                 tests/ns-s-flow-seq-entries.n=4.c=flow-in.invalid.output+                 tests/ns-s-flow-seq-entries.n=4.c=flow-in.multi.input+                 tests/ns-s-flow-seq-entries.n=4.c=flow-in.multi.output+                 tests/ns-s-flow-seq-entries.n=4.c=flow-in.single.input+                 tests/ns-s-flow-seq-entries.n=4.c=flow-in.single.output+                 tests/ns-single-char.input tests/ns-single-char.invalid.input+                 tests/ns-single-char.invalid.output+                 tests/ns-single-char.output+                 tests/ns-s-simple-yaml-key.just.input+                 tests/ns-s-simple-yaml-key.just.output+                 tests/ns-s-simple-yaml-key.long.input+                 tests/ns-s-simple-yaml-key.long.output+                 tests/ns-s-simple-yaml-key.short.input+                 tests/ns-s-simple-yaml-key.short.output+                 tests/ns-tag-char.input tests/ns-tag-char.invalid.input+                 tests/ns-tag-char.invalid.output tests/ns-tag-char.output+                 tests/ns-tag-directive.input+                 tests/ns-tag-directive.invalid.input+                 tests/ns-tag-directive.invalid.output+                 tests/ns-tag-directive.output tests/ns-tag-prefix.global.input+                 tests/ns-tag-prefix.global.output+                 tests/ns-tag-prefix.invalid.input+                 tests/ns-tag-prefix.invalid.output+                 tests/ns-tag-prefix.local.input+                 tests/ns-tag-prefix.local.output tests/ns-uri-char.6.input+                 tests/ns-uri-char.6.output tests/ns-uri-char.ampersand.input+                 tests/ns-uri-char.ampersand.output+                 tests/ns-uri-char.asterisk.input+                 tests/ns-uri-char.asterisk.output tests/ns-uri-char.at.input+                 tests/ns-uri-char.at.output tests/ns-uri-char.colon.input+                 tests/ns-uri-char.colon.output tests/ns-uri-char.comma.input+                 tests/ns-uri-char.comma.output tests/ns-uri-char.dollar.input+                 tests/ns-uri-char.dollar.output tests/ns-uri-char.equal.input+                 tests/ns-uri-char.equal.output tests/ns-uri-char.escaped.input+                 tests/ns-uri-char.escaped.output+                 tests/ns-uri-char.exclamation.input+                 tests/ns-uri-char.exclamation.output+                 tests/ns-uri-char.hyphen.input tests/ns-uri-char.hyphen.output+                 tests/ns-uri-char.invalid.input+                 tests/ns-uri-char.invalid.output+                 tests/ns-uri-char.left-round.input+                 tests/ns-uri-char.left-round.output+                 tests/ns-uri-char.left-square.input+                 tests/ns-uri-char.left-square.output tests/ns-uri-char.n.input+                 tests/ns-uri-char.n.output tests/ns-uri-char.period.input+                 tests/ns-uri-char.period.output tests/ns-uri-char.plus.input+                 tests/ns-uri-char.plus.output tests/ns-uri-char.question.input+                 tests/ns-uri-char.question.output+                 tests/ns-uri-char.right-round.input+                 tests/ns-uri-char.right-round.output+                 tests/ns-uri-char.right-square.input+                 tests/ns-uri-char.right-square.output+                 tests/ns-uri-char.semicolon.input+                 tests/ns-uri-char.semicolon.output+                 tests/ns-uri-char.single-quote.input+                 tests/ns-uri-char.single-quote.output+                 tests/ns-uri-char.slash.input tests/ns-uri-char.slash.output+                 tests/ns-uri-char.tilde.input tests/ns-uri-char.tilde.output+                 tests/ns-uri-char.underscore.input+                 tests/ns-uri-char.underscore.output tests/ns-word-char.0.input+                 tests/ns-word-char.0.output tests/ns-word-char.hyphen.input+                 tests/ns-word-char.hyphen.output+                 tests/ns-word-char.invalid.input+                 tests/ns-word-char.invalid.output tests/ns-word-char.n.input+                 tests/ns-word-char.n.output tests/ns-yaml-directive.input+                 tests/ns-yaml-directive.invalid.input+                 tests/ns-yaml-directive.invalid.output+                 tests/ns-yaml-directive.output tests/ns-yaml-version.input+                 tests/ns-yaml-version.invalid.input+                 tests/ns-yaml-version.invalid.output+                 tests/ns-yaml-version.output tests/s-b-comment.empty.input+                 tests/s-b-comment.empty.output tests/s-b-comment.invalid.input+                 tests/s-b-comment.invalid.output+                 tests/s-b-comment.sol-text.input+                 tests/s-b-comment.sol-text.output+                 tests/s-b-comment.spaces.input tests/s-b-comment.spaces.output+                 tests/s-b-comment.spaces-text.input+                 tests/s-b-comment.spaces-text.output+                 tests/s-b-double-escaped.input+                 tests/s-b-double-escaped.invalid.input+                 tests/s-b-double-escaped.invalid.output+                 tests/s-b-double-escaped.output tests/s-double-multi.n=4.input+                 tests/s-double-multi.n=4.invalid.input+                 tests/s-double-multi.n=4.invalid.output+                 tests/s-double-multi.n=4.output+                 tests/s-ignored-prefix-block.n=4.input+                 tests/s-ignored-prefix-block.n=4.invalid.input+                 tests/s-ignored-prefix-block.n=4.invalid.output+                 tests/s-ignored-prefix-block.n=4.output+                 tests/s-ignored-prefix-flow.n=4.indent.input+                 tests/s-ignored-prefix-flow.n=4.indent.output+                 tests/s-ignored-prefix-flow.n=4.invalid.input+                 tests/s-ignored-prefix-flow.n=4.invalid.output+                 tests/s-ignored-prefix-flow.n=4.tab.input+                 tests/s-ignored-prefix-flow.n=4.tab.output+                 tests/s-ignored-prefix.n=4.s=double.input+                 tests/s-ignored-prefix.n=4.s=double.output+                 tests/s-ignored-prefix.n=4.s=folded.invalid.input+                 tests/s-ignored-prefix.n=4.s=folded.invalid.output+                 tests/s-ignored-prefix.n=4.s=literal.input+                 tests/s-ignored-prefix.n=4.s=literal.output+                 tests/s-ignored-prefix.n=4.s=plain.input+                 tests/s-ignored-prefix.n=4.s=plain.output+                 tests/s-ignored-prefix.n=4.s=single.input+                 tests/s-ignored-prefix.n=4.s=single.output+                 tests/s-indent-le.n=0.input tests/s-indent-le.n=0.output+                 tests/s-indent-le.n=-1.invalid.input+                 tests/s-indent-le.n=-1.invalid.output+                 tests/s-indent-le.n=4.input+                 tests/s-indent-le.n=4.invalid.input+                 tests/s-indent-le.n=4.invalid.output+                 tests/s-indent-le.n=4.output+                 tests/s-indent-lt.n=0.invalid.input+                 tests/s-indent-lt.n=0.invalid.output+                 tests/s-indent-lt.n=-1.invalid.input+                 tests/s-indent-lt.n=-1.invalid.output+                 tests/s-indent-lt.n=4.input+                 tests/s-indent-lt.n=4.invalid.input+                 tests/s-indent-lt.n=4.invalid.output+                 tests/s-indent-lt.n=4.output tests/s-indent.n=0.input+                 tests/s-indent.n=0.output tests/s-indent.n=-1.input+                 tests/s-indent.n=-1.output tests/s-indent.n=4.input+                 tests/s-indent.n=4.invalid.input+                 tests/s-indent.n=4.invalid.output tests/s-indent.n=4.output+                 tests/s-l+block-content.n=2.c=block-in.sequence.input+                 tests/s-l+block-content.n=2.c=block-in.sequence.output+                 tests/s-l+block-content.n=2.c=block-out.folded.input+                 tests/s-l+block-content.n=2.c=block-out.folded.output+                 tests/s-l+block-content.n=2.c=block-out.invalid.input+                 tests/s-l+block-content.n=2.c=block-out.invalid.output+                 tests/s-l+block-content.n=2.c=block-out.literal.input+                 tests/s-l+block-content.n=2.c=block-out.literal.output+                 tests/s-l+block-content.n=2.c=block-out.mapping.input+                 tests/s-l+block-content.n=2.c=block-out.mapping.output+                 tests/s-l+block-in-block.n=2.c=block-out.invalid.input+                 tests/s-l+block-in-block.n=2.c=block-out.invalid.output+                 tests/s-l+block-in-block.n=2.c=block-out.tagged.input+                 tests/s-l+block-in-block.n=2.c=block-out.tagged.output+                 tests/s-l+block-in-block.n=2.c=block-out.untagged.input+                 tests/s-l+block-in-block.n=2.c=block-out.untagged.output+                 tests/s-l+block-indented.n=2.c=block-in.invalid.input+                 tests/s-l+block-indented.n=2.c=block-in.invalid.output+                 tests/s-l+block-indented.n=2.c=block-in.sequence.input+                 tests/s-l+block-indented.n=2.c=block-in.sequence.output+                 tests/s-l+block-indented.n=2.c=block-out.in-line-map.input+                 tests/s-l+block-indented.n=2.c=block-out.in-line-map.output+                 tests/s-l+block-indented.n=2.c=block-out.in-line-seq.input+                 tests/s-l+block-indented.n=2.c=block-out.in-line-seq.output+                 tests/s-l+block-indented.n=2.c=block-out.literal.input+                 tests/s-l+block-indented.n=2.c=block-out.literal.output+                 tests/s-l+block-indented.n=2.c=block-out.sequence.input+                 tests/s-l+block-indented.n=2.c=block-out.sequence.output+                 tests/s-l+block-node.n=2.c=block-out.block.input+                 tests/s-l+block-node.n=2.c=block-out.block.output+                 tests/s-l+block-node.n=2.c=block-out.flow.input+                 tests/s-l+block-node.n=2.c=block-out.flow.output+                 tests/s-l+block-node.n=2.c=block-out.invalid.input+                 tests/s-l+block-node.n=2.c=block-out.invalid.output+                 tests/s-l-comments.invalid.input+                 tests/s-l-comments.invalid.output+                 tests/s-l-comments.multi.input tests/s-l-comments.multi.output+                 tests/s-l-comments.sol.input tests/s-l-comments.sol.output+                 tests/s-l-double-any.n=4.escaped.input+                 tests/s-l-double-any.n=4.escaped.output+                 tests/s-l-double-any.n=4.folded.input+                 tests/s-l-double-any.n=4.folded.output+                 tests/s-l-double-any.n=4.invalid.input+                 tests/s-l-double-any.n=4.invalid.output+                 tests/s-l-flow-folded.n=4.invalid.input+                 tests/s-l-flow-folded.n=4.invalid.output+                 tests/s-l-flow-folded.n=4.lf.input+                 tests/s-l-flow-folded.n=4.lf.output+                 tests/s-l-flow-folded.n=4.sp-lf-lf.input+                 tests/s-l-flow-folded.n=4.sp-lf-lf.output+                 tests/s-l+flow-in-block.n=2.input+                 tests/s-l+flow-in-block.n=2.invalid.input+                 tests/s-l+flow-in-block.n=2.invalid.output+                 tests/s-l+flow-in-block.n=2.output+                 tests/s-nb-folded-text.n=4.input+                 tests/s-nb-folded-text.n=4.invalid.input+                 tests/s-nb-folded-text.n=4.invalid.output+                 tests/s-nb-folded-text.n=4.output+                 tests/s-nb-spaced-text.n=4.input+                 tests/s-nb-spaced-text.n=4.invalid.input+                 tests/s-nb-spaced-text.n=4.invalid.output+                 tests/s-nb-spaced-text.n=4.output+                 tests/s-ns-double-chars.input+                 tests/s-ns-double-chars.invalid.input+                 tests/s-ns-double-chars.invalid.output+                 tests/s-ns-double-chars.output+                 tests/s-ns-double-next.n=4.input+                 tests/s-ns-double-next.n=4.invalid.input+                 tests/s-ns-double-next.n=4.invalid.output+                 tests/s-ns-double-next.n=4.output+                 tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.input+                 tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.invalid.input+                 tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.invalid.output+                 tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.output+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.empty.input+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.empty.output+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.json.input+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.json.output+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.value.input+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.value.output+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.yaml.input+                 tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.yaml.output+                 tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.input+                 tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.invalid.input+                 tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.invalid.output+                 tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.output+                 tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.input+                 tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.invalid.input+                 tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.invalid.output+                 tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.output+                 tests/s-ns-plain-chars.c=flow-in.input+                 tests/s-ns-plain-chars.c=flow-in.invalid.input+                 tests/s-ns-plain-chars.c=flow-in.invalid.output+                 tests/s-ns-plain-chars.c=flow-in.output+                 tests/s-ns-plain-next.n=4.c=flow-in.input+                 tests/s-ns-plain-next.n=4.c=flow-in.invalid.input+                 tests/s-ns-plain-next.n=4.c=flow-in.invalid.output+                 tests/s-ns-plain-next.n=4.c=flow-in.output+                 tests/s-ns-single-chars.input+                 tests/s-ns-single-chars.invalid.input+                 tests/s-ns-single-chars.invalid.output+                 tests/s-ns-single-chars.output+                 tests/s-ns-single-next.n=4.input+                 tests/s-ns-single-next.n=4.invalid.input+                 tests/s-ns-single-next.n=4.invalid.output+                 tests/s-ns-single-next.n=4.output+                 tests/s-separate-in-flow.n=4.c=flow-key.empty.input+                 tests/s-separate-in-flow.n=4.c=flow-key.empty.output+                 tests/s-separate-in-flow.n=4.c=flow-key.invalid.input+                 tests/s-separate-in-flow.n=4.c=flow-key.invalid.output+                 tests/s-separate-in-flow.n=4.c=flow-key.sp.input+                 tests/s-separate-in-flow.n=4.c=flow-key.sp.output+                 tests/s-separate-in-flow.n=4.c=flow-out.empty.input+                 tests/s-separate-in-flow.n=4.c=flow-out.empty.output+                 tests/s-separate-in-flow.n=4.c=flow-out.line.input+                 tests/s-separate-in-flow.n=4.c=flow-out.line.output+                 tests/s-separate-in-flow.n=4.c=flow-out.sp.input+                 tests/s-separate-in-flow.n=4.c=flow-out.sp.output+                 tests/s-separate-in-line.invalid.input+                 tests/s-separate-in-line.invalid.output+                 tests/s-separate-in-line.sol.input+                 tests/s-separate-in-line.sol.output+                 tests/s-separate-in-line.sp.input+                 tests/s-separate-in-line.sp.output+                 tests/s-separate-lines.n=4.invalid.input+                 tests/s-separate-lines.n=4.invalid.output+                 tests/s-separate-lines.n=4.lines.input+                 tests/s-separate-lines.n=4.lines.output+                 tests/s-separate-lines.n=4.sol.input+                 tests/s-separate-lines.n=4.sol.output+                 tests/s-separate-lines.n=4.sp.input+                 tests/s-separate-lines.n=4.sp.output+                 tests/s-single-multi.n=4.input+                 tests/s-single-multi.n=4.invalid.input+                 tests/s-single-multi.n=4.invalid.output+                 tests/s-single-multi.n=4.output tests/s-space.input+                 tests/s-space.invalid.input tests/s-space.invalid.output+                 tests/s-space.output tests/s-tab.input+                 tests/s-tab.invalid.input tests/s-tab.invalid.output+                 tests/s-tab.output tests/s-white.invalid.input+                 tests/s-white.invalid.output tests/s-white.sp.input+                 tests/s-white.sp.output tests/s-white.tab.input+                 tests/s-white.tab.output++Executable:      yaml2yeast+Main-Is:         yaml2yeast/Main.hs+Extensions:      CPP, MultiParamTypeClasses++Executable:      yaml2yeast-test+Main-Is:         yaml2yeast-test/Main.hs+Extensions:      CPP, MultiParamTypeClasses
+ lgpl.txt view
@@ -0,0 +1,345 @@++		  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.+  +  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser General Public License from time to time.+Such new versions will be similar in spirit to the present version,+but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++			    NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.++		     END OF TERMS AND CONDITIONS
+ tests/b-as-line-feed.input view
@@ -0,0 +1,1 @@+
+ tests/b-as-line-feed.output view
@@ -0,0 +1,1 @@+L\x0a
+ tests/b-carriage-return.input view
@@ -0,0 +1,1 @@+
+ tests/b-carriage-return.output view
@@ -0,0 +1,1 @@+?\x0d
+ tests/b-char.cr.input view
@@ -0,0 +1,1 @@+
+ tests/b-char.cr.output view
@@ -0,0 +1,1 @@+?\x0d
+ tests/b-char.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/b-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/b-char.lf.input view
@@ -0,0 +1,1 @@+
+ tests/b-char.lf.output view
@@ -0,0 +1,1 @@+?\x0a
+ tests/b-char.ls.input view
@@ -0,0 +1,1 @@+

+ tests/b-char.ls.output view
@@ -0,0 +1,1 @@+?\u2028
+ tests/b-char.nl.input view
@@ -0,0 +1,1 @@+…
+ tests/b-char.nl.output view
@@ -0,0 +1,1 @@+?\x85
+ tests/b-char.ps.input view
@@ -0,0 +1,1 @@+

+ tests/b-char.ps.output view
@@ -0,0 +1,1 @@+?\u2029
+ tests/b-chomped-last.t=clip.input view
@@ -0,0 +1,1 @@+
+ tests/b-chomped-last.t=clip.invalid.input view
@@ -0,0 +1,1 @@+#
+ tests/b-chomped-last.t=clip.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/b-chomped-last.t=clip.output view
@@ -0,0 +1,2 @@+L\x0a+s
+ tests/b-chomped-last.t=keep.input view
@@ -0,0 +1,1 @@+
+ tests/b-chomped-last.t=keep.output view
@@ -0,0 +1,1 @@+L\x0a
+ tests/b-chomped-last.t=strip.input view
@@ -0,0 +1,1 @@+
+ tests/b-chomped-last.t=strip.output view
@@ -0,0 +1,2 @@+s+b\x0a
+ tests/b-generic.cr.input view
@@ -0,0 +1,1 @@+
+ tests/b-generic.cr.output view
@@ -0,0 +1,1 @@+?\x0d
+ tests/b-generic.crlf.input view
@@ -0,0 +1,1 @@+
+ tests/b-generic.crlf.output view
@@ -0,0 +1,1 @@+?\x0d\x0a
+ tests/b-generic.invalid.input view
@@ -0,0 +1,2 @@++
+ tests/b-generic.invalid.output view
@@ -0,0 +1,2 @@+?\x0a+!$InputFile$: line 2: column 0: Expected end of input
+ tests/b-generic.lf.input view
@@ -0,0 +1,1 @@+
+ tests/b-generic.lf.output view
@@ -0,0 +1,1 @@+?\x0a
+ tests/b-generic.nl.input view
@@ -0,0 +1,1 @@+…
+ tests/b-generic.nl.output view
@@ -0,0 +1,1 @@+?\x85
+ tests/b-ignored-any.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/b-ignored-any.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/b-ignored-any.lf.input view
@@ -0,0 +1,1 @@+
+ tests/b-ignored-any.lf.output view
@@ -0,0 +1,1 @@+b\x0a
+ tests/b-ignored-any.ls.input view
@@ -0,0 +1,1 @@+

+ tests/b-ignored-any.ls.output view
@@ -0,0 +1,1 @@+b\u2028
+ tests/b-ignored-generic.input view
@@ -0,0 +1,1 @@+
+ tests/b-ignored-generic.output view
@@ -0,0 +1,1 @@+b\x0a
+ tests/b-l-folded-any.n=4.s=plain.as-space.input view
@@ -0,0 +1,1 @@+
+ tests/b-l-folded-any.n=4.s=plain.as-space.output view
@@ -0,0 +1,1 @@+l\x0a
+ tests/b-l-folded-any.n=4.s=plain.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/b-l-folded-any.n=4.s=plain.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/b-l-folded-any.n=4.s=plain.specific.input view
@@ -0,0 +1,2 @@+
+

+ tests/b-l-folded-any.n=4.s=plain.specific.output view
@@ -0,0 +1,3 @@+B\u2028+L\x0a+B\u2028
+ tests/b-l-folded-any.n=4.s=plain.trimmed.input view
@@ -0,0 +1,2 @@++

+ tests/b-l-folded-any.n=4.s=plain.trimmed.output view
@@ -0,0 +1,3 @@+b\x0a+B\u2028+L\x0a
+ tests/b-l-folded-as-space.input view
@@ -0,0 +1,1 @@+
+ tests/b-l-folded-as-space.invalid.input view
@@ -0,0 +1,3 @@+++
+ tests/b-l-folded-as-space.invalid.output view
@@ -0,0 +1,2 @@+l\x0a+!$InputFile$: line 2: column 0: Expected end of input
+ tests/b-l-folded-as-space.output view
@@ -0,0 +1,1 @@+l\x0a
+ tests/b-l-folded-specific.n=4.s=plain.invalid.input view
@@ -0,0 +1,3 @@+++
+ tests/b-l-folded-specific.n=4.s=plain.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '\x0a'
+ tests/b-l-folded-specific.n=4.s=plain.ls-lf-ls.input view
@@ -0,0 +1,2 @@+
+

+ tests/b-l-folded-specific.n=4.s=plain.ls-lf-ls.output view
@@ -0,0 +1,3 @@+B\u2028+L\x0a+B\u2028
+ tests/b-l-folded-specific.n=4.s=plain.ls.input view
@@ -0,0 +1,1 @@+

+ tests/b-l-folded-specific.n=4.s=plain.ls.output view
@@ -0,0 +1,1 @@+B\u2028
+ tests/b-l-folded-trimmed.n=4.s=plain.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/b-l-folded-trimmed.n=4.s=plain.invalid.output view
@@ -0,0 +1,2 @@+b\x0a+!$InputFile$: line 2: column 0: Unexpected end of input
+ tests/b-l-folded-trimmed.n=4.s=plain.lf-ls-lf.input view
@@ -0,0 +1,2 @@++

+ tests/b-l-folded-trimmed.n=4.s=plain.lf-ls-lf.output view
@@ -0,0 +1,3 @@+b\x0a+B\u2028+L\x0a
+ tests/b-l-literal-next.n=4.input view
@@ -0,0 +1,3 @@++  +      a
+ tests/b-l-literal-next.n=4.invalid.input view
@@ -0,0 +1,2 @@++  a
+ tests/b-l-literal-next.n=4.invalid.output view
@@ -0,0 +1,2 @@+L\x0a+!$InputFile$: line 2: column 2: Unexpected 'a'
+ tests/b-l-literal-next.n=4.output view
@@ -0,0 +1,5 @@+L\x0a+i  +L\x0a+i    +?  a
+ tests/b-l-spaced.n=4.input view
@@ -0,0 +1,2 @@++
+ tests/b-l-spaced.n=4.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/b-l-spaced.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/b-l-spaced.n=4.output view
@@ -0,0 +1,3 @@+L\x0a+i  +L\x0a
+ tests/b-line-feed.input view
@@ -0,0 +1,1 @@+
+ tests/b-line-feed.output view
@@ -0,0 +1,1 @@+?\x0a
+ tests/b-line-separator.input view
@@ -0,0 +1,1 @@+

+ tests/b-line-separator.output view
@@ -0,0 +1,1 @@+?\u2028
+ tests/b-next-line.input view
@@ -0,0 +1,1 @@+…
+ tests/b-next-line.output view
@@ -0,0 +1,1 @@+?\x85
+ tests/b-normalized.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/b-normalized.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/b-normalized.lf.input view
@@ -0,0 +1,1 @@+
+ tests/b-normalized.lf.output view
@@ -0,0 +1,1 @@+L\x0a
+ tests/b-normalized.ls.input view
@@ -0,0 +1,1 @@+

+ tests/b-normalized.ls.output view
@@ -0,0 +1,1 @@+B\u2028
+ tests/b-paragraph-separator.input view
@@ -0,0 +1,1 @@+

+ tests/b-paragraph-separator.output view
@@ -0,0 +1,1 @@+?\u2029
+ tests/b-specific.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/b-specific.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '\x0a'
+ tests/b-specific.ls.input view
@@ -0,0 +1,1 @@+

+ tests/b-specific.ls.output view
@@ -0,0 +1,1 @@+?\u2028
+ tests/b-specific.ps.input view
@@ -0,0 +1,1 @@+

+ tests/b-specific.ps.output view
@@ -0,0 +1,1 @@+?\u2029
+ tests/c-alias.input view
@@ -0,0 +1,1 @@+*
+ tests/c-alias.output view
@@ -0,0 +1,1 @@+I*
+ tests/c-anchor.input view
@@ -0,0 +1,1 @@+&
+ tests/c-anchor.output view
@@ -0,0 +1,1 @@+I&
+ tests/c-b+block-header.n=2.s=folded.i.input view
@@ -0,0 +1,1 @@+>
+ tests/c-b+block-header.n=2.s=folded.i.output view
@@ -0,0 +1,4 @@+I>+b\x0a+!Commit to 'node' was made outside it+$(m,t)=(1,clip)
+ tests/c-b+block-header.n=2.s=folded.im.input view
@@ -0,0 +1,1 @@+>7
+ tests/c-b+block-header.n=2.s=folded.im.output view
@@ -0,0 +1,5 @@+I>+I7+b\x0a+!Commit to 'node' was made outside it+$(m,t)=(7,clip)
+ tests/c-b+block-header.n=2.s=folded.imt.input view
@@ -0,0 +1,1 @@+>7-
+ tests/c-b+block-header.n=2.s=folded.imt.output view
@@ -0,0 +1,6 @@+I>+I7+I-+b\x0a+!Commit to 'node' was made outside it+$(m,t)=(7,strip)
+ tests/c-b+block-header.n=2.s=folded.invalid.input view
@@ -0,0 +1,1 @@+-
+ tests/c-b+block-header.n=2.s=folded.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '-'
+ tests/c-b+block-header.n=2.s=folded.it.input view
@@ -0,0 +1,1 @@+>-
+ tests/c-b+block-header.n=2.s=folded.it.output view
@@ -0,0 +1,5 @@+I>+I-+b\x0a+!Commit to 'node' was made outside it+$(m,t)=(1,strip)
+ tests/c-b+block-header.n=2.s=folded.itm.input view
@@ -0,0 +1,1 @@+>-7
+ tests/c-b+block-header.n=2.s=folded.itm.output view
@@ -0,0 +1,6 @@+I>+I-+I7+b\x0a+!Commit to 'node' was made outside it+$(m,t)=(7,strip)
+ tests/c-byte-order-mark.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-byte-order-mark.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-byte-order-mark.utf16be.input view
@@ -0,0 +1,1 @@+þÿ
+ tests/c-byte-order-mark.utf16be.output view
@@ -0,0 +1,1 @@+UTF16BE
+ tests/c-byte-order-mark.utf16le.input view
@@ -0,0 +1,1 @@+ÿþ
+ tests/c-byte-order-mark.utf16le.output view
@@ -0,0 +1,1 @@+UTF16LE
+ tests/c-byte-order-mark.utf8.input view
@@ -0,0 +1,1 @@+
+ tests/c-byte-order-mark.utf8.output view
@@ -0,0 +1,1 @@+UTF8
+ tests/c-chomping-indicator.empty.input view
+ tests/c-chomping-indicator.empty.output view
@@ -0,0 +1,1 @@+$t=clip
+ tests/c-chomping-indicator.hyphen.input view
@@ -0,0 +1,1 @@+-
+ tests/c-chomping-indicator.hyphen.output view
@@ -0,0 +1,2 @@+I-+$t=strip
+ tests/c-chomping-indicator.invalid.input view
@@ -0,0 +1,1 @@+2
+ tests/c-chomping-indicator.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Expected end of input
+ tests/c-chomping-indicator.plus.input view
@@ -0,0 +1,1 @@++
+ tests/c-chomping-indicator.plus.output view
@@ -0,0 +1,3 @@+I++!Commit to 'header' was made outside it+$t=keep
+ tests/c-collect-entry.input view
@@ -0,0 +1,1 @@+,
+ tests/c-collect-entry.output view
@@ -0,0 +1,1 @@+I,
+ tests/c-comment.input view
@@ -0,0 +1,1 @@+#
+ tests/c-comment.output view
@@ -0,0 +1,1 @@+I#
+ tests/c-directive.input view
@@ -0,0 +1,1 @@+%
+ tests/c-directive.output view
@@ -0,0 +1,1 @@+I%
+ tests/c-document-end.input view
@@ -0,0 +1,1 @@+...
+ tests/c-document-end.invalid.input view
@@ -0,0 +1,1 @@+..+
+ tests/c-document-end.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 2: Unexpected '+'
+ tests/c-document-end.output view
@@ -0,0 +1,1 @@+k...
+ tests/c-document-start.input view
@@ -0,0 +1,1 @@+---
+ tests/c-document-start.invalid.input view
@@ -0,0 +1,1 @@+--+
+ tests/c-document-start.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 2: Unexpected '+'
+ tests/c-document-start.output view
@@ -0,0 +1,1 @@+K---
+ tests/c-double-quote.input view
@@ -0,0 +1,1 @@+"
+ tests/c-double-quote.output view
@@ -0,0 +1,1 @@+I"
+ tests/c-double-quoted.n=4.c=flow-out.input view
@@ -0,0 +1,2 @@+" a +    	a b	c "
+ tests/c-double-quoted.n=4.c=flow-out.invalid.input view
@@ -0,0 +1,1 @@+"a
+ tests/c-double-quoted.n=4.c=flow-out.invalid.output view
@@ -0,0 +1,5 @@+S+I"+Ta+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 2: Unexpected '\x0a'
+ tests/c-double-quoted.n=4.c=flow-out.output view
@@ -0,0 +1,11 @@+S+I"+T a+w +l\x0a+i    +w\x09+Ta b\x09c +I"+s+!Commit to 'node' was made outside it
+ tests/c-escape.input view
@@ -0,0 +1,1 @@+\
+ tests/c-escape.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-escape.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-escape.output view
@@ -0,0 +1,1 @@+I\x5c
+ tests/c-flow-indicator.collect-entry.input view
@@ -0,0 +1,1 @@+,
+ tests/c-flow-indicator.collect-entry.output view
@@ -0,0 +1,1 @@+I,
+ tests/c-flow-indicator.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-flow-indicator.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-flow-indicator.mapping-end.input view
@@ -0,0 +1,1 @@+}
+ tests/c-flow-indicator.mapping-end.output view
@@ -0,0 +1,1 @@+I}
+ tests/c-flow-indicator.mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/c-flow-indicator.mapping-start.output view
@@ -0,0 +1,1 @@+I{
+ tests/c-flow-indicator.sequence-end.input view
@@ -0,0 +1,1 @@+]
+ tests/c-flow-indicator.sequence-end.output view
@@ -0,0 +1,1 @@+I]
+ tests/c-flow-indicator.sequence-start.input view
@@ -0,0 +1,1 @@+[
+ tests/c-flow-indicator.sequence-start.output view
@@ -0,0 +1,1 @@+I[
+ tests/c-flow-json-content.n=4.c=flow-in.double.input view
@@ -0,0 +1,1 @@+"a"
+ tests/c-flow-json-content.n=4.c=flow-in.double.output view
@@ -0,0 +1,6 @@+S+I"+Ta+I"+s+!Commit to 'node' was made outside it
+ tests/c-flow-json-content.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+|
+ tests/c-flow-json-content.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,2 @@+S+!$InputFile$: line 1: column 0: Unexpected '|'
+ tests/c-flow-json-content.n=4.c=flow-in.mapping.input view
@@ -0,0 +1,1 @@+{a: b}
+ tests/c-flow-json-content.n=4.c=flow-in.mapping.output view
@@ -0,0 +1,19 @@+M+I{+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+I}+m+!Commit to 'node' was made outside it
+ tests/c-flow-json-content.n=4.c=flow-in.sequence.input view
@@ -0,0 +1,1 @@+[a]
+ tests/c-flow-json-content.n=4.c=flow-in.sequence.output view
@@ -0,0 +1,10 @@+Q+I[+N+S+Ta+s+n+I]+q+!Commit to 'node' was made outside it
+ tests/c-flow-json-node.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-flow-json-node.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-flow-json-node.n=4.c=flow-in.tagged.input view
@@ -0,0 +1,1 @@+!t "a"
+ tests/c-flow-json-node.n=4.c=flow-in.tagged.output view
@@ -0,0 +1,17 @@+N+P+G+H+I!+h+tt+g+p+w +S+I"+Ta+I"+s+n+!Commit to 'node' was made outside it
+ tests/c-flow-json-node.n=4.c=flow-in.untagged.input view
@@ -0,0 +1,1 @@+"a"
+ tests/c-flow-json-node.n=4.c=flow-in.untagged.output view
@@ -0,0 +1,8 @@+N+S+I"+Ta+I"+s+n+!Commit to 'node' was made outside it
+ tests/c-flow-mapping.n=4.c=flow-in.compact.input view
@@ -0,0 +1,1 @@+{"a":b,? c,: d,e}
+ tests/c-flow-mapping.n=4.c=flow-in.compact.output view
@@ -0,0 +1,61 @@+M+I{+X+N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+x+I,+X+I?+w +N+S+Tc+s+n+N+S+s+n+x+I,+X+N+S+s+n+I:+w +N+S+Td+s+n+x+I,+X+N+S+Te+s+n+N+S+s+n+x+I}+m+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-flow-mapping.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+{a
+ tests/c-flow-mapping.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,15 @@+M+I{+X+N+S+Ta+s+n+N+S+s+n+x+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 2: Unexpected end of input
+ tests/c-flow-mapping.n=4.c=flow-in.spaced.input view
@@ -0,0 +1,1 @@+{ "a" : b, ? c, : d , e , }
+ tests/c-flow-mapping.n=4.c=flow-in.spaced.output view
@@ -0,0 +1,71 @@+M+I{+w +X+N+S+I"+Ta+I"+s+n+w +I:+w +N+S+Tb+s+n+x+I,+w +X+I?+w +N+S+Tc+s+n+N+S+s+n+x+I,+w +X+N+S+s+n+I:+w +N+S+Td+s+n+x+w +I,+w +X+N+S+Te+s+n+w +N+S+s+n+x+I,+w +I}+m+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-flow-sequence.n=4.c=flow-in.compact.input view
@@ -0,0 +1,1 @@+[a,c: d]
+ tests/c-flow-sequence.n=4.c=flow-in.compact.output view
@@ -0,0 +1,28 @@+Q+I[+N+S+Ta+s+n+I,+M+X+N+S+Tc+s+n+I:+w +N+S+Td+s+n+x+m+I]+q+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-flow-sequence.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+[a,
+ tests/c-flow-sequence.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,10 @@+Q+I[+N+S+Ta+s+n+I,+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 3: Unexpected end of input
+ tests/c-flow-sequence.n=4.c=flow-in.spaced.input view
@@ -0,0 +1,1 @@+[ a , c: d , ]
+ tests/c-flow-sequence.n=4.c=flow-in.spaced.output view
@@ -0,0 +1,34 @@+Q+I[+w +N+S+Ta+s+n+w +I,+w +M+X+N+S+Tc+s+n+I:+w +N+S+Td+s+n+x+m+w +I,+w +I]+q+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-folded.input view
@@ -0,0 +1,1 @@+>
+ tests/c-folded.output view
@@ -0,0 +1,1 @@+I>
+ tests/c-indentation-indicator.n=0.input view
@@ -0,0 +1,1 @@+7
+ tests/c-indentation-indicator.n=0.invalid.input view
@@ -0,0 +1,1 @@+0
+ tests/c-indentation-indicator.n=0.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Expected end of input
+ tests/c-indentation-indicator.n=0.output view
@@ -0,0 +1,2 @@+I7+$m=7
+ tests/c-indicator.alias.input view
@@ -0,0 +1,1 @@+*
+ tests/c-indicator.alias.output view
@@ -0,0 +1,1 @@+I*
+ tests/c-indicator.anchor.input view
@@ -0,0 +1,1 @@+&
+ tests/c-indicator.anchor.output view
@@ -0,0 +1,1 @@+I&
+ tests/c-indicator.collect-entry.input view
@@ -0,0 +1,1 @@+,
+ tests/c-indicator.collect-entry.output view
@@ -0,0 +1,1 @@+I,
+ tests/c-indicator.comment.input view
@@ -0,0 +1,1 @@+#
+ tests/c-indicator.comment.output view
@@ -0,0 +1,1 @@+I#
+ tests/c-indicator.directive.input view
@@ -0,0 +1,1 @@+%
+ tests/c-indicator.directive.output view
@@ -0,0 +1,1 @@+I%
+ tests/c-indicator.double-quote.input view
@@ -0,0 +1,1 @@+"
+ tests/c-indicator.double-quote.output view
@@ -0,0 +1,1 @@+I"
+ tests/c-indicator.folded.input view
@@ -0,0 +1,1 @@+>
+ tests/c-indicator.folded.output view
@@ -0,0 +1,1 @@+I>
+ tests/c-indicator.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-indicator.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-indicator.literal.input view
@@ -0,0 +1,1 @@+|
+ tests/c-indicator.literal.output view
@@ -0,0 +1,1 @@+I|
+ tests/c-indicator.mapping-end.input view
@@ -0,0 +1,1 @@+}
+ tests/c-indicator.mapping-end.output view
@@ -0,0 +1,1 @@+I}
+ tests/c-indicator.mapping-key.input view
@@ -0,0 +1,1 @@+?
+ tests/c-indicator.mapping-key.output view
@@ -0,0 +1,1 @@+I?
+ tests/c-indicator.mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/c-indicator.mapping-start.output view
@@ -0,0 +1,1 @@+I{
+ tests/c-indicator.mapping-value.input view
@@ -0,0 +1,1 @@+:
+ tests/c-indicator.mapping-value.output view
@@ -0,0 +1,1 @@+I:
+ tests/c-indicator.reserved.at.input view
@@ -0,0 +1,1 @@+@
+ tests/c-indicator.reserved.at.output view
@@ -0,0 +1,1 @@+I@
+ tests/c-indicator.reserved.backtick.input view
@@ -0,0 +1,1 @@+`
+ tests/c-indicator.reserved.backtick.output view
@@ -0,0 +1,1 @@+I`
+ tests/c-indicator.sequence-end.input view
@@ -0,0 +1,1 @@+]
+ tests/c-indicator.sequence-end.output view
@@ -0,0 +1,1 @@+I]
+ tests/c-indicator.sequence-entry.input view
@@ -0,0 +1,1 @@+-
+ tests/c-indicator.sequence-entry.output view
@@ -0,0 +1,1 @@+I-
+ tests/c-indicator.sequence-start.input view
@@ -0,0 +1,1 @@+[
+ tests/c-indicator.sequence-start.output view
@@ -0,0 +1,1 @@+I[
+ tests/c-indicator.single-quote.input view
@@ -0,0 +1,1 @@+'
+ tests/c-indicator.single-quote.output view
@@ -0,0 +1,1 @@+I'
+ tests/c-indicator.tag.input view
@@ -0,0 +1,1 @@+!
+ tests/c-indicator.tag.output view
@@ -0,0 +1,1 @@+I!
+ tests/c-l+folded.n=2.indent.input view
@@ -0,0 +1,7 @@+>2 #+     a+    b++     c++  #
+ tests/c-l+folded.n=2.indent.output view
@@ -0,0 +1,26 @@+S+I>+I2+w +C+I#+c+b\x0a+i    +T a+L\x0a+i    +Tb+L\x0a+L\x0a+i    +T c+L\x0a+s+b\x0a+i  +C+I#+c+b\x0a+!Commit to 'node' was made outside it
+ tests/c-l+folded.n=2.invalid.input view
@@ -0,0 +1,2 @@+>+  a
+ tests/c-l+folded.n=2.invalid.output view
@@ -0,0 +1,5 @@+S+I>+b\x0a+!Commit to 'node' was made outside it+!$InputFile$: line 2: column 0: Expected end of input
+ tests/c-l+folded.n=2.simple.input view
@@ -0,0 +1,2 @@+>+    a
+ tests/c-l+folded.n=2.simple.output view
@@ -0,0 +1,8 @@+S+I>+b\x0a+i    +Ta+L\x0a+s+!Commit to 'node' was made outside it
+ tests/c-l+literal.n=2.invalid.input view
@@ -0,0 +1,2 @@+|2-+   a
+ tests/c-l+literal.n=2.invalid.output view
@@ -0,0 +1,7 @@+S+I|+I2+I-+b\x0a+!Commit to 'node' was made outside it+!$InputFile$: line 2: column 0: Expected end of input
+ tests/c-l+literal.n=2.simple.input view
@@ -0,0 +1,2 @@+|+    a
+ tests/c-l+literal.n=2.simple.output view
@@ -0,0 +1,8 @@+S+I|+b\x0a+i    +Ta+L\x0a+s+!Commit to 'node' was made outside it
+ tests/c-l+literal.n=2.strip-indent.input view
@@ -0,0 +1,7 @@+|-2+    # a+    b+      #c++  +  #
+ tests/c-l+literal.n=2.strip-indent.output view
@@ -0,0 +1,24 @@+S+I|+I-+I2+b\x0a+i    +T# a+L\x0a+i    +Tb+L\x0a+i    +T  #c+s+b\x0a+b\x0a+i  +b\x0a+i  +C+I#+c+b\x0a+!Commit to 'node' was made outside it
+ tests/c-l+literal.n=2.strip.input view
@@ -0,0 +1,7 @@+|-+    # a+    b+      #c++  +  #
+ tests/c-l+literal.n=2.strip.output view
@@ -0,0 +1,23 @@+S+I|+I-+b\x0a+i    +T# a+L\x0a+i    +Tb+L\x0a+i    +T  #c+s+b\x0a+b\x0a+i  +b\x0a+i  +C+I#+c+b\x0a+!Commit to 'node' was made outside it
+ tests/c-l-block-map-explicit-entry.n=2.input view
@@ -0,0 +1,2 @@+? a+  : b
+ tests/c-l-block-map-explicit-entry.n=2.invalid.input view
@@ -0,0 +1,1 @@+a : b
+ tests/c-l-block-map-explicit-entry.n=2.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-l-block-map-explicit-entry.n=2.output view
@@ -0,0 +1,20 @@+I?+w +N+S+Ta+s+n+b\x0a+i  +I:+w +N+S+Tb+s+n+b\x0a+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-l-block-map-explicit-key.n=2.input view
@@ -0,0 +1,1 @@+? a
+ tests/c-l-block-map-explicit-key.n=2.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-l-block-map-explicit-key.n=2.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-l-block-map-explicit-key.n=2.output view
@@ -0,0 +1,10 @@+I?+w +N+S+Ta+s+n+b\x0a+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-l-block-map-implicit-value.n=2.empty.input view
@@ -0,0 +1,1 @@+:
+ tests/c-l-block-map-implicit-value.n=2.empty.output view
@@ -0,0 +1,7 @@+I:+N+S+s+n+b\x0a+!Commit to 'node' was made outside it
+ tests/c-l-block-map-implicit-value.n=2.invalid.input view
@@ -0,0 +1,1 @@+:"a"
+ tests/c-l-block-map-implicit-value.n=2.invalid.output view
@@ -0,0 +1,7 @@+I:+N+S+s+n+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 1: Expected start of line
+ tests/c-l-block-map-implicit-value.n=2.plain.input view
@@ -0,0 +1,1 @@+: a
+ tests/c-l-block-map-implicit-value.n=2.plain.output view
@@ -0,0 +1,10 @@+I:+w +N+S+Ta+s+n+b\x0a+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-l-block-seq-entry.n=2.input view
@@ -0,0 +1,1 @@+- a
+ tests/c-l-block-seq-entry.n=2.invalid.input view
@@ -0,0 +1,1 @@+ - a
+ tests/c-l-block-seq-entry.n=2.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/c-l-block-seq-entry.n=2.output view
@@ -0,0 +1,10 @@+I-+w +N+S+Ta+s+n+b\x0a+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/c-literal.input view
@@ -0,0 +1,1 @@+|
+ tests/c-literal.output view
@@ -0,0 +1,1 @@+I|
+ tests/c-mapping-end.input view
@@ -0,0 +1,1 @@+}
+ tests/c-mapping-end.output view
@@ -0,0 +1,1 @@+I}
+ tests/c-mapping-key.input view
@@ -0,0 +1,1 @@+?
+ tests/c-mapping-key.output view
@@ -0,0 +1,1 @@+I?
+ tests/c-mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/c-mapping-start.output view
@@ -0,0 +1,1 @@+I{
+ tests/c-mapping-value.input view
@@ -0,0 +1,1 @@+:
+ tests/c-mapping-value.output view
@@ -0,0 +1,1 @@+I:
+ tests/c-named-tag-handle.input view
@@ -0,0 +1,1 @@+!name!
+ tests/c-named-tag-handle.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-named-tag-handle.invalid.output view
@@ -0,0 +1,2 @@+H+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-named-tag-handle.output view
@@ -0,0 +1,5 @@+H+I!+tname+I!+h
+ tests/c-nb-comment-text.comment-text.input view
@@ -0,0 +1,1 @@+# text
+ tests/c-nb-comment-text.comment-text.output view
@@ -0,0 +1,4 @@+C+I#+t text+c
+ tests/c-nb-comment-text.comment.input view
@@ -0,0 +1,1 @@+#
+ tests/c-nb-comment-text.comment.output view
@@ -0,0 +1,3 @@+C+I#+c
+ tests/c-nb-comment-text.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/c-nb-comment-text.invalid.output view
@@ -0,0 +1,2 @@+C+!$InputFile$: line 1: column 0: Unexpected '\x0a'
+ tests/c-non-specific-tag.input view
@@ -0,0 +1,1 @@+!
+ tests/c-non-specific-tag.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-non-specific-tag.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-non-specific-tag.output view
@@ -0,0 +1,1 @@+I!
+ tests/c-ns-alias.input view
@@ -0,0 +1,1 @@+**&!name
+ tests/c-ns-alias.invalid.input view
@@ -0,0 +1,1 @@+*,
+ tests/c-ns-alias.invalid.output view
@@ -0,0 +1,4 @@+R+I*+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 1: Unexpected ','
+ tests/c-ns-alias.output view
@@ -0,0 +1,5 @@+R+I*+t*&!name+r+!Commit to 'node' was made outside it
+ tests/c-ns-anchor-property.input view
@@ -0,0 +1,1 @@+&&*!name
+ tests/c-ns-anchor-property.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-ns-anchor-property.invalid.output view
@@ -0,0 +1,2 @@+A+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-ns-anchor-property.output view
@@ -0,0 +1,4 @@+A+I&+t&*!name+a
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.compact.input view
@@ -0,0 +1,1 @@+:a
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.compact.output view
@@ -0,0 +1,8 @@+I:+N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.empty.input view
@@ -0,0 +1,1 @@+:
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.empty.output view
@@ -0,0 +1,6 @@+I:+N+S+s+n+!Commit to 'pair' was made outside it
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.spaced.input view
@@ -0,0 +1,1 @@+: a
+ tests/c-ns-flow-map-adjacent-value.n=4.c=flow-in.spaced.output view
@@ -0,0 +1,9 @@+I:+w +N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.compact.input view
@@ -0,0 +1,1 @@+"a":b
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.compact.output view
@@ -0,0 +1,15 @@+N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.empty.input view
@@ -0,0 +1,1 @@+"a"
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.empty.output view
@@ -0,0 +1,11 @@+N+S+I"+Ta+I"+s+n+N+S+s+n
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a: b
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.spaced.input view
@@ -0,0 +1,1 @@+"a" : b
+ tests/c-ns-flow-map-implicit-json.n=4.c=flow-in.spaced.output view
@@ -0,0 +1,17 @@+N+S+I"+Ta+I"+s+n+w +I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/c-ns-flow-map-separate-value.n=4.c=flow-in.empty.input view
@@ -0,0 +1,1 @@+:
+ tests/c-ns-flow-map-separate-value.n=4.c=flow-in.empty.output view
@@ -0,0 +1,6 @@+I:+N+S+s+n+!Commit to 'pair' was made outside it
+ tests/c-ns-flow-map-separate-value.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+:a
+ tests/c-ns-flow-map-separate-value.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,7 @@+I:+N+S+s+n+!Commit to 'pair' was made outside it+!$InputFile$: line 1: column 1: Expected end of input
+ tests/c-ns-flow-map-separate-value.n=4.c=flow-in.value.input view
@@ -0,0 +1,1 @@+: a
+ tests/c-ns-flow-map-separate-value.n=4.c=flow-in.value.output view
@@ -0,0 +1,9 @@+I:+w +N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/c-ns-flow-map-single-json.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+"a":b
+ tests/c-ns-flow-map-single-json.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a: b
+ tests/c-ns-flow-map-single-json.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-ns-flow-map-single-json.n=4.c=flow-in.output view
@@ -0,0 +1,15 @@+N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/c-ns-local-tag-prefix.input view
@@ -0,0 +1,1 @@+!prefix
+ tests/c-ns-local-tag-prefix.invalid.input view
@@ -0,0 +1,1 @@+!a^b
+ tests/c-ns-local-tag-prefix.invalid.output view
@@ -0,0 +1,3 @@+I!+ta+!$InputFile$: line 1: column 2: Expected end of input
+ tests/c-ns-local-tag-prefix.output view
@@ -0,0 +1,2 @@+I!+tprefix
+ tests/c-ns-properties.input view
@@ -0,0 +1,1 @@+&&*!name !suffix
+ tests/c-ns-properties.invalid.input view
@@ -0,0 +1,1 @@+@a
+ tests/c-ns-properties.invalid.output view
@@ -0,0 +1,3 @@+P+G+!$InputFile$: line 1: column 0: Unexpected '@'
+ tests/c-ns-properties.output view
@@ -0,0 +1,13 @@+P+A+I&+t&*!name+a+w +G+H+I!+h+tsuffix+g+p
+ tests/c-ns-property.anchor.input view
@@ -0,0 +1,1 @@+&&*!name
+ tests/c-ns-property.anchor.output view
@@ -0,0 +1,4 @@+A+I&+t&*!name+a
+ tests/c-ns-property.invalid.input view
@@ -0,0 +1,1 @@+^a
+ tests/c-ns-property.invalid.output view
@@ -0,0 +1,2 @@+G+!$InputFile$: line 1: column 0: Unexpected '^'
+ tests/c-ns-property.tag.input view
@@ -0,0 +1,1 @@+!suffix
+ tests/c-ns-property.tag.output view
@@ -0,0 +1,6 @@+G+H+I!+h+tsuffix+g
+ tests/c-ns-shorthand-tag.invalid.input view
@@ -0,0 +1,1 @@+!!
+ tests/c-ns-shorthand-tag.invalid.output view
@@ -0,0 +1,4 @@+H+I!+h+!$InputFile$: line 1: column 1: Unexpected '!'
+ tests/c-ns-shorthand-tag.named.input view
@@ -0,0 +1,1 @@+!name!suffix
+ tests/c-ns-shorthand-tag.named.output view
@@ -0,0 +1,6 @@+H+I!+tname+I!+h+tsuffix
+ tests/c-ns-shorthand-tag.primary.input view
@@ -0,0 +1,1 @@+!suffix
+ tests/c-ns-shorthand-tag.primary.output view
@@ -0,0 +1,4 @@+H+I!+h+tsuffix
+ tests/c-ns-shorthand-tag.secondary.input view
@@ -0,0 +1,1 @@+!!suffix
+ tests/c-ns-shorthand-tag.secondary.output view
@@ -0,0 +1,5 @@+H+I!+I!+h+tsuffix
+ tests/c-ns-tag-property.invalid.input view
@@ -0,0 +1,1 @@+!<a
+ tests/c-ns-tag-property.invalid.output view
@@ -0,0 +1,4 @@+G+I!+g+!$InputFile$: line 1: column 1: Expected end of input
+ tests/c-ns-tag-property.non-specific.input view
@@ -0,0 +1,1 @@+!
+ tests/c-ns-tag-property.non-specific.output view
@@ -0,0 +1,3 @@+G+I!+g
+ tests/c-ns-tag-property.shorthand.input view
@@ -0,0 +1,1 @@+!suffix
+ tests/c-ns-tag-property.shorthand.output view
@@ -0,0 +1,6 @@+G+H+I!+h+tsuffix+g
+ tests/c-ns-tag-property.verbatim.input view
@@ -0,0 +1,1 @@+!<verbatim>
+ tests/c-ns-tag-property.verbatim.output view
@@ -0,0 +1,6 @@+G+I!+I<+tverbatim+I>+g
+ tests/c-primary-tag-handle.input view
@@ -0,0 +1,1 @@+!
+ tests/c-primary-tag-handle.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-primary-tag-handle.invalid.output view
@@ -0,0 +1,2 @@+H+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-primary-tag-handle.output view
@@ -0,0 +1,3 @@+H+I!+h
+ tests/c-printable.10000.input view
@@ -0,0 +1,1 @@+𐀀
+ tests/c-printable.10000.output view
@@ -0,0 +1,1 @@+?\U00010000
+ tests/c-printable.10ffff.input view
@@ -0,0 +1,1 @@+􏿿
+ tests/c-printable.10ffff.output view
@@ -0,0 +1,1 @@+?\U0010ffff
+ tests/c-printable.cr.input view
@@ -0,0 +1,1 @@+

+ tests/c-printable.cr.output view
@@ -0,0 +1,1 @@+?\x0d
+ tests/c-printable.d7ff.input view
@@ -0,0 +1,1 @@+퟿
+ tests/c-printable.d7ff.output view
@@ -0,0 +1,1 @@+?\ud7ff
+ tests/c-printable.e000.input view
@@ -0,0 +1,1 @@+
+ tests/c-printable.e000.output view
@@ -0,0 +1,1 @@+?\ue000
+ tests/c-printable.fffd.input view
@@ -0,0 +1,1 @@+�
+ tests/c-printable.fffd.output view
@@ -0,0 +1,1 @@+?\ufffd
+ tests/c-printable.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/c-printable.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '\x01'
+ tests/c-printable.lf.input view
@@ -0,0 +1,1 @@+
+ tests/c-printable.lf.output view
@@ -0,0 +1,1 @@+?\x0a
+ tests/c-printable.nbsp.input view
@@ -0,0 +1,1 @@+ 
+ tests/c-printable.nbsp.output view
@@ -0,0 +1,1 @@+?\xa0
+ tests/c-printable.nel.input view
@@ -0,0 +1,1 @@+…
+ tests/c-printable.nel.output view
@@ -0,0 +1,1 @@+?\x85
+ tests/c-printable.sp.input view
@@ -0,0 +1,1 @@+ 
+ tests/c-printable.sp.output view
@@ -0,0 +1,1 @@+? 
+ tests/c-printable.tab.input view
@@ -0,0 +1,1 @@+	
+ tests/c-printable.tab.output view
@@ -0,0 +1,1 @@+?\x09
+ tests/c-printable.tilde.input view
@@ -0,0 +1,1 @@+~
+ tests/c-printable.tilde.output view
@@ -0,0 +1,1 @@+?~
+ tests/c-quoted-quote.input view
@@ -0,0 +1,1 @@+''
+ tests/c-quoted-quote.invalid.input view
@@ -0,0 +1,1 @@+'a
+ tests/c-quoted-quote.invalid.output view
@@ -0,0 +1,4 @@+E+I'+!Commit to 'escape' was made outside it+!$InputFile$: line 1: column 1: Unexpected 'a'
+ tests/c-quoted-quote.output view
@@ -0,0 +1,5 @@+E+I'+t'+e+!Commit to 'escape' was made outside it
+ tests/c-reserved.at.input view
@@ -0,0 +1,1 @@+@
+ tests/c-reserved.at.output view
@@ -0,0 +1,1 @@+I@
+ tests/c-reserved.backtick.input view
@@ -0,0 +1,1 @@+`
+ tests/c-reserved.backtick.output view
@@ -0,0 +1,1 @@+I`
+ tests/c-s-simple-json-key.just.input view
@@ -0,0 +1,1 @@+"123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcde"
+ tests/c-s-simple-json-key.just.output view
@@ -0,0 +1,7 @@+N+S+I"+T123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcde+I"+s+n
+ tests/c-s-simple-json-key.long.input view
@@ -0,0 +1,1 @@+"123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdeX"
+ tests/c-s-simple-json-key.long.output view
@@ -0,0 +1,5 @@+N+S+I"+T123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdeX+!$InputFile$: line 1: column 1024: Lookahead limit reached
+ tests/c-s-simple-json-key.short.input view
@@ -0,0 +1,1 @@+"a" 
+ tests/c-s-simple-json-key.short.output view
@@ -0,0 +1,8 @@+N+S+I"+Ta+I"+s+n+w 
+ tests/c-secondary-tag-handle.input view
@@ -0,0 +1,1 @@+!!
+ tests/c-secondary-tag-handle.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-secondary-tag-handle.invalid.output view
@@ -0,0 +1,2 @@+H+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-secondary-tag-handle.output view
@@ -0,0 +1,4 @@+H+I!+I!+h
+ tests/c-sequence-end.input view
@@ -0,0 +1,1 @@+]
+ tests/c-sequence-end.output view
@@ -0,0 +1,1 @@+I]
+ tests/c-sequence-entry.input view
@@ -0,0 +1,1 @@+-
+ tests/c-sequence-entry.output view
@@ -0,0 +1,1 @@+I-
+ tests/c-sequence-start.input view
@@ -0,0 +1,1 @@+[
+ tests/c-sequence-start.output view
@@ -0,0 +1,1 @@+I[
+ tests/c-single-quote.input view
@@ -0,0 +1,1 @@+'
+ tests/c-single-quote.output view
@@ -0,0 +1,1 @@+I'
+ tests/c-single-quoted.n=4.c=flow-out.input view
@@ -0,0 +1,2 @@+' a +    	a b	c '
+ tests/c-single-quoted.n=4.c=flow-out.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-single-quoted.n=4.c=flow-out.invalid.output view
@@ -0,0 +1,2 @@+S+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-single-quoted.n=4.c=flow-out.output view
@@ -0,0 +1,10 @@+S+I'+T a+w +l\x0a+i    +w\x09+Ta b\x09c +I'+s
+ tests/c-style-indicator.s=folded.input view
@@ -0,0 +1,1 @@+>
+ tests/c-style-indicator.s=folded.output view
@@ -0,0 +1,1 @@+I>
+ tests/c-style-indicator.s=literal.input view
@@ -0,0 +1,1 @@+|
+ tests/c-style-indicator.s=literal.invalid.input view
@@ -0,0 +1,1 @@++
+ tests/c-style-indicator.s=literal.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '+'
+ tests/c-style-indicator.s=literal.output view
@@ -0,0 +1,1 @@+I|
+ tests/c-tag-handle.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/c-tag-handle.invalid.output view
@@ -0,0 +1,2 @@+H+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/c-tag-handle.named.input view
@@ -0,0 +1,1 @@+!name!
+ tests/c-tag-handle.named.output view
@@ -0,0 +1,5 @@+H+I!+tname+I!+h
+ tests/c-tag-handle.primary.input view
@@ -0,0 +1,1 @@+!
+ tests/c-tag-handle.primary.output view
@@ -0,0 +1,3 @@+H+I!+h
+ tests/c-tag-handle.secondary.input view
@@ -0,0 +1,1 @@+!!
+ tests/c-tag-handle.secondary.output view
@@ -0,0 +1,4 @@+H+I!+I!+h
+ tests/c-tag.input view
@@ -0,0 +1,1 @@+!
+ tests/c-tag.output view
@@ -0,0 +1,1 @@+I!
+ tests/c-verbatim-tag.input view
@@ -0,0 +1,1 @@+!<verbatim>
+ tests/c-verbatim-tag.invalid.input view
@@ -0,0 +1,1 @@+!<a
+ tests/c-verbatim-tag.invalid.output view
@@ -0,0 +1,4 @@+I!+I<+ta+!$InputFile$: line 1: column 3: Unexpected end of input
+ tests/c-verbatim-tag.output view
@@ -0,0 +1,4 @@+I!+I<+tverbatim+I>
+ tests/count-spaces.n=-1.0.input view
+ tests/count-spaces.n=-1.0.output view
@@ -0,0 +1,1 @@+$m=1
+ tests/count-spaces.n=-1.1.input view
@@ -0,0 +1,1 @@+ 
+ tests/count-spaces.n=-1.1.output view
@@ -0,0 +1,2 @@+? +$m=1
+ tests/count-spaces.n=-1.2.input view
@@ -0,0 +1,1 @@+  
+ tests/count-spaces.n=-1.2.output view
@@ -0,0 +1,2 @@+?  +$m=1
+ tests/count-spaces.n=0.0.input view
+ tests/count-spaces.n=0.0.output view
@@ -0,0 +1,1 @@+$m=1
+ tests/count-spaces.n=0.1.input view
@@ -0,0 +1,1 @@+ 
+ tests/count-spaces.n=0.1.output view
@@ -0,0 +1,2 @@+? +$m=1
+ tests/count-spaces.n=0.2.input view
@@ -0,0 +1,1 @@+  
+ tests/count-spaces.n=0.2.output view
@@ -0,0 +1,2 @@+?  +$m=2
+ tests/count-spaces.n=1.0.input view
+ tests/count-spaces.n=1.0.output view
@@ -0,0 +1,1 @@+$m=1
+ tests/count-spaces.n=1.1.input view
@@ -0,0 +1,1 @@+ 
+ tests/count-spaces.n=1.1.output view
@@ -0,0 +1,2 @@+? +$m=2
+ tests/count-spaces.n=1.2.input view
@@ -0,0 +1,1 @@+  
+ tests/count-spaces.n=1.2.output view
@@ -0,0 +1,2 @@+?  +$m=3
+ tests/debug-leak.input view
@@ -0,0 +1,1 @@+#
+ tests/debug-leak.output view
@@ -0,0 +1,2 @@+I#+?\x0a
+ tests/detect-collection-indentation.n=1.input view
@@ -0,0 +1,3 @@+   #+   +  -
+ tests/detect-collection-indentation.n=1.output view
@@ -0,0 +1,1 @@+$m=1
+ tests/detect-inline-indentation.input view
@@ -0,0 +1,1 @@+  
+ tests/detect-inline-indentation.output view
@@ -0,0 +1,1 @@+$m=2
+ tests/detect-scalar-indentation.n=2.input view
@@ -0,0 +1,5 @@+aa++ +  +   
+ tests/detect-scalar-indentation.n=2.output view
@@ -0,0 +1,1 @@+$m=1
+ tests/e-no-document.input view
+ tests/e-no-document.output view
+ tests/e-node.input view
+ tests/e-node.output view
@@ -0,0 +1,4 @@+N+S+s+n
+ tests/e-scalar.input view
+ tests/e-scalar.output view
@@ -0,0 +1,2 @@+S+s
+ tests/l+block-mapping.n=1.input view
@@ -0,0 +1,3 @@+  a: b+  ? c+  : d
+ tests/l+block-mapping.n=1.output view
@@ -0,0 +1,40 @@+M+i  +X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+b\x0a+x+i  +X+I?+w +N+S+Tc+s+n+b\x0a+i  +I:+w +N+S+Td+s+n+b\x0a+x+m+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/l+block-mapping.n=2.invalid.input view
@@ -0,0 +1,1 @@+  a: b
+ tests/l+block-mapping.n=2.invalid.output view
@@ -0,0 +1,2 @@+M+!$InputFile$: line 1: column 2: Unexpected 'a'
+ tests/l+block-sequence.n=1.input view
@@ -0,0 +1,5 @@+  - a+  -+   - b+  - - c+    - d
+ tests/l+block-sequence.n=1.output view
@@ -0,0 +1,54 @@+Q+i  +I-+w +N+S+Ta+s+n+b\x0a+i  +I-+N+b\x0a+Q+i   +I-+w +N+S+Tb+s+n+b\x0a+q+n+i  +I-+i +N+Q+I-+w +N+S+Tc+s+n+b\x0a+i    +I-+w +N+S+Td+s+n+b\x0a+q+n+q+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/l+block-sequence.n=2.invalid.input view
@@ -0,0 +1,1 @@+  - a
+ tests/l+block-sequence.n=2.invalid.output view
@@ -0,0 +1,2 @@+Q+!$InputFile$: line 1: column 2: Unexpected '-'
+ tests/l-block-map-explicit-value.n=2.input view
@@ -0,0 +1,1 @@+  : a
+ tests/l-block-map-explicit-value.n=2.invalid.input view
@@ -0,0 +1,1 @@+  ? a
+ tests/l-block-map-explicit-value.n=2.invalid.output view
@@ -0,0 +1,2 @@+i  +!$InputFile$: line 1: column 2: Unexpected '?'
+ tests/l-block-map-explicit-value.n=2.output view
@@ -0,0 +1,10 @@+i  +I:+w +N+S+Ta+s+n+b\x0a+!Commit to 'node' was made outside it
+ tests/l-chomped-empty.n=4.t=clip.input view
@@ -0,0 +1,4 @@++  +  #+
+ tests/l-chomped-empty.n=4.t=clip.output view
@@ -0,0 +1,9 @@+b\x0a+i  +b\x0a+i  +C+I#+c+b\x0a+b\x0a
+ tests/l-chomped-empty.n=4.t=keep.input view
@@ -0,0 +1,4 @@++  +  #+
+ tests/l-chomped-empty.n=4.t=keep.output view
@@ -0,0 +1,10 @@+L\x0a+i  +L\x0a+s+i  +C+I#+c+b\x0a+b\x0a
+ tests/l-chomped-empty.n=4.t=strip.input view
@@ -0,0 +1,4 @@++  +  #+
+ tests/l-chomped-empty.n=4.t=strip.output view
@@ -0,0 +1,9 @@+b\x0a+i  +b\x0a+i  +C+I#+c+b\x0a+b\x0a
+ tests/l-comment.empty.input view
@@ -0,0 +1,1 @@+
+ tests/l-comment.empty.output view
@@ -0,0 +1,1 @@+b\x0a
+ tests/l-comment.invalid.input view
@@ -0,0 +1,1 @@+  a#
+ tests/l-comment.invalid.output view
@@ -0,0 +1,2 @@+w  +!$InputFile$: line 1: column 2: Unexpected 'a'
+ tests/l-comment.spaces-comment.input view
@@ -0,0 +1,1 @@+ #
+ tests/l-comment.spaces-comment.output view
@@ -0,0 +1,5 @@+w +C+I#+c+b\x0a
+ tests/l-directive.invalid.input view
@@ -0,0 +1,1 @@+% name
+ tests/l-directive.invalid.output view
@@ -0,0 +1,3 @@+D+I%+!$InputFile$: line 1: column 1: Unexpected ' '
+ tests/l-directive.reserved.input view
@@ -0,0 +1,1 @@+%name value # text
+ tests/l-directive.reserved.output view
@@ -0,0 +1,11 @@+D+I%+tname+w +tvalue+w +t#+w +ttext+d+b\x0a
+ tests/l-directive.tag.input view
@@ -0,0 +1,2 @@+%TAG !name! !prefix+#
+ tests/l-directive.tag.invalid.input view
@@ -0,0 +1,1 @@+%TAG a
+ tests/l-directive.tag.invalid.output view
@@ -0,0 +1,6 @@+D+I%+tTAG+w +H+!$InputFile$: line 1: column 5: Unexpected 'a'
+ tests/l-directive.tag.output view
@@ -0,0 +1,20 @@+D+I%+tTAG+w +H+I!+tname+I!+h+w +G+I!+tprefix+g+d+b\x0a+C+I#+c+b\x0a
+ tests/l-directive.yaml.input view
@@ -0,0 +1,1 @@+%YAML 0.1
+ tests/l-directive.yaml.invalid.input view
@@ -0,0 +1,1 @@+%YAML a
+ tests/l-directive.yaml.invalid.output view
@@ -0,0 +1,5 @@+D+I%+tYAML+w +!$InputFile$: line 1: column 6: Unexpected 'a'
+ tests/l-directive.yaml.output view
@@ -0,0 +1,7 @@+D+I%+tYAML+w +t0.1+d+b\x0a
+ tests/l-document-prefix.bom-comment.input view
@@ -0,0 +1,1 @@+# comment
+ tests/l-document-prefix.bom-comment.output view
@@ -0,0 +1,6 @@+UTF8+C+I#+t comment+c+b\x0a
+ tests/l-document-prefix.bom.input view
@@ -0,0 +1,1 @@+
+ tests/l-document-prefix.bom.output view
@@ -0,0 +1,1 @@+UTF8
+ tests/l-document-prefix.comment.input view
@@ -0,0 +1,1 @@+# comment
+ tests/l-document-prefix.comment.output view
@@ -0,0 +1,5 @@+C+I#+t comment+c+b\x0a
+ tests/l-document-prefix.empty.input view
+ tests/l-document-prefix.empty.output view
+ tests/l-document-prefix.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/l-document-prefix.invalid.output view
@@ -0,0 +1,2 @@+UTF8+!$InputFile$: line 1: column 0: Expected end of input
+ tests/l-document-suffix.input view
@@ -0,0 +1,1 @@+... # end
+ tests/l-document-suffix.invalid.input view
@@ -0,0 +1,1 @@+....
+ tests/l-document-suffix.invalid.output view
@@ -0,0 +1,2 @@+k...+!$InputFile$: line 1: column 3: Expected start of line
+ tests/l-document-suffix.output view
@@ -0,0 +1,7 @@+k...+w +C+I#+t end+c+b\x0a
+ tests/l-documents.explicit.input view
@@ -0,0 +1,2 @@+--- a+--- b
+ tests/l-documents.explicit.output view
@@ -0,0 +1,24 @@+O+K---+O+w +N+S+Ta+s+n+b\x0a+o+o+O+K---+O+w +N+S+Tb+s+n+b\x0a+o+o
+ tests/l-documents.implicit.input view
@@ -0,0 +1,2 @@+a+--- b
+ tests/l-documents.implicit.output view
@@ -0,0 +1,20 @@+O+N+S+Ta+s+n+b\x0a+o+O+K---+O+w +N+S+Tb+s+n+b\x0a+o+o
+ tests/l-empty.n=4.s=literal.indent-lt.input view
@@ -0,0 +1,1 @@+   
+ tests/l-empty.n=4.s=literal.indent-lt.output view
@@ -0,0 +1,2 @@+i   +L\x0a
+ tests/l-empty.n=4.s=literal.indent-sp.invalid.input view
@@ -0,0 +1,1 @@+     
+ tests/l-empty.n=4.s=literal.indent-sp.invalid.output view
@@ -0,0 +1,2 @@+i    +!$InputFile$: line 1: column 4: Unexpected ' '
+ tests/l-empty.n=4.s=literal.indent.input view
@@ -0,0 +1,1 @@+    
+ tests/l-empty.n=4.s=literal.indent.output view
@@ -0,0 +1,2 @@+i    +L\x0a
+ tests/l-empty.n=4.s=plain.indent-lt.input view
@@ -0,0 +1,1 @@+   
+ tests/l-empty.n=4.s=plain.indent-lt.output view
@@ -0,0 +1,2 @@+i   +L\x0a
+ tests/l-empty.n=4.s=plain.indent-sp.input view
@@ -0,0 +1,1 @@+     
+ tests/l-empty.n=4.s=plain.indent-sp.output view
@@ -0,0 +1,3 @@+i    +w +L\x0a
+ tests/l-empty.n=4.s=plain.indent.input view
@@ -0,0 +1,1 @@+    
+ tests/l-empty.n=4.s=plain.indent.output view
@@ -0,0 +1,2 @@+i    +L\x0a
+ tests/l-explicit-document.invalid.input view
@@ -0,0 +1,2 @@+---+...
+ tests/l-explicit-document.invalid.output view
@@ -0,0 +1,10 @@+O+K---+N+S+s+n+b\x0a+o+!Commit to 'doc' was made outside it+!$InputFile$: line 2: column 0: Expected end of input
+ tests/l-explicit-document.literal.input view
@@ -0,0 +1,2 @@+--- |+a
+ tests/l-explicit-document.literal.output view
@@ -0,0 +1,15 @@+O+K---+O+N+w +S+I|+b\x0a+Ta+L\x0a+s+n+o+o+!Commit to 'doc' was made outside it
+ tests/l-explicit-document.plain.input view
@@ -0,0 +1,2 @@+%YAML 1.1+--- a
+ tests/l-explicit-document.plain.output view
@@ -0,0 +1,21 @@+O+D+I%+tYAML+w +t1.1+d+b\x0a+K---+O+w +N+S+Ta+s+n+b\x0a+o+o+!Commit to 'doc' was made outside it+!Commit to 'doc' was made outside it
+ tests/l-folded-content.n=4.t=strip.input view
@@ -0,0 +1,6 @@+     a+    b++     c++  #
+ tests/l-folded-content.n=4.t=strip.invalid.input view
@@ -0,0 +1,2 @@+  +  a
+ tests/l-folded-content.n=4.t=strip.invalid.output view
@@ -0,0 +1,3 @@+i  +b\x0a+!$InputFile$: line 2: column 0: Expected end of input
+ tests/l-folded-content.n=4.t=strip.output view
@@ -0,0 +1,17 @@+i    +? a+L\x0a+i    +?b+L\x0a+L\x0a+i    +? c+s+b\x0a+b\x0a+i  +C+I#+c+b\x0a
+ tests/l-following-document.empty.input view
+ tests/l-following-document.empty.output view
+ tests/l-following-document.explicit.input view
@@ -0,0 +1,2 @@+%YAML 1.1+--- a
+ tests/l-following-document.explicit.output view
@@ -0,0 +1,19 @@+O+D+I%+tYAML+w +t1.1+d+b\x0a+K---+O+w +N+S+Ta+s+n+b\x0a+o+o
+ tests/l-following-document.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/l-following-document.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Expected end of input
+ tests/l-forbidden.end-space.input view
@@ -0,0 +1,1 @@+... 
+ tests/l-forbidden.end-space.output view
@@ -0,0 +1,2 @@+k...+? 
+ tests/l-forbidden.invalid.input view
@@ -0,0 +1,1 @@+----
+ tests/l-forbidden.invalid.output view
@@ -0,0 +1,2 @@+K---+!$InputFile$: line 1: column 3: Expected end of input
+ tests/l-forbidden.start-lf.input view
@@ -0,0 +1,1 @@+---
+ tests/l-forbidden.start-lf.output view
@@ -0,0 +1,2 @@+K---+?\x0a
+ tests/l-forbidden.start.input view
@@ -0,0 +1,1 @@+---
+ tests/l-forbidden.start.output view
@@ -0,0 +1,1 @@+K---
+ tests/l-implicit-document.invalid.input view
@@ -0,0 +1,1 @@+---
+ tests/l-implicit-document.invalid.output view
@@ -0,0 +1,4 @@+O+N+S+!$InputFile$: line 1: column 0: Forbidden pattern detected
+ tests/l-implicit-document.literal.input view
@@ -0,0 +1,2 @@+|+a
+ tests/l-implicit-document.literal.output view
@@ -0,0 +1,11 @@+O+N+S+I|+b\x0a+Ta+L\x0a+s+n+o+!Commit to 'node' was made outside it
+ tests/l-implicit-document.plain.input view
@@ -0,0 +1,1 @@+a
+ tests/l-implicit-document.plain.output view
@@ -0,0 +1,9 @@+O+N+S+Ta+s+n+b\x0a+o+!Commit to 'node' was made outside it
+ tests/l-keep-empty.n=4.0.input view
@@ -0,0 +1,3 @@++  +
+ tests/l-keep-empty.n=4.0.output view
@@ -0,0 +1,5 @@+L\x0a+i  +L\x0a+L\x0a+s
+ tests/l-keep-empty.n=4.1.input view
@@ -0,0 +1,4 @@++  +  #+
+ tests/l-keep-empty.n=4.1.output view
@@ -0,0 +1,10 @@+L\x0a+i  +L\x0a+s+i  +C+I#+c+b\x0a+b\x0a
+ tests/l-leading-document.empty.input view
+ tests/l-leading-document.empty.output view
+ tests/l-leading-document.explicit.input view
@@ -0,0 +1,2 @@+%YAML 1.1+--- a
+ tests/l-leading-document.explicit.output view
@@ -0,0 +1,19 @@+O+D+I%+tYAML+w +t1.1+d+b\x0a+K---+O+w +N+S+Ta+s+n+b\x0a+o+o
+ tests/l-leading-document.implicit.input view
@@ -0,0 +1,1 @@+a
+ tests/l-leading-document.implicit.output view
@@ -0,0 +1,8 @@+O+N+S+Ta+s+n+b\x0a+o
+ tests/l-literal-content.n=4.t=strip.input view
@@ -0,0 +1,8 @@++    # a+    b+  +      # c++  +  # d
+ tests/l-literal-content.n=4.t=strip.invalid.input view
@@ -0,0 +1,1 @@+   a
+ tests/l-literal-content.n=4.t=strip.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Expected end of input
+ tests/l-literal-content.n=4.t=strip.output view
@@ -0,0 +1,22 @@+L\x0a+i    +?# a+L\x0a+i    +?b+L\x0a+i  +L\x0a+i    +?  # c+s+b\x0a+b\x0a+i  +b\x0a+i  +C+I#+t d+c+b\x0a
+ tests/l-nb-folded-lines.n=4.input view
@@ -0,0 +1,4 @@+    a+    b++    c
+ tests/l-nb-folded-lines.n=4.invalid.input view
@@ -0,0 +1,2 @@+    a+  b
+ tests/l-nb-folded-lines.n=4.invalid.output view
@@ -0,0 +1,4 @@+i    +?a+!Commit to 'fold' was made outside it+!$InputFile$: line 1: column 5: Expected end of input
+ tests/l-nb-folded-lines.n=4.output view
@@ -0,0 +1,11 @@+i    +?a+l\x0a+i    +?b+b\x0a+L\x0a+i    +?c+!Commit to 'fold' was made outside it+!Commit to 'fold' was made outside it
+ tests/l-nb-literal-chars.n=4.input view
@@ -0,0 +1,3 @@++  +      a  
+ tests/l-nb-literal-chars.n=4.invalid.input view
@@ -0,0 +1,1 @@+  a
+ tests/l-nb-literal-chars.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 2: Unexpected 'a'
+ tests/l-nb-literal-chars.n=4.output view
@@ -0,0 +1,5 @@+L\x0a+i  +L\x0a+i    +?  a  
+ tests/l-nb-spaced-lines.n=4.input view
@@ -0,0 +1,4 @@+     a+     b++     c
+ tests/l-nb-spaced-lines.n=4.invalid.input view
@@ -0,0 +1,1 @@+    a
+ tests/l-nb-spaced-lines.n=4.invalid.output view
@@ -0,0 +1,2 @@+i    +!$InputFile$: line 1: column 4: Unexpected 'a'
+ tests/l-nb-spaced-lines.n=4.output view
@@ -0,0 +1,11 @@+i    +? a+L\x0a+i    +? b+L\x0a+L\x0a+i    +? c+!Commit to 'fold' was made outside it+!Commit to 'fold' was made outside it
+ tests/l-nb-start-with-any.n=4.folded.input view
@@ -0,0 +1,4 @@+    a+     b++    c
+ tests/l-nb-start-with-any.n=4.folded.output view
@@ -0,0 +1,9 @@+i    +?a+L\x0a+i    +? b+L\x0a+L\x0a+i    +?c
+ tests/l-nb-start-with-any.n=4.invalid.input view
@@ -0,0 +1,2 @@+  +  a
+ tests/l-nb-start-with-any.n=4.invalid.output view
@@ -0,0 +1,3 @@+i  +L\x0a+!$InputFile$: line 2: column 2: Unexpected 'a'
+ tests/l-nb-start-with-any.n=4.spaced.input view
@@ -0,0 +1,4 @@+     a+    b++     c
+ tests/l-nb-start-with-any.n=4.spaced.output view
@@ -0,0 +1,9 @@+i    +? a+L\x0a+i    +?b+L\x0a+L\x0a+i    +? c
+ tests/l-nb-start-with-folded.n=4.input view
@@ -0,0 +1,5 @@+  +    a+     b++    c
+ tests/l-nb-start-with-folded.n=4.invalid.input view
@@ -0,0 +1,2 @@+  +  a
+ tests/l-nb-start-with-folded.n=4.invalid.output view
@@ -0,0 +1,3 @@+i  +L\x0a+!$InputFile$: line 2: column 2: Unexpected 'a'
+ tests/l-nb-start-with-folded.n=4.output view
@@ -0,0 +1,12 @@+i  +L\x0a+i    +?a+L\x0a+i    +? b+L\x0a+L\x0a+i    +?c+!Commit to 'fold' was made outside it
+ tests/l-nb-start-with-spaced.n=4.input view
@@ -0,0 +1,4 @@+     a+    b++     c
+ tests/l-nb-start-with-spaced.n=4.invalid.input view
@@ -0,0 +1,2 @@+  +    a
+ tests/l-nb-start-with-spaced.n=4.invalid.output view
@@ -0,0 +1,4 @@+i  +L\x0a+i    +!$InputFile$: line 2: column 4: Unexpected 'a'
+ tests/l-nb-start-with-spaced.n=4.output view
@@ -0,0 +1,10 @@+i    +? a+L\x0a+i    +?b+L\x0a+L\x0a+i    +? c+!Commit to 'fold' was made outside it
+ tests/l-strip-empty.n=4.0.input view
@@ -0,0 +1,3 @@++  +
+ tests/l-strip-empty.n=4.0.output view
@@ -0,0 +1,4 @@+b\x0a+i  +b\x0a+b\x0a
+ tests/l-strip-empty.n=4.1.input view
@@ -0,0 +1,4 @@++  +  #+
+ tests/l-strip-empty.n=4.1.output view
@@ -0,0 +1,9 @@+b\x0a+i  +b\x0a+i  +C+I#+c+b\x0a+b\x0a
+ tests/l-trail-comments.n=4.1.input view
@@ -0,0 +1,1 @@+  #
+ tests/l-trail-comments.n=4.1.output view
@@ -0,0 +1,5 @@+i  +C+I#+c+b\x0a
+ tests/l-trail-comments.n=4.2.input view
@@ -0,0 +1,2 @@+  #+#
+ tests/l-trail-comments.n=4.2.output view
@@ -0,0 +1,9 @@+i  +C+I#+c+b\x0a+C+I#+c+b\x0a
+ tests/l-trail-comments.n=4.3.input view
@@ -0,0 +1,3 @@+  #++#
+ tests/l-trail-comments.n=4.3.output view
@@ -0,0 +1,10 @@+i  +C+I#+c+b\x0a+b\x0a+C+I#+c+b\x0a
+ tests/l-trail-comments.n=4.invalid.input view
@@ -0,0 +1,1 @@+    #
+ tests/l-trail-comments.n=4.invalid.output view
@@ -0,0 +1,3 @@+i  +C+!$InputFile$: line 1: column 2: Unexpected ' '
+ tests/l-yaml-stream.empty.input view
@@ -0,0 +1,2 @@+...+...
+ tests/l-yaml-stream.empty.output view
@@ -0,0 +1,6 @@+Y+k...+b\x0a+k...+b\x0a+y
+ tests/l-yaml-stream.explicit.input view
@@ -0,0 +1,3 @@+--- a+...+--- b
+ tests/l-yaml-stream.explicit.output view
@@ -0,0 +1,28 @@+Y+O+K---+O+w +N+S+Ta+s+n+b\x0a+o+o+k...+b\x0a+O+K---+O+w +N+S+Tb+s+n+b\x0a+o+o+y
+ tests/l-yaml-stream.implicit.input view
@@ -0,0 +1,3 @@+a+...+b
+ tests/l-yaml-stream.implicit.output view
@@ -0,0 +1,20 @@+Y+O+N+S+Ta+s+n+b\x0a+o+k...+b\x0a+O+N+S+Tb+s+n+b\x0a+o+y
+ tests/nb-char.input view
@@ -0,0 +1,1 @@+a
+ tests/nb-char.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/nb-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '\x0a'
+ tests/nb-char.output view
@@ -0,0 +1,1 @@+?a
+ tests/nb-double-char.a.input view
@@ -0,0 +1,1 @@+a
+ tests/nb-double-char.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/nb-double-char.backslash.invalid.input view
@@ -0,0 +1,1 @@+\
+ tests/nb-double-char.backslash.invalid.output view
@@ -0,0 +1,3 @@+E+I\x5c+!$InputFile$: line 1: column 1: Unexpected end of input
+ tests/nb-double-char.double-quote.invalid.input view
@@ -0,0 +1,1 @@+"
+ tests/nb-double-char.double-quote.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '"'
+ tests/nb-double-char.escaped.input view
@@ -0,0 +1,1 @@+\\
+ tests/nb-double-char.escaped.output view
@@ -0,0 +1,4 @@+E+I\x5c+t\x5c+e
+ tests/nb-double-text.n=4.c=flow-key.input view
@@ -0,0 +1,1 @@+ a	
+ tests/nb-double-text.n=4.c=flow-key.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/nb-double-text.n=4.c=flow-key.invalid.output view
@@ -0,0 +1,2 @@+?a+!$InputFile$: line 1: column 1: Expected end of input
+ tests/nb-double-text.n=4.c=flow-key.output view
@@ -0,0 +1,1 @@+? a\x09
+ tests/nb-double-text.n=4.c=flow-out.input view
@@ -0,0 +1,2 @@+ a +    	a b	c 
+ tests/nb-double-text.n=4.c=flow-out.output view
@@ -0,0 +1,6 @@+? a+w +l\x0a+i    +w\x09+?a b\x09c 
+ tests/nb-plain-char.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+,
+ tests/nb-plain-char.c=flow-in.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ','
+ tests/nb-plain-char.c=flow-in.space.input view
@@ -0,0 +1,1 @@+ 
+ tests/nb-plain-char.c=flow-in.space.output view
@@ -0,0 +1,1 @@+? 
+ tests/nb-plain-char.c=flow-out.a.input view
@@ -0,0 +1,1 @@+a
+ tests/nb-plain-char.c=flow-out.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/nb-plain-char.c=flow-out.comma.input view
@@ -0,0 +1,1 @@+,
+ tests/nb-plain-char.c=flow-out.comma.output view
@@ -0,0 +1,1 @@+?,
+ tests/nb-single-char.escaped.input view
@@ -0,0 +1,1 @@+''
+ tests/nb-single-char.escaped.output view
@@ -0,0 +1,4 @@+E+I'+t'+e
+ tests/nb-single-char.invalid.input view
@@ -0,0 +1,1 @@+'
+ tests/nb-single-char.invalid.output view
@@ -0,0 +1,3 @@+E+I'+!$InputFile$: line 1: column 1: Unexpected end of input
+ tests/nb-single-text.n=4.c=flow-key.input view
@@ -0,0 +1,1 @@+ a	
+ tests/nb-single-text.n=4.c=flow-key.output view
@@ -0,0 +1,1 @@+? a\x09
+ tests/nb-single-text.n=4.c=flow-out.input view
@@ -0,0 +1,2 @@+ a +    	a b	c 
+ tests/nb-single-text.n=4.c=flow-out.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/nb-single-text.n=4.c=flow-out.invalid.output view
@@ -0,0 +1,2 @@+?a+!$InputFile$: line 1: column 1: Expected end of input
+ tests/nb-single-text.n=4.c=flow-out.output view
@@ -0,0 +1,6 @@+? a+w +l\x0a+i    +w\x09+?a b\x09c 
+ tests/ns-anchor-char.input view
@@ -0,0 +1,1 @@+@
+ tests/ns-anchor-char.invalid.input view
@@ -0,0 +1,1 @@+,
+ tests/ns-anchor-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ','
+ tests/ns-anchor-char.output view
@@ -0,0 +1,1 @@+?@
+ tests/ns-anchor-name.input view
@@ -0,0 +1,1 @@+!*&name
+ tests/ns-anchor-name.invalid.input view
@@ -0,0 +1,1 @@+,a
+ tests/ns-anchor-name.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ','
+ tests/ns-anchor-name.output view
@@ -0,0 +1,1 @@+t!*&name
+ tests/ns-ascii-letter.Z.input view
@@ -0,0 +1,1 @@+Z
+ tests/ns-ascii-letter.Z.output view
@@ -0,0 +1,1 @@+?Z
+ tests/ns-ascii-letter.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-ascii-letter.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-ascii-letter.invalid.input view
@@ -0,0 +1,1 @@+_
+ tests/ns-ascii-letter.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '_'
+ tests/ns-char.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-char.invalid.input view
@@ -0,0 +1,1 @@+ 
+ tests/ns-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-char.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-dec-digit.0.input view
@@ -0,0 +1,1 @@+0
+ tests/ns-dec-digit.0.output view
@@ -0,0 +1,1 @@+?0
+ tests/ns-dec-digit.1.input view
@@ -0,0 +1,1 @@+1
+ tests/ns-dec-digit.1.output view
@@ -0,0 +1,1 @@+?1
+ tests/ns-dec-digit.2.input view
@@ -0,0 +1,1 @@+2
+ tests/ns-dec-digit.2.output view
@@ -0,0 +1,1 @@+?2
+ tests/ns-dec-digit.3.input view
@@ -0,0 +1,1 @@+3
+ tests/ns-dec-digit.3.output view
@@ -0,0 +1,1 @@+?3
+ tests/ns-dec-digit.4.input view
@@ -0,0 +1,1 @@+4
+ tests/ns-dec-digit.4.output view
@@ -0,0 +1,1 @@+?4
+ tests/ns-dec-digit.5.input view
@@ -0,0 +1,1 @@+5
+ tests/ns-dec-digit.5.output view
@@ -0,0 +1,1 @@+?5
+ tests/ns-dec-digit.6.input view
@@ -0,0 +1,1 @@+6
+ tests/ns-dec-digit.6.output view
@@ -0,0 +1,1 @@+?6
+ tests/ns-dec-digit.7.input view
@@ -0,0 +1,1 @@+7
+ tests/ns-dec-digit.7.output view
@@ -0,0 +1,1 @@+?7
+ tests/ns-dec-digit.8.input view
@@ -0,0 +1,1 @@+8
+ tests/ns-dec-digit.8.output view
@@ -0,0 +1,1 @@+?8
+ tests/ns-dec-digit.9.input view
@@ -0,0 +1,1 @@+9
+ tests/ns-dec-digit.9.output view
@@ -0,0 +1,1 @@+?9
+ tests/ns-dec-digit.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-dec-digit.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/ns-directive-name.input view
@@ -0,0 +1,1 @@+name
+ tests/ns-directive-name.invalid.input view
@@ -0,0 +1,1 @@+ name
+ tests/ns-directive-name.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-directive-name.output view
@@ -0,0 +1,1 @@+tname
+ tests/ns-directive-parameter.input view
@@ -0,0 +1,1 @@+value
+ tests/ns-directive-parameter.invalid.input view
@@ -0,0 +1,1 @@+ value
+ tests/ns-directive-parameter.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-directive-parameter.output view
@@ -0,0 +1,1 @@+tvalue
+ tests/ns-double-char.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-double-char.invalid.input view
@@ -0,0 +1,1 @@+ 
+ tests/ns-double-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-double-char.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-esc-16-bit.input view
@@ -0,0 +1,1 @@+uFEDC
+ tests/ns-esc-16-bit.output view
@@ -0,0 +1,3 @@+Iu+tFEDC+!Commit to 'escaped' was made outside it
+ tests/ns-esc-32-bit.input view
@@ -0,0 +1,1 @@+U0010FEDC
+ tests/ns-esc-32-bit.output view
@@ -0,0 +1,3 @@+IU+t0010FEDC+!Commit to 'escaped' was made outside it
+ tests/ns-esc-8-bit.input view
@@ -0,0 +1,1 @@+xFF
+ tests/ns-esc-8-bit.output view
@@ -0,0 +1,3 @@+Ix+tFF+!Commit to 'escaped' was made outside it
+ tests/ns-esc-backslash.input view
@@ -0,0 +1,1 @@+\
+ tests/ns-esc-backslash.output view
@@ -0,0 +1,1 @@+t\x5c
+ tests/ns-esc-backspace.input view
@@ -0,0 +1,1 @@+b
+ tests/ns-esc-backspace.output view
@@ -0,0 +1,1 @@+tb
+ tests/ns-esc-bell.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-esc-bell.output view
@@ -0,0 +1,1 @@+ta
+ tests/ns-esc-carriage-return.input view
@@ -0,0 +1,1 @@+r
+ tests/ns-esc-carriage-return.output view
@@ -0,0 +1,1 @@+tr
+ tests/ns-esc-char.16-bit.input view
@@ -0,0 +1,1 @@+\uFEDC
+ tests/ns-esc-char.16-bit.output view
@@ -0,0 +1,6 @@+E+I\x5c+Iu+tFEDC+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.32-bit.input view
@@ -0,0 +1,1 @@+\U0010FEDC
+ tests/ns-esc-char.32-bit.output view
@@ -0,0 +1,6 @@+E+I\x5c+IU+t0010FEDC+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.8-bit.input view
@@ -0,0 +1,1 @@+\xFF
+ tests/ns-esc-char.8-bit.output view
@@ -0,0 +1,6 @@+E+I\x5c+Ix+tFF+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.backslash.input view
@@ -0,0 +1,1 @@+\\
+ tests/ns-esc-char.backslash.output view
@@ -0,0 +1,5 @@+E+I\x5c+t\x5c+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.bell.input view
@@ -0,0 +1,1 @@+\a
+ tests/ns-esc-char.bell.output view
@@ -0,0 +1,5 @@+E+I\x5c+ta+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.bs.input view
@@ -0,0 +1,1 @@+\b
+ tests/ns-esc-char.bs.output view
@@ -0,0 +1,5 @@+E+I\x5c+tb+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.cr.input view
@@ -0,0 +1,1 @@+\r
+ tests/ns-esc-char.cr.output view
@@ -0,0 +1,5 @@+E+I\x5c+tr+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.double-quote.input view
@@ -0,0 +1,1 @@+\"
+ tests/ns-esc-char.double-quote.output view
@@ -0,0 +1,5 @@+E+I\x5c+t"+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.esc.input view
@@ -0,0 +1,1 @@+\e
+ tests/ns-esc-char.esc.output view
@@ -0,0 +1,5 @@+E+I\x5c+te+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.ff.input view
@@ -0,0 +1,1 @@+\f
+ tests/ns-esc-char.ff.output view
@@ -0,0 +1,5 @@+E+I\x5c+tf+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.lf.input view
@@ -0,0 +1,1 @@+\n
+ tests/ns-esc-char.lf.output view
@@ -0,0 +1,5 @@+E+I\x5c+tn+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.ls.input view
@@ -0,0 +1,1 @@+\L
+ tests/ns-esc-char.ls.output view
@@ -0,0 +1,5 @@+E+I\x5c+tL+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.nbsp.input view
@@ -0,0 +1,1 @@+\_
+ tests/ns-esc-char.nbsp.output view
@@ -0,0 +1,5 @@+E+I\x5c+t_+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.nl.input view
@@ -0,0 +1,1 @@+\N
+ tests/ns-esc-char.nl.output view
@@ -0,0 +1,5 @@+E+I\x5c+tN+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.null.input view
@@ -0,0 +1,1 @@+\0
+ tests/ns-esc-char.null.output view
@@ -0,0 +1,5 @@+E+I\x5c+t0+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.ps.input view
@@ -0,0 +1,1 @@+\P
+ tests/ns-esc-char.ps.output view
@@ -0,0 +1,5 @@+E+I\x5c+tP+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.sp.input view
@@ -0,0 +1,1 @@+\ 
+ tests/ns-esc-char.sp.output view
@@ -0,0 +1,5 @@+E+I\x5c+t +e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.tab.input view
@@ -0,0 +1,1 @@+\t
+ tests/ns-esc-char.tab.output view
@@ -0,0 +1,5 @@+E+I\x5c+tt+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-char.vt.input view
@@ -0,0 +1,1 @@+\v
+ tests/ns-esc-char.vt.output view
@@ -0,0 +1,5 @@+E+I\x5c+tv+e+!Commit to 'escape' was made outside it
+ tests/ns-esc-double-quote.input view
@@ -0,0 +1,1 @@+"
+ tests/ns-esc-double-quote.output view
@@ -0,0 +1,1 @@+t"
+ tests/ns-esc-escape.input view
@@ -0,0 +1,1 @@+e
+ tests/ns-esc-escape.output view
@@ -0,0 +1,1 @@+te
+ tests/ns-esc-form-feed.input view
@@ -0,0 +1,1 @@+f
+ tests/ns-esc-form-feed.output view
@@ -0,0 +1,1 @@+tf
+ tests/ns-esc-horizontal-tab.t.input view
@@ -0,0 +1,1 @@+t
+ tests/ns-esc-horizontal-tab.t.output view
@@ -0,0 +1,1 @@+tt
+ tests/ns-esc-horizontal-tab.tab.input view
@@ -0,0 +1,1 @@+	
+ tests/ns-esc-horizontal-tab.tab.output view
@@ -0,0 +1,1 @@+t\x09
+ tests/ns-esc-line-feed.input view
@@ -0,0 +1,1 @@+n
+ tests/ns-esc-line-feed.output view
@@ -0,0 +1,1 @@+tn
+ tests/ns-esc-line-separator.input view
@@ -0,0 +1,1 @@+L
+ tests/ns-esc-line-separator.output view
@@ -0,0 +1,1 @@+tL
+ tests/ns-esc-next-line.input view
@@ -0,0 +1,1 @@+N
+ tests/ns-esc-next-line.output view
@@ -0,0 +1,1 @@+tN
+ tests/ns-esc-non-breaking-space.input view
@@ -0,0 +1,1 @@+_
+ tests/ns-esc-non-breaking-space.output view
@@ -0,0 +1,1 @@+t_
+ tests/ns-esc-null.input view
@@ -0,0 +1,1 @@+0
+ tests/ns-esc-null.output view
@@ -0,0 +1,1 @@+t0
+ tests/ns-esc-paragraph-separator.input view
@@ -0,0 +1,1 @@+P
+ tests/ns-esc-paragraph-separator.output view
@@ -0,0 +1,1 @@+tP
+ tests/ns-esc-space.input view
@@ -0,0 +1,1 @@+ 
+ tests/ns-esc-space.output view
@@ -0,0 +1,1 @@+t 
+ tests/ns-esc-vertical-tab.input view
@@ -0,0 +1,1 @@+v
+ tests/ns-esc-vertical-tab.output view
@@ -0,0 +1,1 @@+tv
+ tests/ns-flow-content.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+|
+ tests/ns-flow-content.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,2 @@+S+!$InputFile$: line 1: column 0: Unexpected '|'
+ tests/ns-flow-content.n=4.c=flow-in.json.input view
@@ -0,0 +1,1 @@+"a"
+ tests/ns-flow-content.n=4.c=flow-in.json.output view
@@ -0,0 +1,6 @@+S+I"+Ta+I"+s+!Commit to 'node' was made outside it
+ tests/ns-flow-content.n=4.c=flow-in.yaml.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-content.n=4.c=flow-in.yaml.output view
@@ -0,0 +1,4 @@+S+Ta+s+!Commit to 'node' was made outside it
+ tests/ns-flow-map-entry.n=4.c=flow-in.explicit.input view
@@ -0,0 +1,1 @@+? a: b
+ tests/ns-flow-map-entry.n=4.c=flow-in.explicit.output view
@@ -0,0 +1,17 @@+X+I?+w +N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+!Commit to 'node' was made outside it
+ tests/ns-flow-map-entry.n=4.c=flow-in.implicit.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-map-entry.n=4.c=flow-in.implicit.output view
@@ -0,0 +1,11 @@+X+N+S+Ta+s+n+N+S+s+n+x
+ tests/ns-flow-map-entry.n=4.c=flow-in.invalid.input view
+ tests/ns-flow-map-entry.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,6 @@+X+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected end of input
+ tests/ns-flow-map-implicit-empty.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+: a
+ tests/ns-flow-map-implicit-empty.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+:"a"
+ tests/ns-flow-map-implicit-empty.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,11 @@+N+S+s+n+I:+N+S+s+n+!Commit to 'pair' was made outside it+!$InputFile$: line 1: column 1: Expected end of input
+ tests/ns-flow-map-implicit-empty.n=4.c=flow-in.output view
@@ -0,0 +1,13 @@+N+S+s+n+I:+w +N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.empty.input view
@@ -0,0 +1,1 @@+: a
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.empty.output view
@@ -0,0 +1,13 @@+N+S+s+n+I:+w +N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+? a: b
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,5 @@+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected '?'
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.json.input view
@@ -0,0 +1,1 @@+"a":b
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.json.output view
@@ -0,0 +1,15 @@+N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.yaml.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-flow-map-implicit-entry.n=4.c=flow-in.yaml.output view
@@ -0,0 +1,14 @@+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.compact.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.compact.output view
@@ -0,0 +1,14 @@+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.empty.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.empty.output view
@@ -0,0 +1,9 @@+N+S+Ta+s+n+N+S+s+n
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a:b
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,9 @@+N+S+Ta:b+s+n+N+S+s+n
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.spaced.input view
@@ -0,0 +1,1 @@+a : b
+ tests/ns-flow-map-implicit-yaml.n=4.c=flow-in.spaced.output view
@@ -0,0 +1,15 @@+N+S+Ta+s+n+w +I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.empty.input view
@@ -0,0 +1,1 @@+: b
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.empty.output view
@@ -0,0 +1,13 @@+N+S+s+n+I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,5 @@+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.json.input view
@@ -0,0 +1,1 @@+"a":b
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.json.output view
@@ -0,0 +1,15 @@+N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.yaml.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-flow-map-single-entry.n=4.c=flow-in.yaml.output view
@@ -0,0 +1,14 @@+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-single-pair.n=4.c=flow-in.explicit.input view
@@ -0,0 +1,1 @@+? a: b
+ tests/ns-flow-map-single-pair.n=4.c=flow-in.explicit.output view
@@ -0,0 +1,20 @@+M+X+I?+w +N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+m+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-single-pair.n=4.c=flow-in.implicit.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-flow-map-single-pair.n=4.c=flow-in.implicit.output view
@@ -0,0 +1,18 @@+M+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+m+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-map-single-pair.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-map-single-pair.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,7 @@+M+X+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/ns-flow-map-single-yaml.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-flow-map-single-yaml.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a:b
+ tests/ns-flow-map-single-yaml.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,6 @@+N+S+Ta:b+s+n+!$InputFile$: line 1: column 3: Unexpected end of input
+ tests/ns-flow-map-single-yaml.n=4.c=flow-in.output view
@@ -0,0 +1,14 @@+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-flow-node.n=4.c=flow-in.alias.input view
@@ -0,0 +1,1 @@+*a
+ tests/ns-flow-node.n=4.c=flow-in.alias.output view
@@ -0,0 +1,7 @@+N+R+I*+ta+r+n+!Commit to 'node' was made outside it
+ tests/ns-flow-node.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+|
+ tests/ns-flow-node.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected '|'
+ tests/ns-flow-node.n=4.c=flow-in.tag.input view
@@ -0,0 +1,1 @@+!t
+ tests/ns-flow-node.n=4.c=flow-in.tag.output view
@@ -0,0 +1,12 @@+N+P+G+H+I!+h+tt+g+p+S+s+n
+ tests/ns-flow-node.n=4.c=flow-in.tagged.input view
@@ -0,0 +1,1 @@+!t "a"
+ tests/ns-flow-node.n=4.c=flow-in.tagged.output view
@@ -0,0 +1,17 @@+N+P+G+H+I!+h+tt+g+p+w +S+I"+Ta+I"+s+n+!Commit to 'node' was made outside it
+ tests/ns-flow-node.n=4.c=flow-in.untagged.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-node.n=4.c=flow-in.untagged.output view
@@ -0,0 +1,6 @@+N+S+Ta+s+n+!Commit to 'node' was made outside it
+ tests/ns-flow-seq-entry.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+#a
+ tests/ns-flow-seq-entry.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/ns-flow-seq-entry.n=4.c=flow-in.node.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-seq-entry.n=4.c=flow-in.node.output view
@@ -0,0 +1,5 @@+N+S+Ta+s+n
+ tests/ns-flow-seq-entry.n=4.c=flow-in.pair.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-flow-seq-entry.n=4.c=flow-in.pair.output view
@@ -0,0 +1,17 @@+M+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+m+!Commit to 'node' was made outside it
+ tests/ns-flow-yaml-content.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-yaml-content.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+|
+ tests/ns-flow-yaml-content.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,2 @@+S+!$InputFile$: line 1: column 0: Unexpected '|'
+ tests/ns-flow-yaml-content.n=4.c=flow-in.output view
@@ -0,0 +1,4 @@+S+Ta+s+!Commit to 'node' was made outside it
+ tests/ns-flow-yaml-node.n=4.c=flow-in.alias.input view
@@ -0,0 +1,1 @@+*a
+ tests/ns-flow-yaml-node.n=4.c=flow-in.alias.output view
@@ -0,0 +1,7 @@+N+R+I*+ta+r+n+!Commit to 'node' was made outside it
+ tests/ns-flow-yaml-node.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+'a'
+ tests/ns-flow-yaml-node.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected '''
+ tests/ns-flow-yaml-node.n=4.c=flow-in.tag.input view
@@ -0,0 +1,1 @@+!t
+ tests/ns-flow-yaml-node.n=4.c=flow-in.tag.output view
@@ -0,0 +1,12 @@+N+P+G+H+I!+h+tt+g+p+S+s+n
+ tests/ns-flow-yaml-node.n=4.c=flow-in.tagged.input view
@@ -0,0 +1,1 @@+!t a
+ tests/ns-flow-yaml-node.n=4.c=flow-in.tagged.output view
@@ -0,0 +1,15 @@+N+P+G+H+I!+h+tt+g+p+w +S+Ta+s+n+!Commit to 'node' was made outside it
+ tests/ns-flow-yaml-node.n=4.c=flow-in.untagged.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-flow-yaml-node.n=4.c=flow-in.untagged.output view
@@ -0,0 +1,6 @@+N+S+Ta+s+n+!Commit to 'node' was made outside it
+ tests/ns-global-tag-prefix.input view
@@ -0,0 +1,1 @@+prefix
+ tests/ns-global-tag-prefix.invalid.input view
@@ -0,0 +1,1 @@+a^b
+ tests/ns-global-tag-prefix.invalid.output view
@@ -0,0 +1,2 @@+ta+!$InputFile$: line 1: column 1: Expected end of input
+ tests/ns-global-tag-prefix.output view
@@ -0,0 +1,1 @@+tprefix
+ tests/ns-hex-digit.6.input view
@@ -0,0 +1,1 @@+6
+ tests/ns-hex-digit.6.output view
@@ -0,0 +1,1 @@+?6
+ tests/ns-hex-digit.B.input view
@@ -0,0 +1,1 @@+B
+ tests/ns-hex-digit.B.output view
@@ -0,0 +1,1 @@+?B
+ tests/ns-hex-digit.D.input view
@@ -0,0 +1,1 @@+D
+ tests/ns-hex-digit.D.output view
@@ -0,0 +1,1 @@+?D
+ tests/ns-hex-digit.F.input view
@@ -0,0 +1,1 @@+F
+ tests/ns-hex-digit.F.output view
@@ -0,0 +1,1 @@+?F
+ tests/ns-hex-digit.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-hex-digit.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-hex-digit.c.input view
@@ -0,0 +1,1 @@+c
+ tests/ns-hex-digit.c.output view
@@ -0,0 +1,1 @@+?c
+ tests/ns-hex-digit.e.input view
@@ -0,0 +1,1 @@+e
+ tests/ns-hex-digit.e.output view
@@ -0,0 +1,1 @@+?e
+ tests/ns-hex-digit.invalid.input view
@@ -0,0 +1,1 @@+g
+ tests/ns-hex-digit.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'g'
+ tests/ns-l-block-map-entry.n=2.explicit.input view
@@ -0,0 +1,3 @@+? a+  : b+
+ tests/ns-l-block-map-entry.n=2.explicit.output view
@@ -0,0 +1,21 @@+X+I?+w +N+S+Ta+s+n+b\x0a+i  +I:+w +N+S+Tb+s+n+b\x0a+b\x0a+x+!Commit to 'node' was made outside it
+ tests/ns-l-block-map-entry.n=2.implicit.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-l-block-map-entry.n=2.implicit.output view
@@ -0,0 +1,16 @@+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+b\x0a+x+!Commit to 'node' was made outside it
+ tests/ns-l-block-map-entry.n=2.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-l-block-map-entry.n=2.invalid.output view
@@ -0,0 +1,6 @@+X+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/ns-l-block-map-implicit-entry.n=2.empty.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-l-block-map-implicit-entry.n=2.empty.output view
@@ -0,0 +1,11 @@+N+S+s+n+I:+N+S+s+n+b\x0a+!Commit to 'node' was made outside it
+ tests/ns-l-block-map-implicit-entry.n=2.invalid.input view
@@ -0,0 +1,1 @@+? a: b
+ tests/ns-l-block-map-implicit-entry.n=2.invalid.output view
@@ -0,0 +1,5 @@+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected '?'
+ tests/ns-l-block-map-implicit-entry.n=2.non-empty.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-l-block-map-implicit-entry.n=2.non-empty.output view
@@ -0,0 +1,14 @@+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+b\x0a+!Commit to 'node' was made outside it
+ tests/ns-l-in-line-mapping.n=2.input view
@@ -0,0 +1,2 @@+a: b+  c: d
+ tests/ns-l-in-line-mapping.n=2.invalid.input view
@@ -0,0 +1,1 @@+ a: b
+ tests/ns-l-in-line-mapping.n=2.invalid.output view
@@ -0,0 +1,8 @@+N+M+X+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-l-in-line-mapping.n=2.output view
@@ -0,0 +1,37 @@+N+M+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+b\x0a+x+i  +X+N+S+Tc+s+n+I:+w +N+S+Td+s+n+b\x0a+x+m+n+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-l-in-line-sequence.n=3.input view
@@ -0,0 +1,2 @@+- a+   - b
+ tests/ns-l-in-line-sequence.n=3.invalid.input view
@@ -0,0 +1,2 @@+- a+  - b
+ tests/ns-l-in-line-sequence.n=3.invalid.output view
@@ -0,0 +1,15 @@+N+Q+I-+w +N+S+Ta+s+n+b\x0a+q+n+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it+!$InputFile$: line 2: column 0: Expected end of input
+ tests/ns-l-in-line-sequence.n=3.output view
@@ -0,0 +1,24 @@+N+Q+I-+w +N+S+Ta+s+n+b\x0a+i   +I-+w +N+S+Tb+s+n+b\x0a+q+n+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it+!Commit to 'node' was made outside it
+ tests/ns-plain-char.c=flow-in.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-plain-char.c=flow-in.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-plain-char.c=flow-in.ac.input view
@@ -0,0 +1,1 @@+a#
+ tests/ns-plain-char.c=flow-in.ac.output view
@@ -0,0 +1,1 @@+?a#
+ tests/ns-plain-char.c=flow-in.acc.input view
@@ -0,0 +1,1 @@+a##
+ tests/ns-plain-char.c=flow-in.acc.output view
@@ -0,0 +1,1 @@+?a##
+ tests/ns-plain-char.c=flow-in.c.input view
@@ -0,0 +1,1 @@+#
+ tests/ns-plain-char.c=flow-in.c.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/ns-plain-char.c=flow-in.m.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-plain-char.c=flow-in.m.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ':'
+ tests/ns-plain-char.c=flow-in.ma.input view
@@ -0,0 +1,1 @@+:a
+ tests/ns-plain-char.c=flow-in.ma.output view
@@ -0,0 +1,1 @@+?:a
+ tests/ns-plain-char.c=flow-in.mc.input view
@@ -0,0 +1,1 @@+:#
+ tests/ns-plain-char.c=flow-in.mc.output view
@@ -0,0 +1,1 @@+?:#
+ tests/ns-plain-char.c=flow-in.mmcc.input view
@@ -0,0 +1,1 @@+::##
+ tests/ns-plain-char.c=flow-in.mmcc.output view
@@ -0,0 +1,1 @@+?::##
+ tests/ns-plain-char.c=flow-in.mms.input view
@@ -0,0 +1,1 @@+::s
+ tests/ns-plain-char.c=flow-in.mms.output view
@@ -0,0 +1,1 @@+?::s
+ tests/ns-plain-char.c=flow-in.s.input view
@@ -0,0 +1,1 @@+ 
+ tests/ns-plain-char.c=flow-in.s.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-plain-first.c=flow-in.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-plain-first.c=flow-in.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-plain-first.c=flow-in.c.input view
@@ -0,0 +1,1 @@+#
+ tests/ns-plain-first.c=flow-in.c.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/ns-plain-first.c=flow-in.d.input view
@@ -0,0 +1,1 @@+-
+ tests/ns-plain-first.c=flow-in.d.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '-'
+ tests/ns-plain-first.c=flow-in.da.input view
@@ -0,0 +1,1 @@+-a
+ tests/ns-plain-first.c=flow-in.da.output view
@@ -0,0 +1,1 @@+?-a
+ tests/ns-plain-first.c=flow-in.dc.input view
@@ -0,0 +1,1 @@+-#
+ tests/ns-plain-first.c=flow-in.dc.output view
@@ -0,0 +1,1 @@+?-#
+ tests/ns-plain-first.c=flow-in.ds.input view
@@ -0,0 +1,1 @@+- 
+ tests/ns-plain-first.c=flow-in.ds.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '-'
+ tests/ns-plain-first.c=flow-in.i.input view
@@ -0,0 +1,1 @@+%
+ tests/ns-plain-first.c=flow-in.i.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '%'
+ tests/ns-plain-first.c=flow-in.ia.input view
@@ -0,0 +1,1 @@+%a
+ tests/ns-plain-first.c=flow-in.ia.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '%'
+ tests/ns-plain-first.c=flow-in.k.input view
@@ -0,0 +1,1 @@+?
+ tests/ns-plain-first.c=flow-in.k.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '?'
+ tests/ns-plain-first.c=flow-in.ka.input view
@@ -0,0 +1,1 @@+?a
+ tests/ns-plain-first.c=flow-in.ka.output view
@@ -0,0 +1,1 @@+??a
+ tests/ns-plain-first.c=flow-in.kc.input view
@@ -0,0 +1,1 @@+?#
+ tests/ns-plain-first.c=flow-in.kc.output view
@@ -0,0 +1,1 @@+??#
+ tests/ns-plain-first.c=flow-in.ks.input view
@@ -0,0 +1,1 @@+? 
+ tests/ns-plain-first.c=flow-in.ks.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '?'
+ tests/ns-plain-first.c=flow-in.m.input view
@@ -0,0 +1,1 @@+{
+ tests/ns-plain-first.c=flow-in.m.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '{'
+ tests/ns-plain-first.c=flow-in.s.input view
@@ -0,0 +1,1 @@+ 
+ tests/ns-plain-first.c=flow-in.s.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-plain-first.c=flow-in.v.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-plain-first.c=flow-in.v.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ':'
+ tests/ns-plain-first.c=flow-in.va.input view
@@ -0,0 +1,1 @@+:a
+ tests/ns-plain-first.c=flow-in.va.output view
@@ -0,0 +1,1 @@+?:a
+ tests/ns-plain-first.c=flow-in.vc.input view
@@ -0,0 +1,1 @@+:#
+ tests/ns-plain-first.c=flow-in.vc.output view
@@ -0,0 +1,1 @@+?:#
+ tests/ns-plain-first.c=flow-in.vs.input view
@@ -0,0 +1,1 @@+: 
+ tests/ns-plain-first.c=flow-in.vs.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ':'
+ tests/ns-plain-first.c=flow-out.m.input view
@@ -0,0 +1,1 @@+{
+ tests/ns-plain-first.c=flow-out.m.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '{'
+ tests/ns-plain-multi.n=4.c=flow-in.input view
@@ -0,0 +1,4 @@+a	++          b  +      c
+ tests/ns-plain-multi.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,2 @@+a+    12,345
+ tests/ns-plain-multi.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,6 @@+?a+l\x0a+i    +?12+!Commit to 'node' was made outside it+!$InputFile$: line 2: column 6: Expected end of input
+ tests/ns-plain-multi.n=4.c=flow-in.output view
@@ -0,0 +1,13 @@+?a+w\x09+b\x0a+L\x0a+i    +w      +?b+w  +l\x0a+i    +w  +?c+!Commit to 'node' was made outside it
+ tests/ns-plain-safe-in.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-plain-safe-in.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-plain-safe-in.c.input view
@@ -0,0 +1,1 @@+#
+ tests/ns-plain-safe-in.c.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/ns-plain-safe-in.mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/ns-plain-safe-in.mapping-start.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '{'
+ tests/ns-plain-safe-in.v.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-plain-safe-in.v.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ':'
+ tests/ns-plain-safe-out.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-plain-safe-out.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-plain-safe-out.c.input view
@@ -0,0 +1,1 @@+#
+ tests/ns-plain-safe-out.c.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/ns-plain-safe-out.mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/ns-plain-safe-out.mapping-start.output view
@@ -0,0 +1,1 @@+?{
+ tests/ns-plain-safe-out.v.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-plain-safe-out.v.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ':'
+ tests/ns-plain-safe.c=flow-in.mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/ns-plain-safe.c=flow-in.mapping-start.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '{'
+ tests/ns-plain-safe.c=flow-in.v.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-plain-safe.c=flow-in.v.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ':'
+ tests/ns-plain-safe.c=flow-out.a.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-plain-safe.c=flow-out.a.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-plain-safe.c=flow-out.c.input view
@@ -0,0 +1,1 @@+#
+ tests/ns-plain-safe.c=flow-out.c.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '#'
+ tests/ns-plain-safe.c=flow-out.mapping-start.input view
@@ -0,0 +1,1 @@+{
+ tests/ns-plain-safe.c=flow-out.mapping-start.output view
@@ -0,0 +1,1 @@+?{
+ tests/ns-plain-single.c=flow-key.invalid.input view
@@ -0,0 +1,1 @@+12,345
+ tests/ns-plain-single.c=flow-key.invalid.output view
@@ -0,0 +1,3 @@+?12+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 2: Expected end of input
+ tests/ns-plain-single.c=flow-out.input view
@@ -0,0 +1,1 @@+a 	" :# {} b
+ tests/ns-plain-single.c=flow-out.output view
@@ -0,0 +1,2 @@+?a \x09" :# {} b+!Commit to 'node' was made outside it
+ tests/ns-plain.n=4.c=flow-in.input view
@@ -0,0 +1,4 @@+a	++          b  +      c
+ tests/ns-plain.n=4.c=flow-in.output view
@@ -0,0 +1,15 @@+S+Ta+w\x09+b\x0a+L\x0a+i    +w      +Tb+w  +l\x0a+i    +w  +Tc+s+!Commit to 'node' was made outside it
+ tests/ns-plain.n=4.c=flow-key.input view
@@ -0,0 +1,1 @@+a 	" :# () b
+ tests/ns-plain.n=4.c=flow-key.invalid.input view
@@ -0,0 +1,1 @@+12,345
+ tests/ns-plain.n=4.c=flow-key.invalid.output view
@@ -0,0 +1,5 @@+S+T12+s+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 2: Expected end of input
+ tests/ns-plain.n=4.c=flow-key.output view
@@ -0,0 +1,4 @@+S+Ta \x09" :# () b+s+!Commit to 'node' was made outside it
+ tests/ns-reserved-directive.input view
@@ -0,0 +1,1 @@+name value1 value2
+ tests/ns-reserved-directive.invalid.input view
@@ -0,0 +1,1 @@+ name value
+ tests/ns-reserved-directive.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-reserved-directive.output view
@@ -0,0 +1,5 @@+tname+w +tvalue1+w +tvalue2
+ tests/ns-s-block-map-implicit-key.invalid.input view
@@ -0,0 +1,1 @@+? a
+ tests/ns-s-block-map-implicit-key.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected '?'
+ tests/ns-s-block-map-implicit-key.json.input view
@@ -0,0 +1,1 @@+"a" 
+ tests/ns-s-block-map-implicit-key.json.output view
@@ -0,0 +1,8 @@+N+S+I"+Ta+I"+s+n+w 
+ tests/ns-s-block-map-implicit-key.yaml.input view
@@ -0,0 +1,1 @@+a 
+ tests/ns-s-block-map-implicit-key.yaml.output view
@@ -0,0 +1,6 @@+N+S+Ta+s+n+w 
+ tests/ns-s-flow-map-entries.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a,,b
+ tests/ns-s-flow-map-entries.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,13 @@+X+N+S+Ta+s+n+N+S+s+n+x+I,+!$InputFile$: line 1: column 2: Expected end of input
+ tests/ns-s-flow-map-entries.n=4.c=flow-in.multi.input view
@@ -0,0 +1,1 @@+a: b, ? c, d, 
+ tests/ns-s-flow-map-entries.n=4.c=flow-in.multi.output view
@@ -0,0 +1,45 @@+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+I,+w +X+I?+w +N+S+Tc+s+n+N+S+s+n+x+I,+w +X+N+S+Td+s+n+N+S+s+n+x+I,+w +!Commit to 'node' was made outside it
+ tests/ns-s-flow-map-entries.n=4.c=flow-in.single.input view
@@ -0,0 +1,1 @@+a: b
+ tests/ns-s-flow-map-entries.n=4.c=flow-in.single.output view
@@ -0,0 +1,15 @@+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+x+!Commit to 'node' was made outside it
+ tests/ns-s-flow-seq-entries.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a,,b
+ tests/ns-s-flow-seq-entries.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,7 @@+N+S+Ta+s+n+I,+!$InputFile$: line 1: column 2: Expected end of input
+ tests/ns-s-flow-seq-entries.n=4.c=flow-in.multi.input view
@@ -0,0 +1,1 @@+a , c: d 
+ tests/ns-s-flow-seq-entries.n=4.c=flow-in.multi.output view
@@ -0,0 +1,26 @@+N+S+Ta+s+n+w +I,+w +M+X+N+S+Tc+s+n+I:+w +N+S+Td+s+n+x+m+w +!Commit to 'node' was made outside it
+ tests/ns-s-flow-seq-entries.n=4.c=flow-in.single.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-s-flow-seq-entries.n=4.c=flow-in.single.output view
@@ -0,0 +1,5 @@+N+S+Ta+s+n
+ tests/ns-s-simple-yaml-key.just.input view
@@ -0,0 +1,1 @@+123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 
+ tests/ns-s-simple-yaml-key.just.output view
@@ -0,0 +1,6 @@+N+S+T123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef+s+n+w 
+ tests/ns-s-simple-yaml-key.long.input view
@@ -0,0 +1,1 @@+123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef X
+ tests/ns-s-simple-yaml-key.long.output view
@@ -0,0 +1,7 @@+N+S+T123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef 123456789abcdef+s+n+w +!$InputFile$: line 1: column 1024: Expected end of input
+ tests/ns-s-simple-yaml-key.short.input view
@@ -0,0 +1,1 @@+a 
+ tests/ns-s-simple-yaml-key.short.output view
@@ -0,0 +1,6 @@+N+S+Ta+s+n+w 
+ tests/ns-single-char.input view
@@ -0,0 +1,1 @@+a
+ tests/ns-single-char.invalid.input view
@@ -0,0 +1,1 @@+ 
+ tests/ns-single-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/ns-single-char.output view
@@ -0,0 +1,1 @@+?a
+ tests/ns-tag-char.input view
@@ -0,0 +1,1 @@+@
+ tests/ns-tag-char.invalid.input view
@@ -0,0 +1,1 @@+!
+ tests/ns-tag-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '!'
+ tests/ns-tag-char.output view
@@ -0,0 +1,1 @@+?@
+ tests/ns-tag-directive.input view
@@ -0,0 +1,1 @@+TAG !name! !prefix
+ tests/ns-tag-directive.invalid.input view
@@ -0,0 +1,1 @@+TAG a
+ tests/ns-tag-directive.invalid.output view
@@ -0,0 +1,5 @@+tTAG+w +H+!Commit to 'directive' was made outside it+!$InputFile$: line 1: column 4: Unexpected 'a'
+ tests/ns-tag-directive.output view
@@ -0,0 +1,13 @@+tTAG+w +H+I!+tname+I!+h+w +G+I!+tprefix+g+!Commit to 'directive' was made outside it
+ tests/ns-tag-prefix.global.input view
@@ -0,0 +1,1 @@+prefix
+ tests/ns-tag-prefix.global.output view
@@ -0,0 +1,3 @@+G+tprefix+g
+ tests/ns-tag-prefix.invalid.input view
@@ -0,0 +1,1 @@+!a^b
+ tests/ns-tag-prefix.invalid.output view
@@ -0,0 +1,5 @@+G+I!+ta+g+!$InputFile$: line 1: column 2: Expected end of input
+ tests/ns-tag-prefix.local.input view
@@ -0,0 +1,1 @@+!prefix
+ tests/ns-tag-prefix.local.output view
@@ -0,0 +1,4 @@+G+I!+tprefix+g
+ tests/ns-uri-char.6.input view
@@ -0,0 +1,1 @@+6
+ tests/ns-uri-char.6.output view
@@ -0,0 +1,1 @@+?6
+ tests/ns-uri-char.ampersand.input view
@@ -0,0 +1,1 @@+&
+ tests/ns-uri-char.ampersand.output view
@@ -0,0 +1,1 @@+?&
+ tests/ns-uri-char.asterisk.input view
@@ -0,0 +1,1 @@+*
+ tests/ns-uri-char.asterisk.output view
@@ -0,0 +1,1 @@+?*
+ tests/ns-uri-char.at.input view
@@ -0,0 +1,1 @@+@
+ tests/ns-uri-char.at.output view
@@ -0,0 +1,1 @@+?@
+ tests/ns-uri-char.colon.input view
@@ -0,0 +1,1 @@+:
+ tests/ns-uri-char.colon.output view
@@ -0,0 +1,1 @@+?:
+ tests/ns-uri-char.comma.input view
@@ -0,0 +1,1 @@+,
+ tests/ns-uri-char.comma.output view
@@ -0,0 +1,1 @@+?,
+ tests/ns-uri-char.dollar.input view
@@ -0,0 +1,1 @@+$
+ tests/ns-uri-char.dollar.output view
@@ -0,0 +1,1 @@+?$
+ tests/ns-uri-char.equal.input view
@@ -0,0 +1,1 @@+=
+ tests/ns-uri-char.equal.output view
@@ -0,0 +1,1 @@+?=
+ tests/ns-uri-char.escaped.input view
@@ -0,0 +1,1 @@+%0a
+ tests/ns-uri-char.escaped.output view
@@ -0,0 +1,1 @@+?%0a
+ tests/ns-uri-char.exclamation.input view
@@ -0,0 +1,1 @@+!
+ tests/ns-uri-char.exclamation.output view
@@ -0,0 +1,1 @@+?!
+ tests/ns-uri-char.hyphen.input view
@@ -0,0 +1,1 @@+-
+ tests/ns-uri-char.hyphen.output view
@@ -0,0 +1,1 @@+?-
+ tests/ns-uri-char.invalid.input view
@@ -0,0 +1,1 @@+%aq
+ tests/ns-uri-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 2: Unexpected 'q'
+ tests/ns-uri-char.left-round.input view
@@ -0,0 +1,1 @@+(
+ tests/ns-uri-char.left-round.output view
@@ -0,0 +1,1 @@+?(
+ tests/ns-uri-char.left-square.input view
@@ -0,0 +1,1 @@+[
+ tests/ns-uri-char.left-square.output view
@@ -0,0 +1,1 @@+?[
+ tests/ns-uri-char.n.input view
@@ -0,0 +1,1 @@+n
+ tests/ns-uri-char.n.output view
@@ -0,0 +1,1 @@+?n
+ tests/ns-uri-char.period.input view
@@ -0,0 +1,1 @@+.
+ tests/ns-uri-char.period.output view
@@ -0,0 +1,1 @@+?.
+ tests/ns-uri-char.plus.input view
@@ -0,0 +1,1 @@++
+ tests/ns-uri-char.plus.output view
@@ -0,0 +1,1 @@+?+
+ tests/ns-uri-char.question.input view
@@ -0,0 +1,1 @@+?
+ tests/ns-uri-char.question.output view
@@ -0,0 +1,1 @@+??
+ tests/ns-uri-char.right-round.input view
@@ -0,0 +1,1 @@+)
+ tests/ns-uri-char.right-round.output view
@@ -0,0 +1,1 @@+?)
+ tests/ns-uri-char.right-square.input view
@@ -0,0 +1,1 @@+]
+ tests/ns-uri-char.right-square.output view
@@ -0,0 +1,1 @@+?]
+ tests/ns-uri-char.semicolon.input view
@@ -0,0 +1,1 @@+;
+ tests/ns-uri-char.semicolon.output view
@@ -0,0 +1,1 @@+?;
+ tests/ns-uri-char.single-quote.input view
@@ -0,0 +1,1 @@+'
+ tests/ns-uri-char.single-quote.output view
@@ -0,0 +1,1 @@+?'
+ tests/ns-uri-char.slash.input view
@@ -0,0 +1,1 @@+/
+ tests/ns-uri-char.slash.output view
@@ -0,0 +1,1 @@+?/
+ tests/ns-uri-char.tilde.input view
@@ -0,0 +1,1 @@+~
+ tests/ns-uri-char.tilde.output view
@@ -0,0 +1,1 @@+?~
+ tests/ns-uri-char.underscore.input view
@@ -0,0 +1,1 @@+_
+ tests/ns-uri-char.underscore.output view
@@ -0,0 +1,1 @@+?_
+ tests/ns-word-char.0.input view
@@ -0,0 +1,1 @@+0
+ tests/ns-word-char.0.output view
@@ -0,0 +1,1 @@+?0
+ tests/ns-word-char.hyphen.input view
@@ -0,0 +1,1 @@+-
+ tests/ns-word-char.hyphen.output view
@@ -0,0 +1,1 @@+?-
+ tests/ns-word-char.invalid.input view
@@ -0,0 +1,1 @@+_
+ tests/ns-word-char.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '_'
+ tests/ns-word-char.n.input view
@@ -0,0 +1,1 @@+n
+ tests/ns-word-char.n.output view
@@ -0,0 +1,1 @@+?n
+ tests/ns-yaml-directive.input view
@@ -0,0 +1,1 @@+YAML 0.1
+ tests/ns-yaml-directive.invalid.input view
@@ -0,0 +1,1 @@+YAML a
+ tests/ns-yaml-directive.invalid.output view
@@ -0,0 +1,4 @@+tYAML+w +!Commit to 'directive' was made outside it+!$InputFile$: line 1: column 5: Unexpected 'a'
+ tests/ns-yaml-directive.output view
@@ -0,0 +1,4 @@+tYAML+w +t0.1+!Commit to 'directive' was made outside it
+ tests/ns-yaml-version.input view
@@ -0,0 +1,1 @@+0.1
+ tests/ns-yaml-version.invalid.input view
@@ -0,0 +1,1 @@+0a
+ tests/ns-yaml-version.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 1: Unexpected 'a'
+ tests/ns-yaml-version.output view
@@ -0,0 +1,1 @@+t0.1
+ tests/s-b-comment.empty.input view
@@ -0,0 +1,1 @@+
+ tests/s-b-comment.empty.output view
@@ -0,0 +1,1 @@+b\x0a
+ tests/s-b-comment.invalid.input view
@@ -0,0 +1,1 @@+a#
+ tests/s-b-comment.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-b-comment.sol-text.input view
@@ -0,0 +1,1 @@+#text
+ tests/s-b-comment.sol-text.output view
@@ -0,0 +1,5 @@+C+I#+ttext+c+b\x0a
+ tests/s-b-comment.spaces-text.input view
@@ -0,0 +1,1 @@+ #text
+ tests/s-b-comment.spaces-text.output view
@@ -0,0 +1,6 @@+w +C+I#+ttext+c+b\x0a
+ tests/s-b-comment.spaces.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-b-comment.spaces.output view
@@ -0,0 +1,2 @@+w +b\x0a
+ tests/s-b-double-escaped.input view
@@ -0,0 +1,1 @@+ \
+ tests/s-b-double-escaped.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/s-b-double-escaped.invalid.output view
@@ -0,0 +1,2 @@+E+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-b-double-escaped.output view
@@ -0,0 +1,6 @@+? +E+I\x5c+b\x0a+e+!Commit to 'escape' was made outside it
+ tests/s-double-multi.n=4.input view
@@ -0,0 +1,2 @@+ a +    	a b	c 
+ tests/s-double-multi.n=4.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/s-double-multi.n=4.invalid.output view
@@ -0,0 +1,2 @@+?a+!$InputFile$: line 1: column 1: Expected end of input
+ tests/s-double-multi.n=4.output view
@@ -0,0 +1,6 @@+? a+w +l\x0a+i    +w\x09+?a b\x09c 
+ tests/s-ignored-prefix-block.n=4.input view
@@ -0,0 +1,1 @@+    
+ tests/s-ignored-prefix-block.n=4.invalid.input view
@@ -0,0 +1,1 @@+   
+ tests/s-ignored-prefix-block.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 3: Unexpected end of input
+ tests/s-ignored-prefix-block.n=4.output view
@@ -0,0 +1,1 @@+i    
+ tests/s-ignored-prefix-flow.n=4.indent.input view
@@ -0,0 +1,1 @@+    
+ tests/s-ignored-prefix-flow.n=4.indent.output view
@@ -0,0 +1,1 @@+i    
+ tests/s-ignored-prefix-flow.n=4.invalid.input view
@@ -0,0 +1,1 @@+   
+ tests/s-ignored-prefix-flow.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 3: Unexpected end of input
+ tests/s-ignored-prefix-flow.n=4.tab.input view
@@ -0,0 +1,1 @@+    	
+ tests/s-ignored-prefix-flow.n=4.tab.output view
@@ -0,0 +1,2 @@+i    +w\x09
+ tests/s-ignored-prefix.n=4.s=double.input view
@@ -0,0 +1,1 @@+    	
+ tests/s-ignored-prefix.n=4.s=double.output view
@@ -0,0 +1,2 @@+i    +w\x09
+ tests/s-ignored-prefix.n=4.s=folded.invalid.input view
@@ -0,0 +1,1 @@+     
+ tests/s-ignored-prefix.n=4.s=folded.invalid.output view
@@ -0,0 +1,2 @@+i    +!$InputFile$: line 1: column 4: Expected end of input
+ tests/s-ignored-prefix.n=4.s=literal.input view
@@ -0,0 +1,1 @@+    
+ tests/s-ignored-prefix.n=4.s=literal.output view
@@ -0,0 +1,1 @@+i    
+ tests/s-ignored-prefix.n=4.s=plain.input view
@@ -0,0 +1,1 @@+    
+ tests/s-ignored-prefix.n=4.s=plain.output view
@@ -0,0 +1,1 @@+i    
+ tests/s-ignored-prefix.n=4.s=single.input view
@@ -0,0 +1,1 @@+     
+ tests/s-ignored-prefix.n=4.s=single.output view
@@ -0,0 +1,2 @@+i    +w 
+ tests/s-indent-le.n=-1.invalid.input view
+ tests/s-indent-le.n=-1.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Fewer than 0 repetitions
+ tests/s-indent-le.n=0.input view
+ tests/s-indent-le.n=0.output view
+ tests/s-indent-le.n=4.input view
@@ -0,0 +1,1 @@+    
+ tests/s-indent-le.n=4.invalid.input view
@@ -0,0 +1,1 @@+     
+ tests/s-indent-le.n=4.invalid.output view
@@ -0,0 +1,2 @@+i   +!$InputFile$: line 1: column 3: Expected end of input
+ tests/s-indent-le.n=4.output view
@@ -0,0 +1,1 @@+i    
+ tests/s-indent-lt.n=-1.invalid.input view
+ tests/s-indent-lt.n=-1.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Fewer than 0 repetitions
+ tests/s-indent-lt.n=0.invalid.input view
+ tests/s-indent-lt.n=0.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Fewer than 0 repetitions
+ tests/s-indent-lt.n=4.input view
@@ -0,0 +1,1 @@+   
+ tests/s-indent-lt.n=4.invalid.input view
@@ -0,0 +1,1 @@+    
+ tests/s-indent-lt.n=4.invalid.output view
@@ -0,0 +1,2 @@+i  +!$InputFile$: line 1: column 2: Expected end of input
+ tests/s-indent-lt.n=4.output view
@@ -0,0 +1,1 @@+i   
+ tests/s-indent.n=-1.input view
+ tests/s-indent.n=-1.output view
+ tests/s-indent.n=0.input view
+ tests/s-indent.n=0.output view
+ tests/s-indent.n=4.input view
@@ -0,0 +1,1 @@+    
+ tests/s-indent.n=4.invalid.input view
@@ -0,0 +1,1 @@+   
+ tests/s-indent.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 3: Unexpected end of input
+ tests/s-indent.n=4.output view
@@ -0,0 +1,1 @@+i    
+ tests/s-l+block-content.n=2.c=block-in.sequence.input view
@@ -0,0 +1,2 @@++  - a
+ tests/s-l+block-content.n=2.c=block-in.sequence.output view
@@ -0,0 +1,13 @@+b\x0a+Q+i  +I-+w +N+S+Ta+s+n+b\x0a+q+!Commit to 'node' was made outside it
+ tests/s-l+block-content.n=2.c=block-out.folded.input view
@@ -0,0 +1,2 @@+>+   a
+ tests/s-l+block-content.n=2.c=block-out.folded.output view
@@ -0,0 +1,8 @@+S+I>+b\x0a+i   +Ta+L\x0a+s+!Commit to 'node' was made outside it
+ tests/s-l+block-content.n=2.c=block-out.invalid.input view
@@ -0,0 +1,2 @@++  - a
+ tests/s-l+block-content.n=2.c=block-out.invalid.output view
@@ -0,0 +1,3 @@+b\x0a+M+!$InputFile$: line 2: column 2: Unexpected '-'
+ tests/s-l+block-content.n=2.c=block-out.literal.input view
@@ -0,0 +1,2 @@+ |+   a
+ tests/s-l+block-content.n=2.c=block-out.literal.output view
@@ -0,0 +1,9 @@+w +S+I|+b\x0a+i   +Ta+L\x0a+s+!Commit to 'node' was made outside it
+ tests/s-l+block-content.n=2.c=block-out.mapping.input view
@@ -0,0 +1,2 @@++   a: b
+ tests/s-l+block-content.n=2.c=block-out.mapping.output view
@@ -0,0 +1,20 @@+b\x0a+M+i   +X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+b\x0a+x+m+!Commit to 'node' was made outside it
+ tests/s-l+block-in-block.n=2.c=block-out.invalid.input view
@@ -0,0 +1,1 @@+*a
+ tests/s-l+block-in-block.n=2.c=block-out.invalid.output view
@@ -0,0 +1,3 @@+N+M+!$InputFile$: line 1: column 0: Unexpected '*'
+ tests/s-l+block-in-block.n=2.c=block-out.tagged.input view
@@ -0,0 +1,2 @@+ !t |+   a
+ tests/s-l+block-in-block.n=2.c=block-out.tagged.output view
@@ -0,0 +1,20 @@+N+w +P+G+H+I!+h+tt+g+p+w +S+I|+b\x0a+i   +Ta+L\x0a+s+n+!Commit to 'node' was made outside it
+ tests/s-l+block-in-block.n=2.c=block-out.untagged.input view
@@ -0,0 +1,2 @@+|+   a
+ tests/s-l+block-in-block.n=2.c=block-out.untagged.output view
@@ -0,0 +1,10 @@+N+S+I|+b\x0a+i   +Ta+L\x0a+s+n+!Commit to 'node' was made outside it
+ tests/s-l+block-indented.n=2.c=block-in.invalid.input view
@@ -0,0 +1,1 @@+- a
+ tests/s-l+block-indented.n=2.c=block-in.invalid.output view
@@ -0,0 +1,5 @@+N+S+s+n+!$InputFile$: line 1: column 0: Expected end of input
+ tests/s-l+block-indented.n=2.c=block-in.sequence.input view
@@ -0,0 +1,2 @@++  - a
+ tests/s-l+block-indented.n=2.c=block-in.sequence.output view
@@ -0,0 +1,15 @@+N+b\x0a+Q+i  +I-+w +N+S+Ta+s+n+b\x0a+q+n+!Commit to 'node' was made outside it
+ tests/s-l+block-indented.n=2.c=block-out.in-line-map.input view
@@ -0,0 +1,2 @@+ a: b+    c: d
+ tests/s-l+block-indented.n=2.c=block-out.in-line-map.output view
@@ -0,0 +1,36 @@+i +N+M+X+N+S+Ta+s+n+I:+w +N+S+Tb+s+n+b\x0a+x+i    +X+N+S+Tc+s+n+I:+w +N+S+Td+s+n+b\x0a+x+m+n
+ tests/s-l+block-indented.n=2.c=block-out.in-line-seq.input view
@@ -0,0 +1,2 @@+ - a+    - b
+ tests/s-l+block-indented.n=2.c=block-out.in-line-seq.output view
@@ -0,0 +1,22 @@+i +N+Q+I-+w +N+S+Ta+s+n+b\x0a+i    +I-+w +N+S+Tb+s+n+b\x0a+q+n
+ tests/s-l+block-indented.n=2.c=block-out.literal.input view
@@ -0,0 +1,2 @@+ |+   a
+ tests/s-l+block-indented.n=2.c=block-out.literal.output view
@@ -0,0 +1,11 @@+N+w +S+I|+b\x0a+i   +Ta+L\x0a+s+n+!Commit to 'node' was made outside it
+ tests/s-l+block-indented.n=2.c=block-out.sequence.input view
@@ -0,0 +1,2 @@++   - a
+ tests/s-l+block-indented.n=2.c=block-out.sequence.output view
@@ -0,0 +1,15 @@+N+b\x0a+Q+i   +I-+w +N+S+Ta+s+n+b\x0a+q+n+!Commit to 'node' was made outside it
+ tests/s-l+block-node.n=2.c=block-out.block.input view
@@ -0,0 +1,2 @@+|+   a
+ tests/s-l+block-node.n=2.c=block-out.block.output view
@@ -0,0 +1,10 @@+N+S+I|+b\x0a+i   +Ta+L\x0a+s+n+!Commit to 'node' was made outside it
+ tests/s-l+block-node.n=2.c=block-out.flow.input view
@@ -0,0 +1,1 @@+a
+ tests/s-l+block-node.n=2.c=block-out.flow.output view
@@ -0,0 +1,7 @@+N+S+Ta+s+n+b\x0a+!Commit to 'node' was made outside it
+ tests/s-l+block-node.n=2.c=block-out.invalid.input view
@@ -0,0 +1,1 @@+|!
+ tests/s-l+block-node.n=2.c=block-out.invalid.output view
@@ -0,0 +1,5 @@+N+S+I|+!Commit to 'node' was made outside it+!$InputFile$: line 1: column 1: Unexpected '!'
+ tests/s-l+flow-in-block.n=2.input view
@@ -0,0 +1,1 @@+a
+ tests/s-l+flow-in-block.n=2.invalid.input view
@@ -0,0 +1,1 @@+|
+ tests/s-l+flow-in-block.n=2.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected '|'
+ tests/s-l+flow-in-block.n=2.output view
@@ -0,0 +1,7 @@+N+S+Ta+s+n+b\x0a+!Commit to 'node' was made outside it
+ tests/s-l-comments.invalid.input view
@@ -0,0 +1,1 @@+a#
+ tests/s-l-comments.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Expected end of input
+ tests/s-l-comments.multi.input view
@@ -0,0 +1,3 @@++#+
+ tests/s-l-comments.multi.output view
@@ -0,0 +1,6 @@+b\x0a+C+I#+c+b\x0a+b\x0a
+ tests/s-l-comments.sol.input view
+ tests/s-l-comments.sol.output view
+ tests/s-l-double-any.n=4.escaped.input view
@@ -0,0 +1,1 @@+ \
+ tests/s-l-double-any.n=4.escaped.output view
@@ -0,0 +1,5 @@+? +E+I\x5c+b\x0a+e
+ tests/s-l-double-any.n=4.folded.input view
@@ -0,0 +1,2 @@+ +
+ tests/s-l-double-any.n=4.folded.output view
@@ -0,0 +1,3 @@+w +b\x0a+L\x0a
+ tests/s-l-double-any.n=4.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/s-l-double-any.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-l-flow-folded.n=4.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/s-l-flow-folded.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-l-flow-folded.n=4.lf.input view
@@ -0,0 +1,1 @@+
+ tests/s-l-flow-folded.n=4.lf.output view
@@ -0,0 +1,1 @@+l\x0a
+ tests/s-l-flow-folded.n=4.sp-lf-lf.input view
@@ -0,0 +1,2 @@+ +
+ tests/s-l-flow-folded.n=4.sp-lf-lf.output view
@@ -0,0 +1,3 @@+w +b\x0a+L\x0a
+ tests/s-nb-folded-text.n=4.input view
@@ -0,0 +1,1 @@+    a
+ tests/s-nb-folded-text.n=4.invalid.input view
@@ -0,0 +1,1 @@+  a
+ tests/s-nb-folded-text.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 2: Unexpected 'a'
+ tests/s-nb-folded-text.n=4.output view
@@ -0,0 +1,3 @@+i    +?a+!Commit to 'fold' was made outside it
+ tests/s-nb-spaced-text.n=4.input view
@@ -0,0 +1,1 @@+     a
+ tests/s-nb-spaced-text.n=4.invalid.input view
@@ -0,0 +1,1 @@+  a
+ tests/s-nb-spaced-text.n=4.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 2: Unexpected 'a'
+ tests/s-nb-spaced-text.n=4.output view
@@ -0,0 +1,3 @@+i    +? a+!Commit to 'fold' was made outside it
+ tests/s-ns-double-chars.input view
@@ -0,0 +1,1 @@+ 	a
+ tests/s-ns-double-chars.invalid.input view
@@ -0,0 +1,1 @@+"
+ tests/s-ns-double-chars.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '"'
+ tests/s-ns-double-chars.output view
@@ -0,0 +1,1 @@+? \x09a
+ tests/s-ns-double-next.n=4.input view
@@ -0,0 +1,2 @@++    	a b	c
+ tests/s-ns-double-next.n=4.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/s-ns-double-next.n=4.invalid.output view
@@ -0,0 +1,2 @@+l\x0a+!$InputFile$: line 2: column 0: Unexpected end of input
+ tests/s-ns-double-next.n=4.output view
@@ -0,0 +1,4 @@+l\x0a+i    +w\x09+?a b\x09c
+ tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+ : a
+ tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a: b
+ tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,5 @@+N+S+s+n+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-ns-flow-map-explicit-empty.n=4.c=flow-in.output view
@@ -0,0 +1,14 @@+w +N+S+s+n+I:+w +N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.empty.input view
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.empty.output view
@@ -0,0 +1,8 @@+N+S+s+n+N+S+s+n
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.json.input view
@@ -0,0 +1,1 @@+ "a":b
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.json.output view
@@ -0,0 +1,16 @@+w +N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.value.input view
@@ -0,0 +1,1 @@+ : a
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.value.output view
@@ -0,0 +1,14 @@+w +N+S+s+n+I:+w +N+S+Ta+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.yaml.input view
@@ -0,0 +1,1 @@+ a: b
+ tests/s-ns-flow-map-explicit-entry.n=4.c=flow-in.yaml.output view
@@ -0,0 +1,15 @@+w +N+S+Ta+s+n+I:+w +N+S+Tb+s+n+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+ "a":b
+ tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+a: b
+ tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-ns-flow-map-explicit-json.n=4.c=flow-in.output view
@@ -0,0 +1,17 @@+w +N+S+I"+Ta+I"+s+n+I:+N+S+Tb+s+n+!Commit to 'entry' was made outside it+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.input view
@@ -0,0 +1,1 @@+ a: b
+ tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+"a": b
+ tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,3 @@+N+S+!$InputFile$: line 1: column 0: Unexpected '"'
+ tests/s-ns-flow-map-explicit-yaml.n=4.c=flow-in.output view
@@ -0,0 +1,16 @@+w +N+S+Ta+s+n+I:+w +N+S+Tb+s+n+!Commit to 'entry' was made outside it+!Commit to 'pair' was made outside it+!Commit to 'node' was made outside it
+ tests/s-ns-plain-chars.c=flow-in.input view
@@ -0,0 +1,1 @@+ 	a
+ tests/s-ns-plain-chars.c=flow-in.invalid.input view
@@ -0,0 +1,1 @@+ ,
+ tests/s-ns-plain-chars.c=flow-in.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 1: Unexpected ','
+ tests/s-ns-plain-chars.c=flow-in.output view
@@ -0,0 +1,1 @@+? \x09a
+ tests/s-ns-plain-next.n=4.c=flow-in.input view
@@ -0,0 +1,2 @@++      a  b
+ tests/s-ns-plain-next.n=4.c=flow-in.invalid.input view
@@ -0,0 +1,2 @@+  +    12,345
+ tests/s-ns-plain-next.n=4.c=flow-in.invalid.output view
@@ -0,0 +1,5 @@+w  +l\x0a+i    +?12+!$InputFile$: line 2: column 6: Expected end of input
+ tests/s-ns-plain-next.n=4.c=flow-in.output view
@@ -0,0 +1,4 @@+l\x0a+i    +w  +?a  b
+ tests/s-ns-single-chars.input view
@@ -0,0 +1,1 @@+ 	a
+ tests/s-ns-single-chars.invalid.input view
@@ -0,0 +1,1 @@+  'a
+ tests/s-ns-single-chars.invalid.output view
@@ -0,0 +1,4 @@+?  +E+I'+!$InputFile$: line 1: column 3: Unexpected 'a'
+ tests/s-ns-single-chars.output view
@@ -0,0 +1,1 @@+? \x09a
+ tests/s-ns-single-next.n=4.input view
@@ -0,0 +1,2 @@++    	a b	c
+ tests/s-ns-single-next.n=4.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/s-ns-single-next.n=4.invalid.output view
@@ -0,0 +1,2 @@+l\x0a+!$InputFile$: line 2: column 0: Unexpected end of input
+ tests/s-ns-single-next.n=4.output view
@@ -0,0 +1,4 @@+l\x0a+i    +w\x09+?a b\x09c
+ tests/s-separate-in-flow.n=4.c=flow-key.empty.input view
+ tests/s-separate-in-flow.n=4.c=flow-key.empty.output view
+ tests/s-separate-in-flow.n=4.c=flow-key.invalid.input view
@@ -0,0 +1,1 @@+
+ tests/s-separate-in-flow.n=4.c=flow-key.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Expected end of input
+ tests/s-separate-in-flow.n=4.c=flow-key.sp.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-separate-in-flow.n=4.c=flow-key.sp.output view
@@ -0,0 +1,1 @@+w 
+ tests/s-separate-in-flow.n=4.c=flow-out.empty.input view
+ tests/s-separate-in-flow.n=4.c=flow-out.empty.output view
+ tests/s-separate-in-flow.n=4.c=flow-out.line.input view
@@ -0,0 +1,2 @@++    
+ tests/s-separate-in-flow.n=4.c=flow-out.line.output view
@@ -0,0 +1,2 @@+b\x0a+i    
+ tests/s-separate-in-flow.n=4.c=flow-out.sp.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-separate-in-flow.n=4.c=flow-out.sp.output view
@@ -0,0 +1,1 @@+w 
+ tests/s-separate-in-line.invalid.input view
@@ -0,0 +1,1 @@+ #
+ tests/s-separate-in-line.invalid.output view
@@ -0,0 +1,2 @@+w +!$InputFile$: line 1: column 1: Expected end of input
+ tests/s-separate-in-line.sol.input view
+ tests/s-separate-in-line.sol.output view
+ tests/s-separate-in-line.sp.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-separate-in-line.sp.output view
@@ -0,0 +1,1 @@+w 
+ tests/s-separate-lines.n=4.invalid.input view
@@ -0,0 +1,2 @@+  +  
+ tests/s-separate-lines.n=4.invalid.output view
@@ -0,0 +1,2 @@+w  +!$InputFile$: line 1: column 2: Expected end of input
+ tests/s-separate-lines.n=4.lines.input view
@@ -0,0 +1,2 @@+ #+    	
+ tests/s-separate-lines.n=4.lines.output view
@@ -0,0 +1,7 @@+w +C+I#+c+b\x0a+i    +w\x09
+ tests/s-separate-lines.n=4.sol.input view
+ tests/s-separate-lines.n=4.sol.output view
+ tests/s-separate-lines.n=4.sp.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-separate-lines.n=4.sp.output view
@@ -0,0 +1,1 @@+w 
+ tests/s-single-multi.n=4.input view
@@ -0,0 +1,2 @@+ a +    	a b	c 
+ tests/s-single-multi.n=4.invalid.input view
@@ -0,0 +1,2 @@+ a+  b
+ tests/s-single-multi.n=4.invalid.output view
@@ -0,0 +1,2 @@+? a+!$InputFile$: line 1: column 2: Expected end of input
+ tests/s-single-multi.n=4.output view
@@ -0,0 +1,6 @@+? a+w +l\x0a+i    +w\x09+?a b\x09c 
+ tests/s-space.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-space.invalid.input view
@@ -0,0 +1,1 @@+	
+ tests/s-space.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected '\x09'
+ tests/s-space.output view
@@ -0,0 +1,1 @@+? 
+ tests/s-tab.input view
@@ -0,0 +1,1 @@+	
+ tests/s-tab.invalid.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-tab.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected ' '
+ tests/s-tab.output view
@@ -0,0 +1,1 @@+?\x09
+ tests/s-white.invalid.input view
@@ -0,0 +1,1 @@+a
+ tests/s-white.invalid.output view
@@ -0,0 +1,1 @@+!$InputFile$: line 1: column 0: Unexpected 'a'
+ tests/s-white.sp.input view
@@ -0,0 +1,1 @@+ 
+ tests/s-white.sp.output view
@@ -0,0 +1,1 @@+? 
+ tests/s-white.tab.input view
@@ -0,0 +1,1 @@+	
+ tests/s-white.tab.output view
@@ -0,0 +1,1 @@+?\x09
+ yaml2yeast-test/Main.hs view
@@ -0,0 +1,231 @@+-------------------------------------------------------------------------------+-- |+-- Module      :  yaml2yeast-test+-- Copyright   :  (c) Oren Ben-Kiki 2007+-- License     :  LGPL+-- +-- Maintainer  :  oren@ben-kiki.org+-- Stability   :  alpha+-- Portability :  portable+--+-- Execute all test cases located in a specified list of directories. Usage+-- is:+-- @+--  yaml2yeast-test [directories...]+-- @+-- If no directories are given, @yaml2yeast-test@ looks for tests in the+-- current working directory (\"@.@\"). Note that @yaml2yeast-test@ does not+-- recurse into sub-directories.+--+-- Each tests consists of two files, with the names+-- \"/production/@.@/testcase/@.input@\" and+-- \"/production/@.@/testcase/@.output@\", where /production/ is the syntax+-- production to be tested and /testcase/ is an arbitrary name. The @.input@+-- file contains the YAML text fed to the parser and the @.output@ file+-- contains the expected output, which is either a set of YEAST tokens or the+-- expected parsing error message.+--+-- If the @.output@ file is missing, the test will automatically fail. If a+-- test fails, a @.error@ file is created. This makes it easy to set up new+-- tests, simply create the input files, run @yaml2yeast-test@, and rename the+-- @.error@ files to @.output@ files (after reviewing them for correctness, of+-- course).+--+-- Exit status is the number of failed tests (0 - success - if all tests pass).+-------------------------------------------------------------------------------+module Main (main) where++import           Control.Monad+import qualified Data.ByteString.Lazy.Char8 as C+import qualified Data.HashTable as Hash+import           System.Directory+import           System.Environment+import           System.Exit+import           System.IO+import           Test.HUnit+import           Text.Regex+import           Text.Yaml.Reference++-- | Map each tokenizer name to whether a test for it was seen.+type Seen = Hash.HashTable String Bool++-- | @allTokenizers@ returns a hash table populated with all known tokenizers+-- where each has the initial value of @False@.+allTokenizers :: IO Seen+allTokenizers = do hash <- Hash.new (==) Hash.hashString+                   mapM (\name -> Hash.insert hash name False) tokenizerNames+                   return hash++-- | @reportMissing seen@ reports the productions (tokenizers) which were not+-- /seen/ and returns their number.+reportMissing :: Seen -> IO Int+reportMissing seen = do list <- Hash.toList seen+                        missing <- foldM reportTest 0 list+                        if missing > 0+                           then hPutStrLn stderr $ "Missing: " ++ (show missing)+                           else return ()+                        return missing+                        where reportTest count (name, wasSeen)+                                | wasSeen   = return count+                                | otherwise = do hPutStrLn stderr $ "No tests for " ++ name+                                                 return $ count + 1++-- | Different types of test files.+data TestType = Plain  -- ^ Production without arguments.+              | WithN  -- ^ Production requiring $n$ argument.+              | WithC  -- ^ Production requiring $c$ argument.+              | WithS  -- ^ Production requiring $s$ argument.+              | WithT  -- ^ Production requiring $t$ argument.+              | WithNC -- ^ Production requiring $n$ and $c$ arguments.+              | WithNS -- ^ Production requiring $n$ and $s$ arguments.+              | WithNT -- ^ Production requiring $n$ and $t$ arguments.+  deriving Eq++-- | @show testType@ converts a /testType/ to a human-friendly name for error+-- messages.+instance Show TestType where+  show testType =+      case testType of+           Plain  -> ""+           WithN  -> " n"+           WithC  -> " c"+           WithS  -> " s"+           WithT  -> " t"+           WithNC -> " n c"+           WithNS -> " n s"+           WithNT -> " n t"++-- | @isTestInputFile file@ returns whether the specified /file/ is a test+-- input file (ends with \"@.input@\").+isTestInputFile :: FilePath -> IO Bool+isTestInputFile file = do isFile <- doesFileExist file+                          if not isFile+                             then return False+                             else case matchRegex (mkRegex "\\.input$") file of+                                       Just _  -> return True+                                       Nothing -> return False++-- | @isWith parameter file@ returns whether the specified /file/ is for a production+-- that requires the specified /parameter/ (file name contains @.@/parameter/@=@).+isWith :: String -> FilePath -> IO Bool+isWith parameter file =+  case matchRegex (mkRegex $ "\\." ++ parameter ++ "=") file of+       Just _  -> return True+       Nothing -> return False++-- | @testType file@ deduces the type of test stored in the /file/.+testType :: FilePath -> IO TestType+testType file = do withN <- isWith "n" file+                   withC <- isWith "c" file+                   withS <- isWith "s" file+                   withT <- isWith "t" file+                   case (withN, withC, withS, withT) of+                        (False, False, False, False) -> return Plain+                        (True,  False, False, False) -> return WithN+                        (False, False, True,  False) -> return WithS+                        (False, True,  False, False) -> return WithC+                        (False, False, False, True)  -> return WithT+                        (True,  True,  False, False) -> return WithNC+                        (True,  False, True,  False) -> return WithNS+                        (True,  False, False, True)  -> return WithNT+                        (_,     _,     _,     _)     -> error $ file ++ ": unknown parameters combination"++-- | @testProduction file@ extracts the production name from a test input+-- /file/ name (file name starts with \"/pattern/@.@\").+testProduction :: FilePath -> String+testProduction file = subRegex (mkRegex "^.*/([0-9a-z+-]+)\\.[^/]*$") file "\\1"++-- | @testParameter parameter file@ extracts the /parameter/ value from a test+-- input /file/ name (file name contains \"@.@/parameter/@=@/value/@.@\"). Also+-- patch the @-@ characters in the @c@ parameter into @_@ to make it possible+-- for the built-in lexer to handle them.+testParameter :: (Read t) => String -> FilePath -> t+testParameter parameter file =+  read $ subRegex patchRegex (subRegex extractRegex file "\\1") "\\1_"+  where extractRegex = mkRegex $ "^.*\\." ++ parameter ++ "=([^.]+)\\.[^/]*$"+        patchRegex = mkRegex "([a-z])-"++-- | @testOutputFile file@ converts a test input /file/ name to test output+-- file name.+testOutputFile :: FilePath -> FilePath+testOutputFile file = subRegex (mkRegex "\\.input$") file ".output"++-- | @testErrorFile file@ converts a test input /file/ name to test error+-- file name.+testErrorFile :: FilePath -> FilePath+testErrorFile file = subRegex (mkRegex "\\.input$") file ".error"++-- | @embedVariables text inputFile@ embeds variables in the /text/ instead of+-- their expanded values; currently only /InputFile/ is embedded instead of the+-- input file name (we cheat by replacing whatever looks like one).+embedVariables :: String -> String+embedVariables text = subRegex (mkRegex "!.*: line ") text "!$InputFile$: line "++-- | @assertTest inputFile@ runs the parser on the input contained in the+-- /inputFile/ using the production extracted from the file name, asserting the+-- result is identical to the content of the matching output file.+assertTest :: FilePath -> Assertion+assertTest inputFile =+  do input <- C.readFile inputFile+     let outputFile = testOutputFile inputFile+     existsOutputFile <- doesFileExist outputFile+     expected <- if existsOutputFile+                    then readFile outputFile+                    else return "(missing file)"+     runType <- testType inputFile+     let result = case runType of+                       Plain  -> tokenizer (testProduction inputFile)+                       WithN  -> tokenizerWithN (testProduction inputFile)  (testParameter "n" inputFile)+                       WithC  -> tokenizerWithC (testProduction inputFile)  (testParameter "c" inputFile)+                       WithS  -> tokenizerWithS (testProduction inputFile)  (testParameter "s" inputFile)+                       WithT  -> tokenizerWithT (testProduction inputFile)  (testParameter "t" inputFile)+                       WithNC -> tokenizerWithNC (testProduction inputFile) (testParameter "n" inputFile) (testParameter "c" inputFile)+                       WithNS -> tokenizerWithNS (testProduction inputFile) (testParameter "n" inputFile) (testParameter "s" inputFile)+                       WithNT -> tokenizerWithNT (testProduction inputFile) (testParameter "n" inputFile) (testParameter "t" inputFile)+     case result of+          Nothing -> assertFailure $ inputFile ++ ": unknown production" ++ (show runType) ++ ": " ++ (testProduction inputFile)+          Just resolved -> do let actual = embedVariables $ showTokens $ resolved inputFile input+                              when (actual /= expected) $ writeFile (testErrorFile inputFile) actual+                              assertEqual inputFile expected actual++-- | @fileTest seen file@ wraps @assertTest@ in a test case named after the+-- /file/ and marks it as /seen/.+fileTest :: Seen -> FilePath -> IO Test+fileTest seen file = do Hash.update seen (testProduction file) True+                        return $ TestLabel file $ TestCase $ assertTest file++-- | @directoryTestInputFiles directory@ returns the list of test input files+-- contained in the /directory/.+directoryTestInputFiles :: String -> IO [FilePath]+directoryTestInputFiles directory = do entries <- getDirectoryContents directory+                                       filterM isTestInputFile $ map ((directory ++) . ("/" ++)) entries++-- | @directoryTests seen directory@ returns the list of test cases contained+-- in the /directory/, wrapped in a test case named after it, and updates the+-- /seen/ hash.+directoryTests :: Seen -> String -> IO Test+directoryTests seen directory = do files <- directoryTestInputFiles directory+                                   tests <- mapM (fileTest seen) files+                                   return $ TestLabel directory $ TestList tests++-- | @allTests seen directories@ returns the list of test cases contained in+-- the /directories/ (or \"@.@\" if none is specified), wrapped in a test case+-- named @all@ if there is more than one directory, updating the /seen/ hash.+allTests :: Seen -> [String] -> IO Test+allTests seen directories = do case directories of+                                    [] -> directoryTests seen "."+                                    [directory] -> directoryTests seen directory+                                    _ -> do tests <- mapM (directoryTests seen) directories+                                            return $ TestLabel "all" $ TestList tests++-- | @main@ executes all the tests contained in the directories specified in+-- the command line (or \"@.@\" if none is specified).+main :: IO ()+main = do directories <- getArgs+          seen <- allTokenizers+          tests <- allTests seen directories+          missing <- reportMissing seen+          results <- runTestTT tests+          case missing + (errors results) + (failures results) of+               0 -> exitWith ExitSuccess+               n -> exitWith $ ExitFailure n
+ yaml2yeast.css view
@@ -0,0 +1,91 @@+html {+    cursor: default;+}+h1 {+    margin-left: 1em;+}+td.legend_glyph {+    text-align: center;+    border: solid 1px black;+}+div.tree_div {+    position: absolute;+    left: 0%;+    top: 0%;+    width: 50%;+    height: 100%;+    overflow: scroll;+}+div.text_div {+    position: absolute;+    left: 50%;+    top: 0%;+    width: 50%;+    height: 100%;+    overflow: scroll;+}+span.highlight {+    background-color: yellow;+}+span.text {+    font-family: monospace;+}+span.tree_glyph {+    text-align: center;+    font-family: monospace;+    padding-left: 0.25em;+    padding-right: 0.25em;+    border: solid 1px black;+}+span.tree_glyph.parent_node {+    cursor: pointer;+}+span.tree_text {+    font-family: sans-serif;+    margin-left: 0.5em;+    cursor: pointer;+}+span.legend_node {+    cursor: default;+}+span.text {+    cursor: pointer;+}+span.legend_text {+    font-family: sans-serif;+}+table.legend_table {+    margin-left: 0.25em;+}+td.legend_space {+    padding-right: 0.25em;+}+span.tree_space {+    margin-left: 0.25em;+    margin-right: 0.25em;+}+td.legend_space,+span.space_1,+span.space_3,+span.space_5,+span.space_7,+span.space_9,+span.space_11,+span.space_13,+span.space_15,+span.space_17,+span.space_19 {+    border-left: solid 1px green;+}+span.space_2,+span.space_4,+span.space_6,+span.space_8,+span.space_10,+span.space_12,+span.space_14,+span.space_16,+span.space_18,+span.space_20 {+    border-left: solid 1px blue;+}
+ yaml2yeast/Main.hs view
@@ -0,0 +1,298 @@+-------------------------------------------------------------------------------+-- |+-- Module      :  yaml2yeast+-- Copyright   :  (c) Oren Ben-Kiki 2007+-- License     :  LGPL+-- +-- Maintainer  :  yaml-oren@ben-kiki.org+-- Stability   :  alpha+-- Portability :  portable+--+-- Convert an input YAML file to a YEAST (YAML Elaborate Atomic Syntax Tokens).+-- Command line options are:+--+--  [@-h@ @-?@ @--help@] Prints short usage message+--+--  [@-o@ @--output@ @file@] Specify output file (default is \"@-@\" for+--  stdout)+--+--  [@-u@ @--unbuffered@] Disable @stdout@ buffering.+--+--  [@-p@ @--production@ @production@] Specify the top production (default is+--  full YAML stream).+--+--  [@-n@ @--n-value@ @n@] Specify the /n/ parameter of the production.+--+--  [@-c@ @--c-value@ @c@] Specify the /c/ parameter of the production.+--+--  [@-s@ @--s-value@ @s@] Specify the /s/ parameter of the production.+--+--  [@-t@ @--t-value@ @t@] Specify the /t/ parameter of the production.+--+--  [@input@] Specify the input file (default is \"@-@\" for stdin).+--+-- The YEAST format is designed to allow trivial post-processing. Since YEAST+-- contains all the syntactical information contained in the original YAML+-- file, such processing can perform tasks which are impossible or difficult+-- using higher-level YAML parsers, such as pretty-printing. For example, the+-- @yeast2html@ program generates an HTML visualization of the syntactical+-- structure of the original YAML file.+--+-- YEAST contains one line per token, where the first character is the token+-- code and the following characters are the input characters contained in the+-- token, if any. Non printable\/non ASCII characters (including line breaks)+-- are escaped using either \"@\\x@/XX/\", \"@\\u@/XXXX/\" or+-- \"@\\U@/XXXXXXXX/\" notation. Therefore YEAST files are restricted to 7-bit+-- printable ASCII, making them sufficiently human-readable for debugging+-- purposes.+--+-- The YEAST token codes are:+--+--  [@U@] BOM, contains \"@TF8@\", \"@TF16LE@\" or \"@TF16BE@\"+--+--  [@T@] Contains presrved content text characters+--+--  [@t@] Contains non-content (meta) text characters+--+--  [@B@] Contains preserved content line break+--+--  [@b@] Contains separation line break+--+--  [@L@] Contains line break normalized to content line feed+--+--  [@l@] Contains line break folded to content space+--+--  [@I@] Contains character indicating structure+--+--  [@w@] Contains separation white space+--+--  [@i@] Contains indentation spaces+--+--  [@K@] Document start marker+--+--  [@k@] Document end marker+--+--  [@E@] Begins escape sequence+--+--  [@e@] Ends escape sequence+--+--  [@C@] Begins comment+--+--  [@c@] Ends comment+--+--  [@D@] Begins directive+--+--  [@d@] Ends directive+--+--  [@G@] Begins tag+--+--  [@g@] Ends tag+--+--  [@H@] Begins tag handle+--+--  [@h@] Ends tag handle+--+--  [@A@] Begins anchor+--+--  [@a@] Ends anchor+--+--  [@P@] Begins node properties+--+--  [@p@] Ends node properties+--+--  [@R@] Begins alias (reference)+--+--  [@r@] Ends alias (reference)+--+--  [@S@] Begins scalar content+--+--  [@s@] Ends scalar content+--+--  [@Q@] Begins sequence content+--+--  [@q@] Ends sequence content+--+--  [@M@] Begins mapping content+--+--  [@m@] Ends mapping content+--+--  [@N@] Begins complete node+--+--  [@n@] Ends complete node+--+--  [@X@] Begins mapping key:value pair+--+--  [@x@] Ends mapping key:value pair+--+--  [@O@] Begins document+--+--  [@o@] Ends document+--+--  [@Y@] Begins YAML stream+--+--  [@y@] Ends YAML stream+--+-- In addition, the following codes are used for testing partial productions+-- and do not appear when parsing a complete YAML stream:+--+--  [@?@] Contains test characters otherwise unassigned+--+--  [@\/@] Value of detected parameters+--+-------------------------------------------------------------------------------+module Main (main) where++import           Control.Monad+import qualified Data.ByteString.Lazy.Char8 as C+import           System.Console.GetOpt+import           System.Environment+import           System.IO+import           Text.Regex+import           Text.Yaml.Reference+++-- | Command line flag.+data Flag = Help                   -- ^ Request printing usage.+          | Output String          -- ^ Specify output file name.+          | Production String      -- ^ Specify start production name.+          | Unbuffered             -- ^ Disable @stdout@ bufferting.+          | ParamN (Maybe Int)     -- ^ Specify $n$ parameter.+          | ParamT (Maybe Chomp)   -- ^ Specify $t$ parameter.+          | ParamS (Maybe Style)   -- ^ Specify $s$ parameter.+          | ParamC (Maybe Context) -- ^ Specify $c$ parameter.+          | Input String           -- ^ Specify input file name.+    deriving Show++-- | Command line options.+optionDescriptions :: [OptDescr Flag]+optionDescriptions = [+      Option ['h', '?'] ["help"]+             (NoArg Help)+             "print usage and exit",+      Option ['o'] ["output"]+             (ReqArg Output "file")+             "output file",+      Option ['u'] ["unbuffered"]+             (NoArg Unbuffered)+             "disable stdout buffering",+      Option ['p'] ["production"]+             (ReqArg Production "production")+             "top production",+      Option ['n'] ["n-value"]+             (ReqArg (ParamN . readParameter) "indentation")+             "n parameter value (indentation)",+      Option ['c'] ["context"]+             (ReqArg (ParamC . readParameter) "context")+             "c parameter value (context)",+      Option ['s'] ["style"]+             (ReqArg (ParamS . readParameter) "style")+             "s parameter value (style)",+      Option ['t'] ["chomp"]+             (ReqArg (ParamT . readParameter) "chomp")+             "t parameter value (chomp)"+  ]++-- | @testParameter parameter@ converts the /parameter/ to a typed value. Patch+-- the @-@ characters in the /c/ parameter into @_@ to make it possible for the+-- built-in lexer to handle them.+readParameter :: (Read t) => String -> Maybe t+readParameter text = Just $ read $ subRegex (mkRegex "([a-z])-") text "\\1_"++-- | @usage@ returns the usage string for the program.+usage :: String+usage = usageInfo "yamlSyntax: [options] [file]" optionDescriptions++-- | @collectFlags args@ converts the command line /args/ to list of 'Flag'.+collectFlags :: [String] -> IO [Flag]+collectFlags args =+  case getOpt Permute optionDescriptions args of+       (_,     _,     [error:errors]) -> ioError $ userError $ (concat [error:errors]) ++ usage+       (flags, [],    [])             -> do return flags+       (flags, [arg], [])             -> do return $ [Input arg] ++ flags+       (flags, _,     [])             -> ioError $ userError "more than one input file"++-- | Options controlling program behavior+data Options = Options {+      oToHelp     :: Bool,          -- ^ Whether to just print the usage.+      oToUnbuffer :: Bool,          -- ^ Whether to disable @stdout@ buffering.+      oInput      :: String,        -- ^ Name of input file ("-": @stdin@).+      oOutput     :: String,        -- ^ Name of output file ("-": @stdout@).+      oProduction :: String,        -- ^ Name of start production.+      oN          :: Maybe Int,     -- ^ N parameter, if any.+      oC          :: Maybe Context, -- ^ C parameter, if any.+      oS          :: Maybe Style,   -- ^ S parameter, if any.+      oT          :: Maybe Chomp    -- ^ T parameter, if any.+  }++-- | Default options if no flags are specified.+defaultOptions = Options {+      oToHelp     = False,+      oToUnbuffer = False,+      oInput      = "-",+      oOutput     = "-",+      oProduction = "l-yaml-stream",+      oN          = Nothing,+      oC          = Nothing,+      oS          = Nothing,+      oT          = Nothing+  }++-- | @applyFlags flags options@ applies the specified /flags/ to the /options/.+applyFlags :: [Flag] -> Options -> IO Options+applyFlags []           options = return options+applyFlags (flag:flags) options =+  case flag of+       Help            -> applyFlags flags options { oToHelp = True }+       Unbuffered      -> applyFlags flags options { oToUnbuffer = True }+       Output name     -> applyFlags flags options { oOutput = name }+       Input name      -> applyFlags flags options { oInput = name }+       ParamN value    -> applyFlags flags options { oN = value }+       ParamC value    -> applyFlags flags options { oC = value }+       ParamS value    -> applyFlags flags options { oS = value }+       ParamT value    -> applyFlags flags options { oT = value }+       Production name -> applyFlags flags options { oProduction = name }++-- | @fromFile name@ returns the contents of the specified input file called+-- /name/ (may be "-" for @stdin@).+fromFile :: String -> IO C.ByteString+fromFile name =+  case name of+       "-"  -> C.getContents+       path -> C.readFile path++-- | @intoFile name text@ writes the /text/ into the specified output file+-- called /name/ (may be "-" for @stdout@).+intoFile :: String -> String -> IO ()+intoFile name text =+  case name of+       "-"  -> putStr text+       path -> writeFile path $ text++-- | @runWith options@ runs the program with the specified /options/.+runWith :: Options -> IO ()+runWith options =+  do let resolved = case ((oN options), (oC options), (oS options), (oT options)) of+                         (Nothing,    Nothing,    Nothing,    Nothing) -> tokenizer       (oProduction options)+                         (Just n,     Nothing,    Nothing,    Nothing) -> tokenizerWithN  (oProduction options) n+                         (Nothing,    Just c,     Nothing,    Nothing) -> tokenizerWithC  (oProduction options) c+                         (Nothing,    Nothing,    Just s,     Nothing) -> tokenizerWithS  (oProduction options) s+                         (Nothing,    Nothing,    Nothing,    Just t)  -> tokenizerWithT  (oProduction options) t+                         (Just n,     Just c,     Nothing,    Nothing) -> tokenizerWithNC (oProduction options) n c+                         (Just n,     Nothing,    Just s,     Nothing) -> tokenizerWithNS (oProduction options) n s+                         (Just n,     Nothing,    Nothing,    Just t)  -> tokenizerWithNT (oProduction options) n t+                         _                                             -> error "No production with this combination of parameters"+     case resolved of+          Nothing     -> error $ "No production " ++ (oProduction options) ++ " or it doesn't take this combination of parameters"+          Just parser -> do text <- fromFile (oInput options)+                            let tokens = parser (oInput options) text+                            intoFile (oOutput options) (showTokens tokens)++-- | @main@ converts an input YAML file to YEAST tokens.+main :: IO ()+main = do args <- getArgs+          flags <- collectFlags args+          options <- applyFlags flags defaultOptions+          when (oToUnbuffer options) $ hSetBuffering stdout NoBuffering+          if oToHelp options+             then putStrLn usage+             else runWith options
+ yeast2html view
@@ -0,0 +1,476 @@+#!/usr/bin/perl -w++# Modules.+use strict;+use English;+use Pod::Usage;+use Getopt::Long;+use IO::File;++# YEAST byte codes.+my $code2class = {+    U => { code => 'U', type => 'bom',   title => "Byte order mark" },+    T => { code => 'T', type => 'text',  title => "Content text" },+    t => { code => 't', type => 'text',  title => "Non-content text" },+    B => { code => 'B', type => 'line',  title => "Content line break" },+    b => { code => 'b', type => 'line',  title => "Non-content line break" },+    L => { code => 'L', type => 'line',  title => "Line break normalized to line feed" },+    l => { code => 'l', type => 'line',  title => "Line break folded to space" },+    I => { code => 'I', type => 'text',  title => "Indicator character" },+    w => { code => 'w', type => 'text',  title => "Non-content white space" },+    i => { code => 'i', type => 'text',  title => "Indentation white space" },+    K => { code => 'K', type => 'text',  title => "Document start marker" },+    k => { code => 'k', type => 'text',  title => "Document end marker" },+    E => { code => 'E', type => 'begin', title => "Escape sequence" },+    e => { code => 'e', type => 'end',   title => "Escape sequence" },+    C => { code => 'C', type => 'begin', title => "Comment" },+    c => { code => 'c', type => 'end',   title => "Comment" },+    D => { code => 'D', type => 'begin', title => "Directive" },+    d => { code => 'd', type => 'end',   title => "Directive" },+    G => { code => 'G', type => 'begin', title => "Tag" },+    g => { code => 'g', type => 'end',   title => "Tag" },+    H => { code => 'H', type => 'begin', title => "Handle" },+    h => { code => 'h', type => 'end',   title => "Handle" },+    A => { code => 'A', type => 'begin', title => "Anchor" },+    a => { code => 'a', type => 'end',   title => "Anchor" },+    P => { code => 'P', type => 'begin', title => "Properties" },+    p => { code => 'p', type => 'end',   title => "Properties" },+    R => { code => 'R', type => 'begin', title => "Alias" },+    r => { code => 'r', type => 'end',   title => "Alias" },+    S => { code => 'S', type => 'begin', title => "Scalar" },+    s => { code => 's', type => 'end',   title => "Scalar" },+    Q => { code => 'Q', type => 'begin', title => "Sequence" },+    q => { code => 'q', type => 'end',   title => "Sequence" },+    M => { code => 'M', type => 'begin', title => "Mapping" },+    m => { code => 'm', type => 'end',   title => "Mapping" },+    N => { code => 'N', type => 'begin', title => "Node" },+    n => { code => 'n', type => 'end',   title => "Node" },+    X => { code => 'X', type => 'begin', title => "Key:value pair" },+    x => { code => 'x', type => 'end',   title => "Key:value pair" },+    O => { code => 'O', type => 'begin', title => "Document" },+    o => { code => 'o', type => 'end',   title => "Document" },+    Y => { code => 'Y', type => 'begin', title => "Stream" },+    y => { code => 'y', type => 'end',   title => "Stream" }+};++# Command line arguments.+my $output_file = '';+my $css_file = '';+my $link_css = '';+my $output = *STDOUT{IO};+my $tree_title = 'Syntax Tree';+my $text_title = 'YAML Text';++# Loaded byte codes.+my $data = [];++# Tree printing.+my $next_id;++# Main program.+parse_argv();+load_input();+print_output();++# Functions.++sub parse_argv {+    my $do_help = "";+    my $do_man = "";+    GetOptions("help|h" => \$do_help,+               "man|m" => \$do_man,+               "output|o=s" => \$output_file,+               "css|c=s" => \$css_file,+               "tree-title|r=s" => \$tree_title,+               "text-title|x=s" => \$text_title,+               "link-css|l" => \$link_css)+        || pod2usage(-verbose => 0);+    pod2usage(-verbose => 1) if $do_help;+    pod2usage(-verbose => 2) if $do_man;+    die("Only one input file, please\n") if @ARGV > 1;+    die("No CSS file specified to link to\n") if $link_css && !$css_file;+    if ($output_file) {+        open ($output, ">$output_file") || die("open(>$output_file): $!");+    }+}++sub load_input {+    my $stack = [];+    my $num = 0;+    while (my $line = <>) {+        $num++;+        chomp($line);+        die("Line $num is not a byte code line\n")+            unless $line =~ /^(.)(.*)$/;+        my $code = $1;+        my $text = $2;+        my $class = $code2class->{$code};+        die("Line $num contains unknown code \"$code\"\n")+            unless $class;+        die("Oops!") unless $class->{code} eq $code;+        if ($class->{type} eq 'bom') {+            $text = "$code$text";+        } else {+            $text =~ s:\\x0[dD]:&crarr;:g;+            $text =~ s:\\x0[aA]:&darr;:g;+            $text =~ s:\\x85:&dArr;:g;+            $text =~ s:\\u2028:&sect;:g;+            $text =~ s:\\u2029:&para;:g;+            $text =~ s:\t:&rarr;:g;+            $text =~ s: :&middot;:g;+            $text =~ s:\\u202F:&diams;:g;+        }+        if ($class->{type} eq 'begin') {+            push(@$stack, [$num, $class]);+        } elsif ($class->{type} eq 'end') {+            my $title = $class->{title};+            my ($begin_num, $begin_class) = @{pop(@$stack)};+            my $begin_code = $begin_class->{code};+            my $begin_title = $begin_class->{title};+            die("Line $num ($code/$title) "+              . "ends line $begin_num ($begin_code/$begin_title)\n")+                if $title ne $begin_title;+        }+        push(@$data, [$class, $text]);+    }+    die("Unterminated groups\n") if @$stack;+}++sub print_output {+    print $output <<"EOF";+<html>+<?xml version="1.0" encoding="ISO-8859-1"?>+<!DOCTYPE html PUBLIC+ "-//W3C//DTD XHTML 1.0 Transitional//EN"+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">+<html xmlns="http://www.w3.org/1999/xhtml">+<head>+<title>YEAST2HTML</title>+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />+<meta name="generator" content="yeast2html" />+EOF+    print_css();+    print_script();+    print $output <<"EOF";+</head>+<body>+EOF+    print_text();+    print_tree();+    print $output <<"EOF";+</body>+</html>+EOF+}++sub print_css {+    if ($link_css) {+        print $output "<link rel=\"stylesheet\" href=\"$css_file\" type=\"text/css\" />\n";+        return;+    }+    print $output "<style type=\"text/css\">\n";+    if ($css_file) {+        open(CSS, "$css_file") || die("open($css_file): $!\n");+        while (my $line = <CSS>) {+            print $output $line;+        }+        close(CSS) || die("close($css_file): $!\n");+    } else {+        print $output <<"EOF";+div.tree_div {+    position: absolute;+    left: 0%;+    top: 0%;+    width: 50%;+    height: 100%;+    overflow: scroll;+}+div.text_div {+    position: absolute;+    left: 50%;+    top: 0%;+    width: 50%;+    height: 100%;+    overflow: scroll;+}+span.highlight {+    background-color: yellow;+}+span.text {+    font-family: monospace;+}+EOF+    }+    print $output "</style>\n";+}++sub print_script {+    print $output <<"EOF";+<script language="JavaScript">+function toggle(id) {+    var nest_style = document.getElementById("tree_nest_" + id).style;+    var glyph = document.getElementById("tree_glyph_" + id);+    if (nest_style.display == "none") {+        nest_style.display = "block";+        glyph.innerHTML = "&mdash;";+    } else {+        nest_style.display = "none";+        glyph.innerHTML = "+";+    }+}+var highlighted = 0;+function highlight(id) {+    if (highlighted == 0) {+        var text = document.getElementById("text_" + id);+        var tree = document.getElementById("tree_text_" + id);+        text.className = "text highlight";+        tree.className = "tree_text highlight";+        highlighted = id;+    } else if (highlighted == id) {+        var text = document.getElementById("text_" + id);+        var tree = document.getElementById("tree_text_" + id);+        text.className = "text";+        tree.className = "tree_text";+        highlighted = 0;+        return;+    } else {+        var old_text = document.getElementById("text_" + highlighted);+        var old_tree = document.getElementById("tree_text_" + highlighted);+        var new_text = document.getElementById("text_" + id);+        var new_tree = document.getElementById("tree_text_" + id);+        old_text.className = "text";+        old_tree.className = "tree_text";+        new_text.className = "text highlight";+        new_tree.className = "tree_text highlight";+        highlighted = id;+    }+}+</script>+EOF+}++sub print_tree {+    print $output "<div id=\"tree_div\" name=\"tree_div\" class=\"tree_div\">\n";+    print $output "<h1 id=\"tree_title\" name=\"tree_title\" class=\"tree_title\">$tree_title</h1>";+    $next_id = 0;+    start_tree_node(0, "Legend");+    print_legend();+    end_tree_node();+    my $depth = 0;+    for my $entry (@$data) {+        my ($class, $text) = @$entry;+        if ($class->{type} eq 'begin') {+            start_tree_node($depth++, $class->{title});+        } elsif ($class->{type} eq 'end') {+            end_tree_node();+            $depth--;+        } else {+            my $label = $class->{title};+            $label .= " ($text)" if $class->{type} eq 'bom';+            tree_leaf($depth, $label);+        }+    }+    print $output "</div>\n";+}++sub start_tree_node {+    my $depth = shift;+    my $text = shift;+    print $output "<div id=\"tree_line_$next_id\" name=\"tree_line_$next_id\" class=\"tree_node parent_node\">\n";+    for (my $i = 1; $i <= $depth; $i++) {+        print $output "<span class=\"tree_space parent_node space_$i depth_$depth\">&nbsp;</span>"+    }+    print $output "<span id=\"tree_glyph_$next_id\" name=\"tree_glyph_$next_id\" class=\"tree_glyph parent_node\" onclick=\"toggle($next_id)\">&mdash;</span>";+    print $output "<span id=\"tree_text_$next_id\" name=\"tree_text_$next_id\" class=\"tree_text parent_node"+                . ($next_id > 0 ? "" : " legend_node")+                . "\" onclick=\"highlight($next_id)\">$text</span>\n";+    print $output "<div id=\"tree_nest_$next_id\" name=\"tree_nest_$next_id\" class=\"tree_nest\">\n";+    $next_id++;+}++sub end_tree_node {+    print $output "</div></div>\n";+}++sub tree_leaf {+    my $depth = shift;+    my $text = shift;+    print $output "<div id=\"tree_line_$next_id\" name=\"tree_line_$next_id\" class=\"tree_node leaf_node\">\n";+    for (my $i = 1; $i <= $depth; $i++) {+        print $output "<span class=\"tree_space leaf_node space_$i depth_$depth\">&nbsp;</span>"+    }+    print $output "<span id=\"tree_glyph_$next_id\" name=\"tree_glyph_$next_id\" class=\"tree_glyph leaf_node\"\">&middot;</span>";+    print $output "<span id=\"tree_text_$next_id\" name=\"tree_text_$next_id\" class=\"tree_text leaf_node\" onclick=\"highlight($next_id)\">$text</span>\n";+    print $output "</div>\n";+    $next_id++;+}++sub print_legend {+    print <<"EOF";+<table id="legend_table" name="legend_table" class="legend_table">+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&crarr;</td>+<td class="legend_text">Carriage Return</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&darr;</td>+<td class="legend_text">Line Feed</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&dArr;</td>+<td class="legend_text">Next Line</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&sect;</td>+<td class="legend_text">Line separator</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&para;</td>+<td class="legend_text">Paragraph separator</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&rarr;</td>+<td class="legend_text">Tab</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&diams;</td>+<td class="legend_text">Non-breaking space</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&middot;</td>+<td class="legend_text">Space</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&deg;</td>+<td class="legend_text">Empty</td>+</tr>+<tr>+<td class="legend_space">&nbsp;</td>+<td class="legend_glyph">&hArr;</td>+<td class="legend_text">Byte order mark</td>+</tr>+</table>+EOF+}++sub print_text {+    print $output "<div id=\"text_div\" name=\"text_div\" class=\"text_div\">\n";+    print $output "<h1 id=\"text_title\" name=\"text_title\" class=\"text_title\">$text_title</h1>";+    $next_id = 1;+    my $pending_break = 0;+    for my $entry (@$data) {+        my ($class, $text) = @$entry;+        if ($class->{type} eq 'end') {+            print $output "</span>";+            next;+        }+        if ($pending_break) {+            print $output "<br/>\n";+            $pending_break = 0;+        }+        print $output "<span id=\"text_$next_id\" name=\"text_$next_id\" class=\"text\"";+        print " onclick=\"highlight($next_id)\"" unless $class->{type} eq 'begin';+        print ">";+        $next_id++;+        next if $class->{type} eq 'begin';+        if ($class->{type} eq 'bom') {+            print $output "&hArr;</span>";+        } else {+            print $output "$text</span>";+        }+        $pending_break = $class->{type} eq 'line';+    }+    print $output "\n</div>\n";+}++__END__++=head1 NAME++yeast2html - Convert YEAST byte codes to viewable HTML++=head1 SYNOPSIS++yeast2html [options] [yeast-file]++=head1 DESCRIPTION++This Perl script is designed to allow exploring the syntactical structure of+YAML files in an interactive way. The input file is a sequence of YEAST byte+codes that describe the YAML text. The output is an XHTML file that allows+viewing the YAML syntax tree together with the original (reconstructed) YAML+text.++=head1 COMMAND LINE OPTIONS++=over 4++=item B<--output|-o> I<output-file>++Redirect the output XHTML to the specified I<output-file>. By default the XHTML+is written to standard output.++=item B<--css|-c> I<css-file>++Use the specified I<css-file> to control the style of the generated XHTML. By+default, a minimal set of CSS rules is used, which doesn't look very pretty.++=item B<--link-css|-l>++By default, the content of the I<css-file> is embedded in the header of the+generated XHTML. If this flag is given, this is replaced by a link to the+I<css-file>. Note that in this case the I<css-file> path must be relative to+the URL used for the XHTML file.++=item B<--tree-title|-r> I<title>++The title for the tree part of the display. By default, it says "Syntax Tree".++=item B<--text-title|-x> I<title>++The title for the text part of the display. By default, it says "YAML Text".++=item B<--help|-h>++Print short usage message and exit.++=item B<--man|-m>++Print this man page and exit.++=back++=head1 SEE ALSO++L<yaml2yeast>++=head1 AUTHOR++Oren Ben-Kiki <oren@ben-kiki.org>++=head1 COPYRIGHT++Copyright (c) 2007, Oren Ben-Kiki++This program is free software; you can redistribute it and/or modify it under+the terms of the GNU Lesser General Public License as published by the Free+Software Foundation; either version 2.1 of the License, or (at your option) any+later version.++This library is distributed in the hope that it will be useful, but WITHOUT ANY+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A+PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more+details.++You should have received a copy of the GNU Lesser General Public License along+with this library; if not, write to the Free Software Foundation, Inc.,+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA