Re : [Caml-list] Re: camlp4 stream parser syntax

[Matthieu Wipliez <mwipliez@yahoo.fr>]

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

> I don't think this will work elegantly.
> 
> Static first makes a Structure (is make the right term?) and then makes a bunch 
> of other modules using it. A custom Structure will be needed to downcase the 
> keywords before inserting them into the hash table, so Static will need to be 
> duplicated as well.

Well I just duplicated Static to Static1 (and added Camlp4.Struct.Grammar where necessary) and replaced:
  module Structure = Camlp4.Struct.Grammar.Structure.Make Lexer;
by:
  module Structure = struct
        include Camlp4.Struct.Grammar.Structure.Make Lexer;
        
        value using { gkeywords = table; gfilter = filter } kwd =
            let kwd = String.lowercase kwd in
        let r = try Hashtbl.find table kwd with
                [ Not_found ->
                    let r = ref 0 in do { Hashtbl.add table kwd r; r } ]
        in do { Token.Filter.keyword_added filter kwd (r.val = 0);
                incr r };
    end;

This way, I redefine "using" to my liking, the only modification being the lower-casing on the first line.

Structure is then passed to other functors as usual.
Note that you need to compile Static1 with camlp4r because it is revised syntax (in ocamlbuild _tags this is camlp4r, use_camlp4).
This seems to work (you need the lowercase in match_keyword too btw): I have "acTIon" and "actiON" in the parser, and parses "action" in input files.

Cheers,
Matthieu



      

[-- Attachment #2: Static1.ml --]
[-- Type: application/octet-stream, Size: 3481 bytes --]

(****************************************************************************)
(*                                                                          *)
(*                              Objective Caml                              *)
(*                                                                          *)
(*                            INRIA Rocquencourt                            *)
(*                                                                          *)
(*  Copyright  2006   Institut National de Recherche  en  Informatique et   *)
(*  en Automatique.  All rights reserved.  This file is distributed under   *)
(*  the terms of the GNU Library General Public License, with the special   *)
(*  exception on linking described in LICENSE at the top of the Objective   *)
(*  Caml source tree.                                                       *)
(*                                                                          *)
(****************************************************************************)

(* Authors:
 * - Daniel de Rauglaudre: initial version
 * - Nicolas Pouillard: refactoring
*)

open Camlp4;

value uncurry f (x,y) = f x y;
value flip f x y = f y x;

module Make (Lexer : Sig.Lexer)
: Sig.Grammar.Static with module Loc = Lexer.Loc
                        and module Token = Lexer.Token
= struct
  module Structure = struct
		include Camlp4.Struct.Grammar.Structure.Make Lexer;
		
		value using { gkeywords = table; gfilter = filter } kwd =
			let kwd = String.lowercase kwd in
	    let r = try Hashtbl.find table kwd with
	            [ Not_found ->
	                let r = ref 0 in do { Hashtbl.add table kwd r; r } ]
	    in do { Token.Filter.keyword_added filter kwd (r.val = 0);
	            incr r };
	end;
  module Delete = Camlp4.Struct.Grammar.Delete.Make Structure;
  module Insert = Camlp4.Struct.Grammar.Insert.Make Structure;
  module Fold = Camlp4.Struct.Grammar.Fold.Make Structure;
  include Structure;

  value gram =
    let gkeywords = Hashtbl.create 301 in
    {
      gkeywords = gkeywords;
      gfilter = Token.Filter.mk (Hashtbl.mem gkeywords);
      glexer = Lexer.mk ();
      warning_verbose = ref True; (* FIXME *)
      error_verbose = Camlp4_config.verbose
    };

  module Entry = struct
    module E = Camlp4.Struct.Grammar.Entry.Make Structure;
    type t 'a = E.t 'a;
    value mk = E.mk gram;
    value of_parser name strm = E.of_parser gram name strm;
    value setup_parser = E.setup_parser;
    value name = E.name;
    value print = E.print;
    value clear = E.clear;
    value dump = E.dump;
    value obj x = x;
  end;

  value get_filter () = gram.gfilter;

  value lex loc cs = gram.glexer loc cs;

  value lex_string loc str = lex loc (Stream.of_string str);

  value filter ts = Token.Filter.filter gram.gfilter ts;

  value parse_tokens_after_filter entry ts = Entry.E.parse_tokens_after_filter entry ts;

  value parse_tokens_before_filter entry ts = parse_tokens_after_filter entry (filter ts);

  value parse entry loc cs = parse_tokens_before_filter entry (lex loc cs);

  value parse_string entry loc str = parse_tokens_before_filter entry (lex_string loc str);

  value delete_rule = Delete.delete_rule;

  value srules e rl =
    Stree (List.fold_left (flip (uncurry (Insert.insert_tree e))) DeadEnd rl);
  value sfold0 = Fold.sfold0;
  value sfold1 = Fold.sfold1;
  value sfold0sep = Fold.sfold0sep;
  (* value sfold1sep = Fold.sfold1sep; *)

  value extend = Insert.extend;

end;