Menu
▾
▴
[Krobot-commits] [SCM] krobot branch, master, updated. b5dd28ad72923a038b155c247d8457f2c9eb0e4a
|
From: Pierre C. <Ba...@us...> - 2013-04-06 20:56:03
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "krobot".
The branch, master has been updated
via b5dd28ad72923a038b155c247d8457f2c9eb0e4a (commit)
from 367d701262d78c6d664a24f4eee9a27c79b5329e (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit b5dd28ad72923a038b155c247d8457f2c9eb0e4a
Author: Pierre Chambart <pie...@oc...>
Date: Sat Apr 6 22:53:27 2013 +0200
add ocaml-urg to receive data from the urg. Add the krobot_urg tool to send the data on the bus
-----------------------------------------------------------------------
Changes:
diff --git a/info/control2011/_oasis b/info/control2011/_oasis
index 797df32..91019c0 100644
--- a/info/control2011/_oasis
+++ b/info/control2011/_oasis
@@ -26,6 +26,10 @@ Flag cv
Description: enable opencv
Default: true
+Flag urg
+ Description: enable lib urg
+ Default: true
+
Flag sdl
Description: enable sdl
Default: true
@@ -300,6 +304,14 @@ Executable "krobot-pet"
MainIs: krobot_pet.ml
BuildDepends: krobot, lwt.syntax
+Executable "krobot-urg"
+ Path: src/tools
+ Build$: flag(urg)
+ Install$: flag(urg)
+ CompiledObject: best
+ MainIs: krobot_urg.ml
+ BuildDepends: krobot, urg, lwt.syntax, lwt.preemptive, threads
+
# +-------------------------------------------------------------------+
# | Examples |
# +-------------------------------------------------------------------+
diff --git a/info/control2011/_tags b/info/control2011/_tags
index 1bdb883..5ca553f 100644
--- a/info/control2011/_tags
+++ b/info/control2011/_tags
@@ -2,4 +2,279 @@
<src/interfaces/*.ml>: -syntax_camlp4o
# OASIS_START
+# DO NOT EDIT (digest: 9d24891399e4580abf4972e7db50e404)
+# Ignore VCS directories, you can use the same kind of rule outside
+# OASIS_START/STOP if you want to exclude directories that contains
+# useless stuff for the build process
+<**/.svn>: -traverse
+<**/.svn>: not_hygienic
+".bzr": -traverse
+".bzr": not_hygienic
+".hg": -traverse
+".hg": not_hygienic
+".git": -traverse
+".git": not_hygienic
+"_darcs": -traverse
+"_darcs": not_hygienic
+# Library krobot
+"src/lib/krobot.cmxs": use_krobot
+<src/lib/krobot.{cma,cmxa}>: use_libkrobot_stubs
+<src/lib/*.ml{,i}>: pkg_lwt.syntax
+<src/lib/*.ml{,i}>: pkg_lwt.unix
+<src/lib/*.ml{,i}>: pkg_lwt.react
+"src/lib/krobot_message_stubs.c": pkg_lwt.syntax
+"src/lib/krobot_message_stubs.c": pkg_lwt.unix
+"src/lib/krobot_message_stubs.c": pkg_lwt.react
+# Library krobot-can
+"src/can/krobot-can.cmxs": use_krobot-can
+<src/can/krobot-can.{cma,cmxa}>: use_libkrobot-can_stubs
+<src/can/*.ml{,i}>: use_krobot
+<src/can/*.ml{,i}>: pkg_lwt.syntax
+<src/can/*.ml{,i}>: pkg_sexplib
+<src/can/*.ml{,i}>: pkg_sexplib.syntax
+<src/can/*.ml{,i}>: pkg_lwt.unix
+<src/can/*.ml{,i}>: pkg_bitstring
+<src/can/*.ml{,i}>: pkg_lwt.react
+"src/can/can_stubs.c": use_krobot
+"src/can/can_stubs.c": pkg_lwt.syntax
+"src/can/can_stubs.c": pkg_sexplib
+"src/can/can_stubs.c": pkg_sexplib.syntax
+"src/can/can_stubs.c": pkg_lwt.unix
+"src/can/can_stubs.c": pkg_bitstring
+"src/can/can_stubs.c": pkg_lwt.react
+# Executable krobot-driver
+<src/driver/krobot_driver.{native,byte}>: use_krobot-can
+<src/driver/krobot_driver.{native,byte}>: use_krobot
+<src/driver/krobot_driver.{native,byte}>: pkg_lwt.syntax
+<src/driver/krobot_driver.{native,byte}>: pkg_sexplib
+<src/driver/krobot_driver.{native,byte}>: pkg_sexplib.syntax
+<src/driver/krobot_driver.{native,byte}>: pkg_lwt.unix
+<src/driver/krobot_driver.{native,byte}>: pkg_bitstring
+<src/driver/krobot_driver.{native,byte}>: pkg_lwt.react
+<src/driver/*.ml{,i}>: use_krobot-can
+<src/driver/*.ml{,i}>: use_krobot
+<src/driver/*.ml{,i}>: pkg_lwt.syntax
+<src/driver/*.ml{,i}>: pkg_sexplib
+<src/driver/*.ml{,i}>: pkg_sexplib.syntax
+<src/driver/*.ml{,i}>: pkg_lwt.unix
+<src/driver/*.ml{,i}>: pkg_bitstring
+<src/driver/*.ml{,i}>: pkg_lwt.react
+# Executable krobot-hub
+<src/tools/krobot_hub.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_hub.{native,byte}>: pkg_lwt.unix
+# Executable krobot-dump
+<src/tools/krobot_dump.{native,byte}>: use_krobot
+<src/tools/krobot_dump.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_dump.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_dump.{native,byte}>: pkg_lwt.react
+# Executable krobot-monitor
+<src/tools/krobot_monitor.{native,byte}>: use_krobot
+<src/tools/krobot_monitor.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_monitor.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_monitor.{native,byte}>: pkg_lwt.react
+# Executable krobot-dump-encoders
+<src/tools/krobot_dump_encoders.{native,byte}>: use_krobot
+<src/tools/krobot_dump_encoders.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_dump_encoders.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_dump_encoders.{native,byte}>: pkg_lwt.react
+# Executable krobot-record
+<src/tools/krobot_record.{native,byte}>: use_krobot
+<src/tools/krobot_record.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_record.{native,byte}>: pkg_threads
+<src/tools/krobot_record.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_record.{native,byte}>: pkg_lwt.react
+# Executable krobot-replay
+<src/tools/krobot_replay.{native,byte}>: use_krobot
+<src/tools/krobot_replay.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_replay.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_replay.{native,byte}>: pkg_lwt.react
+# Executable krobot-read
+<src/tools/krobot_read.{native,byte}>: use_krobot
+<src/tools/krobot_read.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_read.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_read.{native,byte}>: pkg_lwt.react
+# Executable krobot-plot
+<src/tools/krobot_plot.{native,byte}>: use_krobot
+<src/tools/krobot_plot.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_plot.{native,byte}>: pkg_cairo.lablgtk2
+<src/tools/krobot_plot.{native,byte}>: pkg_lwt.glib
+<src/tools/krobot_plot.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_plot.{native,byte}>: pkg_lwt.react
+# Executable krobot-plot-battery
+<src/tools/krobot_plot_battery.{native,byte}>: use_krobot
+<src/tools/krobot_plot_battery.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_plot_battery.{native,byte}>: pkg_cairo.lablgtk2
+<src/tools/krobot_plot_battery.{native,byte}>: pkg_lwt.glib
+<src/tools/krobot_plot_battery.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_plot_battery.{native,byte}>: pkg_lwt.react
+# Executable krobot-viewer
+<src/tools/krobot_viewer.{native,byte}>: use_krobot
+<src/tools/krobot_viewer.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_viewer.{native,byte}>: pkg_cairo.lablgtk2
+<src/tools/krobot_viewer.{native,byte}>: pkg_lwt.glib
+<src/tools/krobot_viewer.{native,byte}>: pkg_lablgtk2.glade
+<src/tools/krobot_viewer.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_viewer.{native,byte}>: pkg_lwt.react
+<src/tools/*.ml{,i}>: pkg_lablgtk2.glade
+# Executable krobot-simulator
+<src/tools/krobot_simulator.{native,byte}>: use_krobot
+<src/tools/krobot_simulator.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_simulator.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_simulator.{native,byte}>: pkg_lwt.react
+# Executable krobot-hil-simulator
+<src/tools/krobot_hil_simulator.{native,byte}>: use_krobot
+<src/tools/krobot_hil_simulator.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_hil_simulator.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_hil_simulator.{native,byte}>: pkg_lwt.react
+# Executable krobot-planner
+<src/tools/krobot_planner.{native,byte}>: use_krobot
+<src/tools/krobot_planner.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_planner.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_planner.{native,byte}>: pkg_lwt.react
+# Executable krobot-fake-beacons
+<src/tools/krobot_fake_beacons.{native,byte}>: use_krobot
+<src/tools/krobot_fake_beacons.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_fake_beacons.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_fake_beacons.{native,byte}>: pkg_lwt.react
+# Executable krobot-objects
+<src/tools/krobot_objects.{native,byte}>: use_krobot
+<src/tools/krobot_objects.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_objects.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_objects.{native,byte}>: pkg_lwt.react
+# Executable krobot-webcam
+<src/tools/krobot_webcam.{native,byte}>: use_krobot
+<src/tools/krobot_webcam.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_webcam.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_webcam.{native,byte}>: pkg_lwt.react
+# Executable krobot-kill
+<src/tools/krobot_kill.{native,byte}>: use_krobot
+<src/tools/krobot_kill.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_kill.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_kill.{native,byte}>: pkg_lwt.react
+# Executable krobot-calibrate-sharps
+<src/tools/krobot_calibrate_sharps.{native,byte}>: use_krobot
+<src/tools/krobot_calibrate_sharps.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_calibrate_sharps.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_calibrate_sharps.{native,byte}>: pkg_lwt.react
+# Executable krobot-sharps
+<src/tools/krobot_sharps.{native,byte}>: use_krobot
+<src/tools/krobot_sharps.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_sharps.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_sharps.{native,byte}>: pkg_lwt.react
+# Executable krobot-vm
+<src/tools/krobot_vm.{native,byte}>: use_krobot
+<src/tools/krobot_vm.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_vm.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_vm.{native,byte}>: pkg_lwt.react
+# Executable krobot-ia
+<src/tools/krobot_ia.{native,byte}>: use_krobot
+<src/tools/krobot_ia.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_ia.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_ia.{native,byte}>: pkg_lwt.react
+# Executable krobot-homologation
+<src/tools/krobot_homologation.{native,byte}>: use_krobot
+<src/tools/krobot_homologation.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_homologation.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_homologation.{native,byte}>: pkg_lwt.react
+# Executable krobot-can-display
+<src/tools/krobot_can_display.{native,byte}>: use_krobot-can
+<src/tools/krobot_can_display.{native,byte}>: use_krobot
+<src/tools/krobot_can_display.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_can_display.{native,byte}>: pkg_sexplib
+<src/tools/krobot_can_display.{native,byte}>: pkg_sexplib.syntax
+<src/tools/krobot_can_display.{native,byte}>: pkg_cairo.lablgtk2
+<src/tools/krobot_can_display.{native,byte}>: pkg_lwt.glib
+<src/tools/krobot_can_display.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_can_display.{native,byte}>: pkg_bitstring
+<src/tools/krobot_can_display.{native,byte}>: pkg_lwt.react
+<src/tools/*.ml{,i}>: pkg_cairo.lablgtk2
+<src/tools/*.ml{,i}>: pkg_lwt.glib
+# Executable krobot-ax12-control
+<src/tools/krobot_ax12_control.{native,byte}>: use_krobot-can
+<src/tools/krobot_ax12_control.{native,byte}>: use_krobot
+<src/tools/krobot_ax12_control.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_ax12_control.{native,byte}>: pkg_sexplib
+<src/tools/krobot_ax12_control.{native,byte}>: pkg_sexplib.syntax
+<src/tools/krobot_ax12_control.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_ax12_control.{native,byte}>: pkg_bitstring
+<src/tools/krobot_ax12_control.{native,byte}>: pkg_lwt.react
+# Executable krobot-dump-ax12
+<src/tools/krobot_dump_ax12.{native,byte}>: use_krobot-can
+<src/tools/krobot_dump_ax12.{native,byte}>: use_krobot
+<src/tools/krobot_dump_ax12.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_dump_ax12.{native,byte}>: pkg_sexplib
+<src/tools/krobot_dump_ax12.{native,byte}>: pkg_sexplib.syntax
+<src/tools/krobot_dump_ax12.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_dump_ax12.{native,byte}>: pkg_bitstring
+<src/tools/krobot_dump_ax12.{native,byte}>: pkg_lwt.react
+<src/tools/*.ml{,i}>: use_krobot-can
+<src/tools/*.ml{,i}>: pkg_sexplib
+<src/tools/*.ml{,i}>: pkg_sexplib.syntax
+<src/tools/*.ml{,i}>: pkg_bitstring
+# Executable krobot-ax12-clean
+# Executable krobot-see-coin
+<src/tools/krobot_see_coin.{native,byte}>: use_krobot
+<src/tools/krobot_see_coin.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_see_coin.{native,byte}>: pkg_cv
+<src/tools/krobot_see_coin.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_see_coin.{native,byte}>: pkg_lwt.react
+<src/tools/*.ml{,i}>: pkg_cv
+# Executable krobot-stop-beacon
+<src/tools/krobot_stop_beacon.{native,byte}>: use_krobot
+<src/tools/krobot_stop_beacon.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_stop_beacon.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_stop_beacon.{native,byte}>: pkg_lwt.react
+# Executable krobot-joystick
+<src/tools/krobot_joystick.{native,byte}>: use_krobot
+<src/tools/krobot_joystick.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_joystick.{native,byte}>: pkg_sdl
+<src/tools/krobot_joystick.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_joystick.{native,byte}>: pkg_lwt.react
+<src/tools/*.ml{,i}>: pkg_sdl
+# Executable krobot-pet
+<src/tools/krobot_pet.{native,byte}>: use_krobot
+<src/tools/krobot_pet.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_pet.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_pet.{native,byte}>: pkg_lwt.react
+# Executable krobot-urg
+<src/tools/krobot_urg.{native,byte}>: use_krobot
+<src/tools/krobot_urg.{native,byte}>: pkg_lwt.syntax
+<src/tools/krobot_urg.{native,byte}>: pkg_urg
+<src/tools/krobot_urg.{native,byte}>: pkg_lwt.preemptive
+<src/tools/krobot_urg.{native,byte}>: pkg_threads
+<src/tools/krobot_urg.{native,byte}>: pkg_lwt.unix
+<src/tools/krobot_urg.{native,byte}>: pkg_lwt.react
+<src/tools/*.ml{,i}>: use_krobot
+<src/tools/*.ml{,i}>: pkg_lwt.syntax
+<src/tools/*.ml{,i}>: pkg_urg
+<src/tools/*.ml{,i}>: pkg_lwt.preemptive
+<src/tools/*.ml{,i}>: pkg_threads
+<src/tools/*.ml{,i}>: pkg_lwt.unix
+<src/tools/*.ml{,i}>: pkg_lwt.react
+# Executable dump-can
+<examples/dump_can.{native,byte}>: use_krobot-can
+<examples/dump_can.{native,byte}>: use_krobot
+<examples/dump_can.{native,byte}>: pkg_lwt.syntax
+<examples/dump_can.{native,byte}>: pkg_sexplib
+<examples/dump_can.{native,byte}>: pkg_sexplib.syntax
+<examples/dump_can.{native,byte}>: pkg_lwt.unix
+<examples/dump_can.{native,byte}>: pkg_bitstring
+<examples/dump_can.{native,byte}>: pkg_lwt.react
+# Executable send-can
+<examples/send_can.{native,byte}>: use_krobot-can
+<examples/send_can.{native,byte}>: use_krobot
+<examples/send_can.{native,byte}>: pkg_lwt.syntax
+<examples/send_can.{native,byte}>: pkg_sexplib
+<examples/send_can.{native,byte}>: pkg_sexplib.syntax
+<examples/send_can.{native,byte}>: pkg_lwt.unix
+<examples/send_can.{native,byte}>: pkg_bitstring
+<examples/send_can.{native,byte}>: pkg_lwt.react
+<examples/*.ml{,i}>: use_krobot-can
+<examples/*.ml{,i}>: use_krobot
+<examples/*.ml{,i}>: pkg_lwt.syntax
+<examples/*.ml{,i}>: pkg_sexplib
+<examples/*.ml{,i}>: pkg_sexplib.syntax
+<examples/*.ml{,i}>: pkg_lwt.unix
+<examples/*.ml{,i}>: pkg_bitstring
+<examples/*.ml{,i}>: pkg_lwt.react
# OASIS_STOP
diff --git a/info/control2011/myocamlbuild.ml b/info/control2011/myocamlbuild.ml
index 86231e0..ebd412e 100644
--- a/info/control2011/myocamlbuild.ml
+++ b/info/control2011/myocamlbuild.ml
@@ -1,4 +1,499 @@
(* OASIS_START *)
+(* DO NOT EDIT (digest: d2ba10e1d203a414b96ccf471790ac22) *)
+module OASISGettext = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISGettext.ml" *)
+
+ let ns_ str =
+ str
+
+ let s_ str =
+ str
+
+ let f_ (str : ('a, 'b, 'c, 'd) format4) =
+ str
+
+ let fn_ fmt1 fmt2 n =
+ if n = 1 then
+ fmt1^^""
+ else
+ fmt2^^""
+
+ let init =
+ []
+
+end
+
+module OASISExpr = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISExpr.ml" *)
+
+
+
+ open OASISGettext
+
+ type test = string
+
+ type flag = string
+
+ type t =
+ | EBool of bool
+ | ENot of t
+ | EAnd of t * t
+ | EOr of t * t
+ | EFlag of flag
+ | ETest of test * string
+
+
+ type 'a choices = (t * 'a) list
+
+ let eval var_get t =
+ let rec eval' =
+ function
+ | EBool b ->
+ b
+
+ | ENot e ->
+ not (eval' e)
+
+ | EAnd (e1, e2) ->
+ (eval' e1) && (eval' e2)
+
+ | EOr (e1, e2) ->
+ (eval' e1) || (eval' e2)
+
+ | EFlag nm ->
+ let v =
+ var_get nm
+ in
+ assert(v = "true" || v = "false");
+ (v = "true")
+
+ | ETest (nm, vl) ->
+ let v =
+ var_get nm
+ in
+ (v = vl)
+ in
+ eval' t
+
+ let choose ?printer ?name var_get lst =
+ let rec choose_aux =
+ function
+ | (cond, vl) :: tl ->
+ if eval var_get cond then
+ vl
+ else
+ choose_aux tl
+ | [] ->
+ let str_lst =
+ if lst = [] then
+ s_ "<empty>"
+ else
+ String.concat
+ (s_ ", ")
+ (List.map
+ (fun (cond, vl) ->
+ match printer with
+ | Some p -> p vl
+ | None -> s_ "<no printer>")
+ lst)
+ in
+ match name with
+ | Some nm ->
+ failwith
+ (Printf.sprintf
+ (f_ "No result for the choice list '%s': %s")
+ nm str_lst)
+ | None ->
+ failwith
+ (Printf.sprintf
+ (f_ "No result for a choice list: %s")
+ str_lst)
+ in
+ choose_aux (List.rev lst)
+
+end
+
+
+# 117 "myocamlbuild.ml"
+module BaseEnvLight = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/base/BaseEnvLight.ml" *)
+
+ module MapString = Map.Make(String)
+
+ type t = string MapString.t
+
+ let default_filename =
+ Filename.concat
+ (Sys.getcwd ())
+ "setup.data"
+
+ let load ?(allow_empty=false) ?(filename=default_filename) () =
+ if Sys.file_exists filename then
+ begin
+ let chn =
+ open_in_bin filename
+ in
+ let st =
+ Stream.of_channel chn
+ in
+ let line =
+ ref 1
+ in
+ let st_line =
+ Stream.from
+ (fun _ ->
+ try
+ match Stream.next st with
+ | '\n' -> incr line; Some '\n'
+ | c -> Some c
+ with Stream.Failure -> None)
+ in
+ let lexer =
+ Genlex.make_lexer ["="] st_line
+ in
+ let rec read_file mp =
+ match Stream.npeek 3 lexer with
+ | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->
+ Stream.junk lexer;
+ Stream.junk lexer;
+ Stream.junk lexer;
+ read_file (MapString.add nm value mp)
+ | [] ->
+ mp
+ | _ ->
+ failwith
+ (Printf.sprintf
+ "Malformed data file '%s' line %d"
+ filename !line)
+ in
+ let mp =
+ read_file MapString.empty
+ in
+ close_in chn;
+ mp
+ end
+ else if allow_empty then
+ begin
+ MapString.empty
+ end
+ else
+ begin
+ failwith
+ (Printf.sprintf
+ "Unable to load environment, the file '%s' doesn't exist."
+ filename)
+ end
+
+ let var_get name env =
+ let rec var_expand str =
+ let buff =
+ Buffer.create ((String.length str) * 2)
+ in
+ Buffer.add_substitute
+ buff
+ (fun var ->
+ try
+ var_expand (MapString.find var env)
+ with Not_found ->
+ failwith
+ (Printf.sprintf
+ "No variable %s defined when trying to expand %S."
+ var
+ str))
+ str;
+ Buffer.contents buff
+ in
+ var_expand (MapString.find name env)
+
+ let var_choose lst env =
+ OASISExpr.choose
+ (fun nm -> var_get nm env)
+ lst
+end
+
+
+# 215 "myocamlbuild.ml"
+module MyOCamlbuildFindlib = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml" *)
+
+ (** OCamlbuild extension, copied from
+ * http://brion.inria.fr/gallium/index.php/Using_ocamlfind_with_ocamlbuild
+ * by N. Pouillard and others
+ *
+ * Updated on 2009/02/28
+ *
+ * Modified by Sylvain Le Gall
+ *)
+ open Ocamlbuild_plugin
+
+ (* these functions are not really officially exported *)
+ let run_and_read =
+ Ocamlbuild_pack.My_unix.run_and_read
+
+ let blank_sep_strings =
+ Ocamlbuild_pack.Lexers.blank_sep_strings
+
+ let split s ch =
+ let x =
+ ref []
+ in
+ let rec go s =
+ let pos =
+ String.index s ch
+ in
+ x := (String.before s pos)::!x;
+ go (String.after s (pos + 1))
+ in
+ try
+ go s
+ with Not_found -> !x
+
+ let split_nl s = split s '\n'
+
+ let before_space s =
+ try
+ String.before s (String.index s ' ')
+ with Not_found -> s
+
+ (* this lists all supported packages *)
+ let find_packages () =
+ List.map before_space (split_nl & run_and_read "ocamlfind list")
+
+ (* this is supposed to list available syntaxes, but I don't know how to do it. *)
+ let find_syntaxes () = ["camlp4o"; "camlp4r"]
+
+ (* ocamlfind command *)
+ let ocamlfind x = S[A"ocamlfind"; x]
+
+ let dispatch =
+ function
+ | Before_options ->
+ (* by using Before_options one let command line options have an higher priority *)
+ (* on the contrary using After_options will guarantee to have the higher priority *)
+ (* override default commands by ocamlfind ones *)
+ Options.ocamlc := ocamlfind & A"ocamlc";
+ Options.ocamlopt := ocamlfind & A"ocamlopt";
+ Options.ocamldep := ocamlfind & A"ocamldep";
+ Options.ocamldoc := ocamlfind & A"ocamldoc";
+ Options.ocamlmktop := ocamlfind & A"ocamlmktop"
+
+ | After_rules ->
+
+ (* When one link an OCaml library/binary/package, one should use -linkpkg *)
+ flag ["ocaml"; "link"; "program"] & A"-linkpkg";
+
+ (* For each ocamlfind package one inject the -package option when
+ * compiling, computing dependencies, generating documentation and
+ * linking. *)
+ List.iter
+ begin fun pkg ->
+ flag ["ocaml"; "compile"; "pkg_"^pkg] & S[A"-package"; A pkg];
+ flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S[A"-package"; A pkg];
+ flag ["ocaml"; "doc"; "pkg_"^pkg] & S[A"-package"; A pkg];
+ flag ["ocaml"; "link"; "pkg_"^pkg] & S[A"-package"; A pkg];
+ flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S[A"-package"; A pkg];
+ end
+ (find_packages ());
+
+ (* Like -package but for extensions syntax. Morover -syntax is useless
+ * when linking. *)
+ List.iter begin fun syntax ->
+ flag ["ocaml"; "compile"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
+ flag ["ocaml"; "ocamldep"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
+ flag ["ocaml"; "doc"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
+ flag ["ocaml"; "infer_interface"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
+ end (find_syntaxes ());
+
+ (* The default "thread" tag is not compatible with ocamlfind.
+ * Indeed, the default rules add the "threads.cma" or "threads.cmxa"
+ * options when using this tag. When using the "-linkpkg" option with
+ * ocamlfind, this module will then be added twice on the command line.
+ *
+ * To solve this, one approach is to add the "-thread" option when using
+ * the "threads" package using the previous plugin.
+ *)
+ flag ["ocaml"; "pkg_threads"; "compile"] (S[A "-thread"]);
+ flag ["ocaml"; "pkg_threads"; "doc"] (S[A "-I"; A "+threads"]);
+ flag ["ocaml"; "pkg_threads"; "link"] (S[A "-thread"]);
+ flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"])
+
+ | _ ->
+ ()
+
+end
+
+module MyOCamlbuildBase = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)
+
+ (** Base functions for writing myocamlbuild.ml
+ @author Sylvain Le Gall
+ *)
+
+
+
+ open Ocamlbuild_plugin
+ module OC = Ocamlbuild_pack.Ocaml_compiler
+
+ type dir = string
+ type file = string
+ type name = string
+ type tag = string
+
+(* # 56 "/home/chambart/.opam/base/build/oasis.0.3.0/src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)
+
+ type t =
+ {
+ lib_ocaml: (name * dir list) list;
+ lib_c: (name * dir * file list) list;
+ flags: (tag list * (spec OASISExpr.choices)) list;
+ (* Replace the 'dir: include' from _tags by a precise interdepends in
+ * directory.
+ *)
+ includes: (dir * dir list) list;
+ }
+
+ let env_filename =
+ Pathname.basename
+ BaseEnvLight.default_filename
+
+ let dispatch_combine lst =
+ fun e ->
+ List.iter
+ (fun dispatch -> dispatch e)
+ lst
+
+ let tag_libstubs nm =
+ "use_lib"^nm^"_stubs"
+
+ let nm_libstubs nm =
+ nm^"_stubs"
+
+ let dispatch t e =
+ let env =
+ BaseEnvLight.load
+ ~filename:env_filename
+ ~allow_empty:true
+ ()
+ in
+ match e with
+ | Before_options ->
+ let no_trailing_dot s =
+ if String.length s >= 1 && s.[0] = '.' then
+ String.sub s 1 ((String.length s) - 1)
+ else
+ s
+ in
+ List.iter
+ (fun (opt, var) ->
+ try
+ opt := no_trailing_dot (BaseEnvLight.var_get var env)
+ with Not_found ->
+ Printf.eprintf "W: Cannot get variable %s" var)
+ [
+ Options.ext_obj, "ext_obj";
+ Options.ext_lib, "ext_lib";
+ Options.ext_dll, "ext_dll";
+ ]
+
+ | After_rules ->
+ (* Declare OCaml libraries *)
+ List.iter
+ (function
+ | nm, [] ->
+ ocaml_lib nm
+ | nm, dir :: tl ->
+ ocaml_lib ~dir:dir (dir^"/"^nm);
+ List.iter
+ (fun dir ->
+ List.iter
+ (fun str ->
+ flag ["ocaml"; "use_"^nm; str] (S[A"-I"; P dir]))
+ ["compile"; "infer_interface"; "doc"])
+ tl)
+ t.lib_ocaml;
+
+ (* Declare directories dependencies, replace "include" in _tags. *)
+ List.iter
+ (fun (dir, include_dirs) ->
+ Pathname.define_context dir include_dirs)
+ t.includes;
+
+ (* Declare C libraries *)
+ List.iter
+ (fun (lib, dir, headers) ->
+ (* Handle C part of library *)
+ flag ["link"; "library"; "ocaml"; "byte"; tag_libstubs lib]
+ (S[A"-dllib"; A("-l"^(nm_libstubs lib)); A"-cclib";
+ A("-l"^(nm_libstubs lib))]);
+
+ flag ["link"; "library"; "ocaml"; "native"; tag_libstubs lib]
+ (S[A"-cclib"; A("-l"^(nm_libstubs lib))]);
+
+ flag ["link"; "program"; "ocaml"; "byte"; tag_libstubs lib]
+ (S[A"-dllib"; A("dll"^(nm_libstubs lib))]);
+
+ (* When ocaml link something that use the C library, then one
+ need that file to be up to date.
+ *)
+ dep ["link"; "ocaml"; "program"; tag_libstubs lib]
+ [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
+
+ dep ["compile"; "ocaml"; "program"; tag_libstubs lib]
+ [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
+
+ (* TODO: be more specific about what depends on headers *)
+ (* Depends on .h files *)
+ dep ["compile"; "c"]
+ headers;
+
+ (* Setup search path for lib *)
+ flag ["link"; "ocaml"; "use_"^lib]
+ (S[A"-I"; P(dir)]);
+ )
+ t.lib_c;
+
+ (* Add flags *)
+ List.iter
+ (fun (tags, cond_specs) ->
+ let spec =
+ BaseEnvLight.var_choose cond_specs env
+ in
+ flag tags & spec)
+ t.flags
+ | _ ->
+ ()
+
+ let dispatch_default t =
+ dispatch_combine
+ [
+ dispatch t;
+ MyOCamlbuildFindlib.dispatch;
+ ]
+
+end
+
+
+# 476 "myocamlbuild.ml"
+open Ocamlbuild_plugin;;
+let package_default =
+ {
+ MyOCamlbuildBase.lib_ocaml =
+ [("krobot", ["src/lib"]); ("krobot-can", ["src/can"])];
+ lib_c = [("krobot", "src/lib", []); ("krobot-can", "src/can", [])];
+ flags = [];
+ includes =
+ [
+ ("src/tools", ["src/can"; "src/lib"]);
+ ("src/driver", ["src/can"; "src/lib"]);
+ ("src/can", ["src/lib"]);
+ ("examples", ["src/can"])
+ ];
+ }
+ ;;
+
+let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;
+
+# 497 "myocamlbuild.ml"
(* OASIS_STOP *)
open Ocamlbuild_plugin
diff --git a/info/control2011/setup.ml b/info/control2011/setup.ml
index f41d9b8..0e2f232 100644
--- a/info/control2011/setup.ml
+++ b/info/control2011/setup.ml
@@ -8,10 +8,6857 @@
*)
(* OASIS_START *)
-(* DO NOT EDIT (digest: 7f47a529f70709161149c201ccd90f0b) *)
-#use "topfind";;
-#require "oasis.dynrun";;
-open OASISDynRun;;
+(* DO NOT EDIT (digest: 93e97b5dfbc11c54162cfd7f571db7a3) *)
+(*
+ Regenerated by OASIS v0.3.0
+ Visit http://oasis.forge.ocamlcore.org for more information and
+ documentation about functions used in this file.
+*)
+module OASISGettext = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISGettext.ml" *)
+
+ let ns_ str =
+ str
+
+ let s_ str =
+ str
+
+ let f_ (str : ('a, 'b, 'c, 'd) format4) =
+ str
+
+ let fn_ fmt1 fmt2 n =
+ if n = 1 then
+ fmt1^^""
+ else
+ fmt2^^""
+
+ let init =
+ []
+
+end
+
+module OASISContext = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISContext.ml" *)
+
+ open OASISGettext
+
+ type level =
+ [ `Debug
+ | `Info
+ | `Warning
+ | `Error]
+
+ type t =
+ {
+ quiet: bool;
+ info: bool;
+ debug: bool;
+ ignore_plugins: bool;
+ ignore_unknown_fields: bool;
+ printf: level -> string -> unit;
+ }
+
+ let printf lvl str =
+ let beg =
+ match lvl with
+ | `Error -> s_ "E: "
+ | `Warning -> s_ "W: "
+ | `Info -> s_ "I: "
+ | `Debug -> s_ "D: "
+ in
+ prerr_endline (beg^str)
+
+ let default =
+ ref
+ {
+ quiet = false;
+ info = false;
+ debug = false;
+ ignore_plugins = false;
+ ignore_unknown_fields = false;
+ printf = printf;
+ }
+
+ let quiet =
+ {!default with quiet = true}
+
+
+ let args () =
+ ["-quiet",
+ Arg.Unit (fun () -> default := {!default with quiet = true}),
+ (s_ " Run quietly");
+
+ "-info",
+ Arg.Unit (fun () -> default := {!default with info = true}),
+ (s_ " Display information message");
+
+
+ "-debug",
+ Arg.Unit (fun () -> default := {!default with debug = true}),
+ (s_ " Output debug message")]
+end
+
+module OASISString = struct
+(* # 1 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISString.ml" *)
+
+
+
+ (** Various string utilities.
+
+ Mostly inspired by extlib and batteries ExtString and BatString libraries.
+
+ @author Sylvain Le Gall
+ *)
+
+ let nsplitf str f =
+ if str = "" then
+ []
+ else
+ let buf = Buffer.create 13 in
+ let lst = ref [] in
+ let push () =
+ lst := Buffer.contents buf :: !lst;
+ Buffer.clear buf
+ in
+ let str_len = String.length str in
+ for i = 0 to str_len - 1 do
+ if f str.[i] then
+ push ()
+ else
+ Buffer.add_char buf str.[i]
+ done;
+ push ();
+ List.rev !lst
+
+ (** [nsplit c s] Split the string [s] at char [c]. It doesn't include the
+ separator.
+ *)
+ let nsplit str c =
+ nsplitf str ((=) c)
+
+ let find ~what ?(offset=0) str =
+ let what_idx = ref 0 in
+ let str_idx = ref offset in
+ while !str_idx < String.length str &&
+ !what_idx < String.length what do
+ if str.[!str_idx] = what.[!what_idx] then
+ incr what_idx
+ else
+ what_idx := 0;
+ incr str_idx
+ done;
+ if !what_idx <> String.length what then
+ raise Not_found
+ else
+ !str_idx - !what_idx
+
+ let sub_start str len =
+ let str_len = String.length str in
+ if len >= str_len then
+ ""
+ else
+ String.sub str len (str_len - len)
+
+ let sub_end ?(offset=0) str len =
+ let str_len = String.length str in
+ if len >= str_len then
+ ""
+ else
+ String.sub str 0 (str_len - len)
+
+ let starts_with ~what ?(offset=0) str =
+ let what_idx = ref 0 in
+ let str_idx = ref offset in
+ let ok = ref true in
+ while !ok &&
+ !str_idx < String.length str &&
+ !what_idx < String.length what do
+ if str.[!str_idx] = what.[!what_idx] then
+ incr what_idx
+ else
+ ok := false;
+ incr str_idx
+ done;
+ if !what_idx = String.length what then
+ true
+ else
+ false
+
+ let strip_starts_with ~what str =
+ if starts_with ~what str then
+ sub_start str (String.length what)
+ else
+ raise Not_found
+
+ let ends_with ~what ?(offset=0) str =
+ let what_idx = ref ((String.length what) - 1) in
+ let str_idx = ref ((String.length str) - 1) in
+ let ok = ref true in
+ while !ok &&
+ offset <= !str_idx &&
+ 0 <= !what_idx do
+ if str.[!str_idx] = what.[!what_idx] then
+ decr what_idx
+ else
+ ok := false;
+ decr str_idx
+ done;
+ if !what_idx = -1 then
+ true
+ else
+ false
+
+ let strip_ends_with ~what str =
+ if ends_with ~what str then
+ sub_end str (String.length what)
+ else
+ raise Not_found
+
+ let replace_chars f s =
+ let buf = String.make (String.length s) 'X' in
+ for i = 0 to String.length s - 1 do
+ buf.[i] <- f s.[i]
+ done;
+ buf
+
+end
+
+module OASISUtils = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISUtils.ml" *)
+
+ open OASISGettext
+
+ module MapString = Map.Make(String)
+
+ let map_string_of_assoc assoc =
+ List.fold_left
+ (fun acc (k, v) -> MapString.add k v acc)
+ MapString.empty
+ assoc
+
+ module SetString = Set.Make(String)
+
+ let set_string_add_list st lst =
+ List.fold_left
+ (fun acc e -> SetString.add e acc)
+ st
+ lst
+
+ let set_string_of_list =
+ set_string_add_list
+ SetString.empty
+
+
+ let compare_csl s1 s2 =
+ String.compare (String.lowercase s1) (String.lowercase s2)
+
+ module HashStringCsl =
+ Hashtbl.Make
+ (struct
+ type t = string
+
+ let equal s1 s2 =
+ (String.lowercase s1) = (String.lowercase s2)
+
+ let hash s =
+ Hashtbl.hash (String.lowercase s)
+ end)
+
+ let varname_of_string ?(hyphen='_') s =
+ if String.length s = 0 then
+ begin
+ invalid_arg "varname_of_string"
+ end
+ else
+ begin
+ let buf =
+ OASISString.replace_chars
+ (fun c ->
+ if ('a' <= c && c <= 'z')
+ ||
+ ('A' <= c && c <= 'Z')
+ ||
+ ('0' <= c && c <= '9') then
+ c
+ else
+ hyphen)
+ s;
+ in
+ let buf =
+ (* Start with a _ if digit *)
+ if '0' <= s.[0] && s.[0] <= '9' then
+ "_"^buf
+ else
+ buf
+ in
+ String.lowercase buf
+ end
+
+ let varname_concat ?(hyphen='_') p s =
+ let what = String.make 1 hyphen in
+ let p =
+ try
+ OASISString.strip_ends_with ~what p
+ with Not_found ->
+ p
+ in
+ let s =
+ try
+ OASISString.strip_starts_with ~what s
+ with Not_found ->
+ s
+ in
+ p^what^s
+
+
+ let is_varname str =
+ str = varname_of_string str
+
+ let failwithf fmt = Printf.ksprintf failwith fmt
+
+end
+
+module PropList = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/PropList.ml" *)
+
+ open OASISGettext
+
+ type name = string
+
+ exception Not_set of name * string option
+ exception No_printer of name
+ exception Unknown_field of name * name
+
+ let () =
+ Printexc.register_printer
+ (function
+ | Not_set (nm, Some rsn) ->
+ Some
+ (Printf.sprintf (f_ "Field '%s' is not set: %s") nm rsn)
+ | Not_set (nm, None) ->
+ Some
+ (Printf.sprintf (f_ "Field '%s' is not set") nm)
+ | No_printer nm ->
+ Some
+ (Printf.sprintf (f_ "No default printer for value %s") nm)
+ | Unknown_field (nm, schm) ->
+ Some
+ (Printf.sprintf (f_ "Field %s is not defined in schema %s") nm schm)
+ | _ ->
+ None)
+
+ module Data =
+ struct
+
+ type t =
+ (name, unit -> unit) Hashtbl.t
+
+ let create () =
+ Hashtbl.create 13
+
+ let clear t =
+ Hashtbl.clear t
+
+(* # 71 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/PropList.ml" *)
+ end
+
+ module Schema =
+ struct
+
+ type ('ctxt, 'extra) value =
+ {
+ get: Data.t -> string;
+ set: Data.t -> ?context:'ctxt -> string -> unit;
+ help: (unit -> string) option;
+ extra: 'extra;
+ }
+
+ type ('ctxt, 'extra) t =
+ {
+ name: name;
+ fields: (name, ('ctxt, 'extra) value) Hashtbl.t;
+ order: name Queue.t;
+ name_norm: string -> string;
+ }
+
+ let create ?(case_insensitive=false) nm =
+ {
+ name = nm;
+ fields = Hashtbl.create 13;
+ order = Queue.create ();
+ name_norm =
+ (if case_insensitive then
+ String.lowercase
+ else
+ fun s -> s);
+ }
+
+ let add t nm set get extra help =
+ let key =
+ t.name_norm nm
+ in
+
+ if Hashtbl.mem t.fields key then
+ failwith
+ (Printf.sprintf
+ (f_ "Field '%s' is already defined in schema '%s'")
+ nm t.name);
+ Hashtbl.add
+ t.fields
+ key
+ {
+ set = set;
+ get = get;
+ help = help;
+ extra = extra;
+ };
+ Queue.add nm t.order
+
+ let mem t nm =
+ Hashtbl.mem t.fields nm
+
+ let find t nm =
+ try
+ Hashtbl.find t.fields (t.name_norm nm)
+ with Not_found ->
+ raise (Unknown_field (nm, t.name))
+
+ let get t data nm =
+ (find t nm).get data
+
+ let set t data nm ?context x =
+ (find t nm).set
+ data
+ ?context
+ x
+
+ let fold f acc t =
+ Queue.fold
+ (fun acc k ->
+ let v =
+ find t k
+ in
+ f acc k v.extra v.help)
+ acc
+ t.order
+
+ let iter f t =
+ fold
+ (fun () -> f)
+ ()
+ t
+
+ let name t =
+ t.name
+ end
+
+ module Field =
+ struct
+
+ type ('ctxt, 'value, 'extra) t =
+ {
+ set: Data.t -> ?context:'ctxt -> 'value -> unit;
+ get: Data.t -> 'value;
+ sets: Data.t -> ?context:'ctxt -> string -> unit;
+ gets: Data.t -> string;
+ help: (unit -> string) option;
+ extra: 'extra;
+ }
+
+ let new_id =
+ let last_id =
+ ref 0
+ in
+ fun () -> incr last_id; !last_id
+
+ let create ?schema ?name ?parse ?print ?default ?update ?help extra =
+ (* Default value container *)
+ let v =
+ ref None
+ in
+
+ (* If name is not given, create unique one *)
+ let nm =
+ match name with
+ | Some s -> s
+ | None -> Printf.sprintf "_anon_%d" (new_id ())
+ in
+
+ (* Last chance to get a value: the default *)
+ let default () =
+ match default with
+ | Some d -> d
+ | None -> raise (Not_set (nm, Some (s_ "no default value")))
+ in
+
+ (* Get data *)
+ let get data =
+ (* Get value *)
+ try
+ (Hashtbl.find data nm) ();
+ match !v with
+ | Some x -> x
+ | None -> default ()
+ with Not_found ->
+ default ()
+ in
+
+ (* Set data *)
+ let set data ?context x =
+ let x =
+ match update with
+ | Some f ->
+ begin
+ try
+ f ?context (get data) x
+ with Not_set _ ->
+ x
+ end
+ | None ->
+ x
+ in
+ Hashtbl.replace
+ data
+ nm
+ (fun () -> v := Some x)
+ in
+
+ (* Parse string value, if possible *)
+ let parse =
+ match parse with
+ | Some f ->
+ f
+ | None ->
+ fun ?context s ->
+ failwith
+ (Printf.sprintf
+ (f_ "Cannot parse field '%s' when setting value %S")
+ nm
+ s)
+ in
+
+ (* Set data, from string *)
+ let sets data ?context s =
+ set ?context data (parse ?context s)
+ in
+
+ (* Output value as string, if possible *)
+ let print =
+ match print with
+ | Some f ->
+ f
+ | None ->
+ fun _ -> raise (No_printer nm)
+ in
+
+ (* Get data, as a string *)
+ let gets data =
+ print (get data)
+ in
+
+ begin
+ match schema with
+ | Some t ->
+ Schema.add t nm sets gets extra help
+ | None ->
+ ()
+ end;
+
+ {
+ set = set;
+ get = get;
+ sets = sets;
+ gets = gets;
+ help = help;
+ extra = extra;
+ }
+
+ let fset data t ?context x =
+ t.set data ?context x
+
+ let fget data t =
+ t.get data
+
+ let fsets data t ?context s =
+ t.sets data ?context s
+
+ let fgets data t =
+ t.gets data
+
+ end
+
+ module FieldRO =
+ struct
+
+ let create ?schema ?name ?parse ?print ?default ?update ?help extra =
+ let fld =
+ Field.create ?schema ?name ?parse ?print ?default ?update ?help extra
+ in
+ fun data -> Field.fget data fld
+
+ end
+end
+
+module OASISMessage = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISMessage.ml" *)
+
+
+ open OASISGettext
+ open OASISContext
+
+ let generic_message ~ctxt lvl fmt =
+ let cond =
+ if ctxt.quiet then
+ false
+ else
+ match lvl with
+ | `Debug -> ctxt.debug
+ | `Info -> ctxt.info
+ | _ -> true
+ in
+ Printf.ksprintf
+ (fun str ->
+ if cond then
+ begin
+ ctxt.printf lvl str
+ end)
+ fmt
+
+ let debug ~ctxt fmt =
+ generic_message ~ctxt `Debug fmt
+
+ let info ~ctxt fmt =
+ generic_message ~ctxt `Info fmt
+
+ let warning ~ctxt fmt =
+ generic_message ~ctxt `Warning fmt
+
+ let error ~ctxt fmt =
+ generic_message ~ctxt `Error fmt
+
+end
+
+module OASISVersion = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISVersion.ml" *)
+
+ open OASISGettext
+
+
+
+ type s = string
+
+ type t = string
+
+ type comparator =
+ | VGreater of t
+ | VGreaterEqual of t
+ | VEqual of t
+ | VLesser of t
+ | VLesserEqual of t
+ | VOr of comparator * comparator
+ | VAnd of comparator * comparator
+
+
+ (* Range of allowed characters *)
+ let is_digit c =
+ '0' <= c && c <= '9'
+
+ let is_alpha c =
+ ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
+
+ let is_special =
+ function
+ | '.' | '+' | '-' | '~' -> true
+ | _ -> false
+
+ let rec version_compare v1 v2 =
+ if v1 <> "" || v2 <> "" then
+ begin
+ (* Compare ascii string, using special meaning for version
+ * related char
+ *)
+ let val_ascii c =
+ if c = '~' then -1
+ else if is_digit c then 0
+ else if c = '\000' then 0
+ else if is_alpha c then Char.code c
+ else (Char.code c) + 256
+ in
+
+ let len1 = String.length v1 in
+ let len2 = String.length v2 in
+
+ let p = ref 0 in
+
+ (** Compare ascii part *)
+ let compare_vascii () =
+ let cmp = ref 0 in
+ while !cmp = 0 &&
+ !p < len1 && !p < len2 &&
+ not (is_digit v1.[!p] && is_digit v2.[!p]) do
+ cmp := (val_ascii v1.[!p]) - (val_ascii v2.[!p]);
+ incr p
+ done;
+ if !cmp = 0 && !p < len1 && !p = len2 then
+ val_ascii v1.[!p]
+ else if !cmp = 0 && !p = len1 && !p < len2 then
+ - (val_ascii v2.[!p])
+ else
+ !cmp
+ in
+
+ (** Compare digit part *)
+ let compare_digit () =
+ let extract_int v p =
+ let start_p = !p in
+ while !p < String.length v && is_digit v.[!p] do
+ incr p
+ done;
+ let substr =
+ String.sub v !p ((String.length v) - !p)
+ in
+ let res =
+ match String.sub v start_p (!p - start_p) with
+ | "" -> 0
+ | s -> int_of_string s
+ in
+ res, substr
+ in
+ let i1, tl1 = extract_int v1 (ref !p) in
+ let i2, tl2 = extract_int v2 (ref !p) in
+ i1 - i2, tl1, tl2
+ in
+
+ match compare_vascii () with
+ | 0 ->
+ begin
+ match compare_digit () with
+ | 0, tl1, tl2 ->
+ if tl1 <> "" && is_digit tl1.[0] then
+ 1
+ else if tl2 <> "" && is_digit tl2.[0] then
+ -1
+ else
+ version_compare tl1 tl2
+ | n, _, _ ->
+ n
+ end
+ | n ->
+ n
+ end
+ else
+ begin
+ 0
+ end
+
+
+ let version_of_string str = str
+
+ let string_of_version t = t
+
+ let chop t =
+ try
+ let pos =
+ String.rindex t '.'
+ in
+ String.sub t 0 pos
+ with Not_found ->
+ t
+
+ let rec comparator_apply v op =
+ match op with
+ | VGreater cv ->
+ (version_compare v cv) > 0
+ | VGreaterEqual cv ->
+ (version_compare v cv) >= 0
+ | VLesser cv ->
+ (version_compare v cv) < 0
+ | VLesserEqual cv ->
+ (version_compare v cv) <= 0
+ | VEqual cv ->
+ (version_compare v cv) = 0
+ | VOr (op1, op2) ->
+ (comparator_apply v op1) || (comparator_apply v op2)
+ | VAnd (op1, op2) ->
+ (comparator_apply v op1) && (comparator_apply v op2)
+
+ let rec string_of_comparator =
+ function
+ | VGreater v -> "> "^(string_of_version v)
+ | VEqual v -> "= "^(string_of_version v)
+ | VLesser v -> "< "^(string_of_version v)
+ | VGreaterEqual v -> ">= "^(string_of_version v)
+ | VLesserEqual v -> "<= "^(string_of_version v)
+ | VOr (c1, c2) ->
+ (string_of_comparator c1)^" || "^(string_of_comparator c2)
+ | VAnd (c1, c2) ->
+ (string_of_comparator c1)^" && "^(string_of_comparator c2)
+
+ let rec varname_of_comparator =
+ let concat p v =
+ OASISUtils.varname_concat
+ p
+ (OASISUtils.varname_of_string
+ (string_of_version v))
+ in
+ function
+ | VGreater v -> concat "gt" v
+ | VLesser v -> concat "lt" v
+ | VEqual v -> concat "eq" v
+ | VGreaterEqual v -> concat "ge" v
+ | VLesserEqual v -> concat "le" v
+ | VOr (c1, c2) ->
+ (varname_of_comparator c1)^"_or_"^(varname_of_comparator c2)
+ | VAnd (c1, c2) ->
+ (varname_of_comparator c1)^"_and_"^(varname_of_comparator c2)
+
+ let version_0_3_or_after t =
+ comparator_apply t (VGreaterEqual (string_of_version "0.3"))
+
+end
+
+module OASISLicense = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISLicense.ml" *)
+
+ (** License for _oasis fields
+ @author Sylvain Le Gall
+ *)
+
+
+
+ type license = string
+
+ type license_exception = string
+
+ type license_version =
+ | Version of OASISVersion.t
+ | VersionOrLater of OASISVersion.t
+ | NoVersion
+
+
+ type license_dep_5_unit =
+ {
+ license: license;
+ excption: license_exception option;
+ version: license_version;
+ }
+
+
+ type license_dep_5 =
+ | DEP5Unit of license_dep_5_unit
+ | DEP5Or of license_dep_5 list
+ | DEP5And of license_dep_5 list
+
+
+ type t =
+ | DEP5License of license_dep_5
+ | OtherLicense of string (* URL *)
+
+
+end
+
+module OASISExpr = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISExpr.ml" *)
+
+
+
+ open OASISGettext
+
+ type test = string
+
+ type flag = string
+
+ type t =
+ | EBool of bool
+ | ENot of t
+ | EAnd of t * t
+ | EOr of t * t
+ | EFlag of flag
+ | ETest of test * string
+
+
+ type 'a choices = (t * 'a) list
+
+ let eval var_get t =
+ let rec eval' =
+ function
+ | EBool b ->
+ b
+
+ | ENot e ->
+ not (eval' e)
+
+ | EAnd (e1, e2) ->
+ (eval' e1) && (eval' e2)
+
+ | EOr (e1, e2) ->
+ (eval' e1) || (eval' e2)
+
+ | EFlag nm ->
+ let v =
+ var_get nm
+ in
+ assert(v = "true" || v = "false");
+ (v = "true")
+
+ | ETest (nm, vl) ->
+ let v =
+ var_get nm
+ in
+ (v = vl)
+ in
+ eval' t
+
+ let choose ?printer ?name var_get lst =
+ let rec choose_aux =
+ function
+ | (cond, vl) :: tl ->
+ if eval var_get cond then
+ vl
+ else
+ choose_aux tl
+ | [] ->
+ let str_lst =
+ if lst = [] then
+ s_ "<empty>"
+ else
+ String.concat
+ (s_ ", ")
+ (List.map
+ (fun (cond, vl) ->
+ match printer with
+ | Some p -> p vl
+ | None -> s_ "<no printer>")
+ lst)
+ in
+ match name with
+ | Some nm ->
+ failwith
+ (Printf.sprintf
+ (f_ "No result for the choice list '%s': %s")
+ nm str_lst)
+ | None ->
+ failwith
+ (Printf.sprintf
+ (f_ "No result for a choice list: %s")
+ str_lst)
+ in
+ choose_aux (List.rev lst)
+
+end
+
+module OASISTypes = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISTypes.ml" *)
+
+
+
+
+ type name = string
+ type package_name = string
+ type url = string
+ type unix_dirname = string
+ type unix_filename = string
+ type host_dirname = string
+ type host_filename = string
+ type prog = string
+ type arg = string
+ type args = string list
+ type command_line = (prog * arg list)
+
+ type findlib_name = string
+ type findlib_full = string
+
+ type compiled_object =
+ | Byte
+ | Native
+ | Best
+
+
+ type dependency =
+ | FindlibPackage of findlib_full * OASISVersion.comparator option
+ | InternalLibrary of name
+
+
+ type tool =
+ | ExternalTool of name
+ | InternalExecutable of name
+
+
+ type vcs =
+ | Darcs
+ | Git
+ | Svn
+ | Cvs
+ | Hg
+ | Bzr
+ | Arch
+ | Monotone
+ | OtherVCS of url
+
+
+ type plugin_kind =
+ [ `Configure
+ | `Build
+ | `Doc
+ | `Test
+ | `Install
+ | `Extra
+ ]
+
+ type plugin_data_purpose =
+ [ `Configure
+ | `Build
+ | `Install
+ | `Clean
+ | `Distclean
+ | `Install
+ | `Uninstall
+ | `Test
+ | `Doc
+ | `Extra
+ | `Other of string
+ ]
+
+ type 'a plugin = 'a * name * OASISVersion.t option
+
+ type all_plugin = plugin_kind plugin
+
+ type plugin_data = (all_plugin * plugin_data_purpose * (unit -> unit)) list
+
+(* # 102 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISTypes.ml" *)
+
+ type 'a conditional = 'a OASISExpr.choices
+
+ type custom =
+ {
+ pre_command: (command_line option) conditional;
+ post_command: (command_line option) conditional;
+ }
+
+
+ type common_section =
+ {
+ cs_name: name;
+ cs_data: PropList.Data.t;
+ cs_plugin_data: plugin_data;
+ }
+
+
+ type build_section =
+ {
+ bs_build: bool conditional;
+ bs_install: bool conditional;
+ bs_path: unix_dirname;
+ bs_compiled_object: compiled_object;
+ bs_build_depends: dependency list;
+ bs_build_tools: tool list;
+ bs_c_sources: unix_filename list;
+ bs_data_files: (unix_filename * unix_filename option) list;
+ bs_ccopt: args conditional;
+ bs_cclib: args conditional;
+ bs_dlllib: args conditional;
+ bs_dllpath: args conditional;
+ bs_byteopt: args conditional;
+ bs_nativeopt: args conditional;
+ }
+
+
+ type library =
+ {
+ lib_modules: string list;
+ lib_pack: bool;
+ lib_internal_modules: string list;
+ lib_findlib_parent: findlib_name option;
+ lib_findlib_name: findlib_name option;
+ lib_findlib_containers: findlib_name list;
+ }
+
+ type executable =
+ {
+ exec_custom: bool;
+ exec_main_is: unix_filename;
+ }
+
+ type flag =
+ {
+ flag_description: string option;
+ flag_default: bool conditional;
+ }
+
+ type source_repository =
+ {
+ src_repo_type: vcs;
+ src_repo_location: url;
+ src_repo_browser: url option;
+ src_repo_module: string option;
+ src_repo_branch: string option;
+ src_repo_tag: string option;
+ src_repo_subdir: unix_filename option;
+ }
+
+ type test =
+ {
+ test_type: [`Test] plugin;
+ test_command: command_line conditional;
+ test_custom: custom;
+ test_working_directory: unix_filename option;
+ test_run: bool conditional;
+ test_tools: tool list;
+ }
+
+ type doc_format =
+ | HTML of unix_filename
+ | DocText
+ | PDF
+ | PostScript
+ | Info of unix_filename
+ | DVI
+ | OtherDoc
+
+
+ type doc =
+ {
+ doc_type: [`Doc] plugin;
+ doc_custom: custom;
+ doc_build: bool conditional;
+ doc_install: bool conditional;
+ doc_install_dir: unix_filename;
+ doc_title: string;
+ doc_authors: string list;
+ doc_abstract: string option;
+ doc_format: doc_format;
+ doc_data_files: (unix_filename * unix_filename option) list;
+ doc_build_tools: tool list;
+ }
+
+ type section =
+ | Library of common_section * build_section * library
+ | Executable of common_section * build_section * executable
+ | Flag of common_section * flag
+ | SrcRepo of common_section * source_repository
+ | Test of common_section * test
+ | Doc of common_section * doc
+
+
+ type section_kind =
+ [ `Library | `Executable | `Flag | `SrcRepo | `Test | `Doc ]
+
+ type package =
+ {
+ oasis_version: OASISVersion.t;
+ ocaml_version: OASISVersion.comparator option;
+ findlib_version: OASISVersion.comparator option;
+ name: package_name;
+ version: OASISVersion.t;
+ license: OASISLicense.t;
+ license_file: unix_filename option;
+ copyrights: string list;
+ maintainers: string list;
+ authors: string list;
+ homepage: url option;
+ synopsis: string;
+ description: string option;
+ categories: url list;
+
+ conf_type: [`Configure] plugin;
+ conf_custom: custom;
+
+ build_type: [`Build] plugin;
+ build_custom: custom;
+
+ install_type: [`Install] plugin;
+ install_custom: custom;
+ uninstall_custom: custom;
+
+ clean_custom: custom;
+ distclean_custom: custom;
+
+ files_ab: unix_filename list;
+ sections: section list;
+ plugins: [`Extra] plugin list;
+ schema_data: PropList.Data.t;
+ plugin_data: plugin_data;
+ }
+
+end
+
+module OASISUnixPath = struct
+(* # 21 "/home/chambart/.opam/base/build/oasis.0.3.0/src/oasis/OASISUnixPath.ml" *)
+
+ type unix_filename = string
+ type unix_dirname = string
+
+ type host_filename = string
+ type host_dirname = string
+
+ let current_dir_name = "."
+
+ let parent_dir_name = ".."
+
+ let is_current_dir fn =
+ fn = current_dir_name || fn = ""
+
+ let concat f1 f2 =
+ if is_current_dir f1 then
+ f2
+ else
+ let f1' =
+ try OASISString.strip_ends_with ~what:"/" f1 with Not_found -> f1
+ in
+ f1'^"/"^f2
+
+ let make =
+ function
+ | hd :: tl ->
+ List.fold_left
+ (fun f p -> concat f p)
+ hd
+ tl
+ | [] ->
+ invalid_arg "OASISUnixPath.make"
+
+ let dirname f =
+ try
+ String.sub f 0 (String.rindex f '/')
+ with Not_found ->
+ current_dir_name
+
+ let basename f =
+ try
+ let pos_start =
+ (String.rindex f '/') + 1
+ in
+ String.sub f pos_start ((String.length f) - pos_start)
+ with Not_found ->
+ f
+
+ let chop_extension f =
+ try
+ let last_dot =
+ String.rindex f '.'
+ in
+ let su...
[truncated message content] |
