def sequence()

in src/google/appengine/api/search/QueryParser.py [0:0]
88 lines of code
15 McCabe index (conditional complexity)

    def sequence(self, ):

        retval = self.sequence_return()
        retval.start = self.input.LT(1)

        root_0 = None

        WS11 = None
        factor10 = None

        factor12 = None


        WS11_tree = None
        stream_WS = RewriteRuleTokenStream(self._adaptor, "token WS")
        stream_factor = RewriteRuleSubtreeStream(self._adaptor, "rule factor")
        try:
            try:


                pass
                self._state.following.append(self.FOLLOW_factor_in_sequence262)
                factor10 = self.factor()

                self._state.following.pop()
                stream_factor.add(factor10.tree)

                alt9 = 2
                alt9 = self.dfa9.predict(self.input)
                if alt9 == 1:

                    pass







                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, stream_factor.nextTree())



                    retval.tree = root_0


                elif alt9 == 2:

                    pass

                    cnt8 = 0
                    while True:
                        alt8 = 2
                        alt8 = self.dfa8.predict(self.input)
                        if alt8 == 1:

                            pass

                            cnt7 = 0
                            while True:
                                alt7 = 2
                                LA7_0 = self.input.LA(1)

                                if (LA7_0 == WS) :
                                    alt7 = 1


                                if alt7 == 1:

                                    pass
                                    WS11=self.match(self.input, WS, self.FOLLOW_WS_in_sequence298)
                                    stream_WS.add(WS11)


                                else:
                                    if cnt7 >= 1:
                                        break

                                    eee = EarlyExitException(7, self.input)
                                    raise eee

                                cnt7 += 1


                            self._state.following.append(self.FOLLOW_factor_in_sequence301)
                            factor12 = self.factor()

                            self._state.following.pop()
                            stream_factor.add(factor12.tree)


                        else:
                            if cnt8 >= 1:
                                break

                            eee = EarlyExitException(8, self.input)
                            raise eee

                        cnt8 += 1










                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()


                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SEQUENCE, "SEQUENCE"), root_1)


                    if not (stream_factor.hasNext()):
                        raise RewriteEarlyExitException()

                    while stream_factor.hasNext():
                        self._adaptor.addChild(root_1, stream_factor.nextTree())


                    stream_factor.reset()

                    self._adaptor.addChild(root_0, root_1)



                    retval.tree = root_0






                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException as re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
        finally:

            pass

        return retval