Re: [Caml-list] Printf question

[Damien <Damien.Pous@ens-lyon.fr>]

[-- Attachment #1: Type: text/plain, Size: 994 bytes --]

> You might have a look into the tracing facilities I developed for
> Poesia. These are tracing macros for camlp4.
looks really fine ! but also really complicated...

I personally use the less powerful attached code :

advantages are :
	* you don't need to recompile the code each time you change debug
	options
	* it can _easily_ be adapted to the newbie needs 
	* it doesn't need camlp4 (is this an actual advantage !?)

disadvantages are :
	* you can't automagically display the location in the source code 
	* you need to remove debug statements by hand when compiling efficient
	binaries
	* Basile will certainly find more :-)

note : for the first disadvantage, why not to modify the assert function
in order it also prints the execution stack. 
I don't know if this is possible in both byte and native code, but I
guess it should be when debugging informations are saved (ocamlc -g).
from my mind, this would be really useful.

hope this help,
damien

--
<http://www.ens-lyon.fr/~dpous>

[-- Attachment #2: Makefile --]
[-- Type: application/octet-stream, Size: 162 bytes --]

toto: msg.cmo toto.ml
	ocamlc msg.cmo toto.ml -o toto

msg.cmo: msg.cmi msg.ml
	ocamlc -c msg.ml

msg.cmi: msg.mli
	ocamlc -c msg.mli

clean: 	
	rm -f toto *.cm?

[-- Attachment #3: msg.ml --]
[-- Type: application/octet-stream, Size: 785 bytes --]

(* warning classes  *)
type warning_t = [ 
| `Foo
| `Bar 
| `Arf
]

let map s = 
  match String.uppercase s with
    | "FOO" -> `Foo
    | "BAR" -> `Bar
    | "ARF" -> `Arf
    | _     -> failwith ("Unknown warning : "^s)

(* warnings handled as errors *)
let err_l = ref []
let as_error w = err_l := (map w) :: !err_l

(* ignored warnings *)
let warn_l = ref []
let add_warning w = warn_l := (map w) :: !warn_l


let error () = Printf.kprintf (fun s -> prerr_endline s; exit 1)
let warning w = Obj.magic (
  if List.mem w !err_l then 
    error ()
  else if List.mem w !warn_l then
    Printf.kprintf (fun s -> prerr_endline s; "")
  else
    Printf.kprintf (fun _ -> ""))
(* Obj.magic is used to cast a string to unit and avoid "this expression should have type unit" warnings... *)

[-- Attachment #4: msg.mli --]
[-- Type: application/octet-stream, Size: 334 bytes --]

(* warning classes  *)
type warning_t = [ 
| `Foo
| `Bar 
| `Arf
]

(* warnings to activate or to handle as errors *)
val as_error    : string -> unit
val add_warning : string -> unit

(* warnings / errors *)
val warning : warning_t -> ('a, out_channel, unit) format -> 'a 
val error   :      unit -> ('a, unit, string) format -> 'a


[-- Attachment #5: toto.ml --]
[-- Type: application/octet-stream, Size: 390 bytes --]

let _ = 
  Arg.parse 
    [ "-W", Arg.String Msg.add_warning, " <w>\tenable warnings of kind w"; 
      "-E", Arg.String Msg.as_error,    " <w>\thandle warnings of kind w as errors" ]
    (fun _ -> raise (Arg.Bad "too many arguments"))
    "toto [options]";
  
  Msg.warning `Foo "foo=%d" 51;
  Msg.warning `Bar "bar%s" "jo";
  Msg.warning `Arf "glou: %f" 3.3;
  Msg.error() "boom !"
    


[-- Attachment #6: EXAMPLE --]
[-- Type: application/octet-stream, Size: 124 bytes --]

>./toto
boom !

>./toto -W FOO
foo=51
boom !

>./toto -W FOO -W BAR
foo=51
barjo
boom !

>./toto -W FOO -E BAR
foo=51
barjo