# revsetlang.py - parser, tokenizer and utility for revision set language

#

# Copyright 2010 Olivia Mackall <olivia@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

import string

from .i18n import _

from .pycompat import getattr

from .node import hex

from . import (

    error,

    parser,

    pycompat,

    smartset,

    util,

)

from .utils import stringutil

elements = {

    # token-type: binding-strength, primary, prefix, infix, suffix

    b"(": (21, None, (b"group", 1, b")"), (b"func", 1, b")"), None),

    b"[": (21, None, None, (b"subscript", 1, b"]"), None),

    b"#": (21, None, None, (b"relation", 21), None),

    b"##": (20, None, None, (b"_concat", 20), None),

    b"~": (18, None, None, (b"ancestor", 18), None),

    b"^": (18, None, None, (b"parent", 18), b"parentpost"),

    b"-": (5, None, (b"negate", 19), (b"minus", 5), None),

    b"::": (

        17,

        b"dagrangeall",

        (b"dagrangepre", 17),

        (b"dagrange", 17),

        b"dagrangepost",

    ),

    b"..": (

        17,

        b"dagrangeall",

        (b"dagrangepre", 17),

        (b"dagrange", 17),

        b"dagrangepost",

    ),

    b":": (15, b"rangeall", (b"rangepre", 15), (b"range", 15), b"rangepost"),

    b"not": (10, None, (b"not", 10), None, None),

    b"!": (10, None, (b"not", 10), None, None),

    b"and": (5, None, None, (b"and", 5), None),

    b"&": (5, None, None, (b"and", 5), None),

    b"%": (5, None, None, (b"only", 5), b"onlypost"),

    b"or": (4, None, None, (b"or", 4), None),

    b"|": (4, None, None, (b"or", 4), None),

    b"+": (4, None, None, (b"or", 4), None),

    b"=": (3, None, None, (b"keyvalue", 3), None),

    b",": (2, None, None, (b"list", 2), None),

    b")": (0, None, None, None, None),

    b"]": (0, None, None, None, None),

    b"symbol": (0, b"symbol", None, None, None),

    b"string": (0, b"string", None, None, None),

    b"end": (0, None, None, None, None),

}

keywords = {b'and', b'or', b'not'}

symbols = {}

_quoteletters = {b'"', b"'"}

_simpleopletters = set(pycompat.iterbytestr(b"()[]#:=,-|&+!~^%"))

# default set of valid characters for the initial letter of symbols

_syminitletters = set(

    pycompat.iterbytestr(

        pycompat.sysbytes(string.ascii_letters)

        + pycompat.sysbytes(string.digits)

        + b'._@'

    )

) | set(map(pycompat.bytechr, range(128, 256)))

# default set of valid characters for non-initial letters of symbols

_symletters = _syminitletters | set(pycompat.iterbytestr(b'-/'))

def tokenize(program, lookup=None, syminitletters=None, symletters=None):

    """

    Parse a revset statement into a stream of tokens

    ``syminitletters`` is the set of valid characters for the initial

    letter of symbols.

    By default, character ``c`` is recognized as valid for initial

    letter of symbols, if ``c.isalnum() or c in '._@' or ord(c) > 127``.

    ``symletters`` is the set of valid characters for non-initial

    letters of symbols.

    By default, character ``c`` is recognized as valid for non-initial

    letters of symbols, if ``c.isalnum() or c in '-._/@' or ord(c) > 127``.

    Check that @ is a valid unquoted token character (issue3686):

    >>> list(tokenize(b"@::"))

    [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]

    """

    if not isinstance(program, bytes):

        raise error.ProgrammingError(

            b'revset statement must be bytes, got %r' % program

        )

    program = pycompat.bytestr(program)

    if syminitletters is None:

        syminitletters = _syminitletters

    if symletters is None:

        symletters = _symletters

    if program and lookup:

        # attempt to parse old-style ranges first to deal with

        # things like old-tag which contain query metacharacters

        parts = program.split(b':', 1)

        if all(lookup(sym) for sym in parts if sym):

            if parts[0]:

                yield (b'symbol', parts[0], 0)

            if len(parts) > 1:

                s = len(parts[0])

                yield (b':', None, s)

                if parts[1]:

                    yield (b'symbol', parts[1], s + 1)

            yield (b'end', None, len(program))

            return

    pos, l = 0, len(program)

    while pos < l:

        c = program[pos]

        if c.isspace():  # skip inter-token whitespace

            pass

        elif (

            c == b':' and program[pos : pos + 2] == b'::'

        ):  # look ahead carefully

            yield (b'::', None, pos)

            pos += 1  # skip ahead

        elif (

            c == b'.' and program[pos : pos + 2] == b'..'

        ):  # look ahead carefully

            yield (b'..', None, pos)

            pos += 1  # skip ahead

        elif (

            c == b'#' and program[pos : pos + 2] == b'##'

        ):  # look ahead carefully

            yield (b'##', None, pos)

            pos += 1  # skip ahead

        elif c in _simpleopletters:  # handle simple operators

            yield (c, None, pos)

        elif (

            c in _quoteletters

            or c == b'r'

            and program[pos : pos + 2] in (b"r'", b'r"')

        ):  # handle quoted strings

            if c == b'r':

                pos += 1

                c = program[pos]

                decode = lambda x: x

            else:

                decode = parser.unescapestr

            pos += 1

            s = pos

            while pos < l:  # find closing quote

                d = program[pos]

                if d == b'\\':  # skip over escaped characters

                    pos += 2

                    continue

                if d == c:

                    yield (b'string', decode(program[s:pos]), s)

                    break

                pos += 1

            else:

                raise error.ParseError(_(b"unterminated string"), s)

        # gather up a symbol/keyword

        elif c in syminitletters:

            s = pos

            pos += 1

            while pos < l:  # find end of symbol

                d = program[pos]

                if d not in symletters:

                    break

                if (

                    d == b'.' and program[pos - 1] == b'.'

                ):  # special case for ..

                    pos -= 1

                    break

                pos += 1

            sym = program[s:pos]

            if sym in keywords:  # operator keywords

                yield (sym, None, s)

            elif b'-' in sym:

                # some jerk gave us foo-bar-baz, try to check if it's a symbol

                if lookup and lookup(sym):

                    # looks like a real symbol

                    yield (b'symbol', sym, s)

                else:

                    # looks like an expression

                    parts = sym.split(b'-')

                    for p in parts[:-1]:

                        if p:  # possible consecutive -

                            yield (b'symbol', p, s)

                        s += len(p)

                        yield (b'-', None, s)

                        s += 1

                    if parts[-1]:  # possible trailing -

                        yield (b'symbol', parts[-1], s)

            else:

                yield (b'symbol', sym, s)

            pos -= 1

        else:

            raise error.ParseError(

                _(b"syntax error in revset '%s'") % program, pos

            )

        pos += 1

    yield (b'end', None, pos)

