comparison mercurial/parser.py @ 25803:b3004d273874

parser: factor out function that parses right-hand side of prefix/infix ops

These two had common pattern. The significant difference was just a result
expression:

  prefix: (op-name, rhs)
  infix:  (op-name, lhs, rhs)

25802:cc741c76b26a

        'make sure the tokenizer matches an end condition'
        if self.current[0] != m:
            raise error.ParseError(_("unexpected token: %s") % self.current[0],
                                   self.current[2])
        self._advance()
    def _parse(self, bind=0):
        token, value, pos = self._advance()
        # handle prefix rules on current token
        prefix = self._elements[token][1]
        if not prefix:
            raise error.ParseError(_("not a prefix: %s") % token, pos)
        if len(prefix) == 1:
            expr = (prefix[0], value)
        else:
            if len(prefix) > 2 and prefix[2] == self.current[0]:
                self._match(prefix[2])
                expr = (prefix[0], None)
            else:
                expr = (prefix[0], self._parse(prefix[1]))
                if len(prefix) > 2:
                    self._match(prefix[2])
        # gather tokens until we meet a lower binding strength
        while bind < self._elements[self.current[0]][0]:
            token, value, pos = self._advance()
            infix, suffix = self._elements[token][2:]
            # check for suffix - next token isn't a valid prefix

                expr = (suffix[0], expr)
            else:
                # handle infix rules
                if not infix:
                    raise error.ParseError(_("not an infix: %s") % token, pos)
                if len(infix) == 3 and infix[2] == self.current[0]:
                    self._match(infix[2])
                    expr = (infix[0], expr, (None))
                else:
                    expr = (infix[0], expr, self._parse(infix[1]))
                    if len(infix) == 3:
                        self._match(infix[2])
        return expr
    def parse(self, tokeniter):
        'generate a parse tree from tokens'
        self._iter = tokeniter
        self._advance()

25803:b3004d273874

        'make sure the tokenizer matches an end condition'
        if self.current[0] != m:
            raise error.ParseError(_("unexpected token: %s") % self.current[0],
                                   self.current[2])
        self._advance()
    def _parseoperand(self, bind, m=None):
        'gather right-hand-side operand until an end condition or binding met'
        if m and self.current[0] == m:
            expr = None
        else:
            expr = self._parse(bind)
        if m:
            self._match(m)
        return expr
    def _parse(self, bind=0):
        token, value, pos = self._advance()
        # handle prefix rules on current token
        prefix = self._elements[token][1]
        if not prefix:
            raise error.ParseError(_("not a prefix: %s") % token, pos)
        if len(prefix) == 1:
            expr = (prefix[0], value)
        else:
            expr = (prefix[0], self._parseoperand(*prefix[1:]))
        # gather tokens until we meet a lower binding strength
        while bind < self._elements[self.current[0]][0]:
            token, value, pos = self._advance()
            infix, suffix = self._elements[token][2:]
            # check for suffix - next token isn't a valid prefix

                expr = (suffix[0], expr)
            else:
                # handle infix rules
                if not infix:
                    raise error.ParseError(_("not an infix: %s") % token, pos)
                expr = (infix[0], expr, self._parseoperand(*infix[1:]))
        return expr
    def parse(self, tokeniter):
        'generate a parse tree from tokens'
        self._iter = tokeniter
        self._advance()