Debian Codegraph @

otherlibs/ocamlc-loc/src/ocamlc_loc.ml

raw
1 include Lexer
2 module List = ListLabels
3
4 type report =
5 { loc : loc
6 ; severity : severity
7 ; message : string
8 ; related : (loc * string) list
9 }
10
11 let dyn_of_code { code; name } =
12 let open Dyn in
13 record [ "code", int code; "name", string name ]
14 ;;
15
16 let dyn_of_source =
17 let open Dyn in
18 function
19 | Code { code; name } -> record [ "code", int code; "name", string name ]
20 | Alert s -> string s
21 ;;
22
23 let dyn_of_severity =
24 let open Dyn in
25 function
26 | Error w -> variant "Error" [ option dyn_of_source w ]
27 | Warning w -> variant "Warning" [ dyn_of_code w ]
28 | Alert { name; source } ->
29 variant "Alert" [ record [ "name", string name; "source", string source ] ]
30 ;;
31
32 let dyn_of_loc { path; lines; chars } =
33 let open Dyn in
34 record
35 [ "path", string path
36 ; ( "line"
37 , match lines with
38 | Single i -> variant "Single" [ int i ]
39 | Range (i, j) -> variant "Range" [ int i; int j ] )
40 ; "chars", option (pair int int) chars
41 ]
42 ;;
43
44 let dyn_of_report { loc; message; related; severity } =
45 let open Dyn in
46 record
47 [ "loc", dyn_of_loc loc
48 ; "message", string message
49 ; "related", list (pair dyn_of_loc string) related
50 ; "severity", dyn_of_severity severity
51 ]
52 ;;
53
54 module Tokens : sig
55 type t
56
57 val create : Lexing.lexbuf -> t
58 val peek : t -> Lexer.token
59 val junk : t -> unit
60 val push : t -> Lexer.token -> unit
61 val next : t -> Lexer.token
62 end = struct
63 type t =
64 { lexbuf : Lexing.lexbuf
65 ; mutable unread : Lexer.token list
66 }
67
68 let create lexbuf = { lexbuf; unread = [] }
69 let push t token = t.unread <- token :: t.unread
70
71 let next t =
72 match t.unread with
73 | [] -> Lexer.token t.lexbuf
74 | x :: xs ->
75 t.unread <- xs;
76 x
77 ;;
78
79 let peek t =
80 match t.unread with
81 | x :: _ -> x
82 | [] ->
83 let token = Lexer.token t.lexbuf in
84 t.unread <- [ token ];
85 token
86 ;;
87
88 let junk t =
89 match t.unread with
90 | _ :: xs -> t.unread <- xs
91 | _ -> ignore (Lexer.token t.lexbuf)
92 ;;
93 end
94
95 let indent_of_severity = function
96 | Error _ -> String.length "Error: "
97 | Warning _ -> String.length "Warning: "
98 | Alert { name; source } ->
99 String.length "Alert :" + String.length name + String.length source + 1
100 ;;
101
102 let severity tokens =
103 match Tokens.peek tokens with
104 | Line { contents; indent } ->
105 (match Lexer.severity (Lexing.from_string contents) with
106 | None -> raise Unknown_format
107 | Some (severity, new_contents) ->
108 Tokens.junk tokens;
109 let indent = indent_of_severity severity + indent in
110 Tokens.push tokens (Line { indent; contents = new_contents });
111 severity)
112 | _ -> raise Unknown_format
113 ;;
114
115 let skip_excerpt =
116 let make_skip_excerpt tokens self lex =
117 match Tokens.peek tokens with
118 | Line { contents; indent = _ } ->
119 (match lex (Lexing.from_string contents) with
120 | `Continue ->
121 Tokens.junk tokens;
122 self tokens
123 | `Stop -> ())
124 | _ -> ()
125 in
126 let rec tail tokens = make_skip_excerpt tokens tail Lexer.skip_excerpt_tail in
127 let head tokens = make_skip_excerpt tokens tail Lexer.skip_excerpt_head in
128 head
129 ;;
130
131 let rec acc_message tokens min_indent acc =
132 match Tokens.peek tokens with
133 | Line line ->
134 Tokens.junk tokens;
135 let min_indent = min min_indent line.indent in
136 acc_message tokens min_indent (line :: acc)
137 | _ ->
138 List.rev_map acc ~f:(fun { indent; contents } ->
139 let prefix = String.make (indent - min_indent) ' ' in
140 prefix ^ contents)
141 |> String.concat "\n"
142 |> String.trim
143 ;;
144
145 let rec related tokens acc =
146 match Tokens.peek tokens with
147 | Loc { indent; message; loc } ->
148 if indent = 0
149 then List.rev acc
150 else (
151 Tokens.junk tokens;
152 let message = acc_message tokens indent [ { indent; contents = message } ] in
153 let acc = (loc, message) :: acc in
154 related tokens acc)
155 | _ -> List.rev acc
156 ;;
157
158 let toplevel tokens =
159 match Tokens.next tokens with
160 | Loc { indent; message; loc } ->
161 if indent > 0 then raise Unknown_format;
162 skip_excerpt tokens;
163 let severity = severity tokens in
164 let indent = indent + indent_of_severity severity in
165 let message = acc_message tokens indent [ { indent; contents = message } ] in
166 let related = related tokens [] in
167 { loc; severity; message; related }
168 | _ -> raise Unknown_format
169 ;;
170
171 let parse s =
172 let lexbuf = Lexing.from_string s in
173 let tokens = Tokens.create lexbuf in
174 let rec loop acc =
175 match toplevel tokens with
176 | exception Unknown_format -> List.rev acc
177 | t -> loop (t :: acc)
178 in
179 loop []
180 ;;
181
182 let dyn_of_raw =
183 Dyn.list (function
184 | `Loc loc -> dyn_of_loc loc
185 | `Message m -> Dyn.string m)
186 ;;
187
188 let parse_raw s =
189 let lexbuf = Lexing.from_string s in
190 let tokens = Tokens.create lexbuf in
191 let rec loop acc =
192 match Tokens.peek tokens with
193 | Loc { loc; message; indent } ->
194 Tokens.junk tokens;
195 let acc = `Loc loc :: acc in
196 let message = acc_message tokens indent [ { contents = message; indent } ] in
197 let acc = `Message message :: acc in
198 loop acc
199 | Line line ->
200 Tokens.junk tokens;
201 let message = acc_message tokens line.indent [ line ] in
202 let acc = `Message message :: acc in
203 loop acc
204 | Eof ->
205 Tokens.junk tokens;
206 List.rev acc
207 in
208 loop []
209 ;;