| 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 |
;; |