reconvert.py 5.22 KB
Newer Older
1 2
#! /usr/bin/env python1.5

3
r"""Convert old ("regex") regular expressions to new syntax ("re").
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

When imported as a module, there are two functions, with their own
strings:

  convert(s, syntax=None) -- convert a regex regular expression to re syntax

  quote(s) -- return a quoted string literal

When used as a script, read a Python string literal (or any other
expression evaluating to a string) from stdin, and write the
translated expression to stdout as a string literal.  Unless stdout is
a tty, no trailing \n is written to stdout.  This is done so that it
can be used with Emacs C-U M-| (shell-command-on-region with argument
which filters the region through the shell command).

No attempt has been made at coding for performance.

Translation table...

    \(    (     (unless RE_NO_BK_PARENS set)
    \)    )     (unless RE_NO_BK_PARENS set)
    \|    |     (unless RE_NO_BK_VBAR set)
    \<    \b    (not quite the same, but alla...)
    \>    \b    (not quite the same, but alla...)
    \`    \A
    \'    \Z

Not translated...

    .
    ^
    $
    *
    +           (unless RE_BK_PLUS_QM set, then to \+)
    ?           (unless RE_BK_PLUS_QM set, then to \?)
    \
    \b
    \B
    \w
    \W
    \1 ... \9

Special cases...

    Non-printable characters are always replaced by their 3-digit
    escape code (except \t, \n, \r, which use mnemonic escapes)

    Newline is turned into | when RE_NEWLINE_OR is set

XXX To be done...

    [...]     (different treatment of backslashed items?)
    [^...]    (different treatment of backslashed items?)
    ^ $ * + ? (in some error contexts these are probably treated differently)
    \vDD  \DD (in the regex docs but only works when RE_ANSI_HEX set)

"""


63 64 65 66
import warnings
warnings.filterwarnings("ignore", ".* regex .*", DeprecationWarning, __name__,
                        append=1)

67
import regex
Tim Peters's avatar
Tim Peters committed
68
from regex_syntax import * # RE_*
69

70 71
__all__ = ["convert","quote"]

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
# Default translation table
mastertable = {
    r'\<': r'\b',
    r'\>': r'\b',
    r'\`': r'\A',
    r'\'': r'\Z',
    r'\(': '(',
    r'\)': ')',
    r'\|': '|',
    '(': r'\(',
    ')': r'\)',
    '|': r'\|',
    '\t': r'\t',
    '\n': r'\n',
    '\r': r'\r',
}


def convert(s, syntax=None):
    """Convert a regex regular expression to re syntax.

    The first argument is the regular expression, as a string object,
    just like it would be passed to regex.compile().  (I.e., pass the
    actual string object -- string quotes must already have been
    removed and the standard escape processing has already been done,
    e.g. by eval().)

    The optional second argument is the regex syntax variant to be
    used.  This is an integer mask as passed to regex.set_syntax();
    the flag bits are defined in regex_syntax.  When not specified, or
    when None is given, the current regex syntax mask (as retrieved by
    regex.get_syntax()) is used -- which is 0 by default.

    The return value is a regular expression, as a string object that
    could be passed to re.compile().  (I.e., no string quotes have
    been added -- use quote() below, or repr().)

    The conversion is not always guaranteed to be correct.  More
    syntactical analysis should be performed to detect borderline
    cases and decide what to do with them.  For example, 'x*?' is not
    translated correctly.

    """
    table = mastertable.copy()
    if syntax is None:
117
        syntax = regex.get_syntax()
118
    if syntax & RE_NO_BK_PARENS:
119 120
        del table[r'\('], table[r'\)']
        del table['('], table[')']
121
    if syntax & RE_NO_BK_VBAR:
122 123
        del table[r'\|']
        del table['|']
124
    if syntax & RE_BK_PLUS_QM:
125 126 127 128
        table['+'] = r'\+'
        table['?'] = r'\?'
        table[r'\+'] = '+'
        table[r'\?'] = '?'
129
    if syntax & RE_NEWLINE_OR:
130
        table['\n'] = '|'
131 132 133 134 135
    res = ""

    i = 0
    end = len(s)
    while i < end:
136 137 138 139 140 141 142 143 144 145 146
        c = s[i]
        i = i+1
        if c == '\\':
            c = s[i]
            i = i+1
            key = '\\' + c
            key = table.get(key, key)
            res = res + key
        else:
            c = table.get(c, c)
            res = res + c
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
    return res


def quote(s, quote=None):
    """Convert a string object to a quoted string literal.

    This is similar to repr() but will return a "raw" string (r'...'
    or r"...") when the string contains backslashes, instead of
    doubling all backslashes.  The resulting string does *not* always
    evaluate to the same string as the original; however it will do
    just the right thing when passed into re.compile().

    The optional second argument forces the string quote; it must be
    a single character which is a valid Python string quote.

    """
    if quote is None:
164 165 166 167
        q = "'"
        altq = "'"
        if q in s and altq not in s:
            q = altq
168
    else:
169 170
        assert quote in ('"', "'")
        q = quote
171 172
    res = q
    for c in s:
173 174 175
        if c == q: c = '\\' + c
        elif c < ' ' or c > '~': c = "\\%03o" % ord(c)
        res = res + c
176 177
    res = res + q
    if '\\' in res:
178
        res = 'r' + res
179 180 181 182 183 184 185 186 187
    return res


def main():
    """Main program -- called when run as a script."""
    import sys
    s = eval(sys.stdin.read())
    sys.stdout.write(quote(convert(s)))
    if sys.stdout.isatty():
188
        sys.stdout.write("\n")
189 190 191 192


if __name__ == '__main__':
    main()