ocaml/ocamldoc/odoc_comments.ml

(***********************************************************************)
(*                             OCamldoc                                *)
(*                                                                     *)
(*            Maxence Guesdon, projet Cristal, INRIA Rocquencourt      *)
(*                                                                     *)
(*  Copyright 2001 Institut National de Recherche en Informatique et   *)
(*  en Automatique.  All rights reserved.  This file is distributed    *)
(*  under the terms of the Q Public License version 1.0.               *)
(*                                                                     *)
(***********************************************************************)


(** Analysis of comments. *)

open Odoc_types

let print_DEBUG s = print_string s ; print_newline ();;

(** This variable contains the regular expression representing a blank but not a '\n'.*)
let simple_blank = "[ \013\009\012]"

module type Texter = 
    sig
      (** Return a text structure from a string. *)
      val text_of_string : string -> text
    end

module Info_retriever =
  functor (MyTexter : Texter) ->
  struct
    let create_see s =
      try
	let lexbuf = Lexing.from_string s in
	let (see_ref, s) = Odoc_parser.see_info Odoc_see_lexer.main lexbuf in
	(see_ref, MyTexter.text_of_string s)
      with
      |	Odoc_text.Text_syntax (l, c, s) ->
	  raise (Failure (Odoc_messages.text_parse_error l c s))
      |	_ ->
	  raise (Failure ("Erreur inconnue lors du parse de see : "^s))

    let retrieve_info fun_lex file (s : string) =
      try
	let _ = Odoc_comments_global.init () in
	Odoc_lexer.comments_level := 0;
	let lexbuf = Lexing.from_string s in
	match Odoc_parser.main fun_lex lexbuf with
	  None ->
	    (0, None)
	| Some (desc, remain_opt) ->
	    let mem_nb_chars = !Odoc_comments_global.nb_chars in
	    let _ = 
	      match remain_opt with
		None ->
		  ()
	      | Some s ->
	          (*DEBUG*)print_string ("remain: "^s); print_newline();
		  let lexbuf2 = Lexing.from_string s in
		  Odoc_parser.info_part2 Odoc_lexer.elements lexbuf2
	    in
	    (mem_nb_chars, 
	     Some
	       {
		 i_desc = (match desc with "" -> None | _ -> Some (MyTexter.text_of_string desc));
		 i_authors = !Odoc_comments_global.authors;
		 i_version = !Odoc_comments_global.version;
		 i_sees = (List.map create_see !Odoc_comments_global.sees) ;
		 i_since = !Odoc_comments_global.since;
		 i_deprecated = 
		 (match !Odoc_comments_global.deprecated with 
		   None -> None | Some s -> Some (MyTexter.text_of_string s));
		 i_params = 
		 (List.map (fun (n, s) -> 
		   (n, MyTexter.text_of_string s)) !Odoc_comments_global.params);
		 i_raised_exceptions = 
		 (List.map (fun (n, s) ->
		   (n, MyTexter.text_of_string s)) !Odoc_comments_global.raised_exceptions);
		 i_return_value =
		 (match !Odoc_comments_global.return_value with 
		   None -> None | Some s -> Some (MyTexter.text_of_string s)) ;
		 i_custom = (List.map
			       (fun (tag, s) -> (tag, MyTexter.text_of_string s)) 
			       !Odoc_comments_global.customs)
	       } 
	    )
	       with
		 Failure s ->
		   incr Odoc_global.errors ;
		   prerr_endline (file^" : "^s^"\n");
		   (0, None)
	       | Odoc_text.Text_syntax (l, c, s) ->
		   incr Odoc_global.errors ;
		   prerr_endline (file^" : "^(Odoc_messages.text_parse_error l c s));
		   (0, None)
	       | _ ->
		   incr Odoc_global.errors ;
		   prerr_endline (file^" : "^Odoc_messages.parse_error^"\n");
		   (0, None)

    (** This function takes a string where a simple comment may has been found. It returns
       false if there is a blank line or the first comment is a special one, or if there is
       no comment if the string.*)
    let nothing_before_simple_comment s =
      (* get the position of the first "(*" *)
      try
	print_DEBUG ("comment_is_attached: "^s);
	let pos = Str.search_forward (Str.regexp "(\\*") s 0 in
	let next_char = if (String.length s) >= (pos + 1) then s.[pos + 2] else '_' in
	(next_char <> '*') &&
	(
         (* there is no special comment between the constructor and the coment we got *)
	 let s2 = String.sub s 0 pos in
	 print_DEBUG ("s2="^s2);
	 try
	   let _ = Str.search_forward (Str.regexp ("['\n']"^simple_blank^"*['\n']")) s2 0 in
           (* a blank line was before the comment *)
	   false
	 with
	   Not_found ->
	     true
	)
      with
	Not_found ->
	  false

    (** Return true if the given string contains a blank line. *)
    let blank_line s =
      try
	let _ = Str.search_forward (Str.regexp ("['\n']"^simple_blank^"*['\n']")) s 0 in
        (* a blank line was before the comment *)
	true
      with
	Not_found ->
	  false
	    
    let retrieve_info_special file (s : string) =
      retrieve_info Odoc_lexer.main file s

    let retrieve_info_simple file (s : string) =
      let _ = Odoc_comments_global.init () in
      Odoc_lexer.comments_level := 0;
      let lexbuf = Lexing.from_string s in
      match Odoc_parser.main Odoc_lexer.simple lexbuf with
	None ->
	  (0, None)
      | Some (desc, remain_opt) ->
	  (!Odoc_comments_global.nb_chars, Some Odoc_types.dummy_info)

    (** Return true if the given string contains a blank line outside a simple comment. *)
    let blank_line_outside_simple file s =
      let rec iter s2 =
	match retrieve_info_simple file s2 with
	  (_, None) ->
	    blank_line s2
	| (len, Some _) ->
	    try
	      let pos = Str.search_forward (Str.regexp_string "(*") s2 0 in
	      let s_before = String.sub s2 0 pos in
	      let s_after = String.sub s2 len ((String.length s2) - len) in
	      (blank_line s_before) || (iter s_after)
	    with
	      Not_found ->
		(* we shouldn't get here *)
		false
      in
      iter s

    (** This function returns the first simple comment in
       the given string. If strict is [true] then no
       comment is returned if a blank line or a special
       comment is found before the simple comment. *)
    let retrieve_first_info_simple ?(strict=true) file (s : string) =
      match retrieve_info_simple file s with
	(_, None) ->
	  (0, None)
      |	(len, Some d) ->
	  (* we check if the comment we got was really attached to the constructor,
	     i.e. that there was no blank line or any special comment "(**" before *)
	  if (not strict) or (nothing_before_simple_comment s) then
	    (* ok, we attach the comment to the constructor *)
	    (len, Some d)
	  else
	    (* a blank line or special comment was before the comment,
	       so we must not attach this comment to the constructor. *)
	    (0, None)

    let retrieve_last_info_simple file (s : string) =
      print_DEBUG ("retrieve_last_info_simple:"^s);
      let rec f cur_len cur_d =
	try 
	  let s2 = String.sub s cur_len ((String.length s) - cur_len) in
	  print_DEBUG ("retrieve_last_info_simple.f:"^s2);
	  match retrieve_info_simple file s2 with
	    (len, None) ->
	      print_DEBUG "retrieve_last_info_simple: None";
	      (cur_len + len, cur_d)
	  | (len, Some d) ->
	      print_DEBUG "retrieve_last_info_simple: Some";
	      f (len + cur_len) (Some d)
	with
	  _ ->
	    print_DEBUG "retrieve_last_info_simple : Erreur String.sub";
	    (cur_len, cur_d)
      in
      f 0 None

    let retrieve_last_special_no_blank_after file (s : string) =
      print_DEBUG ("retrieve_last_special_no_blank_after:"^s);
      let rec f cur_len cur_d =
	try 
	  let s2 = String.sub s cur_len ((String.length s) - cur_len) in
	  print_DEBUG ("retrieve_last_special_no_blank_after.f:"^s2);
	  match retrieve_info_special file s2 with
	    (len, None) ->
	      print_DEBUG "retrieve_last_special_no_blank_after: None";
	      (cur_len + len, cur_d)
	  | (len, Some d) ->
	      print_DEBUG "retrieve_last_special_no_blank_after: Some";
	      f (len + cur_len) (Some d)
	with
	  _ ->
	    print_DEBUG "retrieve_last_special_no_blank_after : Erreur String.sub";
	    (cur_len, cur_d)
      in
      f 0 None

    let all_special file s =
      print_DEBUG ("all_special: "^s);
      let rec iter acc n s2 =
	match retrieve_info_special file s2 with
	  (_, None) ->
	    (n, acc)
	| (n2, Some i) ->
	    print_DEBUG ("all_special: avant String.sub new_s="^s2);
	    print_DEBUG ("n2="^(string_of_int n2)) ;
	    print_DEBUG ("len(s2)="^(string_of_int (String.length s2))) ;
	    let new_s = String.sub s2 n2 ((String.length s2) - n2) in
	    print_DEBUG ("all_special: apres String.sub new_s="^new_s);
	    iter (acc @ [i]) (n + n2) new_s
      in
      let res = iter [] 0 s in
      print_DEBUG ("all_special: end");
      res

    let just_after_special file s =
      print_DEBUG ("just_after_special: "^s);
      let res = match retrieve_info_special file s with
	(_, None) ->
	  (0, None)
      |	(len, Some d) ->
	  (* we must not have a simple comment or a blank line before. *)
	  match retrieve_info_simple file (String.sub s 0 len) with
	    (_, None) ->
	      (
	       try
		 (* if the special comment is the stop comment (**/**),
		    then we must not associate it. *)
		 let pos = Str.search_forward (Str.regexp_string "(**") s 0 in
		 if blank_line (String.sub s 0 pos) or 
		   d.Odoc_types.i_desc = Some [Odoc_types.Raw "/*"]
		 then
		   (0, None)
		 else
		   (len, Some d)
	       with
		 Not_found ->
		   (* should not occur *)
		   (0, None)
	      )
	  | (len2, Some d2) ->
	      (0, None)
      in
      print_DEBUG ("just_after_special:end");
      res

    let first_special file s =
      retrieve_info_special file s

    let get_comments f_create_ele file s =
      let (assoc_com, ele_coms) =
        (* get the comments *)
	let (len, special_coms) =  all_special file s in
	(* if there is no blank line after the special comments, and
	   if the last special comment is not the stop special comment, then the 
	   last special comments must be associated to the element. *)
	match List.rev special_coms with
	  [] ->
	    (None, [])
	|  h :: q ->
	    if (blank_line_outside_simple file
		  (String.sub s len ((String.length s) - len)) )
		or h.Odoc_types.i_desc = Some [Odoc_types.Raw "/*"]
	    then
	      (None, special_coms)
	    else
	      (Some h, List.rev q)
      in
      let ele_comments =
	List.fold_left
	  (fun acc -> fun sc ->
	    match sc.Odoc_types.i_desc with
	      None ->
		acc
	    | Some t ->
		acc @ [f_create_ele t])
	  []
	  ele_coms
      in
      (assoc_com, ele_comments)
  end

module Basic_info_retriever = Info_retriever (Odoc_text.Texter)