Commits

james woodyatt committed 4cc5fb8

Adjust whitespace. Update copyright declarations. Use Mercurial keywords
according to what passes for my latest convention. Remove unnecessary
template files. Add ICMPv6 to the list of common IP protocols. Remove
the extraneous call to GC.compact in the initializer for Nx_uri. Update
the Conjury subrepository.

  • Participants
  • Parent commits b4d2c79

Comments (0)

Files changed (152)

-35edb2a24d7c664a9877a5a3014c071404d8c998 Conjury
+26b018e00c6fadcfbbcac8350401de51c523dd6f Conjury
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_cmonad.ml
-
-  Copyright (c) 2002-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2002-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 let eval m x = m (fun () -> x)
 let bridge x b m _ = b (m (fun () -> x))
 
-(*--- End of File [ cf_cmonad.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_cmonad.mli
-
-  Copyright (c) 2002-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2002-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 val init: 'x -> ('x, 'a) t
 
 (** Use [cont f] to produce a monad that applies [f] to the current
-	intermediate context and passes the result into the continuation.
+    intermediate context and passes the result into the continuation.
 *)
 val cont: ('x -> 'x) -> ('x, unit) t
 
 (** Use [bridge x f m] as a shortcut for [init (f (eval m x))]. *)
 val bridge: 'x -> ('x -> 'y) -> ('x, unit) t -> ('y, unit) t
 
-(*--- End of File [ cf_cmonad.mli ] ---*)
+(*--- $File$ ---*)
 /*---------------------------------------------------------------------------*
-  C MODULE  cf_common_p.c
-
-  Copyright (c) 2002-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2002-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     return tablePtr->unknown(n);
 }
 
-/*--- End of File [ cf_common_p.c ] ---*/
+/*--- $File$ ---*/
 /*---------------------------------------------------------------------------*
-  C HEADER  cf_common_p.h
-
-  Copyright (c) 2002-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2002-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 typedef value (*Cf_const_constructor_f)(int n);
 
 struct cf_constant_table_s {
-    const int*			array;
-    unsigned int		size;
-    Cf_const_constructor_f	unknown;
+    const int*              array;
+    unsigned int            size;
+    Cf_const_constructor_f  unknown;
 };
 
 typedef struct cf_constant_table_s Cf_constant_table_t;
 
 extern value cf_get_constant(const Cf_constant_table_t* tablePtr, int n);
 
-#define Nothing		((value) 0)
+#define Nothing     ((value) 0)
 
 /*--- These are imported from the unix library in the ocaml distro ---*/
 extern void unix_error(int code, const char fname[], value arg) Noreturn;
 
 #endif /* defined(_CF_COMMON_P_H) */
 
-/*--- End of File [ cf_common_p.h ] ---*/
+/*--- $File$ ---*/
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_deque.ml
-
-  Copyright (c) 2003-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2003-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
                             assert (not true);
                             None
                     end
-
+                
                 | _, _ ->
                     assert (not true);
                     None
         | y ->
             assert (y = Z);
             None
-
+    
     let rec head = function
         | Y x
         | U (Y x, _, _)
     let of_list s = List.fold_left (fun q a -> B.push a q) nil s
     let of_seq z = Cf_seq.fold (fun q a -> B.push a q) nil z
     let to_list d = B.fold (fun s a -> a :: s) [] d
-
+    
     let rec to_seq d =
         lazy begin
             match pop d with
         | _ ->
             assert (not true);
             Z
-
     
     and pop = function
         | V (c, b, a) ->
                             assert (not true);
                             None
                     end
-
+                
                 | _, _ ->
                     assert (not true);
                     None
         | y ->
             assert (y = Z);
             None
-
+    
     let rec head = function
         | Y x
         | U (_, _, Y x)
         | y ->
             assert (y = Z);
             raise Not_found
-
+    
     let tail d = match pop d with Some (_, d) -> d | None -> Z
     
     let rec fold f v = function
     let of_list s = List.fold_left (fun q a -> A.push a q) nil s
     let of_seq z = Cf_seq.fold (fun q a -> A.push a q) nil z
     let to_list d = A.fold (fun s a -> a :: s) [] d
-
+    
     let rec to_seq d =
         lazy begin
             match pop d with
             iterate f a;
             I.iterate (iterate f) (Lazy.force b);
             iterate f c
-
+    
     let rec predicate f = function
         | Z -> true
         | Y a -> f a
             predicate f a &&
             I.predicate (predicate f) (Lazy.force b) &&
             predicate f c
-
+    
     let filter f =
         let g d' x = if f x then B.push x d' else d' in
         A.fold g Z
-
+    
     let rec map f = function
         | Z ->
             Z
             let b = Lazy.lazy_from_val (I.map (map f) (Lazy.force b)) in
             let c = map f c in
             V (a, b, c)
-
+    
     let optmap f =
         let g d' x = match f x with Some y -> B.push y d' | None -> d' in
         fun d -> Cf_seq.fold g Z (A.to_seq d)
-
+    
     let listmap f =
         let g d' x = List.fold_left (fun d x -> B.push x d) d' (f x) in
         fun d -> Cf_seq.fold g Z (A.to_seq d)
-
+    
     let seqmap f =
         let g d' x = Cf_seq.fold (fun d x -> B.push x d) d' (f x) in
         fun d -> Cf_seq.fold g Z (A.to_seq d)
-
+    
     let partition f =
         let g (d0, d1) x = if f x then B.push x d0, d1 else d0, B.push x d1 in
         fun d -> Cf_seq.fold g (Z, Z) (A.to_seq d)
-
+    
     (** @param d A deque *)
     let rec length = function
         | Z -> 0
         | V (a,b,c) ->
             length a + length c +
             A.fold (fun n d -> n + length d) 0 (Lazy.force b)
-
+    
     let rec catenate q1 q2 =
         match q1, q2 with
         | (Z, q | q, Z) -> q
         ) b in
         let c = sprint f c in
         Printf.sprintf "[%s|%s|%s]" a b c
-
     | V (a, b, c) ->
         let a = sprint f a in
         let b =
         Printf.sprintf "{%s;%s;%s}" a b c
 *)
 
-(*--- End of File [ cf_deque.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_deque.mli
-
-  Copyright (c) 2003-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2003-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
         once in every N operations.  Not tail-recursive.
     *)
     val pop: 'a t -> ('a * 'a t) option
-
+    
     (** [head d] returns the element at the end of the deque [d].  Raises
         [Not_found] if the deque is empty.  Not tail-recursive.
     *)
     val head: 'a t -> 'a
-
+    
     (** [tail d] is discards the element at the end of the deque [d].  Raises
         [Not_found] if the deque is empty.  Not tail-recursive.
     *)
     val tail: 'a t -> 'a t
-
+    
     (** [fold f a0 d] is [f (... (f (f a0 e0) e1) ...) en] when [e0..en] are
         the elements of the deque [d].  Not tail recursive.
     *)
         resulting elements begin at the head of the deque.
     *)
     val of_list: 'a list -> 'a t
-
+    
     (** Use [of_seq z] to construct a deque from a sequence of elements.
         Evaluates the whole sequence and the resulting elements begin at the
         head of the deque..
         deque in the order they would appear by successive calls of [pop d].
     *)
     val to_seq: 'a t -> 'a Cf_seq.t
-
+    
     (** [to_seq2 d] returns a lazily evaluated sequence of the pairs [(hd, tl)]
         obtained by successively calling of [pop d].
     *)
 *)
 val catenate: 'a t -> 'a t -> 'a t
 
