package re
RE is a regular expression library for OCaml
Install
dune-project
Dependency
github.com
Readme
Changelog
LGPL-2.1-or-later WITH OCaml-LGPL-linking-exception License
Edit opam file
Versions (20)
Authors
Maintainers
Sources
1.13.2.tar.gz
md5=df37d9787450525a2182ce4364048d11
sha512=376b3ba1e351317a34b4c9a331fdc9ca5ae7c6a90eb2eb3393403a33b9f35ece63af7444a7c0c71ef29d512aa7fe56f7e485a118946e35d90039ddfd9127c020
doc/src/re/perl.ml.html
Source file perl.ml
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 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
(* RE - A regular expression library Copyright (C) 2001 Jerome Vouillon email: Jerome.Vouillon@pps.jussieu.fr 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, with linking exception; either version 2.1 of the License, or (at your option) any later version. 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *) module Re = Core exception Parse_error = Parse_buffer.Parse_error exception Not_supported let acc_digits = let rec loop base digits acc i = match digits with | [] -> acc | d :: digits -> let acc = acc + (d * i) in let i = i * i in loop base digits acc i in fun ~base ~digits -> loop base digits 0 1 ;; let char_of_int x = match char_of_int x with | x -> x | exception _ -> raise Parse_error ;; let parse multiline dollar_endonly dotall ungreedy s = let buf = Parse_buffer.create s in let accept = Parse_buffer.accept buf in let eos () = Parse_buffer.eos buf in let test c = Parse_buffer.test buf c in let unget () = Parse_buffer.unget buf in let get () = Parse_buffer.get buf in let greedy_mod r = let gr = accept '?' in let gr = if ungreedy then not gr else gr in if gr then Re.non_greedy r else Re.greedy r in let rec regexp () = regexp' (branch ()) and regexp' left = if accept '|' then regexp' (Re.alt [ left; branch () ]) else left and branch () = branch' [] and branch' left = if eos () || test '|' || test ')' then Re.seq (List.rev left) else branch' (piece () :: left) and in_brace ~f ~init = match accept '{' with | false -> None | true -> let rec loop acc = if accept '}' then acc else ( let acc = f acc in loop acc) in Some (loop init) and piece () = let r = atom () in if accept '*' then greedy_mod (Re.rep r) else if accept '+' then greedy_mod (Re.rep1 r) else if accept '?' then greedy_mod (Re.opt r) else if accept '{' then ( match Parse_buffer.integer buf with | Some i -> let j = if accept ',' then Parse_buffer.integer buf else Some i in if not (accept '}') then raise Parse_error; (match j with | Some j when j < i -> raise Parse_error | _ -> ()); greedy_mod (Re.repn r i j) | None -> unget (); r) else r and atom () = if accept '.' then if dotall then Re.any else Re.notnl else if accept '(' then if accept '?' then if accept ':' then ( let r = regexp () in if not (accept ')') then raise Parse_error; r) else if accept '#' then comment () else if accept '<' then ( let name = name () in let r = regexp () in if not (accept ')') then raise Parse_error; Re.group ~name r) else raise Parse_error else ( let r = regexp () in if not (accept ')') then raise Parse_error; Re.group r) else if accept '^' then if multiline then Re.bol else Re.bos else if accept '$' then if multiline then Re.eol else if dollar_endonly then Re.leol else Re.eos else if accept '[' then if accept '^' then Re.compl (bracket []) else Re.alt (bracket []) else if accept '\\' then ( (* XXX - Back-references - \cx (control-x), \ddd *) if eos () then raise Parse_error; match get () with | 'w' -> Re.alt [ Re.alnum; Re.char '_' ] | 'W' -> Re.compl [ Re.alnum; Re.char '_' ] | 's' -> Re.space | 'S' -> Re.compl [ Re.space ] | 'd' -> Re.digit | 'D' -> Re.compl [ Re.digit ] | 'b' -> Re.alt [ Re.bow; Re.eow ] | 'B' -> Re.not_boundary | 'A' -> Re.bos | 'Z' -> Re.leol | 'z' -> Re.eos | 'G' -> Re.start | 'e' -> Re.char '\x1b' | 'f' -> Re.char '\x0c' | 'n' -> Re.char '\n' | 'r' -> Re.char '\r' | 't' -> Re.char '\t' | 'Q' -> quote (Buffer.create 12) | 'E' -> raise Parse_error | 'x' -> let c1, c2 = match in_brace ~init:[] ~f:(fun acc -> hexdigit () :: acc) with | Some [ c1; c2 ] -> c1, c2 | Some [ c2 ] -> 0, c2 | Some _ -> raise Parse_error | None -> let c1 = hexdigit () in let c2 = hexdigit () in c1, c2 in let code = (c1 * 16) + c2 in Re.char (char_of_int code) | 'o' -> (match in_brace ~init:[] ~f:(fun acc -> match maybe_octaldigit () with | None -> raise Parse_error | Some p -> p :: acc) with | None -> raise Parse_error | Some digits -> Re.char (char_of_int (acc_digits ~base:8 ~digits))) | 'a' .. 'z' | 'A' .. 'Z' -> raise Parse_error | '0' .. '7' as n1 -> let n2 = maybe_octaldigit () in let n3 = maybe_octaldigit () in (match n2, n3 with | Some n2, Some n3 -> let n1 = Char.code n1 - Char.code '0' in Re.char (char_of_int ((n1 * (8 * 8)) + (n2 * 8) + n3)) | _, _ -> raise Not_supported) | '8' .. '9' -> raise Not_supported | c -> Re.char c) else ( if eos () then raise Parse_error; match get () with | '*' | '+' | '?' | '{' | '\\' -> raise Parse_error | c -> Re.char c) and quote buf = if accept '\\' then ( if eos () then raise Parse_error; match get () with | 'E' -> Re.str (Buffer.contents buf) | c -> Buffer.add_char buf '\\'; Buffer.add_char buf c; quote buf) else ( if eos () then raise Parse_error; Buffer.add_char buf (get ()); quote buf) and hexdigit () = if eos () then raise Parse_error; match get () with | '0' .. '9' as d -> Char.code d - Char.code '0' | 'a' .. 'f' as d -> Char.code d - Char.code 'a' + 10 | 'A' .. 'F' as d -> Char.code d - Char.code 'A' + 10 | _ -> raise Parse_error and maybe_octaldigit () = if eos () then None else ( match get () with | '0' .. '7' as d -> Some (Char.code d - Char.code '0') | _ -> None) and name () = if eos () then raise Parse_error else ( match get () with | ('_' | 'a' .. 'z' | 'A' .. 'Z') as c -> let b = Buffer.create 32 in Buffer.add_char b c; name' b | _ -> raise Parse_error) and name' b = if eos () then raise Parse_error else ( match get () with | ('_' | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9') as c -> Buffer.add_char b c; name' b | '>' -> Buffer.contents b | _ -> raise Parse_error) and bracket s = if s <> [] && accept ']' then s else ( match char () with | `Set st -> bracket (st :: s) | `Char c -> if accept '-' then if accept ']' then Re.char c :: Re.char '-' :: s else bracket (match char () with | `Char c' -> Re.rg c c' :: s | `Set st' -> Re.char c :: Re.char '-' :: st' :: s) else bracket (Re.char c :: s)) and char () = if eos () then raise Parse_error; let c = get () in if c = '[' then ( if accept '=' then raise Not_supported; match Posix_class.parse buf with | Some set -> `Set set | None -> if accept '.' then ( if eos () then raise Parse_error; let c = get () in if not (accept '.') then raise Not_supported; if not (accept ']') then raise Parse_error; `Char c) else `Char c) else if c = '\\' then ( if eos () then raise Parse_error; let c = get () in (* XXX \127, ... *) match c with | 'b' -> `Char '\008' | 'n' -> `Char '\n' (*XXX*) | 'r' -> `Char '\r' (*XXX*) | 't' -> `Char '\t' (*XXX*) | 'w' -> `Set (Re.alt [ Re.alnum; Re.char '_' ]) | 'W' -> `Set (Re.compl [ Re.alnum; Re.char '_' ]) | 's' -> `Set Re.space | 'S' -> `Set (Re.compl [ Re.space ]) | 'd' -> `Set Re.digit | 'D' -> `Set (Re.compl [ Re.digit ]) | 'a' .. 'z' | 'A' .. 'Z' -> raise Parse_error | '0' .. '9' -> raise Not_supported | _ -> `Char c) else `Char c and comment () = if eos () then raise Parse_error; if accept ')' then Re.epsilon else ( Parse_buffer.junk buf; comment ()) in let res = regexp () in if not (eos ()) then raise Parse_error; res ;; type opt = [ `Ungreedy | `Dotall | `Dollar_endonly | `Multiline | `Anchored | `Caseless ] let re ?(opts = []) s = let r = parse (List.memq `Multiline opts) (List.memq `Dollar_endonly opts) (List.memq `Dotall opts) (List.memq `Ungreedy opts) s in let r = if List.memq `Anchored opts then Re.seq [ Re.start; r ] else r in let r = if List.memq `Caseless opts then Re.no_case r else r in r ;; let compile = Re.compile let compile_pat ?(opts = []) s = compile (re ~opts s)
sectionYPositions = computeSectionYPositions($el), 10)"
x-init="setTimeout(() => sectionYPositions = computeSectionYPositions($el), 10)"
>