+50 -9

lib/automata.ml

··· 79 79 | `First 80 80 ] 81 81 82 82 - let equal = Poly.equal 82 82 + let to_string = function 83 83 + | `Shortest -> "short" 84 84 + | `Longest -> "long" 85 85 + | `First -> "first" 86 86 + ;; 83 87 84 84 - let pp ch k = 85 85 - Format.pp_print_string 86 86 - ch 87 87 - (match k with 88 88 - | `Shortest -> "short" 89 89 - | `Longest -> "long" 90 90 - | `First -> "first") 91 91 - ;; 88 88 + let to_dyn t : Dyn.t = Enum (to_string t) 89 89 + let equal = Poly.equal 90 90 + let pp ch k = Format.pp_print_string ch (to_string k) 92 91 end 93 92 94 93 module Rep_kind = struct ··· 109 108 val compare : t -> t -> int 110 109 val equal : t -> t -> bool 111 110 val pp : t Fmt.t 111 111 + val to_dyn : t -> Dyn.t 112 112 val start : t 113 113 val prev : t -> t 114 114 val next : t -> t ··· 121 121 let equal = Int.equal 122 122 let compare = Int.compare 123 123 let pp = Format.pp_print_int 124 124 + let to_dyn = Dyn.int 124 125 let start = 0 125 126 let prev x = pred x 126 127 let next x = succ x ··· 136 137 type t = private int 137 138 138 139 val pp : t Fmt.t 140 140 + val to_dyn : t -> Dyn.t 139 141 val to_int : t -> int 140 142 val unknown : t 141 143 val initial : t ··· 145 147 end = struct 146 148 type t = int 147 149 150 150 + let to_dyn = Dyn.int 148 151 let to_int x = x 149 152 let pp = Format.pp_print_int 150 153 let used t = t >= 0 ··· 172 175 | After of Category.t 173 176 | Pmark of Pmark.t 174 177 178 178 + let rec dyn_of_def = 179 179 + let open Dyn in 180 180 + function 181 181 + | Cst cset -> variant "Cst" [ Cset.to_dyn cset ] 182 182 + | Alt alt -> variant "Alt" (List.map ~f:to_dyn alt) 183 183 + | Seq (sem, x, y) -> variant "Seq" [ Sem.to_dyn sem; to_dyn x; to_dyn y ] 184 184 + | Eps -> Enum "Eps" 185 185 + | Rep (_, sem, t) -> variant "Rep" [ Sem.to_dyn sem; to_dyn t ] 186 186 + | Mark m -> variant "Mark" [ Mark.to_dyn m ] 187 187 + | Pmark m -> variant "Pmark" [ Pmark.to_dyn m ] 188 188 + | Erase (x, y) -> variant "Erase" [ Mark.to_dyn x; Mark.to_dyn y ] 189 189 + | Before c -> variant "Before" [ Category.to_dyn c ] 190 190 + | After c -> variant "After" [ Category.to_dyn c ] 191 191 + 192 192 + and to_dyn { id = _; def } = dyn_of_def def 193 193 + 175 194 let rec pp ch e = 176 195 let open Fmt in 177 196 match e.def with ··· 239 258 ; pmarks : Pmark.Set.t 240 259 } 241 260 261 261 + let to_dyn { marks; pmarks } : Dyn.t = 262 262 + let open Dyn in 263 263 + record 264 264 + [ ( "marks" 265 265 + , List.map marks ~f:(fun (m, idx) -> pair (Mark.to_dyn m) (Idx.to_dyn idx)) 266 266 + |> list ) 267 267 + ; "pmarks", Pmark.Set.to_list pmarks |> List.map ~f:Pmark.to_dyn |> list 268 268 + ] 269 269 + ;; 270 270 + 242 271 let equal { marks; pmarks } t = 243 272 List.equal 244 273 ~eq:(fun (x, y) (x', y') -> Mark.equal x x' && Idx.equal y y') ··· 318 347 | TMatch of Marks.t 319 348 end 320 349 350 350 + val to_dyn : t -> Dyn.t 321 351 val fold_right : t -> init:'acc -> f:(E.t -> 'acc -> 'acc) -> 'acc 322 352 val tseq : Sem.t -> t -> Expr.t -> t -> t 323 353 val initial : Expr.t -> t ··· 368 398 369 399 type t = E.t list 370 400 401 401 + let rec to_dyn t = Dyn.list (List.map ~f:dyn_of_e t) 402 402 + 403 403 + and dyn_of_e = 404 404 + let open Dyn in 405 405 + function 406 406 + | E.TSeq (sem, x, y) -> variant "TSeq" [ Sem.to_dyn sem; to_dyn x; Expr.to_dyn y ] 407 407 + | TExp (marks, e) -> variant "TExp" [ Marks.to_dyn marks; Expr.to_dyn e ] 408 408 + | TMatch m -> variant "TMarks" [ Marks.to_dyn m ] 409 409 + ;; 410 410 + 371 411 open E 372 412 373 413 let equal = E.equal_list ··· 507 547 } 508 548 509 549 let[@inline] idx t = t.idx 550 550 + let to_dyn t = Desc.to_dyn t.desc 510 551 511 552 let dummy = 512 553 { idx = Idx.unknown

+1

lib/automata.mli

··· 100 100 val create : Category.t -> expr -> t 101 101 val idx : t -> Idx.t 102 102 val status : t -> Status.t 103 103 + val to_dyn : t -> Dyn.t 103 104 104 105 module Table : Hashtbl.S with type key = t 105 106 end

+1

lib/category.ml

··· 13 13 let newline = 8 14 14 let lastnewline = 16 15 15 let search_boundary = 32 16 16 + let to_dyn = Dyn.int 16 17 17 18 let from_char = function 18 19 (* Should match [cword] definition *)

+1

lib/category.mli

··· 19 19 val compare : t -> t -> int 20 20 val intersect : t -> t -> bool 21 21 val pp : t Fmt.t 22 22 + val to_dyn : t -> Dyn.t

+5

lib/cset.ml

··· 129 129 130 130 let pp = Fmt.list ~pp_sep:(Fmt.lit ", ") print_one 131 131 132 132 + let to_dyn t = 133 133 + let open Dyn in 134 134 + List.map t ~f:(fun (x, y) -> pair (int x) (int y)) |> list 135 135 + ;; 136 136 + 132 137 let rec iter t ~f = 133 138 match t with 134 139 | [] -> ()

+1

lib/cset.mli

··· 81 81 val prepend : t -> 'a list -> (t * 'a list) list -> (t * 'a list) list 82 82 val pick : t -> c 83 83 val offset : int -> t -> t 84 84 + val to_dyn : t -> Dyn.t

+13

lib/dyn.ml

··· 1 1 + type t = 2 2 + | Int of int 3 3 + | Pair of t * t 4 4 + | Enum of string 5 5 + | List of t list 6 6 + | Constructor of string * t list 7 7 + | Record of (string * t) list 8 8 + 9 9 + let variant x y = Constructor (x, y) 10 10 + let list x = List x 11 11 + let int x = Int x 12 12 + let pair x y = Pair (x, y) 13 13 + let record fields = Record fields

+2

lib/pmark.ml

··· 25 25 26 26 include Set 27 27 end 28 28 + 29 29 + let to_dyn = Dyn.int

+1

lib/pmark.mli

··· 4 4 val compare : t -> t -> int 5 5 val gen : unit -> t 6 6 val pp : t Fmt.t 7 7 + val to_dyn : t -> Dyn.t 7 8 8 9 module Set : sig 9 10 include Set.S with type elt = t