-(*--- End of File [ cf_deque.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_dfa.ml
-
-  Copyright (c) 2005-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2005-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 end
 
 module type T = sig
-
+    
     module S: Symbol_T
-
+    
     type x
     type 'a r
     type 'a t = (S.t, 'a) Cf_parser.t
-
+    
     val nil: x
-
+    
     module type Expr_Op_T = sig
         val ( $| ): x -> x -> x
         val ( $& ): x -> x -> x
     end
     
     module Expr_Op: Expr_Op_T
-
+    
     module type Op_T = sig
         include Expr_Op_T
-
+        
         val ( $= ): x -> 'a -> 'a r
         val ( $> ): x -> (S.t Cf_seq.t -> 'a) -> 'a r
         val ( $@ ): x -> (int -> 'a t) -> 'a r
     end
     
     module Op: Op_T
-
+    
     val create: 'a r -> 'a t
     
     module X: sig
         type ('c, 'a) r constraint 'c = S.t #Cf_parser.cursor
         type ('c, 'a) t = ('c, S.t, 'a) Cf_parser.X.t
             constraint 'c = S.t #Cf_parser.cursor
-
+        
         module type Op_T = sig
             include Expr_Op_T
-
+            
             val ( $= ): x -> 'a -> ('c, 'a) r
             val ( $> ): x -> (S.t Cf_seq.t -> 'a) -> ('c, 'a) r
             val ( $@ ): x -> (int -> ('c, 'a) t) -> ('c, 'a) r
         end
         
         module Op: Op_T
-
+        
         val create: ('c, 'a) r -> ('c, 'a) t
     end
 end
     class virtual ['i, 'o] satisfier state =
         object(_:'self)
             constraint 'f = int -> ('i, 'o) Cf_parser.t
-
+            
             val state_ = state
             
             method state = state_
     
     let literal_ c =
         object
-            inherit ['i, 'o] satisfier N_set.nil            
+            inherit ['i, 'o] satisfier N_set.nil
             method edge n u = if n = c then N_set.union state_ u else u
         end
         
     let mapped_ f =
         object
-            inherit ['i, 'o] satisfier N_set.nil            
+            inherit ['i, 'o] satisfier N_set.nil
             method edge n u = if f n then N_set.union state_ u else u
         end
     
         y_last_: N_set.t;
         y_follow_: 's N_map.t -> 's N_map.t;
     } constraint 's = ('i, 'o) #satisfier
-
+    
     type 's w = {
         w_null_: bool;
         w_cons_: int -> 's y;
     module type Expr_Op_T = sig
         val ( $| ): x -> x -> x
         val ( $& ): x -> x -> x
-
+        
         val ( !* ): x -> x
         val ( !+ ): x -> x
         val ( !? ): x -> x
         
         let follow_fold_aux_ a m i =
             N_map.replace (i, let sat = N_map.search i m in sat#follow a) m
-
+        
         let ( $& ) wa wb = {
             w_null_ = wa.w_null_ && wb.w_null_;
             w_cons_ = fun i -> 
         
         let star_follow_ y m =
             N_set.fold (follow_fold_aux_ y.y_first_) (y.y_follow_ m) y.y_last_
-
+        
         let ( !* ) w = {
             w_null_ = true;
             w_cons_ = fun i ->
         
         let ( !? ) x = x $| nil
         let ( !+ ) x = x $& (!* x)
-
+        
         let ( !: ) i = expr_ (literal_ i)
         let ( !^ ) f = expr_ (mapped_ f)
         
     
     module type Op_T = sig
         include Expr_Op_T
-
+        
         val ( $= ): x -> 'a -> 'a r
         val ( $> ): x -> (S.t Cf_seq.t -> 'a) -> 'a r
         val ( $@ ): x -> (int -> 'a t) -> 'a r
         val ( !@ ): 'a r list -> 'a r
     end
-
+    
     module Op = struct
         include Expr_Op
         
         let ( $= ) x k =
             let f n z = Some (k, Cf_seq.shift n z) in
             (Obj.magic x) $& (expr_ (acceptor_ f))
-
+        
         let ( $> ) x f =
             let g n z =
                 let hd = Cf_seq.limit n z and tl = Cf_seq.shift n z in
                 Some (f hd, tl)
             in
             (Obj.magic x) $& (expr_ (acceptor_ g))
-
+        
         let ( $@ ) x f =
             (Obj.magic x) $& (expr_ (acceptor_ f))
-
+        
         let ( !@ ) =
             let rec f e = function hd :: tl -> f (hd $| e) tl | [] -> e in
             fun s -> f nil s
     
     module S_order = struct
         type t = int array
-
+        
         let compare = compare
             
         (*
             Buffer.contents b
         *)
     end
-
+    
     module S_map = Cf_rbtree.Map(S_order)
-
+    
     type ('i, 'o) s = {
         s_id_: S_order.t;
         s_accept_: (int -> ('i, 'o) Cf_parser.t) option;
             let s = suspend r in
             fun z ->
                 loop code s nil 0 z z
-        
+    
     let create r = create_aux_ identity_ r
-
+    
     module X = struct
         type ('c, 'a) r = (S.t * 'c, 'a) satisfier w
             constraint 'c = S.t #Cf_parser.cursor
         type ('c, 'a) t = ('c, S.t, 'a) Cf_parser.X.t
             constraint 'c = S.t #Cf_parser.cursor
-
+        
         module type Op_T = sig
             include Expr_Op_T
-
+            
             val ( $= ): x -> 'a -> ('c, 'a) r
             val ( $> ): x -> (S.t Cf_seq.t -> 'a) -> ('c, 'a) r
             val ( $@ ): x -> (int -> ('c, 'a) t) -> ('c, 'a) r
     end
 end
 
-(*--- End of File [ cf_dfa.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_xdfa.mli
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     symbols of the type specified.
 *)
 module type T = sig
-
+    
     (** The module used as the input to the [Create(S: Symbol_T)] functor. *)
     module S: Symbol_T
-
+    
     (** The type of an expression in the regular grammar of an automaton. *)
     type x
-
+    
     (** The type of a rule for recognizing a sequence of symbols according to
         the regular grammar of an automaton and producing an output token.
     *)
     type 'a r
-
+    
     (** A parser that works on the symbols used in the automaton. *)
     type 'a t = (S.t, 'a) Cf_parser.t
-
+    
     (** The expression that matches the empty symbol sequence. *)
     val nil: x
     
         expressions.
     *)
     module type Expr_Op_T = sig
-    
+        
         (** Use [a $| b] to compose an expression that matches either [a] or
             [b] in the symbol stream.
         *)
             [b] in the symbol stream.
         *)
         val ( $& ): x -> x -> x
-
+        
         (** Use [!*a] to compose an expression that matches zero or more
             occurances of [a] in the symbol stream.
         *)
             occurances of [a] in the symbol stream.
         *)
         val ( !+ ): x -> x
-
+        
         (** Use [!?a] to compose an expression that matches zero or one
             occurance of [a] in the symbol stream.
         *)
         val ( !? ): x -> x
-
+        
         (** Use [!:sym] to compose an expression that matches the symbol [sym]
             in the symbol stream.
         *)
     
     (** The module containing the expression operators. *)
     module Expr_Op: Expr_Op_T
-
+    
     (** The signature of the [Op] module, which contains the composition
         operators.
     *)
     module type Op_T = sig
         include Expr_Op_T
-
+        
         (** Use [e $= x] to compose a rule that produces [x] when the symbols
             in the symbol stream match the expression [e].
         *)
             the expression [e] to produce an output token.
         *)
         val ( $> ): x -> (S.t Cf_seq.t -> 'a) -> 'a r
-
+        
         (** Use [e $@ f] to compose a rule that applies the scanning function
             [f] to the input stream when it is recognized by the expression
             [e].  The scanning function is passed the length of the recognized
         scope.
     *)
     module Op: Op_T
-
+    
     (** Use [create r] to construct a parser that recognizes the longest
         sequence that matches the rule [r].
     *)
         require position information in the parse function.
     *)
     module X: sig
-
+        
         (** The type of a rule for recognizing a sequence of symbols in a
             stream woven with a cursor stream and according to the regular
             grammar of an automaton and producing an output token.
         *)
         type ('c, 'a) r constraint 'c = S.t #Cf_parser.cursor
-
+        
         (** An extended parser that works on pairs of symbols and cursor
             objects and used in the automaton.
         *)
         type ('c, 'a) t = ('c, S.t, 'a) Cf_parser.X.t
             constraint 'c = S.t #Cf_parser.cursor
-
+        
         (** The signature of the [Op] module, which contains the composition
             operators.
         *)
         module type Op_T = sig
             include Expr_Op_T
-
+            
             (** Use [e $= x] to compose a rule that produces [x] when the
                 symbols in the symbol stream match the expression [e].
             *)
                 produce an output token.
             *)
             val ( $> ): x -> (S.t Cf_seq.t -> 'a) -> ('c, 'a) r
-
+            
             (** Use [e $@ f] to compose a rule that applies the scanning
                 function [f] to the symbol/cursor input stream when the symbol
                 sequence is recognized by the expression [e].  This operator
                 stream.
             *)
             val ( $@ ): x -> (int -> ('c, 'a) t) -> ('c, 'a) r
-
+            
             (** Use this operator to combine a list of "cursor woven" rules
                 into a single rule.
             *)
             current scope.
         *)
         module Op: Op_T
-
+        
         (** Use [create r] to construct a parser that recognizes the longest
             sequence that matches the rule [r].
         *)
 (** The functor that creates a DFA module. *)
 module Create(S: Symbol_T): T with module S = S
 
-(*--- End of File [ cf_xdfa.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_either.ml
-
-  Copyright (c) 2003-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2003-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
 type ('a, 'b) t = A of 'a | B of 'b
 
-(*--- End of File [ cf_either.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_either.mli
-
-  Copyright (c) 2003-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2003-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
 type ('a, 'b) t = A of 'a | B of 'b
 
-(*--- End of File [ cf_either.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_exnopt.ml
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
 type 'a t = U of 'a | X of exn
 
-(*--- End of File [ cf_exnopt.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_exnopt.mli
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   OF THE POSSIBILITY OF SUCH DAMAGE. 
  *---------------------------------------------------------------------------*)
 
-
 (** A utility type representing the sum of a parameter and an exception. *)
 type 'a t = U of 'a | X of exn
 
-(*--- End of File [ cf_exnopt.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_flow.ml
-
-  Copyright (c) 2002-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2002-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 let writeSC o f s = lazy (P (o, f () s))
 let evalSC m s = m finishSC_ s
 
-(*--- End of File [ cf_flow.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_flow.mli
-
-  Copyright (c) 2002-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2002-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     
     (** Serial loop left. *)
     val ( ~@< ): (('x, 'i) Cf_either.t, ('x, 'o) Cf_either.t) t -> ('i, 'o) t
-
+    
     (** Serial loop through right. *)
     val ( -@- ):
         (('o0, 'i1) Cf_either.t, ('i0, 'o1) Cf_either.t) t -> ('i0, 'o0) t ->
     val more:
         ('i Cf_seq.t option, 'o) t -> 'i Cf_seq.t ->
         'o Cf_seq.t * ('i Cf_seq.t option, 'o) t
-
+    
     (** Use [last w z] to produce the final sequence of output values obtained
         by executing the transcoder stream processor [w] after ingesting the
         "end of input" indication.
 *)
 val evalSC: ('s, ('i, 'o) t, unit) Cf_scmonad.t -> 's -> ('i, 'o) t
 
-(*--- End of File [ cf_flow.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_gadget.ml
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 let create f c = duplex (fun (x, y) -> (f x)#start (fun () -> c y))
 let createM f c = duplex (fun (x, y) -> f x (fun m -> m#start (fun () -> c y)))
 
-(*--- End of File [ cf_gadget.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_gadget.mli
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   OF THE POSSIBILITY OF SUCH DAMAGE. 
  *---------------------------------------------------------------------------*)
 
-
 (** Monadic composition of complex stream processors.  An experimental
     interface for constructing interactive functional systems in a single
     thread of control.
 *)
 
 (** {6 Overview}
-
+    
     This module implements a marginally more general version of the Gadget
     system described in Chapter 30 of Magnus Carlsson's and Thomas Hallgren's
     joint {{:http://www.cs.chalmers.se/~hallgren/Thesis/}Ph.D. thesis}.
     object
         (** Returns a string representation of the wire end identifier. *)
         method id: string
-
+        
         (** Returns [true] if the other end of the wire has not yet been
             reclaimed by the garbage collector.
         *)
     object('self)        
         (** The guard evaluated by this state of the machine. *)
         method virtual private guard: ('i, 'o, unit) guard
-
+        
         (** Use [obj#next] to transition the state of the gadget by applying
             {!Cf_state_gadget.guard} [self#guard].
         *)
     (('c, 'n, 'i, 'o) pad -> ('i, 'o, ('i, 'o) #start) t) ->
     ('i, 'o, ('c, 'n, 'i, 'o) fix) t
 
-(*--- End of File [ cf_gadget.mli ] ---*)
+(*--- $File$ ---*)

cf/cf_gregorian.ml

 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_gregorian.ml
-
-  Copyright (c) 2003-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2003-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
             invalid_arg "Cf_gregorian.to_mjd: integer overflow";
     to_cjd_unsafe ~year:y ~month:m ~day:d
 
-(*--- End of File [ cf_gregorian.ml ] ---*)
+(*--- $File$ ---*)

cf/cf_gregorian.mli

 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_gregorian.mli
-
-  Copyright (c) 2003-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2003-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *)
 val to_mjd: year:int -> month:int -> day:int -> int
 
-
-(*--- End of File [ cf_gregorian.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_heap.ml
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
 module type T = sig
     type t
-
+    
     module Element: sig type t end
     
     val nil: t
     val to_seq2: t -> (Element.t * t) Cf_seq.t
 end
 
-(*--- End of File [ cf_heap.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_heap.mli
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     
     (** The heap type *)
     type t
-
+    
     (** A module defining the type of the element.  Some heap implementations
         may define more functions in this module for disambiguating elements
         from one another.
         all the elements of [h1] and [h2] into a single heap.
     *)
     val merge: t -> t -> t
-
+    
     (** Use [iterate f h] to apply [f] to every element in the heap [h] in an
         arbitrary order (not top to bottom).  Runs in O(n) time and O(1) space.
     *)
         second heap will return all the remaining elements.
     *)
     val partition: (Element.t -> bool) -> t -> t * t
-
+    
     (** Use [of_seq z] to construct a heap from a sequence of elements.
         Evaluates the whole sequence.  Runs in O(n) time and O(1) space.
     *)
     val to_seq2: t -> (Element.t * t) Cf_seq.t
 end
 
-(*--- End of File [ cf_heap.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_journal.ml
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
             method virtual code: 'level -> Priority.t
             method virtual tag: 'level -> string
         end
-
+    
     class ['level] event:
         'level #prioritizer -> 'level -> string ->
         object
             constraint 'event = 'level #event            
             method virtual emit: 'event -> unit
         end
-
+    
     class virtual ['archiver] agent:
         'level #prioritizer -> 'level -> 'archiver list ->
         object
             constraint 'event = 'level #event
             constraint 'archiver = 'event #archiver
-
+            
             val mutable archivers_: 'archiver list
             val mutable limit_: Priority.t            
-
+            
             method private virtual event: 'level -> string -> 'event
-
+            
             method setlimit: 'level -> unit
             method enabled: 'level -> bool
             
             method virtual code: 'level -> Priority.t
             method virtual tag: 'level -> string
         end
-
+    
     class ['level] event prioritizer level message =
         let prioritizer = (prioritizer :> 'level prioritizer) in
         object(_:'event)
         object(self:'self)
             constraint 'event = 'level #event
             constraint 'archiver = 'event #archiver
-
+            
             val mutable archivers_: 'archiver list = archivers
             val mutable limit_ = prioritizer#code limit
-        
+            
             method private virtual event: 'level -> string -> 'event
-
+            
             method setlimit limit = limit_ <- prioritizer#code limit
             method enabled limit = prioritizer#code limit >= limit_
             
 
 module Basic = struct
     include Create(Cf_ordered.Int_order)
-
+    
     type invalid = [ `Invalid ]
     type fail = [ `Fail ]
     type error = [ `Error ]
         constraint 'event = 'level #Basic.event
         constraint 'archiver = 'event #Basic.archiver
         inherit ['archiver] Basic.agent prioritizer limit archivers
-
+        
         method invalid: 'a 'b. ('a, unit, string, 'b) format4 -> 'a =
             self#put `Invalid (fun x -> invalid_arg x#message)
-
+        
         method fail: 'a 'b. ('a, unit, string, 'b) format4 -> 'a =
             self#put `Fail (fun x -> failwith x#message)
         
 let stdout = new basic_stdio_agent basic_stdout_archiver
 let stderr = new basic_stdio_agent basic_stderr_archiver
 
-(*--- End of File [ cf_journal.ml ] ---*)
+(*--- $File$ ---*)

cf/cf_journal.mli

 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_journal.mli
-
-  Copyright (c) 2004-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2004-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
                 code with the prioritizer [p].
             *)
             method virtual code: 'level -> Priority.t
-
+            
             (** Use [p#tag v] to convert the priority level [v] to a message
                 tag with the prioritizer [p].
             *)
             method virtual tag: 'level -> string
         end
-
+    
     (** The minimal class of diagnostic events.  Use [new event p v m] to
         construct an [event] object with the prioritizer [p], the priority
         level [v], and the message [m].
     class ['level] event:
         'level #prioritizer -> 'level -> string ->
         object
-        
+            
             (** Returns the prioritizer used to construct the object. *)
             method prioritizer: 'level prioritizer
-        
+            
             (** Returns the priority level used to construct the object. *)
             method level: 'level
-        
+            
             (** Returns the message text used to construct the object. *)
             method message: string
         end
             *)
             method virtual emit: 'event -> unit
         end
-
+    
     (** The base class for journaling agents.  Use [inherit agent p v s] to
         derive a subclass that defines the private [event_] method to construct
         an event object with a priority level and a message text using the
         object
             constraint 'event = 'level #event
             constraint 'archiver = 'event #archiver
-
+            
             (** The current list of archivers that journal events from
                 this agent. *)
             val mutable archivers_: 'archiver list
                 constructed and passed to the archivers.
             *)
             val mutable limit_: Priority.t            
-
+            
             (** Define the private [event] method to construct an event object
                 with a priority level and a message text.
             *)
             method private virtual event: 'level -> string -> 'event
-
+            
             (** Use [a#setlimit v] to set the minimum priority code to the
                 code corresponding to the priority level [v].
             *)
     
     (** Event journaling with integer priority codes. *)
     include T with type Priority.t = int
-
+    
     (** The priority level for events indicating that an internal program
         function has been called with invalid arguments.  Code=7000.
     *)
     type invalid = [ `Invalid ]
-
+    
     (** The priority level for events indicating that an internal program
         function has failed, results may have been lost and recovery is not
         expected.  Code=6000.
     *)
     type fail = [ `Fail ]
-
+    
     (** The priority level for events indicating that a program has encountered
         invalid input.  The program is expected to recover and continue
         processing further valid input correctly.  Code=5000.
     *)
     type error = [ `Error ]
-
+    
     (** The priority level for events indicating that a program has encountered
         unexpected input, indicating that an external process may have failed.
         The program is expected to continue processing further input normally.
         Code=4000.
     *)
     type warn = [ `Warn ]
-
+    
     (** The priority level for events indicating exceptional information about
         the processing of the program useful for diagnosing external processes.
         Code=2000.
     *)
     type notice = [ `Notice ]
-
+    
     (** The priority level for events indicating normal information about the
         processing of the program useful for diagnosing external processes.
         Code=2000.
     *)
     type info = [ `Info ]
-
+    
     (** The priority level for events describing internal processing of the
         program for the purpose of diagnosing programming errors.  Code=1000.
     *)
 class ['level] basic_prioritizer :
     object
         constraint 'level = [> Basic.level ]
-
+        
         (** Returns the integer corresponding to the priority level. *)
         method code: 'level -> Basic.Priority.t
         
     out_channel ->
     object
         constraint 'event = [> Basic.level ] #Basic.event
-
+        
         (** Returns the channel used to construct the archiver. *)
         method channel: out_channel
         
         constraint 'event = 'level #Basic.event
         constraint 'archiver = 'event #Basic.archiver
         inherit ['archiver] Basic.agent
-
+        
         (** Use [a#invalid msg ...] to format message text to put to the
             archivers at the [`Invalid] level, and finally used to raise an
             [Invalid_argument] exception.
         *)
         method invalid: 'a 'b. ('a, unit, string, 'b) format4 -> 'a
-
+        
         (** Use [a#fail msg ...] to format message text to put to the
             archivers at the [`Fail] level, and finally used to raise an
             [Failure] exception.
         *)
         method fail: 'a 'b. ('a, unit, string, 'b) format4 -> 'a
-
+        
         (** Use [a#error msg ...] to format message text to put to the
             archivers at the [`Error] level.
         *)
         method error: 'a. ('a, unit, string, unit) format4 -> 'a
-
+        
         (** Use [a#warn msg ...] to format message text to put to the
             archivers at the [`Warn] level.
         *)
         method warn: 'a. ('a, unit, string, unit) format4 -> 'a
-
+        
         (** Use [a#notice msg ...] to format message text to put to the
             archivers at the [`Notice] level.
         *)
         method notice: 'a. ('a, unit, string, unit) format4 -> 'a
-
+        
         (** Use [a#info msg ...] to format message text to put to the
             archivers at the [`Info] level.
         *)
         method info: 'a. ('a, unit, string, unit) format4 -> 'a
-
+        
         (** Use [a#debug msg ...] to format message text to put to the
             archivers at the [`Debug] level.  The result of the formatting
             continuation is always [true].  This is to facilitate using the
 *)
 val stderr: t
 
-(*--- End of File [ cf_journal.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_lex.ml
-
-  Copyright (c) 2005-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2005-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 module type Expr_Op_T = sig
     val ( $| ): x -> x -> x
     val ( $& ): x -> x -> x
-
+    
     val ( !* ): x -> x
     val ( !+ ): x -> x
     val ( !? ): x -> x
 module X = struct
     type ('c, 'a) r = ('c, 'a) DFA.X.r
     type ('c, 'a) t = ('c, 'a) DFA.X.t
-
+    
     let create r = DFA.X.create r
-
+    
     module Op = struct
         include DFA.X.Op
         include Expr_Op
-
+        
         let ( $> ) e f = e $> (fun z -> f (Cf_seq.to_string z))
         let ( ?~ ) e = DFA.X.create (e $> identity_)
         let ( ?$ ) s = DFA.X.create (Cf_regex.expr_of_string s $> identity_)
     let nl0 = Cf_seq.to_list (Cf_seq.of_string newline) in
     object(self:'self)
         inherit [char] Cf_parser.cursor c.c_pos
-
+        
         val row_: int = c.c_row
         val col_: int = c.c_col
         val nlz_: char list = nl0
             >}
     end
 
-(*--- End of File [ cf_lex.ml ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_lex.mli
-
-  Copyright (c) 2005-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2005-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 (** Lexical analysis with functional composition of regular grammars. *)
 
 (** {6 Overview}
-
+    
     This module implements functional parsers on octet character sequences
     using regular expressions and functional composition of lazy deterministic
     finite automata.
     module type is included in the signatures of the [Op] and [X.Op] modules.
 *)
 module type Expr_Op_T = sig
-
+    
     (** Alternating composition.  Use [a $| b] to compose an expression that
         matches either expression [a] or expression [b].
     *)
     the current scope.
 *)
 module Op: sig
-
+    
     (** Include the expression operators common among lexical analyzers. *)
     include Expr_Op_T
     
         are matched.
     *)
     val ( $@ ): x -> (int -> 'a t) -> 'a r
-
+    
     (** Rule aggregation.  Use this operator to combine a list of rules into a
         single rule.
     *)
     
     (** The type of lexical analysis rules. *)
     type ('c, 'a) r constraint 'c = char #Cf_parser.cursor
-
+    
     (** Woven character stream parser. *)
     type ('c, 'a) t = ('c, char, 'a) Cf_parser.X.t
         constraint 'c = char #Cf_parser.cursor
-
+    
     (** Use [create r] to compose a lexical analyzer from the rule [r]. *)
     val create: ('c, 'a) r -> ('c, 'a) t
-
+    
     (** Open this module to bring the operator functions for woven parsers into
         the current scope.
     *)
     module Op: sig
-
+        
         (** Include the expression operators common among lexical analyzers. *)
         include Expr_Op_T
         
             the literal object [obj] when the expression [e] is recognized.
         *)
         val ( $= ): x -> 'a -> ('c, 'a) r
-
+        
         (** String token rule.  Use [e $> f] to compose a rule that applies the
             string recognized by the expression [e] to the tokenizer function
             [f] to produce its result.
         *)
         val ( $> ): x -> (string -> 'a) -> ('c, 'a) r
-
+        
         (** Advanced token rule.  Use [e $@ f] to compose a rule that applies
             the length of the character sequence recognized by the expression
             [e] to the advanced tokenizer function [f] to obtain a parser that
             produced and no other rules are matched.
         *)
         val ( $@ ): x -> (int -> ('c, 'a) t) -> ('c, 'a) r
-
+        
         (** Rule aggregation.  Use this operator to combine a list of rules
             into a single rule.
         *)
             DFA from being recreated in every pass.
         *)
         val ( ?~ ): x -> ('c, string) t
-    
+        
         (** String parser.  Use [?$s] to create a simple parser that recognizes
             any string that matches the regular expression specified in the
             string [s] according to the grammar in the {!Cf_regex} module.
         val col_: int           (** The current column number *)
         val nl0_: char list     (** The newline sequence as a [char list]. *)
         val nlz_: char list     (** The current tail of the newline. *)
-
+        
         (** [self#next c] is called in the [advance] method to return a new
             values for the [row_], [col_] and [nlz_] members.
         *)
         method col: int
     end
 
-(*--- End of File [ cf_lex.mli ] ---*)
+(*--- $File$ ---*)
 (*---------------------------------------------------------------------------*
-  IMPLEMENTATION  cf_machine.ml
-
-  Copyright (c) 2005-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2005-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     object(self:'self)
         method private virtual guard:
             ('self, 'i, 'o, unit) Cf_state_gadget.guard
-
+        
         method next: 'a. ('self, 'i, 'o, 'a) Cf_state_gadget.t =
             Cf_state_gadget.store self >>= fun () ->
             Cf_state_gadget.guard self#guard
     end
 
-(*--- End of File [ cf_machine.ml ] ---*)
+(*--- $File$ ---*)

cf/cf_machine.mli

 (*---------------------------------------------------------------------------*
-  INTERFACE  cf_machine.mli
-
-  Copyright (c) 2005-2006, James H. Woodyatt
+  $Change$
+  Copyright (c) 2005-2010, James H. Woodyatt
   All rights reserved.
-
+  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
-
+  
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
-
+    
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution
-
+  
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS