def restriction()

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

    def restriction(self, ):

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

        root_0 = None

        comparable21 = None

        comparator22 = None

        arg23 = None


        stream_comparator = RewriteRuleSubtreeStream(self._adaptor, "rule comparator")
        stream_arg = RewriteRuleSubtreeStream(self._adaptor, "rule arg")
        stream_comparable = RewriteRuleSubtreeStream(self._adaptor, "rule comparable")
        try:
            try:


                pass
                self._state.following.append(self.FOLLOW_comparable_in_restriction467)
                comparable21 = self.comparable()

                self._state.following.pop()
                stream_comparable.add(comparable21.tree)

                alt14 = 2
                alt14 = self.dfa14.predict(self.input)
                if alt14 == 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()


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

                    self._adaptor.addChild(root_1, self._adaptor.createFromType(GLOBAL, "GLOBAL"))
                    self._adaptor.addChild(root_1, stream_comparable.nextTree())

                    self._adaptor.addChild(root_0, root_1)



                    retval.tree = root_0


                elif alt14 == 2:

                    pass
                    self._state.following.append(self.FOLLOW_comparator_in_restriction502)
                    comparator22 = self.comparator()

                    self._state.following.pop()
                    stream_comparator.add(comparator22.tree)
                    self._state.following.append(self.FOLLOW_arg_in_restriction504)
                    arg23 = self.arg()

                    self._state.following.pop()
                    stream_arg.add(arg23.tree)








                    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(stream_comparator.nextNode(), root_1)

                    self._adaptor.addChild(root_1, stream_comparable.nextTree())
                    self._adaptor.addChild(root_1, stream_arg.nextTree())

                    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