lisp/obsolete/sregex.el

   1 ;;; sregex.el --- symbolic regular expressions
   2
   3 ;; Copyright (C) 1997-1998, 2000-2014 Free Software Foundation, Inc.
   4
   5 ;; Author: Bob Glickstein <bobg+sregex@zanshin.com>
   6 ;; Maintainer: Bob Glickstein <bobg+sregex@zanshin.com>
   7 ;; Keywords: extensions
   8 ;; Obsolete-since: 24.1
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;; This package allows you to write regular expressions using a
  28 ;; totally new, Lisp-like syntax.
  29
  30 ;; A "symbolic regular expression" (sregex for short) is a Lisp form
  31 ;; that, when evaluated, produces the string form of the specified
  32 ;; regular expression.  Here's a simple example:
  33
  34 ;;   (sregexq (or "Bob" "Robert"))  =>  "Bob\\|Robert"
  35
  36 ;; As you can see, an sregex is specified by placing one or more
  37 ;; special clauses in a call to `sregexq'.  The clause in this case is
  38 ;; the `or' of two strings (not to be confused with the Lisp function
  39 ;; `or').  The list of allowable clauses appears below.
  40
  41 ;; With sregex, it is never necessary to "escape" magic characters
  42 ;; that are meant to be taken literally; that happens automatically.
  43 ;; For example:
  44
  45 ;;   (sregexq "M*A*S*H")  =>  "M\\*A\\*S\\*H"
  46
  47 ;; It is also unnecessary to "group" parts of the expression together
  48 ;; to overcome operator precedence; that also happens automatically.
  49 ;; For example:
  50
  51 ;;   (sregexq (opt (or "Bob" "Robert")))  =>  "\\(?:Bob\\|Robert\\)?"
  52
  53 ;; It *is* possible to group parts of the expression in order to refer
  54 ;; to them with numbered backreferences:
  55
  56 ;;   (sregexq (group (or "Go" "Run"))
  57 ;;            ", Spot, "
  58 ;;            (backref 1))             =>  "\\(Go\\|Run\\), Spot, \\1"
  59
  60 ;; `sregexq' is a macro.  Each time it is used, it constructs a simple
  61 ;; Lisp expression that then invokes a moderately complex engine to
  62 ;; interpret the sregex and render the string form.  Because of this,
  63 ;; I don't recommend sprinkling calls to `sregexq' throughout your
  64 ;; code, the way one normally does with string regexes (which are
  65 ;; cheap to evaluate).  Instead, it's wiser to precompute the regexes
  66 ;; you need wherever possible instead of repeatedly constructing the
  67 ;; same ones over and over.  Example:
  68
  69 ;;    (let ((field-regex (sregexq (opt "resent-")
  70 ;;                                (or "to" "cc" "bcc"))))
  71 ;;      ...
  72 ;;      (while ...
  73 ;;        ...
  74 ;;        (re-search-forward field-regex ...)
  75 ;;        ...))
  76
  77 ;; The arguments to `sregexq' are automatically quoted, but the
  78 ;; flipside of this is that it is not straightforward to include
  79 ;; computed (i.e., non-constant) values in `sregexq' expressions.  So
  80 ;; `sregex' is a function that is like `sregexq' but which does not
  81 ;; automatically quote its values.  Literal sregex clauses must be
  82 ;; explicitly quoted like so:
  83
  84 ;;   (sregex '(or "Bob" "Robert"))  =>  "Bob\\|Robert"
  85
  86 ;; but computed clauses can be included easily, allowing for the reuse
  87 ;; of common clauses:
  88
  89 ;;  (let ((dotstar '(0+ any))
  90 ;;        (whitespace '(1+ (syntax ?-)))
  91 ;;        (digits '(1+ (char (?0 . ?9)))))
  92 ;;    (sregex 'bol dotstar ":" whitespace digits))  =>  "^.*:\\s-+[0-9]+"
  93
  94 ;; To use this package in a Lisp program, simply (require 'sregex).
  95
  96 ;; Here are the clauses allowed in an `sregex' or `sregexq'
  97 ;; expression:
  98
  99 ;; - a string
 100 ;;   This stands for the literal string.  If it contains
 101 ;;   metacharacters, they will be escaped in the resulting regex
 102 ;;   (using `regexp-quote').
 103
 104 ;; - the symbol `any'
 105 ;;   This stands for ".", a regex matching any character except
 106 ;;   newline.
 107
 108 ;; - the symbol `bol'
 109 ;;   Stands for "^", matching the empty string at the beginning of a line
 110
 111 ;; - the symbol `eol'
 112 ;;   Stands for "$", matching the empty string at the end of a line
 113
 114 ;; - (group CLAUSE ...)
 115 ;;   Groups the given CLAUSEs using "\\(" and "\\)".
 116
 117 ;; - (sequence CLAUSE ...)
 118
 119 ;;   Groups the given CLAUSEs; may or may not use "\\(?:" and "\\)".
 120 ;;   Clauses grouped by `sequence' do not count for purposes of
 121 ;;   numbering backreferences.  Use `sequence' in situations like
 122 ;;   this:
 123
 124 ;;     (sregexq (or "dog" "cat"
 125 ;;                  (sequence (opt "sea ") "monkey")))
 126 ;;                                  =>  "dog\\|cat\\|\\(?:sea \\)?monkey"
 127
 128 ;;   where a single `or' alternate needs to contain multiple
 129 ;;   subclauses.
 130
 131 ;; - (backref N)
 132 ;;   Matches the same string previously matched by the Nth "group" in
 133 ;;   the same sregex.  N is a positive integer.
 134
 135 ;; - (or CLAUSE ...)
 136 ;;   Matches any one of the CLAUSEs by separating them with "\\|".
 137
 138 ;; - (0+ CLAUSE ...)
 139 ;;   Concatenates the given CLAUSEs and matches zero or more
 140 ;;   occurrences by appending "*".
 141
 142 ;; - (1+ CLAUSE ...)
 143 ;;   Concatenates the given CLAUSEs and matches one or more
 144 ;;   occurrences by appending "+".
 145
 146 ;; - (opt CLAUSE ...)
 147 ;;   Concatenates the given CLAUSEs and matches zero or one occurrence
 148 ;;   by appending "?".
 149
 150 ;; - (repeat MIN MAX CLAUSE ...)
 151 ;;   Concatenates the given CLAUSEs and constructs a regex matching at
 152 ;;   least MIN occurrences and at most MAX occurrences.  MIN must be a
 153 ;;   non-negative integer.  MAX must be a non-negative integer greater
 154 ;;   than or equal to MIN; or MAX can be nil to mean "infinity."
 155
 156 ;; - (char CHAR-CLAUSE ...)
 157 ;;   Creates a "character class" matching one character from the given
 158 ;;   set.  See below for how to construct a CHAR-CLAUSE.
 159
 160 ;; - (not-char CHAR-CLAUSE ...)
 161 ;;   Creates a "character class" matching any one character not in the
 162 ;;   given set.  See below for how to construct a CHAR-CLAUSE.
 163
 164 ;; - the symbol `bot'
 165 ;;   Stands for "\\`", matching the empty string at the beginning of
 166 ;;   text (beginning of a string or of a buffer).
 167
 168 ;; - the symbol `eot'
 169 ;;   Stands for "\\'", matching the empty string at the end of text.
 170
 171 ;; - the symbol `point'
 172 ;;   Stands for "\\=", matching the empty string at point.
 173
 174 ;; - the symbol `word-boundary'
 175 ;;   Stands for "\\b", matching the empty string at the beginning or
 176 ;;   end of a word.
 177
 178 ;; - the symbol `not-word-boundary'
 179 ;;   Stands for "\\B", matching the empty string not at the beginning
 180 ;;   or end of a word.
 181
 182 ;; - the symbol `bow'
 183 ;;   Stands for "\\<", matching the empty string at the beginning of a
 184 ;;   word.
 185
 186 ;; - the symbol `eow'
 187 ;;   Stands for "\\>", matching the empty string at the end of a word.
 188
 189 ;; - the symbol `wordchar'
 190 ;;   Stands for the regex "\\w", matching a word-constituent character
 191 ;;   (as determined by the current syntax table)
 192
 193 ;; - the symbol `not-wordchar'
 194 ;;   Stands for the regex "\\W", matching a non-word-constituent
 195 ;;   character.
 196
 197 ;; - (syntax CODE)
 198 ;;   Stands for the regex "\\sCODE", where CODE is a syntax table code
 199 ;;   (a single character).  Matches any character with the requested
 200 ;;   syntax.
 201
 202 ;; - (not-syntax CODE)
 203 ;;   Stands for the regex "\\SCODE", where CODE is a syntax table code
 204 ;;   (a single character).  Matches any character without the
 205 ;;   requested syntax.
 206
 207 ;; - (regex REGEX)
 208 ;;   This is a "trapdoor" for including ordinary regular expression
 209 ;;   strings in the result.  Some regular expressions are clearer when
 210 ;;   written the old way: "[a-z]" vs. (sregexq (char (?a . ?z))), for
 211 ;;   instance.  However, see the note under "Bugs," below.
 212
 213 ;; Each CHAR-CLAUSE that is passed to (char ...) and (not-char ...)
 214 ;; has one of the following forms:
 215
 216 ;; - a character
 217 ;;   Adds that character to the set.
 218
 219 ;; - a string
 220 ;;   Adds all the characters in the string to the set.
 221
 222 ;; - A pair (MIN . MAX)
 223 ;;   Where MIN and MAX are characters, adds the range of characters
 224 ;;   from MIN through MAX to the set.
 225
 226 ;;; To do:
 227
 228 ;; An earlier version of this package could optionally translate the
 229 ;; symbolic regex into other languages' syntaxes, e.g. Perl.  For
 230 ;; instance, with Perl syntax selected, (sregexq (or "ab" "cd")) would
 231 ;; yield "ab|cd" instead of "ab\\|cd".  It might be useful to restore
 232 ;; such a facility.
 233
 234 ;; - handle multibyte chars in sregex--char-aux
 235 ;; - add support for character classes ([:blank:], ...)
 236 ;; - add support for non-greedy operators *? and +?
 237 ;; - bug: (sregexq (opt (opt ?a))) returns "a??" which is a non-greedy "a?"
 238
 239 ;;; Bugs:
 240
 241 ;;; Code:
 242
 243 (eval-when-compile (require 'cl))
 244
 245 ;; Compatibility code for when we didn't have shy-groups
 246 (defvar sregex--current-sregex nil)
 247 (defun sregex-info () nil)
 248 (defmacro sregex-save-match-data (&rest forms) (cons 'save-match-data forms))
 249 (defun sregex-replace-match (r &optional f l str subexp x)
 250   (replace-match r f l str subexp))
 251 (defun sregex-match-string (c &optional i x) (match-string c i))
 252 (defun sregex-match-string-no-properties (count &optional in-string sregex)
 253   (match-string-no-properties count in-string))
 254 (defun sregex-match-beginning (count &optional sregex) (match-beginning count))
 255 (defun sregex-match-end (count &optional sregex) (match-end count))
 256 (defun sregex-match-data (&optional sregex) (match-data))
 257 (defun sregex-backref-num (n &optional sregex) n)
 258
 259
 260 (defun sregex (&rest exps)
 261   "Symbolic regular expression interpreter.
 262 This is exactly like `sregexq' (q.v.) except that it evaluates all its
 263 arguments, so literal sregex clauses must be quoted.  For example:
 264
 265   (sregex '(or \"Bob\" \"Robert\"))  =>  \"Bob\\\\|Robert\"
 266
 267 An argument-evaluating sregex interpreter lets you reuse sregex
 268 subexpressions:
 269
 270   (let ((dotstar '(0+ any))
 271         (whitespace '(1+ (syntax ?-)))
 272         (digits '(1+ (char (?0 . ?9)))))
 273     (sregex 'bol dotstar \":\" whitespace digits))  =>  \"^.*:\\\\s-+[0-9]+\""
 274   (sregex--sequence exps nil))
 275
 276 (defmacro sregexq (&rest exps)
 277   "Symbolic regular expression interpreter.
 278 This macro allows you to specify a regular expression (regexp) in
 279 symbolic form, and converts it into the string form required by Emacs's
 280 regex functions such as `re-search-forward' and `looking-at'.  Here is
 281 a simple example:
 282
 283   (sregexq (or \"Bob\" \"Robert\"))  =>  \"Bob\\\\|Robert\"
 284
 285 As you can see, an sregex is specified by placing one or more special
 286 clauses in a call to `sregexq'.  The clause in this case is the `or'
 287 of two strings (not to be confused with the Lisp function `or').  The
 288 list of allowable clauses appears below.
 289
 290 With `sregex', it is never necessary to \"escape\" magic characters
 291 that are meant to be taken literally; that happens automatically.
 292 For example:
 293
 294   (sregexq \"M*A*S*H\")  =>  \"M\\\\*A\\\\*S\\\\*H\"
 295
 296 It is also unnecessary to \"group\" parts of the expression together
 297 to overcome operator precedence; that also happens automatically.
 298 For example:
 299
 300   (sregexq (opt (or \"Bob\" \"Robert\")))  =>  \"\\\\(Bob\\\\|Robert\\\\)?\"
 301
 302 It *is* possible to group parts of the expression in order to refer
 303 to them with numbered backreferences:
 304
 305   (sregexq (group (or \"Go\" \"Run\"))
 306            \", Spot, \"
 307            (backref 1))             =>  \"\\\\(Go\\\\|Run\\\\), Spot, \\\\1\"
 308
 309 If `sregexq' needs to introduce its own grouping parentheses, it will
 310 automatically renumber your backreferences:
 311
 312   (sregexq (opt \"resent-\")
 313            (group (or \"to\" \"cc\" \"bcc\"))
 314            \": \"
 315            (backref 1))  =>  \"\\\\(resent-\\\\)?\\\\(to\\\\|cc\\\\|bcc\\\\): \\\\2\"
 316
 317 `sregexq' is a macro.  Each time it is used, it constructs a simple
 318 Lisp expression that then invokes a moderately complex engine to
 319 interpret the sregex and render the string form.  Because of this, I
 320 don't recommend sprinkling calls to `sregexq' throughout your code,
 321 the way one normally does with string regexes (which are cheap to
 322 evaluate).  Instead, it's wiser to precompute the regexes you need
 323 wherever possible instead of repeatedly constructing the same ones
 324 over and over.  Example:
 325
 326    (let ((field-regex (sregexq (opt \"resent-\")
 327                                (or \"to\" \"cc\" \"bcc\"))))
 328      ...
 329      (while ...
 330        ...
 331        (re-search-forward field-regex ...)
 332        ...))
 333
 334 The arguments to `sregexq' are automatically quoted, but the
 335 flipside of this is that it is not straightforward to include
 336 computed (i.e., non-constant) values in `sregexq' expressions.  So
 337 `sregex' is a function that is like `sregexq' but which does not
 338 automatically quote its values.  Literal sregex clauses must be
 339 explicitly quoted like so:
 340
 341   (sregex '(or \"Bob\" \"Robert\"))  =>  \"Bob\\\\|Robert\"
 342
 343 but computed clauses can be included easily, allowing for the reuse
 344 of common clauses:
 345
 346   (let ((dotstar '(0+ any))
 347         (whitespace '(1+ (syntax ?-)))
 348         (digits '(1+ (char (?0 . ?9)))))
 349     (sregex 'bol dotstar \":\" whitespace digits))  =>  \"^.*:\\\\s-+[0-9]+\"
 350
 351 Here are the clauses allowed in an `sregex' or `sregexq' expression:
 352
 353 - a string
 354   This stands for the literal string.  If it contains
 355   metacharacters, they will be escaped in the resulting regex
 356   (using `regexp-quote').
 357
 358 - the symbol `any'
 359   This stands for \".\", a regex matching any character except
 360   newline.
 361
 362 - the symbol `bol'
 363   Stands for \"^\", matching the empty string at the beginning of a line
 364
 365 - the symbol `eol'
 366   Stands for \"$\", matching the empty string at the end of a line
 367
 368 - (group CLAUSE ...)
 369   Groups the given CLAUSEs using \"\\\\(\" and \"\\\\)\".
 370
 371 - (sequence CLAUSE ...)
 372
 373   Groups the given CLAUSEs; may or may not use \"\\\\(\" and \"\\\\)\".
 374   Clauses grouped by `sequence' do not count for purposes of
 375   numbering backreferences.  Use `sequence' in situations like
 376   this:
 377
 378     (sregexq (or \"dog\" \"cat\"
 379                  (sequence (opt \"sea \") \"monkey\")))
 380                                  =>  \"dog\\\\|cat\\\\|\\\\(?:sea \\\\)?monkey\"
 381
 382   where a single `or' alternate needs to contain multiple
 383   subclauses.
 384
 385 - (backref N)
 386   Matches the same string previously matched by the Nth \"group\" in
 387   the same sregex.  N is a positive integer.
 388
 389 - (or CLAUSE ...)
 390   Matches any one of the CLAUSEs by separating them with \"\\\\|\".
 391
 392 - (0+ CLAUSE ...)
 393   Concatenates the given CLAUSEs and matches zero or more
 394   occurrences by appending \"*\".
 395
 396 - (1+ CLAUSE ...)
 397   Concatenates the given CLAUSEs and matches one or more
 398   occurrences by appending \"+\".
 399
 400 - (opt CLAUSE ...)
 401   Concatenates the given CLAUSEs and matches zero or one occurrence
 402   by appending \"?\".
 403
 404 - (repeat MIN MAX CLAUSE ...)
 405   Concatenates the given CLAUSEs and constructs a regex matching at
 406   least MIN occurrences and at most MAX occurrences.  MIN must be a
 407   non-negative integer.  MAX must be a non-negative integer greater
 408   than or equal to MIN; or MAX can be nil to mean \"infinity.\"
 409
 410 - (char CHAR-CLAUSE ...)
 411   Creates a \"character class\" matching one character from the given
 412   set.  See below for how to construct a CHAR-CLAUSE.
 413
 414 - (not-char CHAR-CLAUSE ...)
 415   Creates a \"character class\" matching any one character not in the
 416   given set.  See below for how to construct a CHAR-CLAUSE.
 417
 418 - the symbol `bot'
 419   Stands for \"\\\\`\", matching the empty string at the beginning of
 420   text (beginning of a string or of a buffer).
 421
 422 - the symbol `eot'
 423   Stands for \"\\\\'\", matching the empty string at the end of text.
 424
 425 - the symbol `point'
 426   Stands for \"\\\\=\\=\", matching the empty string at point.
 427
 428 - the symbol `word-boundary'
 429   Stands for \"\\\\b\", matching the empty string at the beginning or
 430   end of a word.
 431
 432 - the symbol `not-word-boundary'
 433   Stands for \"\\\\B\", matching the empty string not at the beginning
 434   or end of a word.
 435
 436 - the symbol `bow'
 437   Stands for \"\\\\=\\<\", matching the empty string at the beginning of a
 438   word.
 439
 440 - the symbol `eow'
 441   Stands for \"\\\\=\\>\", matching the empty string at the end of a word.
 442
 443 - the symbol `wordchar'
 444   Stands for the regex \"\\\\w\", matching a word-constituent character
 445   (as determined by the current syntax table)
 446
 447 - the symbol `not-wordchar'
 448   Stands for the regex \"\\\\W\", matching a non-word-constituent
 449   character.
 450
 451 - (syntax CODE)
 452   Stands for the regex \"\\\\sCODE\", where CODE is a syntax table code
 453   (a single character).  Matches any character with the requested
 454   syntax.
 455
 456 - (not-syntax CODE)
 457   Stands for the regex \"\\\\SCODE\", where CODE is a syntax table code
 458   (a single character).  Matches any character without the
 459   requested syntax.
 460
 461 - (regex REGEX)
 462   This is a \"trapdoor\" for including ordinary regular expression
 463   strings in the result.  Some regular expressions are clearer when
 464   written the old way: \"[a-z]\" vs. (sregexq (char (?a . ?z))), for
 465   instance.
 466
 467 Each CHAR-CLAUSE that is passed to (char ...) and (not-char ...)
 468 has one of the following forms:
 469
 470 - a character
 471   Adds that character to the set.
 472
 473 - a string
 474   Adds all the characters in the string to the set.
 475
 476 - A pair (MIN . MAX)
 477   Where MIN and MAX are characters, adds the range of characters
 478   from MIN through MAX to the set."
 479   `(apply 'sregex ',exps))
 480
 481 (defun sregex--engine (exp combine)
 482   (cond
 483    ((stringp exp)
 484     (if (and combine
 485              (eq combine 'suffix)
 486              (/= (length exp) 1))
 487         (concat "\\(?:" (regexp-quote exp) "\\)")
 488       (regexp-quote exp)))
 489    ((symbolp exp)
 490     (ecase exp
 491       (any ".")
 492       (bol "^")
 493       (eol "$")
 494       (wordchar "\\w")
 495       (not-wordchar "\\W")
 496       (bot "\\`")
 497       (eot "\\'")
 498       (point "\\=")
 499       (word-boundary "\\b")
 500       (not-word-boundary "\\B")
 501       (bow "\\<")
 502       (eow "\\>")))
 503    ((consp exp)
 504     (funcall (intern (concat "sregex--"
 505                              (symbol-name (car exp))))
 506              (cdr exp)
 507              combine))
 508    (t (error "Invalid expression: %s" exp))))
 509
 510 (defun sregex--sequence (exps combine)
 511   (if (= (length exps) 1) (sregex--engine (car exps) combine)
 512     (let ((re (mapconcat
 513                (lambda (e) (sregex--engine e 'concat))
 514                exps "")))
 515       (if (eq combine 'suffix)
 516           (concat "\\(?:" re "\\)")
 517         re))))
 518
 519 (defun sregex--or (exps combine)
 520   (if (= (length exps) 1) (sregex--engine (car exps) combine)
 521     (let ((re (mapconcat
 522                (lambda (e) (sregex--engine e 'or))
 523                exps "\\|")))
 524       (if (not (eq combine 'or))
 525           (concat "\\(?:" re "\\)")
 526         re))))
 527
 528 (defun sregex--group (exps combine) (concat "\\(" (sregex--sequence exps nil) "\\)"))
 529
 530 (defun sregex--backref (exps combine) (concat "\\" (int-to-string (car exps))))
 531 (defun sregex--opt (exps combine) (concat (sregex--sequence exps 'suffix) "?"))
 532 (defun sregex--0+ (exps combine) (concat (sregex--sequence exps 'suffix) "*"))
 533 (defun sregex--1+ (exps combine) (concat (sregex--sequence exps 'suffix) "+"))
 534
 535 (defun sregex--char (exps combine) (sregex--char-aux nil exps))
 536 (defun sregex--not-char (exps combine) (sregex--char-aux t exps))
 537
 538 (defun sregex--syntax (exps combine) (format "\\s%c" (car exps)))
 539 (defun sregex--not-syntax (exps combine) (format "\\S%c" (car exps)))
 540
 541 (defun sregex--regex (exps combine)
 542   (if combine (concat "\\(?:" (car exps) "\\)") (car exps)))
 543
 544 (defun sregex--repeat (exps combine)
 545   (let* ((min (or (pop exps) 0))
 546          (minstr (number-to-string min))
 547          (max (pop exps)))
 548     (concat (sregex--sequence exps 'suffix)
 549             (concat "\\{" minstr ","
 550                     (when max (number-to-string max)) "\\}"))))
 551
 552 (defun sregex--char-range (start end)
 553   (let ((startc (char-to-string start))
 554         (endc (char-to-string end)))
 555     (cond
 556      ((> end (+ start 2)) (concat startc "-" endc))
 557      ((> end (+ start 1)) (concat startc (char-to-string (1+ start)) endc))
 558      ((> end start) (concat startc endc))
 559      (t startc))))
 560
 561 (defun sregex--char-aux (complement args)
 562   ;; regex-opt does the same, we should join effort.
 563   (let ((chars (make-bool-vector 256 nil))) ; Yeah, right!
 564     (dolist (arg args)
 565       (cond ((integerp arg) (aset chars arg t))
 566             ((stringp arg) (mapc (lambda (c) (aset chars c t)) arg))
 567             ((consp arg)
 568              (let ((start (car arg))
 569                    (end (cdr arg)))
 570                (when (> start end)
 571                  (let ((tmp start)) (setq start end) (setq end tmp)))
 572                ;; now start <= end
 573                (let ((i start))
 574                  (while (<= i end)
 575                    (aset chars i t)
 576                    (setq i (1+ i))))))))
 577     ;; now chars is a map of the characters in the class
 578     (let ((caret (aref chars ?^))
 579           (dash (aref chars ?-))
 580           (class (if (aref chars ?\]) "]" "")))
 581       (aset chars ?^ nil)
 582       (aset chars ?- nil)
 583       (aset chars ?\] nil)
 584
 585       (let (start end)
 586         (dotimes (i 256)
 587           (if (aref chars i)
 588               (progn
 589                 (unless start (setq start i))
 590                 (setq end i)
 591                 (aset chars i nil))
 592             (when start
 593               (setq class (concat class (sregex--char-range start end)))
 594               (setq start nil))))
 595         (if start
 596             (setq class (concat class (sregex--char-range start end)))))
 597
 598       (if (> (length class) 0)
 599           (setq class (concat class (if caret "^") (if dash "-")))
 600         (setq class (concat class (if dash "-") (if caret "^"))))
 601       (if (and (not complement) (= (length class) 1))
 602           (regexp-quote class)
 603         (concat "[" (if complement "^") class "]")))))
 604
 605 (provide 'sregex)
 606
 607 ;;; sregex.el ends here