94 lines
3.7 KiB
OCaml
94 lines
3.7 KiB
OCaml
(** A program source file, read by the reader its extension names: [.fln] is
|
|
the indented syntax ([Indent_reader]), anything else the paren syntax
|
|
([Reader]). Both give the same [Form.t], so nothing past this point knows
|
|
which one a file was written in, and a program may mix them freely.
|
|
|
|
Only program sources come through here. The prelude, the wire protocol and
|
|
the registry's spellings are paren text the compiler writes itself, and
|
|
read it with [Reader] directly. *)
|
|
|
|
let indented_ext = ".fln"
|
|
let paren_ext = ".flan"
|
|
|
|
let is_indented path = Filename.check_suffix path indented_ext
|
|
|
|
(** A file a package directory contributes, in either syntax. *)
|
|
let is_source path =
|
|
Filename.check_suffix path paren_ext || is_indented path
|
|
|
|
let read_file path =
|
|
if is_indented path then Indent_reader.read_file path else Reader.read_file path
|
|
|
|
(* ── Code from the editor ─────────────────────────────────────────────
|
|
|
|
The dev loop's code-carrying requests say which syntax their [:code] is in
|
|
([:syntax]), and where in the buffer it starts ([:line], [:col]), rather
|
|
than having it guessed from [:file]: an expansion shown in paren syntax is
|
|
sent back under the name of the .fln file it came from, and a REPL line has
|
|
no file at all. [Dev] sets these for the length of one request, and every
|
|
place the session reads editor code reads it through [read_code]. *)
|
|
|
|
type syntax = Paren | Indented
|
|
|
|
let code_syntax = ref Paren
|
|
let code_at : (int * int) option ref = ref None
|
|
|
|
(* The column of the statement editor code was cut out of, when the code
|
|
starts after that statement's first word: see [Indent_reader.layout]. *)
|
|
let code_indent : int option ref = ref None
|
|
|
|
let syntax_of_field = function
|
|
| Some ("indented" | "fln") -> Indented
|
|
| _ -> Paren
|
|
|
|
let in_request = ref false
|
|
|
|
let with_code ?indent ~syntax ~at f =
|
|
let s = !code_syntax and a = !code_at and i = !code_indent
|
|
and r = !in_request in
|
|
code_syntax := syntax;
|
|
code_at := at;
|
|
code_indent := indent;
|
|
in_request := true;
|
|
Fun.protect
|
|
~finally:(fun () ->
|
|
code_syntax := s; code_at := a; code_indent := i; in_request := r) f
|
|
|
|
(* Was the code at [loc] written in the indented syntax? Inside an editor
|
|
request the request says; outside one a file's name does, as
|
|
[read_file] decides. *)
|
|
let indented_at (loc : Loc.t) =
|
|
if !in_request then !code_syntax = Indented else is_indented loc.Loc.file
|
|
|
|
(* The paren reader started at a line and column: [Reader.read_all] always
|
|
starts at 1:1. *)
|
|
let read_paren ?(line = 1) ?(col = 1) ~file src =
|
|
let st = Reader.of_string ~file src in
|
|
st.Reader.line <- line;
|
|
st.Reader.col <- col;
|
|
let rec go acc =
|
|
Reader.skip_ignorable st;
|
|
if Reader.at_end st then List.rev acc else go (Reader.read_form st :: acc)
|
|
in
|
|
go []
|
|
|
|
(** Editor code, in the request's syntax and at its position. With [expr], an
|
|
indented snippet of several statements is one expression, [(do ...)]: a
|
|
block of lines means its lines in order. *)
|
|
let read_code ?(expr = false) ~file code =
|
|
let line, col =
|
|
match !code_at with Some (l, c) -> (l, c) | None -> (1, 1)
|
|
in
|
|
match !code_syntax with
|
|
| Paren -> read_paren ~line ~col ~file code
|
|
| Indented ->
|
|
(match Indent_reader.read_all ~line ~col ?indent:!code_indent ~file code with
|
|
| (first :: _ :: _ as forms) when expr ->
|
|
let last = List.nth forms (List.length forms - 1) in
|
|
let loc =
|
|
{ first.Form.loc with Loc.eline = last.Form.loc.Loc.eline;
|
|
ecol = last.Form.loc.Loc.ecol }
|
|
in
|
|
[ Form.make (Form.List (Form.make (Form.Sym "do") first.Form.loc :: forms)) loc ]
|
|
| forms -> forms)
|