Source file parsing.ml

(*************************************************************************)
(* Copyright 2015-2019 MINES ParisTech -- Dual License LGPL 2.1+ / GPL3+ *)
(* Copyright 2019-2024 Inria           -- Dual License LGPL 2.1+ / GPL3+ *)
(* Copyright 2024-2025 Emilio J. Gallego Arias  -- LGPL 2.1+ / GPL3+     *)
(* Copyright 2025      CNRS                     -- LGPL 2.1+ / GPL3+     *)
(* Written by: Emilio J. Gallego Arias & coq-lsp contributors            *)
(*************************************************************************)
(* Rocq Language Server Protocol: Rocq parsing API                       *)
(*************************************************************************)

module Lexer = struct
  let after = CLexer.after
end

module Stream = struct
  let of_string = Gramlib.Stream.of_string
end

module Pcoq = Procq
module Parsable = Pcoq.Parsable

let parse ~st ps =
  (* Coq is missing this, so we add it here. Note that this MUST run inside
     coq_protect *)
  Control.check_for_interrupt ();
  let mode = State.mode ~st in
  Pcoq.Entry.parse Pvernac.(main_entry mode) ps |> Option.map Ast.of_coq

let parse ~token ~st ps =
  (* This runs already inside Coq.protect *)
  State.in_state ~token ~st ~f:(parse ~st) ps

let parse ~token ~st ps =
  NewProfile.profile "Coq.parse" (fun () -> parse ~token ~st ps) ()

(* Read the input stream until a dot or a "end of proof" token is encountered *)
let parse_to_terminator : unit Pcoq.Entry.t =
  (* type 'a parser_fun = { parser_fun : te LStream.t -> 'a } *)
  let rec dot kwstate st =
    match Gramlib.LStream.next kwstate st with
    | Tok.KEYWORD ("." | "..." | "Qed" | "Defined" | "Admitted") | Tok.BULLET _
      -> ()
    | Tok.EOI -> ()
    | _ -> dot kwstate st
  in
  Pcoq.Entry.of_parser "Coqtoplevel.dot" { parser_fun = dot }

(* If an error occurred while parsing, we try to read the input until a dot
   token is encountered. We assume that when a lexer error occurs, at least one
   char was eaten *)
let rec discard_to_dot ps =
  try Pcoq.Entry.parse parse_to_terminator ps with
  | CLexer.Error.E _ -> discard_to_dot ps
  | e when CErrors.noncritical e -> ()