This file is indexed.

/usr/lib/ocaml/extlib/extString.mli is in libextlib-ocaml-dev 1.7.0-3.

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
(*
 * ExtString - Additional functions for string manipulations.
 * Copyright (C) 2003 Nicolas Cannasse
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version,
 * with the special exception on linking described in file LICENSE.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *)

(** Additional functions for string manipulations. *)

open ExtBytes

exception Invalid_string

module String :
  sig

	(** {6 New Functions} *)

	val init : int -> (int -> char) -> string
	(** [init l f] returns the string of length [l] with the chars
			f 0 , f 1 , f 2 ... f (l-1). *)

	val find : string -> string -> int
	(** [find s x] returns the starting index of the string [x]
	    within the string [s] or raises [Invalid_string] if [x]
	    is not a substring of [s]. *)

	val find_from : string -> int -> string -> int
	(** [find s i x] returns the starting index of the string [x]
			within the string [s] (starting search from position [i]) or
			raises [Invalid_string] if no such substring exists.
			[find s x] is equivalent to [find_from s 0 x]. *)

	val split : string -> string -> string * string
	(** [split s sep] splits the string [s] between the first
			occurrence of [sep].
	    raises [Invalid_string] if the separator is not found. *)

	val nsplit : string -> string -> string list
	(** [nsplit s sep] splits the string [s] into a list of strings
		which are separated by [sep].
                [nsplit "" _] returns the empty list.
    @raise Invalid_string if [sep] is empty string.  *)

	val join : string -> string list -> string
	(** Same as [concat] *)

        val slice : ?first:int -> ?last:int -> string -> string
        (** [slice ?first ?last s] returns a "slice" of the string
          which corresponds to the characters [s.[first]],
          [s.[first+1]], ..., [s[last-1]]. Note that the character at
          index [last] is {b not} included! If [first] is omitted it
          defaults to the start of the string, i.e. index 0, and if
          [last] is omitted is defaults to point just past the end of
          [s], i.e. [length s].  Thus, [slice s] is equivalent to
          [copy s].

          Negative indexes are interpreted as counting from the end of
          the string. For example, [slice ~last:-2 s] will return the
          string [s], but without the last two characters.

          This function {b never} raises any exceptions. If the
          indexes are out of bounds they are automatically clipped.
        *)

	val lchop : string -> string
	(** Returns the same string but without the first character.
	    does nothing if the string is empty. *)

	val rchop : string -> string
	(** Returns the same string but without the last character.
	   does nothing if the string is empty. *)

	val of_int : int -> string
	(** Returns the string representation of an int. *)

	val of_float : float -> string
	(** Returns the string representation of an float. *)

	val of_char : char -> string
	(** Returns a string containing one given character. *)

	val to_int : string -> int
	(** Returns the integer represented by the given string or
	    raises [Invalid_string] if the string does not represent an integer.*)

	val to_float : string -> float
	(** Returns the float represented by the given string or
	    raises Invalid_string if the string does not represent a float. *)

	val ends_with : string -> string -> bool
	(** [ends_with s x] returns true if the string [s] is ending with [x]. *)

	val starts_with : string -> string -> bool
	(** [starts_with s x] return true if [s] is starting with [x]. *)

	val enum : string -> char Enum.t
	(** Returns an enumeration of the characters of a string.*)

	val of_enum : char Enum.t -> string
	(** Creates a string from a character enumeration. *)

	val map : (char -> char) -> string -> string
	(** [map f s] returns a string where all characters [c] in [s] have been
		replaced by [f c]. **)

  val mapi : (int -> char -> char) -> string -> string
	(** [map f s] returns a string where all characters [c] in [s] have been replaced by [f i s.\[i\]]. **)

  val iteri : (int -> char -> unit) -> string -> unit
	(** Call [f i s.\[i\]] for every position [i] in string *)

	val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a
	  (** [fold_left f a s] is
	      [f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]] *)
	val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a
	  (** [fold_right f s b] is
	      [f s.[0] (f s.[1] (... (f s.[n-1] b) ...))] *)

	val explode : string -> char list
	  (** [explode s] returns the list of characters in the string [s]. *)
	val implode : char list -> string
	  (** [implode cs] returns a string resulting from concatenating
	      the characters in the list [cs]. *)

	val strip : ?chars:string -> string -> string
	(** Returns the string without the chars if they are at the beginning or
		at the end of the string. By default chars are " \t\r\n". *)

	val exists : string -> string -> bool
	(** [exists str sub] returns true if [sub] is a substring of [str] or
		false otherwise. *)

	val replace_chars : (char -> string) -> string -> string
	(** [replace_chars f s] returns a string where all chars [c] of [s] have been
		replaced by the string returned by [f c]. *)

        val replace : str:string -> sub:string -> by:string -> bool * string
        (** [replace ~str ~sub ~by] returns a tuple constisting of a boolean
		and a string where the first occurrence of the string [sub]
		within [str] has been replaced by the string [by]. The boolean
		is true if a subtitution has taken place. *)

  (** Return a copy of the argument, without leading and trailing
     whitespace.  The characters regarded as whitespace are: [' '],
     ['\012'], ['\n'], ['\r'], and ['\t'].
     (Note that it is different from {!strip} defaults). *)
  val trim : string -> string

	(** {6 Older Functions} *)

	(** Please refer to the Ocaml Manual for documentation of these
		functions. *)

	val length : string -> int
	val get : string -> int -> char
	val set : Bytes.t -> int -> char -> unit
	val create : int -> Bytes.t
	val make : int -> char -> string
	val copy : string -> string
	val sub : string -> int -> int -> string
	val fill : Bytes.t -> int -> int -> char -> unit
	val blit : string -> int -> Bytes.t -> int -> int -> unit
	val concat : string -> string list -> string
	val iter : (char -> unit) -> string -> unit
	val escaped : string -> string
	val index : string -> char -> int
	val rindex : string -> char -> int
	val index_from : string -> int -> char -> int
	val rindex_from : string -> int -> char -> int
	val contains : string -> char -> bool
	val contains_from : string -> int -> char -> bool
	val rcontains_from : string -> int -> char -> bool
	val uppercase : string -> string
	val lowercase : string -> string
	val capitalize : string -> string
	val uncapitalize : string -> string

	type t = string
	val compare : t -> t -> int

	(**/**)

	external unsafe_get : string -> int -> char = "%string_unsafe_get"
	external unsafe_set : Bytes.t -> int -> char -> unit = "%string_unsafe_set"
	external unsafe_blit : string -> int -> Bytes.t -> int -> int -> unit = "caml_blit_string" "noalloc"
	external unsafe_fill : Bytes.t -> int -> int -> char -> unit = "caml_fill_string" "noalloc"

  end