# helpers

_notset = object()

def getsymbol(x):

    if x and x[0] == b'symbol':

        return x[1]

    raise error.ParseError(_(b'not a symbol'))

def getstring(x, err):

    if x and (x[0] == b'string' or x[0] == b'symbol'):

        return x[1]

    raise error.ParseError(err)

def getinteger(x, err, default=_notset):

    if not x and default is not _notset:

        return default

    try:

        return int(getstring(x, err))

    except ValueError:

        raise error.ParseError(err)

def getboolean(x, err):

    value = stringutil.parsebool(getsymbol(x))

    if value is not None:

        return value

    raise error.ParseError(err)

def getlist(x):

    if not x:

        return []

    if x[0] == b'list':

        return list(x[1:])

    return [x]

def getrange(x, err):

    if not x:

        raise error.ParseError(err)

    op = x[0]

    if op == b'range':

        return x[1], x[2]

    elif op == b'rangepre':

        return None, x[1]

    elif op == b'rangepost':

        return x[1], None

    elif op == b'rangeall':

        return None, None

    raise error.ParseError(err)

def getintrange(x, err1, err2, deffirst=_notset, deflast=_notset):

    """Get [first, last] integer range (both inclusive) from a parsed tree

    If any of the sides omitted, and if no default provided, ParseError will

    be raised.

    """

    if x and (x[0] == b'string' or x[0] == b'symbol'):

        n = getinteger(x, err1)

        return n, n

    a, b = getrange(x, err1)

    return getinteger(a, err2, deffirst), getinteger(b, err2, deflast)

def getargs(x, min, max, err):

    l = getlist(x)

    if len(l) < min or (max >= 0 and len(l) > max):

        raise error.ParseError(err)

    return l

def getargsdict(x, funcname, keys):

    return parser.buildargsdict(

        getlist(x),

        funcname,

        parser.splitargspec(keys),

        keyvaluenode=b'keyvalue',

        keynode=b'symbol',

    )

# cache of {spec: raw parsed tree} built internally

_treecache = {}

def _cachedtree(spec):

    # thread safe because parse() is reentrant and dict.__setitem__() is atomic

    tree = _treecache.get(spec)

    if tree is None:

        _treecache[spec] = tree = parse(spec)

    return tree

def _build(tmplspec, *repls):

    """Create raw parsed tree from a template revset statement

    >>> _build(b'f(_) and _', (b'string', b'1'), (b'symbol', b'2'))

    ('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2'))

    """

    template = _cachedtree(tmplspec)

    return parser.buildtree(template, (b'symbol', b'_'), *repls)

def _match(patspec, tree):

    """Test if a tree matches the given pattern statement; return the matches

    >>> _match(b'f(_)', parse(b'f()'))

    >>> _match(b'f(_)', parse(b'f(1)'))

    [('func', ('symbol', 'f'), ('symbol', '1')), ('symbol', '1')]

    >>> _match(b'f(_)', parse(b'f(1, 2)'))

    """

    pattern = _cachedtree(patspec)

    return parser.matchtree(

        pattern, tree, (b'symbol', b'_'), {b'keyvalue', b'list'}

    )

def _matchonly(revs, bases):

    return _match(b'ancestors(_) and not ancestors(_)', (b'and', revs, bases))

def _fixops(x):

    """Rewrite raw parsed tree to resolve ambiguous syntax which cannot be

    handled well by our simple top-down parser"""

    if not isinstance(x, tuple):

        return x

    op = x[0]

    if op == b'parent':

        # x^:y means (x^) : y, not x ^ (:y)

        # x^:  means (x^) :,   not x ^ (:)

        post = (b'parentpost', x[1])

        if x[2][0] == b'dagrangepre':

            return _fixops((b'dagrange', post, x[2][1]))

        elif x[2][0] == b'dagrangeall':

            return _fixops((b'dagrangepost', post))

        elif x[2][0] == b'rangepre':

            return _fixops((b'range', post, x[2][1]))

        elif x[2][0] == b'rangeall':