646 lines
20 KiB
OCaml
646 lines
20 KiB
OCaml
(* Js_of_ocaml toplevel
|
|
* http://www.ocsigen.org/js_of_ocaml/
|
|
* Copyright (C) 2011 Jérôme Vouillon
|
|
* Laboratoire PPS - CNRS Université Paris Diderot
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, with linking exception;
|
|
* either version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*)
|
|
|
|
open Js_of_ocaml
|
|
open Js_of_ocaml_lwt
|
|
open Js_of_ocaml_tyxml
|
|
open Js_of_ocaml_toplevel
|
|
open Lwt
|
|
|
|
module Graphics_support = struct
|
|
let init elt = Graphics_js.open_canvas elt
|
|
end
|
|
|
|
module Log = Log_js.Log
|
|
|
|
module Ppx_support = struct
|
|
let init () =
|
|
Ppx_graph.init ();
|
|
Ast_mapper.register "js_of_ocaml" (fun _ -> Ppx_js.mapper);
|
|
Ast_mapper.register "ppxlib" (fun _ ->
|
|
Log.info (fun m -> m "Ppxlib.mapper");
|
|
{
|
|
Ast_mapper.default_mapper with
|
|
structure =
|
|
(fun _ ->
|
|
Log.info (fun m -> m "Ppxlib.Driver.map_structure");
|
|
Ppxlib.Driver.map_structure);
|
|
signature =
|
|
(fun _ ->
|
|
Log.info (fun m -> m "Ppxlib.Driver.map_signature");
|
|
Ppxlib.Driver.map_signature);
|
|
})
|
|
end
|
|
|
|
module Colorize = struct
|
|
open Js_of_ocaml
|
|
open Js_of_ocaml_tyxml
|
|
|
|
let text ~a_class:cl s =
|
|
Tyxml_js.Html.(span ~a:[ a_class [ cl ] ] [ txt s ])
|
|
|
|
let ocaml = text
|
|
|
|
let highlight from_ to_ e =
|
|
match Js.Opt.to_option e##.textContent with
|
|
| None -> assert false
|
|
| Some x ->
|
|
let x = Js.to_string x in
|
|
let (`Pos from_) = from_ in
|
|
let to_ =
|
|
match to_ with `Pos n -> n | `Last -> String.length x - 1
|
|
in
|
|
e##.innerHTML := Js.string "";
|
|
let span kind s =
|
|
if s <> "" then
|
|
let span =
|
|
Tyxml_js.Html.(span ~a:[ a_class [ kind ] ] [ txt s ])
|
|
in
|
|
Dom.appendChild e (Tyxml_js.To_dom.of_element span)
|
|
in
|
|
span "normal" (String.sub x 0 from_);
|
|
span "errorloc" (String.sub x from_ (to_ - from_));
|
|
span "normal" (String.sub x to_ (String.length x - to_))
|
|
end
|
|
|
|
module Indent : sig
|
|
val textarea : Dom_html.textAreaElement Js.t -> unit
|
|
end = struct
|
|
let _ = Approx_lexer.enable_extension "lwt"
|
|
|
|
let indent s in_lines =
|
|
let output =
|
|
{
|
|
IndentPrinter.debug = false;
|
|
config = IndentConfig.default;
|
|
in_lines;
|
|
indent_empty = true;
|
|
adaptive = true;
|
|
kind = IndentPrinter.Print (fun s acc -> acc ^ s);
|
|
}
|
|
in
|
|
let stream = Nstream.of_string s in
|
|
IndentPrinter.proceed output stream IndentBlock.empty ""
|
|
|
|
let textarea (textbox : Dom_html.textAreaElement Js.t) : unit =
|
|
let rec loop s acc (i, pos') =
|
|
try
|
|
let pos = String.index_from s pos' '\n' in
|
|
loop s ((i, (pos', pos)) :: acc) (succ i, succ pos)
|
|
with _ -> List.rev ((i, (pos', String.length s)) :: acc)
|
|
in
|
|
let rec find (l : (int * (int * int)) list) c =
|
|
match l with
|
|
| [] -> assert false
|
|
| (i, (lo, up)) :: _ when up >= c -> (c, i, lo, up)
|
|
| (_, (_lo, _up)) :: rem -> find rem c
|
|
in
|
|
let v = textbox##.value in
|
|
let pos =
|
|
let c1 = textbox##.selectionStart
|
|
and c2 = textbox##.selectionEnd in
|
|
if
|
|
Js.Opt.test (Js.Opt.return c1)
|
|
&& Js.Opt.test (Js.Opt.return c2)
|
|
then
|
|
let l = loop (Js.to_string v) [] (0, 0) in
|
|
Some (find l c1, find l c2)
|
|
else None
|
|
in
|
|
let f =
|
|
match pos with
|
|
| None -> fun _ -> true
|
|
| Some ((_c1, line1, _lo1, _up1), (_c2, line2, _lo2, _up2)) ->
|
|
fun l -> l >= line1 + 1 && l <= line2 + 1
|
|
in
|
|
let v = indent (Js.to_string v) f in
|
|
textbox##.value := Js.string v;
|
|
match pos with
|
|
| Some ((c1, line1, _lo1, up1), (c2, line2, _lo2, up2)) ->
|
|
let l = loop v [] (0, 0) in
|
|
let lo1'', up1'' = List.assoc line1 l in
|
|
let lo2'', up2'' = List.assoc line2 l in
|
|
let n1 = max (c1 + up1'' - up1) lo1'' in
|
|
let n2 = max (c2 + up2'' - up2) lo2'' in
|
|
let () = (Obj.magic textbox)##setSelectionRange n1 n2 in
|
|
textbox##focus;
|
|
()
|
|
| None -> ()
|
|
end
|
|
|
|
let compiler_name = "OCaml"
|
|
let by_id s = Dom_html.getElementById s
|
|
|
|
let by_id_coerce s f =
|
|
Js.Opt.get
|
|
(f (Dom_html.getElementById s))
|
|
(fun () -> raise Not_found)
|
|
|
|
let do_by_id s f =
|
|
try f (Dom_html.getElementById s) with Not_found -> ()
|
|
|
|
(* load file using a synchronous XMLHttpRequest *)
|
|
let load_resource_aux filename url =
|
|
Js_of_ocaml_lwt.XmlHttpRequest.perform_raw
|
|
~response_type:XmlHttpRequest.ArrayBuffer url
|
|
>|= fun frame ->
|
|
if frame.Js_of_ocaml_lwt.XmlHttpRequest.code = 200 then
|
|
Js.Opt.case frame.Js_of_ocaml_lwt.XmlHttpRequest.content
|
|
(fun () -> Printf.eprintf "Could not load %s\n" filename)
|
|
(fun b ->
|
|
Sys_js.update_file ~name:filename
|
|
~content:(Typed_array.String.of_arrayBuffer b))
|
|
else ()
|
|
|
|
let load_resource scheme ~prefix ~path:suffix =
|
|
let url = scheme ^ suffix in
|
|
let filename = Filename.concat prefix suffix in
|
|
Lwt.async (fun () -> load_resource_aux filename url);
|
|
Some ""
|
|
|
|
let setup_pseudo_fs () =
|
|
Sys_js.mount ~path:"/dev/" (fun ~prefix:_ ~path:_ -> None);
|
|
Sys_js.mount ~path:"/http/" (load_resource "http://");
|
|
Sys_js.mount ~path:"/https/" (load_resource "https://");
|
|
Sys_js.mount ~path:"/ftp/" (load_resource "ftp://");
|
|
Sys_js.mount ~path:"/home/" (load_resource "filesys/")
|
|
|
|
let exec' s =
|
|
let res : bool = JsooTop.use Format.std_formatter s in
|
|
if not res then Format.eprintf "error while evaluating %s@." s
|
|
|
|
module Version = struct
|
|
type t = int list
|
|
|
|
let split_char ~sep p =
|
|
let len = String.length p in
|
|
let rec split beg cur =
|
|
if cur >= len then
|
|
if cur - beg > 0 then [ String.sub p beg (cur - beg) ] else []
|
|
else if sep p.[cur] then
|
|
String.sub p beg (cur - beg) :: split (cur + 1) (cur + 1)
|
|
else split beg (cur + 1)
|
|
in
|
|
split 0 0
|
|
|
|
let split v =
|
|
match
|
|
split_char
|
|
~sep:(function '+' | '-' | '~' -> true | _ -> false)
|
|
v
|
|
with
|
|
| [] -> assert false
|
|
| x :: _ ->
|
|
List.map int_of_string
|
|
(split_char ~sep:(function '.' -> true | _ -> false) x)
|
|
|
|
let current : t = split Sys.ocaml_version
|
|
let compint (a : int) b = compare a b
|
|
|
|
let rec compare v v' =
|
|
match (v, v') with
|
|
| [ x ], [ y ] -> compint x y
|
|
| [], [] -> 0
|
|
| [], y :: _ -> compint 0 y
|
|
| x :: _, [] -> compint x 0
|
|
| x :: xs, y :: ys -> (
|
|
match compint x y with 0 -> compare xs ys | n -> n)
|
|
end
|
|
|
|
let setup_toplevel () =
|
|
JsooTop.initialize ();
|
|
Sys.interactive := false;
|
|
if Version.compare Version.current [ 4; 07 ] >= 0 then
|
|
exec' "open Stdlib";
|
|
exec'
|
|
"module Lwt_main = struct\n\
|
|
\ let run t = match Lwt.state t with\n\
|
|
\ | Lwt.Return x -> x\n\
|
|
\ | Lwt.Fail e -> raise e\n\
|
|
\ | Lwt.Sleep -> failwith \"Lwt_main.run: thread \
|
|
didn't return\"\n\
|
|
\ end";
|
|
let header1 =
|
|
Printf.sprintf " %s version %%s" compiler_name
|
|
in
|
|
let header2 =
|
|
Printf.sprintf " Compiled with Js_of_ocaml version %s"
|
|
Sys_js.js_of_ocaml_version
|
|
in
|
|
exec'
|
|
(Printf.sprintf "Format.printf \"%s@.\" Sys.ocaml_version;;"
|
|
header1);
|
|
exec' (Printf.sprintf "Format.printf \"%s@.\";;" header2);
|
|
exec' "#enable \"pretty\";;";
|
|
exec' "#disable \"shortvar\";;";
|
|
Ppx_support.init ();
|
|
let[@alert "-deprecated"] new_directive n k =
|
|
Hashtbl.add Toploop.directive_table n k
|
|
in
|
|
new_directive "load_js"
|
|
(Toploop.Directive_string
|
|
(fun name -> Js.Unsafe.global##load_script_ name));
|
|
Sys.interactive := true;
|
|
()
|
|
|
|
let resize ~container ~textbox () =
|
|
Lwt.pause () >>= fun () ->
|
|
textbox##.style##.height := Js.string "auto";
|
|
textbox##.style##.height
|
|
:= Js.string (Printf.sprintf "%dpx" (max 18 textbox##.scrollHeight));
|
|
container##.scrollTop := container##.scrollHeight;
|
|
Lwt.return ()
|
|
|
|
let setup_printers () =
|
|
exec'
|
|
"let _print_error fmt e = Format.pp_print_string fmt \
|
|
(Js_of_ocaml.Js_error.to_string e)";
|
|
Topdirs.dir_install_printer Format.std_formatter
|
|
Longident.(Lident "_print_error");
|
|
exec'
|
|
"let _print_unit fmt (_ : 'a) : 'a = Format.pp_print_string fmt \
|
|
\"()\"";
|
|
Topdirs.dir_install_printer Format.std_formatter
|
|
Longident.(Lident "_print_unit")
|
|
|
|
let setup_examples ~container ~textbox =
|
|
let r = Regexp.regexp "^\\(\\*+(.*)\\*+\\)$" in
|
|
let all = ref [] in
|
|
(try
|
|
let ic = open_in "/static/examples.ml" in
|
|
while true do
|
|
let line = input_line ic in
|
|
match Regexp.string_match r line 0 with
|
|
| Some res ->
|
|
let name =
|
|
match Regexp.matched_group res 1 with
|
|
| Some s -> s
|
|
| None -> assert false
|
|
in
|
|
all := `Title name :: !all
|
|
| None -> all := `Content line :: !all
|
|
done;
|
|
assert false
|
|
with _ -> ());
|
|
let example_container = by_id "toplevel-examples" in
|
|
let _ =
|
|
List.fold_left
|
|
(fun acc tok ->
|
|
match tok with
|
|
| `Content line -> line ^ "\n" ^ acc
|
|
| `Title name ->
|
|
let a =
|
|
Tyxml_js.Html.(
|
|
a
|
|
~a:
|
|
[
|
|
a_class [ "list-group-item" ];
|
|
a_onclick (fun _ ->
|
|
textbox##.value := (Js.string acc)##trim;
|
|
Lwt.async (fun () ->
|
|
resize ~container ~textbox ()
|
|
>>= fun () ->
|
|
textbox##focus;
|
|
Lwt.return_unit);
|
|
true);
|
|
]
|
|
[ txt name ])
|
|
in
|
|
Dom.appendChild example_container (Tyxml_js.To_dom.of_a a);
|
|
"")
|
|
"" !all
|
|
in
|
|
()
|
|
|
|
(* we need to compute the hash form href to avoid different encoding behavior
|
|
across browser. see Url.get_fragment *)
|
|
let parse_hash () =
|
|
let frag = Url.Current.get_fragment () in
|
|
Url.decode_arguments frag
|
|
|
|
let rec iter_on_sharp ~f x =
|
|
Js.Opt.iter (Dom_html.CoerceTo.element x) (fun e ->
|
|
if Js.to_bool (e##.classList##contains (Js.string "sharp")) then
|
|
f e);
|
|
match Js.Opt.to_option x##.nextSibling with
|
|
| None -> ()
|
|
| Some n -> iter_on_sharp ~f n
|
|
|
|
let setup_share_button ~output =
|
|
do_by_id "btn-share" (fun e ->
|
|
e##.style##.display := Js.string "block";
|
|
e##.onclick :=
|
|
Dom_html.handler (fun _ ->
|
|
(* get all ocaml code *)
|
|
let code = ref [] in
|
|
Js.Opt.iter output##.firstChild
|
|
(iter_on_sharp ~f:(fun e ->
|
|
code :=
|
|
Js.Opt.case e##.textContent
|
|
(fun () -> "")
|
|
Js.to_string
|
|
:: !code));
|
|
let code_encoded = String.concat "" (List.rev !code) in
|
|
let url, is_file =
|
|
match Url.Current.get () with
|
|
| Some (Url.Http url) ->
|
|
(Url.Http { url with Url.hu_fragment = "" }, false)
|
|
| Some (Url.Https url) ->
|
|
(Url.Https { url with Url.hu_fragment = "" }, false)
|
|
| Some (Url.File url) ->
|
|
(Url.File { url with Url.fu_fragment = "" }, true)
|
|
| _ -> assert false
|
|
in
|
|
let frag =
|
|
let frags = parse_hash () in
|
|
let frags =
|
|
List.remove_assoc "code" frags
|
|
@ [ ("code", code_encoded) ]
|
|
in
|
|
Url.encode_arguments frags
|
|
in
|
|
let uri = Url.string_of_url url ^ "#" ^ frag in
|
|
let append_url str =
|
|
let dom =
|
|
Tyxml_js.Html.(
|
|
p
|
|
[
|
|
txt "Share this url : ";
|
|
a ~a:[ a_href str ] [ txt str ];
|
|
])
|
|
in
|
|
Dom.appendChild output (Tyxml_js.To_dom.of_element dom)
|
|
in
|
|
Lwt.async (fun () ->
|
|
Lwt.catch
|
|
(fun () ->
|
|
if is_file then
|
|
failwith "Cannot shorten url with file scheme"
|
|
else
|
|
let uri =
|
|
Printf.sprintf
|
|
"http://is.gd/create.php?format=json&url=%s"
|
|
(Url.urlencode uri)
|
|
in
|
|
Lwt.bind (Js_of_ocaml_lwt.Jsonp.call uri)
|
|
(fun o ->
|
|
let str = Js.to_string o##.shorturl in
|
|
append_url str;
|
|
Lwt.return_unit))
|
|
(fun exn ->
|
|
Format.eprintf
|
|
"Could not generate short url. reason: %s@."
|
|
(Printexc.to_string exn);
|
|
append_url uri;
|
|
Lwt.return_unit));
|
|
Js._false))
|
|
|
|
let setup_js_preview () =
|
|
let ph = by_id "last-js" in
|
|
let runcode : string -> 'a = Js.Unsafe.global##.toplevelEval in
|
|
Js.Unsafe.global##.toplevelEval := fun bc ->
|
|
ph##.innerHTML := Js.string bc;
|
|
runcode bc
|
|
|
|
let current_position = ref 0
|
|
|
|
let highlight_location loc =
|
|
let x = ref 0 in
|
|
let output = by_id "output" in
|
|
let first =
|
|
Js.Opt.get
|
|
(output##.childNodes##item !current_position)
|
|
(fun _ -> assert false)
|
|
in
|
|
iter_on_sharp first ~f:(fun e ->
|
|
incr x;
|
|
let _file1, line1, col1 =
|
|
Location.get_pos_info loc.Location.loc_start
|
|
in
|
|
let _file2, line2, col2 =
|
|
Location.get_pos_info loc.Location.loc_end
|
|
in
|
|
if !x >= line1 && !x <= line2 then
|
|
let from_ = if !x = line1 then `Pos col1 else `Pos 0 in
|
|
let to_ = if !x = line2 then `Pos col2 else `Last in
|
|
Colorize.highlight from_ to_ e)
|
|
|
|
let append colorize output cl s =
|
|
Dom.appendChild output
|
|
(Tyxml_js.To_dom.of_element (colorize ~a_class:cl s))
|
|
|
|
module History = struct
|
|
let data = ref [| "" |]
|
|
let idx = ref 0
|
|
|
|
let get_storage () =
|
|
match Js.Optdef.to_option Dom_html.window##.localStorage with
|
|
| exception _ -> raise Not_found
|
|
| None -> raise Not_found
|
|
| Some t -> t
|
|
|
|
let setup () =
|
|
try
|
|
let s = get_storage () in
|
|
match Js.Opt.to_option (s##getItem (Js.string "history")) with
|
|
| None -> raise Not_found
|
|
| Some s ->
|
|
let a = Json.unsafe_input s in
|
|
data := a;
|
|
idx := Array.length a - 1
|
|
with _ -> ()
|
|
|
|
let push text =
|
|
let l = Array.length !data in
|
|
let n = Array.make (l + 1) "" in
|
|
!data.(l - 1) <- text;
|
|
Array.blit !data 0 n 0 l;
|
|
data := n;
|
|
idx := l;
|
|
try
|
|
let s = get_storage () in
|
|
let str = Json.output !data in
|
|
s##setItem (Js.string "history") str
|
|
with Not_found -> ()
|
|
|
|
let current text = !data.(!idx) <- text
|
|
|
|
let previous textbox =
|
|
if !idx > 0 then (
|
|
decr idx;
|
|
textbox##.value := Js.string !data.(!idx))
|
|
|
|
let next textbox =
|
|
if !idx < Array.length !data - 1 then (
|
|
incr idx;
|
|
textbox##.value := Js.string !data.(!idx))
|
|
end
|
|
|
|
let run _ =
|
|
let container = by_id "toplevel-container" in
|
|
let output = by_id "output" in
|
|
let textbox : 'a Js.t =
|
|
by_id_coerce "userinput" Dom_html.CoerceTo.textarea
|
|
in
|
|
let sharp_chan = open_out "/dev/null0" in
|
|
let sharp_ppf = Format.formatter_of_out_channel sharp_chan in
|
|
let caml_chan = open_out "/dev/null1" in
|
|
let caml_ppf = Format.formatter_of_out_channel caml_chan in
|
|
let execute () =
|
|
let content = Js.to_string textbox##.value##trim in
|
|
let content' =
|
|
let len = String.length content in
|
|
if
|
|
try
|
|
content <> ""
|
|
&& content.[len - 1] <> ';'
|
|
&& content.[len - 2] <> ';'
|
|
with _ -> true
|
|
then content ^ ";;"
|
|
else content
|
|
in
|
|
current_position := output##.childNodes##.length;
|
|
textbox##.value := Js.string "";
|
|
History.push content;
|
|
JsooTop.execute true ~pp_code:sharp_ppf ~highlight_location
|
|
caml_ppf content';
|
|
resize ~container ~textbox () >>= fun () ->
|
|
container##.scrollTop := container##.scrollHeight;
|
|
textbox##focus;
|
|
Lwt.return_unit
|
|
in
|
|
let history_down _e =
|
|
let txt = Js.to_string textbox##.value in
|
|
let pos = textbox##.selectionStart in
|
|
try
|
|
if String.length txt = pos then raise Not_found;
|
|
let _ = String.index_from txt pos '\n' in
|
|
Js._true
|
|
with Not_found ->
|
|
History.current txt;
|
|
History.next textbox;
|
|
Js._false
|
|
in
|
|
let history_up _e =
|
|
let txt = Js.to_string textbox##.value in
|
|
let pos = textbox##.selectionStart - 1 in
|
|
try
|
|
if pos < 0 then raise Not_found;
|
|
let _ = String.rindex_from txt pos '\n' in
|
|
Js._true
|
|
with Not_found ->
|
|
History.current txt;
|
|
History.previous textbox;
|
|
Js._false
|
|
in
|
|
let meta e =
|
|
let b = Js.to_bool in
|
|
b e##.ctrlKey || b e##.altKey || b e##.metaKey
|
|
in
|
|
let shift e = Js.to_bool e##.shiftKey in
|
|
(* setup handlers *)
|
|
textbox##.onkeyup :=
|
|
Dom_html.handler (fun _ ->
|
|
Lwt.async (resize ~container ~textbox);
|
|
Js._true);
|
|
textbox##.onchange :=
|
|
Dom_html.handler (fun _ ->
|
|
Lwt.async (resize ~container ~textbox);
|
|
Js._true);
|
|
textbox##.onkeydown :=
|
|
Dom_html.handler (fun e ->
|
|
match e##.keyCode with
|
|
| 13 when not (meta e || shift e) ->
|
|
Lwt.async execute;
|
|
Js._false
|
|
| 13 ->
|
|
Lwt.async (resize ~container ~textbox);
|
|
Js._true
|
|
| 09 ->
|
|
Indent.textarea textbox;
|
|
Js._false
|
|
| 76 when meta e ->
|
|
output##.innerHTML := Js.string "";
|
|
Js._true
|
|
| 75 when meta e ->
|
|
setup_toplevel ();
|
|
Js._false
|
|
| 38 -> history_up e
|
|
| 40 -> history_down e
|
|
| _ -> Js._true);
|
|
(Lwt.async_exception_hook :=
|
|
fun exc ->
|
|
Format.eprintf "exc during Lwt.async: %s@."
|
|
(Printexc.to_string exc);
|
|
match exc with
|
|
| Js_error.Exn e ->
|
|
let e = Js_error.to_error e in
|
|
Firebug.console##log e##.stack
|
|
| _ -> ());
|
|
Lwt.async (fun () ->
|
|
resize ~container ~textbox () >>= fun () ->
|
|
textbox##focus;
|
|
Lwt.return_unit);
|
|
Graphics_support.init
|
|
(by_id_coerce "test-canvas" Dom_html.CoerceTo.canvas);
|
|
Sys_js.set_channel_flusher caml_chan
|
|
(append Colorize.ocaml output "caml");
|
|
Sys_js.set_channel_flusher sharp_chan
|
|
(append Colorize.ocaml output "sharp");
|
|
Sys_js.set_channel_flusher stdout
|
|
(append Colorize.text output "stdout");
|
|
Sys_js.set_channel_flusher stderr
|
|
(append Colorize.text output "stderr");
|
|
let readline () =
|
|
Js.Opt.case
|
|
(Dom_html.window##prompt
|
|
(Js.string "The toplevel expects inputs:")
|
|
(Js.string ""))
|
|
(fun () -> "")
|
|
(fun s -> Js.to_string s ^ "\n")
|
|
in
|
|
Sys_js.set_channel_filler stdin readline;
|
|
setup_share_button ~output;
|
|
Ppx_graph.setup_graph ~container ~textbox;
|
|
setup_examples ~container ~textbox;
|
|
setup_pseudo_fs ();
|
|
setup_toplevel ();
|
|
setup_js_preview ();
|
|
setup_printers ();
|
|
History.setup ();
|
|
textbox##.value := Js.string "";
|
|
(* Run initial code if any *)
|
|
try
|
|
let code = List.assoc "code" (parse_hash ()) in
|
|
textbox##.value := Js.string code;
|
|
Lwt.async execute
|
|
with
|
|
| Not_found -> ()
|
|
| exc ->
|
|
Firebug.console##log_3 (Js.string "exception")
|
|
(Js.string (Printexc.to_string exc))
|
|
exc
|
|
|
|
let _ =
|
|
Dom_html.window##.onload
|
|
:= Dom_html.handler (fun _ ->
|
|
run ();
|
|
Js._false)
|