def comparator()

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

    def comparator(self, ):

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

        root_0 = None

        x = None
        WS24 = None
        WS25 = None

        x_tree = None
        WS24_tree = None
        WS25_tree = None
        stream_NE = RewriteRuleTokenStream(self._adaptor, "token NE")
        stream_LESSTHAN = RewriteRuleTokenStream(self._adaptor, "token LESSTHAN")
        stream_LE = RewriteRuleTokenStream(self._adaptor, "token LE")
        stream_HAS = RewriteRuleTokenStream(self._adaptor, "token HAS")
        stream_WS = RewriteRuleTokenStream(self._adaptor, "token WS")
        stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ")
        stream_GT = RewriteRuleTokenStream(self._adaptor, "token GT")
        stream_GE = RewriteRuleTokenStream(self._adaptor, "token GE")

        try:
            try:


                pass

                while True:
                    alt15 = 2
                    LA15_0 = self.input.LA(1)

                    if (LA15_0 == WS) :
                        alt15 = 1


                    if alt15 == 1:

                        pass
                        WS24=self.match(self.input, WS, self.FOLLOW_WS_in_comparator534)
                        stream_WS.add(WS24)


                    else:
                        break



                alt16 = 7
                LA16 = self.input.LA(1)
                if LA16 == LE:
                    alt16 = 1
                elif LA16 == LESSTHAN:
                    alt16 = 2
                elif LA16 == GE:
                    alt16 = 3
                elif LA16 == GT:
                    alt16 = 4
                elif LA16 == NE:
                    alt16 = 5
                elif LA16 == EQ:
                    alt16 = 6
                elif LA16 == HAS:
                    alt16 = 7
                else:
                    nvae = NoViableAltException("", 16, 0, self.input)

                    raise nvae

                if alt16 == 1:

                    pass
                    x=self.match(self.input, LE, self.FOLLOW_LE_in_comparator540)
                    stream_LE.add(x)


                elif alt16 == 2:

                    pass
                    x=self.match(self.input, LESSTHAN, self.FOLLOW_LESSTHAN_in_comparator546)
                    stream_LESSTHAN.add(x)


                elif alt16 == 3:

                    pass
                    x=self.match(self.input, GE, self.FOLLOW_GE_in_comparator552)
                    stream_GE.add(x)


                elif alt16 == 4:

                    pass
                    x=self.match(self.input, GT, self.FOLLOW_GT_in_comparator558)
                    stream_GT.add(x)


                elif alt16 == 5:

                    pass
                    x=self.match(self.input, NE, self.FOLLOW_NE_in_comparator564)
                    stream_NE.add(x)


                elif alt16 == 6:

                    pass
                    x=self.match(self.input, EQ, self.FOLLOW_EQ_in_comparator570)
                    stream_EQ.add(x)


                elif alt16 == 7:

                    pass
                    x=self.match(self.input, HAS, self.FOLLOW_HAS_in_comparator576)
                    stream_HAS.add(x)




                while True:
                    alt17 = 2
                    LA17_0 = self.input.LA(1)

                    if (LA17_0 == WS) :
                        alt17 = 1


                    if alt17 == 1:

                        pass
                        WS25=self.match(self.input, WS, self.FOLLOW_WS_in_comparator579)
                        stream_WS.add(WS25)


                    else:
                        break










                retval.tree = root_0
                stream_x = RewriteRuleTokenStream(self._adaptor, "token x", x)

                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_x.nextNode())



                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