···

       
2
       
 
       
 (name yamlrw)

     

       
3
       
 
       
 (public_name yamlrw)

     

       
4
       
 
       
 (libraries bytesrw)

     

       
5
       
-
       
 (flags (:standard -w -37-69))

     

       
6
       
 
       
 (modules

     

       
7
       
 
       
  ; Core types

     

       
8
       
 
       
  position

     

···

       
2
       
 
       
 (name yamlrw)

     

       
3
       
 
       
 (public_name yamlrw)

     

       
4
       
 
       
 (libraries bytesrw)

     

       
0
       
 
       

     

       
5
       
 
       
 (modules

     

       
6
       
 
       
  ; Core types

     

       
7
       
 
       
  position

     

···

       
9
       
 
       
type state =

     

       
10
       
 
       
  | Stream_start

     

       
11
       
 
       
  | Implicit_document_start

     

       
12
       
-
       
  | Document_start

     

       
13
       
 
       
  | Document_content

     

       
14
       
 
       
  | Document_content_done  (* After parsing a node, check for unexpected content *)

     

       
15
       
 
       
  | Document_end

     

       
16
       
-
       
  | Block_node

     

       
17
       
-
       
  | Block_node_or_indentless_sequence

     

       
18
       
-
       
  | Flow_node

     

       
19
       
 
       
  | Block_sequence_first_entry

     

       
20
       
 
       
  | Block_sequence_entry

     

       
21
       
 
       
  | Indentless_sequence_entry

     
···

       
30
       
 
       
  | Flow_mapping_first_key

     

       
31
       
 
       
  | Flow_mapping_key

     

       
32
       
 
       
  | Flow_mapping_value

     

       
33
       
-
       
  | Flow_mapping_empty_value

     

       
34
       
 
       
  | End

     

       
35
       
 
       


     

       
36
       
 
       
type t = {

     

       
37
       
 
       
  scanner : Scanner.t;

     

       
38
       
 
       
  mutable state : state;

     

       
39
       
 
       
  mutable states : state list;  (** State stack *)

     

       
40
       
-
       
  mutable marks : Span.t list;  (** Mark stack for span tracking *)

     

       
41
       
 
       
  mutable version : (int * int) option;

     

       
42
       
 
       
  mutable tag_directives : (string * string) list;

     

       
43
       
 
       
  mutable current_token : Token.spanned option;

     
···

       
50
       
 
       
  scanner;

     

       
51
       
 
       
  state = Stream_start;

     

       
52
       
 
       
  states = [];

     

       
53
       
-
       
  marks = [];

     

       
54
       
 
       
  version = None;

     

       
55
       
 
       
  tag_directives = [

     

       
56
       
 
       
    ("!", "!");

     
···

       
645
       
 
       
       | _ ->

     

       
646
       
 
       
           parse_document_start t ~implicit:true)

     

       
647
       
 
       


     

       
648
       
-
       
  | Document_start ->

     

       
649
       
-
       
      parse_document_start t ~implicit:false

     

       
650
       
-
       


     

       
651
       
 
       
  | Document_content ->

     

       
652
       
 
       
      if check t (function

     

       
653
       
 
       
        | Token.Version_directive _ | Token.Tag_directive _

     
···

       
684
       
 
       
  | Document_end ->

     

       
685
       
 
       
      parse_document_end t

     

       
686
       
 
       


     

       
687
       
-
       
  | Block_node ->

     

       
688
       
-
       
      parse_node t ~block:true ~indentless:false

     

       
689
       
-
       


     

       
690
       
-
       
  | Block_node_or_indentless_sequence ->

     

       
691
       
-
       
      parse_node t ~block:true ~indentless:true

     

       
692
       
-
       


     

       
693
       
-
       
  | Flow_node ->

     

       
694
       
-
       
      parse_node t ~block:false ~indentless:false

     

       
695
       
-
       


     

       
696
       
 
       
  | Block_sequence_first_entry ->

     

       
697
       
 
       
      t.state <- Block_sequence_entry;

     

       
698
       
 
       
      parse_block_sequence_entry t

     
···

       
736
       
 
       


     

       
737
       
 
       
  | Flow_mapping_value ->

     

       
738
       
 
       
      parse_flow_mapping_value t ~empty:false

     

       
739
       
-
       


     

       
740
       
-
       
  | Flow_mapping_empty_value ->

     

       
741
       
-
       
      parse_flow_mapping_value t ~empty:true

     

       
742
       
 
       


     

       
743
       
 
       
  | End ->

     

       
744
       
 
       
      let span = Span.point Position.initial in

     

···

       
9
       
 
       
type state =

     

       
10
       
 
       
  | Stream_start

     

       
11
       
 
       
  | Implicit_document_start

     

       
0
       
 
       

     

       
12
       
 
       
  | Document_content

     

       
13
       
 
       
  | Document_content_done  (* After parsing a node, check for unexpected content *)

     

       
14
       
 
       
  | Document_end

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
15
       
 
       
  | Block_sequence_first_entry

     

       
16
       
 
       
  | Block_sequence_entry

     

       
17
       
 
       
  | Indentless_sequence_entry

     
···

       
26
       
 
       
  | Flow_mapping_first_key

     

       
27
       
 
       
  | Flow_mapping_key

     

       
28
       
 
       
  | Flow_mapping_value

     

       
0
       
 
       

     

       
29
       
 
       
  | End

     

       
30
       
 
       


     

       
31
       
 
       
type t = {

     

       
32
       
 
       
  scanner : Scanner.t;

     

       
33
       
 
       
  mutable state : state;

     

       
34
       
 
       
  mutable states : state list;  (** State stack *)

     

       
0
       
 
       

     

       
35
       
 
       
  mutable version : (int * int) option;

     

       
36
       
 
       
  mutable tag_directives : (string * string) list;

     

       
37
       
 
       
  mutable current_token : Token.spanned option;

     
···

       
44
       
 
       
  scanner;

     

       
45
       
 
       
  state = Stream_start;

     

       
46
       
 
       
  states = [];

     

       
0
       
 
       

     

       
47
       
 
       
  version = None;

     

       
48
       
 
       
  tag_directives = [

     

       
49
       
 
       
    ("!", "!");

     
···

       
638
       
 
       
       | _ ->

     

       
639
       
 
       
           parse_document_start t ~implicit:true)

     

       
640
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
641
       
 
       
  | Document_content ->

     

       
642
       
 
       
      if check t (function

     

       
643
       
 
       
        | Token.Version_directive _ | Token.Tag_directive _

     
···

       
674
       
 
       
  | Document_end ->

     

       
675
       
 
       
      parse_document_end t

     

       
676
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
677
       
 
       
  | Block_sequence_first_entry ->

     

       
678
       
 
       
      t.state <- Block_sequence_entry;

     

       
679
       
 
       
      parse_block_sequence_entry t

     
···

       
717
       
 
       


     

       
718
       
 
       
  | Flow_mapping_value ->

     

       
719
       
 
       
      parse_flow_mapping_value t ~empty:false

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
720
       
 
       


     

       
721
       
 
       
  | End ->

     

       
722
       
 
       
      let span = Span.point Position.initial in

     

···

       
17
       
 
       
type indent = {

     

       
18
       
 
       
  indent : int;

     

       
19
       
 
       
  needs_block_end : bool;

     

       
20
       
-
       
  sequence : bool;  (** true if this is a sequence indent *)

     

       
21
       
 
       
}

     

       
22
       
 
       


     

       
23
       
 
       
type t = {

     

       
24
       
 
       
  input : Input.t;

     

       
25
       
-
       
  mutable tokens : Token.spanned Queue.t;

     

       
26
       
 
       
  mutable token_number : int;

     

       
27
       
 
       
  mutable tokens_taken : int;

     

       
28
       
 
       
  mutable stream_started : bool;

     
···

       
35
       
 
       
  mutable leading_whitespace : bool;   (** True when at start of line (only whitespace seen) *)

     

       
36
       
 
       
  mutable document_has_content : bool; (** True if we've emitted content tokens in current document *)

     

       
37
       
 
       
  mutable adjacent_value_allowed_at : Position.t option; (** Position where adjacent : is allowed *)

     

       
38
       
-
       
  mutable pending_value : bool;        (** True if we've emitted a KEY and are waiting for VALUE *)

     

       
39
       
 
       
  mutable flow_mapping_stack : bool list;  (** Stack of whether each flow level is a mapping *)

     

       
40
       
 
       
}

     

       
41
       
 
       


     
···

       
55
       
 
       
    leading_whitespace = true;  (* Start at beginning of stream *)

     

       
56
       
 
       
    document_has_content = false;

     

       
57
       
 
       
    adjacent_value_allowed_at = None;

     

       
58
       
-
       
    pending_value = false;

     

       
59
       
 
       
    flow_mapping_stack = [];

     

       
60
       
 
       
  }

     

       
61
       
 
       


     
···

       
173
       
 
       
  end

     

       
174
       
 
       


     

       
175
       
 
       
(** Roll the indentation level *)

     

       
176
       
-
       
let roll_indent t col ~sequence =

     

       
177
       
 
       
  if t.flow_level = 0 && col > current_indent t then begin

     

       
178
       
-
       
    t.indent_stack <- { indent = col; needs_block_end = true; sequence } :: t.indent_stack;

     

       
179
       
 
       
    true

     

       
180
       
 
       
  end else

     

       
181
       
 
       
    false

     
···

       
1261
       
 
       
    if not t.allow_simple_key then

     

       
1262
       
 
       
      Error.raise_at (Input.mark t.input) Block_sequence_disallowed;

     

       
1263
       
 
       
    let col = column t in

     

       
1264
       
-
       
    if roll_indent t col ~sequence:true then begin

     

       
1265
       
 
       
      let span = Span.point (Input.mark t.input) in

     

       
1266
       
 
       
      emit t span Token.Block_sequence_start

     

       
1267
       
 
       
    end

     
···

       
1302
       
 
       
    if not t.allow_simple_key then

     

       
1303
       
 
       
      Error.raise_at (Input.mark t.input) Expected_key;

     

       
1304
       
 
       
    let col = column t in

     

       
1305
       
-
       
    if roll_indent t col ~sequence:false then begin

     

       
1306
       
 
       
      let span = Span.point (Input.mark t.input) in

     

       
1307
       
 
       
      emit t span Token.Block_mapping_start

     

       
1308
       
 
       
    end

     
···

       
1321
       
 
       
  end;

     

       
1322
       
 
       


     

       
1323
       
 
       
  let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       
1324
       
-
       
  emit t span Token.Key;

     

       
1325
       
-
       
  t.pending_value <- true  (* We've emitted a KEY, now waiting for VALUE *)

     

       
1326
       
 
       


     

       
1327
       
 
       
and check_value t =

     

       
1328
       
 
       
  (* : followed by whitespace in block, or whitespace/flow indicator in flow, or adjacent value *)

     
···

       
1366
       
 
       
        if insert_pos >= Array.length tokens then

     

       
1367
       
 
       
          Queue.add key_token t.tokens;

     

       
1368
       
 
       
        t.token_number <- t.token_number + 1;

     

       
1369
       
-
       
        t.pending_value <- true;  (* We've inserted a KEY token, now waiting for VALUE *)

     

       
1370
       
 
       
        (* Roll indent for implicit block mapping *)

     

       
1371
       
 
       
        if t.flow_level = 0 then begin

     

       
1372
       
 
       
          let col = sk.sk_position.column in

     

       
1373
       
-
       
          if roll_indent t col ~sequence:false then begin

     

       
1374
       
 
       
            let span = Span.point sk.sk_position in

     

       
1375
       
 
       
            (* Insert block mapping start before key *)

     

       
1376
       
 
       
            let bm_token = { Token.token = Token.Block_mapping_start; span } in

     
···

       
1393
       
 
       
          if not t.allow_simple_key then

     

       
1394
       
 
       
            Error.raise_at (Input.mark t.input) Expected_key;

     

       
1395
       
 
       
          let col = column t in

     

       
1396
       
-
       
          if roll_indent t col ~sequence:false then begin

     

       
1397
       
 
       
            let span = Span.point (Input.mark t.input) in

     

       
1398
       
 
       
            emit t span Token.Block_mapping_start

     

       
1399
       
 
       
          end

     
···

       
1428
       
 
       
  skip_whitespace_and_comment t;

     

       
1429
       
 
       


     

       
1430
       
 
       
  let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       
1431
       
-
       
  emit t span Token.Value;

     

       
1432
       
-
       
  t.pending_value <- false  (* We've emitted a VALUE, no longer pending *)

     

       
1433
       
 
       


     

       
1434
       
 
       
and fetch_anchor_or_alias t ~is_alias =

     

       
1435
       
 
       
  save_simple_key t;

     

···

       
17
       
 
       
type indent = {

     

       
18
       
 
       
  indent : int;

     

       
19
       
 
       
  needs_block_end : bool;

     

       
0
       
 
       

     

       
20
       
 
       
}

     

       
21
       
 
       


     

       
22
       
 
       
type t = {

     

       
23
       
 
       
  input : Input.t;

     

       
24
       
+
       
  tokens : Token.spanned Queue.t;

     

       
25
       
 
       
  mutable token_number : int;

     

       
26
       
 
       
  mutable tokens_taken : int;

     

       
27
       
 
       
  mutable stream_started : bool;

     
···

       
34
       
 
       
  mutable leading_whitespace : bool;   (** True when at start of line (only whitespace seen) *)

     

       
35
       
 
       
  mutable document_has_content : bool; (** True if we've emitted content tokens in current document *)

     

       
36
       
 
       
  mutable adjacent_value_allowed_at : Position.t option; (** Position where adjacent : is allowed *)

     

       
0
       
 
       

     

       
37
       
 
       
  mutable flow_mapping_stack : bool list;  (** Stack of whether each flow level is a mapping *)

     

       
38
       
 
       
}

     

       
39
       
 
       


     
···

       
53
       
 
       
    leading_whitespace = true;  (* Start at beginning of stream *)

     

       
54
       
 
       
    document_has_content = false;

     

       
55
       
 
       
    adjacent_value_allowed_at = None;

     

       
0
       
 
       

     

       
56
       
 
       
    flow_mapping_stack = [];

     

       
57
       
 
       
  }

     

       
58
       
 
       


     
···

       
170
       
 
       
  end

     

       
171
       
 
       


     

       
172
       
 
       
(** Roll the indentation level *)

     

       
173
       
+
       
let roll_indent t col =

     

       
174
       
 
       
  if t.flow_level = 0 && col > current_indent t then begin

     

       
175
       
+
       
    t.indent_stack <- { indent = col; needs_block_end = true } :: t.indent_stack;

     

       
176
       
 
       
    true

     

       
177
       
 
       
  end else

     

       
178
       
 
       
    false

     
···

       
1258
       
 
       
    if not t.allow_simple_key then

     

       
1259
       
 
       
      Error.raise_at (Input.mark t.input) Block_sequence_disallowed;

     

       
1260
       
 
       
    let col = column t in

     

       
1261
       
+
       
    if roll_indent t col then begin

     

       
1262
       
 
       
      let span = Span.point (Input.mark t.input) in

     

       
1263
       
 
       
      emit t span Token.Block_sequence_start

     

       
1264
       
 
       
    end

     
···

       
1299
       
 
       
    if not t.allow_simple_key then

     

       
1300
       
 
       
      Error.raise_at (Input.mark t.input) Expected_key;

     

       
1301
       
 
       
    let col = column t in

     

       
1302
       
+
       
    if roll_indent t col then begin

     

       
1303
       
 
       
      let span = Span.point (Input.mark t.input) in

     

       
1304
       
 
       
      emit t span Token.Block_mapping_start

     

       
1305
       
 
       
    end

     
···

       
1318
       
 
       
  end;

     

       
1319
       
 
       


     

       
1320
       
 
       
  let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       
1321
       
+
       
  emit t span Token.Key

     

       
0
       
 
       

     

       
1322
       
 
       


     

       
1323
       
 
       
and check_value t =

     

       
1324
       
 
       
  (* : followed by whitespace in block, or whitespace/flow indicator in flow, or adjacent value *)

     
···

       
1362
       
 
       
        if insert_pos >= Array.length tokens then

     

       
1363
       
 
       
          Queue.add key_token t.tokens;

     

       
1364
       
 
       
        t.token_number <- t.token_number + 1;

     

       
0
       
 
       

     

       
1365
       
 
       
        (* Roll indent for implicit block mapping *)

     

       
1366
       
 
       
        if t.flow_level = 0 then begin

     

       
1367
       
 
       
          let col = sk.sk_position.column in

     

       
1368
       
+
       
          if roll_indent t col then begin

     

       
1369
       
 
       
            let span = Span.point sk.sk_position in

     

       
1370
       
 
       
            (* Insert block mapping start before key *)

     

       
1371
       
 
       
            let bm_token = { Token.token = Token.Block_mapping_start; span } in

     
···

       
1388
       
 
       
          if not t.allow_simple_key then

     

       
1389
       
 
       
            Error.raise_at (Input.mark t.input) Expected_key;

     

       
1390
       
 
       
          let col = column t in

     

       
1391
       
+
       
          if roll_indent t col then begin

     

       
1392
       
 
       
            let span = Span.point (Input.mark t.input) in

     

       
1393
       
 
       
            emit t span Token.Block_mapping_start

     

       
1394
       
 
       
          end

     
···

       
1423
       
 
       
  skip_whitespace_and_comment t;

     

       
1424
       
 
       


     

       
1425
       
 
       
  let span = Span.make ~start ~stop:(Input.mark t.input) in

     

       
1426
       
+
       
  emit t span Token.Value

     

       
0
       
 
       

     

       
1427
       
 
       


     

       
1428
       
 
       
and fetch_anchor_or_alias t ~is_alias =

     

       
1429
       
 
       
  save_simple_key t;