/usr/lib/ocaml/galax/regexp.mli is in libgalax-ocaml-dev 1.1-12.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | (***********************************************************************)
(* *)
(* GALAX *)
(* XQuery Engine *)
(* *)
(* Copyright 2001-2007. *)
(* Distributed only by permission. *)
(* *)
(***********************************************************************)
(* $Id: regexp.mli,v 1.5 2007/02/01 22:08:46 simeon Exp $ *)
(* Module Regexp
Description:
This module implements basic regular expressions over an alphabet
of letters, and the Glushkov construction for both NFA's and
DFA's over the same alphabet. The Glushkov module is a functor
parameterized by a letter types.
*)
open Occurrence
open Error
open Nfa
open Dfa
(***********************)
(* Regular expressions *)
(***********************)
module type RegexpType =
sig
(* Positions within a regular expression *)
type position = int (* a symbol is denoted with its position
- each symbol as a unique position *)
module Position : Set.OrderedType with type t = position
module PositionSet : Set.S with type elt = position
type letter
(* Regular expressions *)
type regexp =
| RSym of (letter * position)
| RSeq of (regexp * regexp)
| REmpty
| RChoice of (regexp * regexp)
| RNone
| RPlus of regexp
| RStar of regexp
| RAmp of (regexp * regexp)
(* helper function on Glushkov construction *)
val nullable : regexp -> bool
(* returns a set of position of the expression *)
val pos : regexp -> PositionSet.t
val first : regexp -> PositionSet.t
val last : regexp -> PositionSet.t
val follow : regexp -> position -> PositionSet.t
(* the chi function: it takes a regular expression and a position (integer). *)
(* returns the label at that position. *)
val chi : regexp -> position -> letter
(* Creates a regular expression in star normal form *)
(* it's a two step process *)
val star_normalize_aux : regexp -> regexp
val star_normalize : regexp -> regexp
end
module MakeRegexpType (Letter : Set.OrderedType) :
RegexpType with type letter = Letter.t
module type GlushkovType =
sig
module Regexp : RegexpType
module NFA : NFA
module DFA : DFA
module NFAPair : NFA
val build_glushkov : Regexp.regexp -> NFA.nfa
val build_dtm_glushkov : Regexp.regexp -> DFA.dfa
val negates_in_alphabet_space : DFA.dfa -> DFA.Alphabet.t -> DFA.dfa
val intersects : NFA.nfa -> NFA.nfa -> NFAPair.nfa
val intersects_dtm : NFA.nfa -> DFA.dfa -> NFAPair.nfa
val print_intersection :
(NFAPair.Alphabet.elt -> unit) ->
(NFAPair.StateSet.elt -> unit) -> NFAPair.nfa -> unit
end
module MakeGlushkovType (Letter : Set.OrderedType) :
GlushkovType with type Regexp.letter = Letter.t
and type NFA.letter = Letter.t
and type NFA.Alphabet.elt = Letter.t
and type NFA.StateToTransitionMap.key = int
and type NFA.TransitionMap.key = Letter.t
and type NFA.StateSet.elt = int
and type DFA.letter = Letter.t
and type DFA.Alphabet.elt = Letter.t
and type DFA.StateToTransitionMap.key = int
and type DFA.TransitionMap.key = Letter.t
and type DFA.StateSet.elt = int
and type NFAPair.letter = Letter.t
and type NFAPair.Alphabet.elt = Letter.t
and type NFAPair.StateToTransitionMap.key = int * int
and type NFAPair.TransitionMap.key = Letter.t
and type NFAPair.StateSet.elt = int * int
|