let debug = ref false

let debug_fun = ref (fun _ -> ())

let update_lang_fun = ref (fun _ -> ())

let read_fun = ref (fun _ _ -> "")

let read_line = fun () -> !read_fun "Standard input" ""

let read_int = fun () -> int_of_string (!read_fun "Standard input" "")

let read_float = fun () -> float_of_string (!read_fun "Standard input" "")

let print_debug s = if !debug then (!debug_fun) s

let message_fun = ref (fun _ -> ())

let default_language = "en"

let default_translation = Hashtbl.create 13

let default_language_name = "English"

let _ = Hashtbl.add default_translation

default_language_name default_language_name

let langs = ref [

(default_language, (default_language_name, default_translation))

]

let _ =

List.iter (fun (lang, messages) ->

let h = Hashtbl.create 13 in

List.iter (fun (x,y) -> Hashtbl.add h x y) messages;

try

let name = Hashtbl.find h default_language_name in

langs := ( lang, (name,h) ) :: !langs

with Not_found -> ()

) Lessons.langs

let langs = List.sort compare !langs

let current_lang = ref default_language

let current_translation = ref default_translation

let translate s =

try Hashtbl.find !current_translation s with Not_found -> s

let this_lesson = ref 0

let this_lesson_title = ref ""

let this_lesson_html = ref ""

let this_lesson_steps = ref [||]

let this_step = ref 0

let this_step_check = ref (fun _ _ -> false)

let this_step_title = ref ""

let this_step_html = ref ""

let lessons_table =

let all_lessons =

let max_lesson = ref 1 in

List.iter (fun (num, _, _, _, _) -> if num > !max_lesson then max_lesson := num) Lessons.lessons;

let all_lessons = Array.create (!max_lesson+1) None in

all_lessons

in

List.iter (fun (num, lesson_title, lesson_html, lesson_langs, steps) ->

let max_steps = ref 1 in

List.iter (fun (num,_,_,_, _) -> if num > !max_steps then max_steps := num) steps;

let all_steps = Array.create (!max_steps+1) None in

List.iter (fun (num, step_title, step_html, step_langs, step_check) ->

all_steps.(num) <- Some (step_title, step_html, step_langs, step_check)

) steps;

all_lessons.(num) <- Some (lesson_title, lesson_html, lesson_langs, all_steps)

) Lessons.lessons;

all_lessons

let user_navigation = ref false

let get_lesson lesson_title lesson_html lesson_langs =

try

List.assoc !current_lang lesson_langs

with Not_found -> (lesson_title, lesson_html)

let update_lesson () =

()

let get_step step_title step_html step_langs =

(step_title, step_html)

let update_step () =

()

let rec step num =

update_step ()

and lesson num =

step 1

and lesson_back num =

step (Array.length steps - 1)

let check_step ppf input output =

(!message_fun) ""

let next () = step (!this_step + 1)

let back () = step (!this_step - 1)

let debug d =

debug := d;

if not d then (!debug_fun "")

let lessons () =

if not !left then Printf.printf "\n%!"

let steps () =

done

let use_multiline = ref false

let multiline flag = use_multiline := flag

let set_lang lang =

!update_lang_fun ()

let lang () = !current_lang

external int_of_int : int -> int = "%identity"

external nativeint_of_nativeint : nativeint -> nativeint = "%identity"

external float_of_float : float -> float = "%identity"

external int32_of_int32 : int32 -> int32 = "%identity"

external int64_of_int64 : int64 -> int64 = "%identity"

external int_to_int : int -> int = "%identity"

external float_to_float : float -> float = "%identity"

module Tutorial = struct end

let init () =

N.init ()