com/dyuproject/protostuff/parser/ProtoParser.g:266:1: field_options[Proto proto, HasFields message, Field field] : LEFTSQUARE field_options_keyval[proto, message, field, true] ( COMMA field_options_keyval[proto, message, field, true] )* RIGHTSQUARE ;
164904
public final ProtoParser.field_options_return field_options(Proto proto, HasFields message, Field field) throws RecognitionException {
        ProtoParser.field_options_return retval = new ProtoParser.field_options_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LEFTSQUARE99=null;
        Token COMMA101=null;
        Token RIGHTSQUARE103=null;
        ProtoParser.field_options_keyval_return field_options_keyval100 = null;

        ProtoParser.field_options_keyval_return field_options_keyval102 = null;


        Object LEFTSQUARE99_tree=null;
        Object COMMA101_tree=null;
        Object RIGHTSQUARE103_tree=null;

        try {
            // com/dyuproject/protostuff/parser/ProtoParser.g:267:5: ( LEFTSQUARE field_options_keyval[proto, message, field, true] ( COMMA field_options_keyval[proto, message, field, true] )* RIGHTSQUARE )
            // com/dyuproject/protostuff/parser/ProtoParser.g:267:9: LEFTSQUARE field_options_keyval[proto, message, field, true] ( COMMA field_options_keyval[proto, message, field, true] )* RIGHTSQUARE
            {
            root_0 = (Object)adaptor.nil();

            LEFTSQUARE99=(Token)match(input,LEFTSQUARE,FOLLOW_LEFTSQUARE_in_field_options1796); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            LEFTSQUARE99_tree = (Object)adaptor.create(LEFTSQUARE99);
            adaptor.addChild(root_0, LEFTSQUARE99_tree);
            }
            pushFollow(FOLLOW_field_options_keyval_in_field_options1798);
            field_options_keyval100=field_options_keyval(proto, message, field, true);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, field_options_keyval100.getTree());
            // com/dyuproject/protostuff/parser/ProtoParser.g:268:9: ( COMMA field_options_keyval[proto, message, field, true] )*
            loop20:
            do {
                int alt20=2;
                switch ( input.LA(1) ) {
                case COMMA:
                    {
                    alt20=1;
                    }
                    break;

                }

                switch (alt20) {
            	case 1 :
            	    // com/dyuproject/protostuff/parser/ProtoParser.g:268:10: COMMA field_options_keyval[proto, message, field, true]
            	    {
            	    COMMA101=(Token)match(input,COMMA,FOLLOW_COMMA_in_field_options1811); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    COMMA101_tree = (Object)adaptor.create(COMMA101);
            	    adaptor.addChild(root_0, COMMA101_tree);
            	    }
            	    pushFollow(FOLLOW_field_options_keyval_in_field_options1813);
            	    field_options_keyval102=field_options_keyval(proto, message, field, true);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, field_options_keyval102.getTree());

            	    }
            	    break;

            	default :
            	    break loop20;
                }
            } while (true);

            RIGHTSQUARE103=(Token)match(input,RIGHTSQUARE,FOLLOW_RIGHTSQUARE_in_field_options1818); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            RIGHTSQUARE103_tree = (Object)adaptor.create(RIGHTSQUARE103);
            adaptor.addChild(root_0, RIGHTSQUARE103_tree);
            }

            }

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

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
377527
public final void mRIGHTSQUARE() throws RecognitionException {
        try {
            int _type = RIGHTSQUARE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/dyuproject/protostuff/parser/ProtoLexer.g:63:5: ( ']' )
            // com/dyuproject/protostuff/parser/ProtoLexer.g:63:9: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
1251648
public static Query withFieldValues(String field,
                                        NaryOp op,
                                        String rfield) {
        Query q = new Query(false);
        q.add("field", field).add("op", op.toString()).add("rfield", rfield);
        return q;
    }
509192
def text(name, options = {})
      field name, CharField.new(options.merge(widget: Widgets::Textarea.new))
    end
71786
def _MergeField(self, tokenizer, message):
    
    message_descriptor = message.DESCRIPTOR
    if (hasattr(message_descriptor, 'syntax') and
        message_descriptor.syntax == 'proto3'):
      # Proto3 doesn't represent presence so we can't test if multiple
      # scalars have occurred.  We have to allow them.
      self._allow_multiple_scalars = True
    if tokenizer.TryConsume('['):
      name = [tokenizer.ConsumeIdentifier()]
      while tokenizer.TryConsume('.'):
        name.append(tokenizer.ConsumeIdentifier())
      name = '.'.join(name)

      if not message_descriptor.is_extendable:
        raise tokenizer.ParseErrorPreviousToken(
            'Message type "%s" does not have extensions.' %
            message_descriptor.full_name)
      # pylint: disable=protected-access
      field = message.Extensions._FindExtensionByName(name)
      # pylint: enable=protected-access
      if not field:
        if self.allow_unknown_extension:
          field = None
        else:
          raise tokenizer.ParseErrorPreviousToken(
              'Extension "%s" not registered.' % name)
      elif message_descriptor != field.containing_type:
        raise tokenizer.ParseErrorPreviousToken(
            'Extension "%s" does not extend message type "%s".' %
            (name, message_descriptor.full_name))

      tokenizer.Consume(']')

    else:
      name = tokenizer.ConsumeIdentifierOrNumber()
      if self.allow_field_number and name.isdigit():
        number = ParseInteger(name, True, True)
        field = message_descriptor.fields_by_number.get(number, None)
        if not field and message_descriptor.is_extendable:
          field = message.Extensions._FindExtensionByNumber(number)
      else:
        field = message_descriptor.fields_by_name.get(name, None)

        # Group names are expected to be capitalized as they appear in the
        # .proto file, which actually matches their type names, not their field
        # names.
        if not field:
          field = message_descriptor.fields_by_name.get(name.lower(), None)
          if field and field.type != descriptor.FieldDescriptor.TYPE_GROUP:
            field = None

        if (field and field.type == descriptor.FieldDescriptor.TYPE_GROUP and
            field.message_type.name != name):
          field = None

      if not field:
        raise tokenizer.ParseErrorPreviousToken(
            'Message type "%s" has no field named "%s".' %
            (message_descriptor.full_name, name))

    if field:
      if not self._allow_multiple_scalars and field.containing_oneof:
        # Check if there's a different field set in this oneof.
        # Note that we ignore the case if the same field was set before, and we
        # apply _allow_multiple_scalars to non-scalar fields as well.
        which_oneof = message.WhichOneof(field.containing_oneof.name)
        if which_oneof is not None and which_oneof != field.name:
          raise tokenizer.ParseErrorPreviousToken(
              'Field "%s" is specified along with field "%s", another member '
              'of oneof "%s" for message type "%s".' %
              (field.name, which_oneof, field.containing_oneof.name,
               message_descriptor.full_name))

      if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
        tokenizer.TryConsume(':')
        merger = self._MergeMessageField
      else:
        tokenizer.Consume(':')
        merger = self._MergeScalarField

      if (field.label == descriptor.FieldDescriptor.LABEL_REPEATED and
          tokenizer.TryConsume('[')):
        # Short repeated format, e.g. "foo: [1, 2, 3]"
        while True:
          merger(tokenizer, message, field)
          if tokenizer.TryConsume(']'):
            break
          tokenizer.Consume(',')

      else:
        merger(tokenizer, message, field)

    else:  # Proto field is unknown.
      assert self.allow_unknown_extension
      _SkipFieldContents(tokenizer)

    # For historical reasons, fields may optionally be separated by commas or
    # semicolons.
    if not tokenizer.TryConsume(','):
      tokenizer.TryConsume(';')
1332979
public final void mOPTIONAL() throws RecognitionException {
        try {
            int _type = OPTIONAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/dyuproject/protostuff/parser/ProtoLexer.g:127:5: ( 'optional' )
            // com/dyuproject/protostuff/parser/ProtoLexer.g:127:9: 'optional'
            {
            match("optional"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
775726
function parseArguments$3(args) {
        var first = args[0];
        var second = args[1];

        return typeof first === 'string' ? { namespace: first, mappings: second } : { namespace: null, mappings: first };
    }
1061060
def p_field_optional2_3(self, p):
        
        p[0] = Field(name=p[1], arguments=p[2], directives=p[3])
973952
function Parser(options) {
  this.options = merge({}, {
    headers: {
      included: false,
      downcase: true,
      upcase: true
    },
    delimiter: 'tab',
    decimalSign: 'comma'
  }, options);
}
18919
@Override
  public Query parse() throws SyntaxError {
    if (field == null) {
      throw new SyntaxError("no " + MTAS_CQL_QPARSER_FIELD);
    } else if (cql == null) {
      throw new SyntaxError("no " + MTAS_CQL_QPARSER_QUERY);
    } else {
      MtasSpanQuery q = null;
      MtasSpanQuery iq = null;
      if (ignoreQuery != null) {
        Reader ignoreReader = new BufferedReader(new StringReader(ignoreQuery));
        MtasCQLParser ignoreParser = new MtasCQLParser(ignoreReader);
        try {
          iq = ignoreParser.parse(field, null, null, null, null);
        } catch (mtas.parser.cql.TokenMgrError
            | mtas.parser.cql.ParseException e) {
          throw new SyntaxError(e);
        }
      }
      Reader queryReader = new BufferedReader(new StringReader(cql));
      MtasCQLParser queryParser = new MtasCQLParser(queryReader);
      try {
        q = queryParser.parse(field, defaultPrefix, variables, iq,
            maximumIgnoreLength);
      } catch (mtas.parser.cql.TokenMgrError
          | mtas.parser.cql.ParseException e) {
        throw new SyntaxError(e);
      }
      return q;
    }
  }
455003
public final void mFIELD_ACCESS() throws RecognitionException {
		try {
			int _type = FIELD_ACCESS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// druidG.g:627:14: ( ( 'FIELD_ACCESS' | 'field_access' ) )
			// druidG.g:627:16: ( 'FIELD_ACCESS' | 'field_access' )
			{
			// druidG.g:627:16: ( 'FIELD_ACCESS' | 'field_access' )
			int alt16=2;
			int LA16_0 = input.LA(1);
			if ( (LA16_0=='F') ) {
				alt16=1;
			}
			else if ( (LA16_0=='f') ) {
				alt16=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 16, 0, input);
				throw nvae;
			}

			switch (alt16) {
				case 1 :
					// druidG.g:627:17: 'FIELD_ACCESS'
					{
					match("FIELD_ACCESS"); 

					}
					break;
				case 2 :
					// druidG.g:627:32: 'field_access'
					{
					match("field_access"); 

					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
957099
def rights_statement_links(options)
      service = Hyrax.config.rights_statement_service_class.new
      to_sentence(options[:value].map { |right| link_to service.label(right), right })
    end
723885
public final void synpred5_DRL6Expressions_fragment() throws RecognitionException {
		// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:139:92: ( LEFT_SQUARE RIGHT_SQUARE )
		// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:139:93: LEFT_SQUARE RIGHT_SQUARE
		{
		match(input,LEFT_SQUARE,FOLLOW_LEFT_SQUARE_in_synpred5_DRL6Expressions611); if (state.failed) return;
		match(input,RIGHT_SQUARE,FOLLOW_RIGHT_SQUARE_in_synpred5_DRL6Expressions613); if (state.failed) return;
		}

	}
318356
def _parse_fields(self, query):
        
        field_args = {
            k: v
            for k, v in query.items() if k.startswith('fields[')
        }

        fields = {}

        for k, v in field_args.items():
            fields[k[7:-1]] = v.split(',')

        return fields
198954
public void mTokens() throws RecognitionException {
        // com/dyuproject/protostuff/parser/ProtoLexer.g:1:8: ( ASSIGN | AT | LEFTCURLY | RIGHTCURLY | LEFTPAREN | RIGHTPAREN | LEFTSQUARE | RIGHTSQUARE | SEMICOLON | COMMA | PLUS | MINUS | TO | TRUE | FALSE | PKG | SYNTAX | IMPORT | OPTION | MESSAGE | SERVICE | ENUM | REQUIRED | OPTIONAL | REPEATED | EXTENSIONS | EXTEND | GROUP | RPC | RETURNS | INT32 | INT64 | UINT32 | UINT64 | SINT32 | SINT64 | FIXED32 | FIXED64 | SFIXED32 | SFIXED64 | FLOAT | DOUBLE | BOOL | STRING | BYTES | DEFAULT | MAX | VOID | FULL_ID | ID | EXP | NUMDOUBLE | NUMFLOAT | NUMINT | HEX | OCTAL | COMMENT | WS | STRING_LITERAL )
        int alt20=59;
        alt20 = dfa20.predict(input);
        switch (alt20) {
            case 1 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:10: ASSIGN
                {
                mASSIGN(); 

                }
                break;
            case 2 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:17: AT
                {
                mAT(); 

                }
                break;
            case 3 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:20: LEFTCURLY
                {
                mLEFTCURLY(); 

                }
                break;
            case 4 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:30: RIGHTCURLY
                {
                mRIGHTCURLY(); 

                }
                break;
            case 5 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:41: LEFTPAREN
                {
                mLEFTPAREN(); 

                }
                break;
            case 6 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:51: RIGHTPAREN
                {
                mRIGHTPAREN(); 

                }
                break;
            case 7 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:62: LEFTSQUARE
                {
                mLEFTSQUARE(); 

                }
                break;
            case 8 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:73: RIGHTSQUARE
                {
                mRIGHTSQUARE(); 

                }
                break;
            case 9 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:85: SEMICOLON
                {
                mSEMICOLON(); 

                }
                break;
            case 10 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:95: COMMA
                {
                mCOMMA(); 

                }
                break;
            case 11 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:101: PLUS
                {
                mPLUS(); 

                }
                break;
            case 12 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:106: MINUS
                {
                mMINUS(); 

                }
                break;
            case 13 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:112: TO
                {
                mTO(); 

                }
                break;
            case 14 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:115: TRUE
                {
                mTRUE(); 

                }
                break;
            case 15 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:120: FALSE
                {
                mFALSE(); 

                }
                break;
            case 16 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:126: PKG
                {
                mPKG(); 

                }
                break;
            case 17 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:130: SYNTAX
                {
                mSYNTAX(); 

                }
                break;
            case 18 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:137: IMPORT
                {
                mIMPORT(); 

                }
                break;
            case 19 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:144: OPTION
                {
                mOPTION(); 

                }
                break;
            case 20 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:151: MESSAGE
                {
                mMESSAGE(); 

                }
                break;
            case 21 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:159: SERVICE
                {
                mSERVICE(); 

                }
                break;
            case 22 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:167: ENUM
                {
                mENUM(); 

                }
                break;
            case 23 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:172: REQUIRED
                {
                mREQUIRED(); 

                }
                break;
            case 24 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:181: OPTIONAL
                {
                mOPTIONAL(); 

                }
                break;
            case 25 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:190: REPEATED
                {
                mREPEATED(); 

                }
                break;
            case 26 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:199: EXTENSIONS
                {
                mEXTENSIONS(); 

                }
                break;
            case 27 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:210: EXTEND
                {
                mEXTEND(); 

                }
                break;
            case 28 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:217: GROUP
                {
                mGROUP(); 

                }
                break;
            case 29 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:223: RPC
                {
                mRPC(); 

                }
                break;
            case 30 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:227: RETURNS
                {
                mRETURNS(); 

                }
                break;
            case 31 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:235: INT32
                {
                mINT32(); 

                }
                break;
            case 32 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:241: INT64
                {
                mINT64(); 

                }
                break;
            case 33 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:247: UINT32
                {
                mUINT32(); 

                }
                break;
            case 34 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:254: UINT64
                {
                mUINT64(); 

                }
                break;
            case 35 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:261: SINT32
                {
                mSINT32(); 

                }
                break;
            case 36 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:268: SINT64
                {
                mSINT64(); 

                }
                break;
            case 37 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:275: FIXED32
                {
                mFIXED32(); 

                }
                break;
            case 38 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:283: FIXED64
                {
                mFIXED64(); 

                }
                break;
            case 39 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:291: SFIXED32
                {
                mSFIXED32(); 

                }
                break;
            case 40 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:300: SFIXED64
                {
                mSFIXED64(); 

                }
                break;
            case 41 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:309: FLOAT
                {
                mFLOAT(); 

                }
                break;
            case 42 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:315: DOUBLE
                {
                mDOUBLE(); 

                }
                break;
            case 43 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:322: BOOL
                {
                mBOOL(); 

                }
                break;
            case 44 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:327: STRING
                {
                mSTRING(); 

                }
                break;
            case 45 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:334: BYTES
                {
                mBYTES(); 

                }
                break;
            case 46 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:340: DEFAULT
                {
                mDEFAULT(); 

                }
                break;
            case 47 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:348: MAX
                {
                mMAX(); 

                }
                break;
            case 48 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:352: VOID
                {
                mVOID(); 

                }
                break;
            case 49 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:357: FULL_ID
                {
                mFULL_ID(); 

                }
                break;
            case 50 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:365: ID
                {
                mID(); 

                }
                break;
            case 51 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:368: EXP
                {
                mEXP(); 

                }
                break;
            case 52 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:372: NUMDOUBLE
                {
                mNUMDOUBLE(); 

                }
                break;
            case 53 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:382: NUMFLOAT
                {
                mNUMFLOAT(); 

                }
                break;
            case 54 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:391: NUMINT
                {
                mNUMINT(); 

                }
                break;
            case 55 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:398: HEX
                {
                mHEX(); 

                }
                break;
            case 56 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:402: OCTAL
                {
                mOCTAL(); 

                }
                break;
            case 57 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:408: COMMENT
                {
                mCOMMENT(); 

                }
                break;
            case 58 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:416: WS
                {
                mWS(); 

                }
                break;
            case 59 :
                // com/dyuproject/protostuff/parser/ProtoLexer.g:1:419: STRING_LITERAL
                {
                mSTRING_LITERAL(); 

                }
                break;

        }

    }
50630
public final void arguments() throws RecognitionException {
		Token LEFT_PAREN27=null;
		Token RIGHT_PAREN28=null;

		try {
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:673:5: ( LEFT_PAREN ( expressionList )? RIGHT_PAREN )
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:673:7: LEFT_PAREN ( expressionList )? RIGHT_PAREN
			{
			LEFT_PAREN27=(Token)match(input,LEFT_PAREN,FOLLOW_LEFT_PAREN_in_arguments4069); if (state.failed) return;
			if ( state.backtracking==0 ) { helper.emit(LEFT_PAREN27, DroolsEditorType.SYMBOL); }
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:674:9: ( expressionList )?
			int alt87=2;
			int LA87_0 = input.LA(1);
			if ( (LA87_0==BOOL||(LA87_0 >= DECIMAL && LA87_0 <= DECR)||LA87_0==FLOAT||LA87_0==HEX||(LA87_0 >= ID && LA87_0 <= INCR)||(LA87_0 >= LEFT_PAREN && LA87_0 <= LESS)||LA87_0==MINUS||LA87_0==NEGATION||LA87_0==NULL||LA87_0==PLUS||(LA87_0 >= STAR && LA87_0 <= TIME_INTERVAL)) ) {
				alt87=1;
			}
			switch (alt87) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:674:9: expressionList
					{
					pushFollow(FOLLOW_expressionList_in_arguments4081);
					expressionList();
					state._fsp--;
					if (state.failed) return;
					}
					break;

			}

			RIGHT_PAREN28=(Token)match(input,RIGHT_PAREN,FOLLOW_RIGHT_PAREN_in_arguments4092); if (state.failed) return;
			if ( state.backtracking==0 ) { helper.emit(RIGHT_PAREN28, DroolsEditorType.SYMBOL); }
			}

		}

		catch (RecognitionException re) {
		    throw re;
		}

		finally {
			// do for sure before leaving
		}
	}
484375
public final ProtoParser.enum_field_return enum_field(Proto proto, Message message, EnumGroup enumGroup) throws RecognitionException {
        ProtoParser.enum_field_return retval = new ProtoParser.enum_field_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ID127=null;
        Token ASSIGN128=null;
        Token NUMINT129=null;
        Token SEMICOLON131=null;
        ProtoParser.enum_options_return enum_options130 = null;


        Object ID127_tree=null;
        Object ASSIGN128_tree=null;
        Object NUMINT129_tree=null;
        Object SEMICOLON131_tree=null;


            EnumGroup.Value v = null;

        try {
            // com/dyuproject/protostuff/parser/ProtoParser.g:547:5: ( ID ASSIGN NUMINT ( enum_options[proto, enumGroup, v] )? SEMICOLON )
            // com/dyuproject/protostuff/parser/ProtoParser.g:547:9: ID ASSIGN NUMINT ( enum_options[proto, enumGroup, v] )? SEMICOLON
            {
            root_0 = (Object)adaptor.nil();

            ID127=(Token)match(input,ID,FOLLOW_ID_in_enum_field2181); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            ID127_tree = (Object)adaptor.create(ID127);
            adaptor.addChild(root_0, ID127_tree);
            }
            ASSIGN128=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_enum_field2183); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            ASSIGN128_tree = (Object)adaptor.create(ASSIGN128);
            adaptor.addChild(root_0, ASSIGN128_tree);
            }
            NUMINT129=(Token)match(input,NUMINT,FOLLOW_NUMINT_in_enum_field2185); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            NUMINT129_tree = (Object)adaptor.create(NUMINT129);
            adaptor.addChild(root_0, NUMINT129_tree);
            }
            if ( state.backtracking==0 ) {

                          v = new EnumGroup.Value((ID127!=null?ID127.getText():null), Integer.parseInt((NUMINT129!=null?NUMINT129.getText():null)), enumGroup);
                          proto.addAnnotationsTo(v);
                      
            }
            // com/dyuproject/protostuff/parser/ProtoParser.g:550:11: ( enum_options[proto, enumGroup, v] )?
            int alt25=2;
            switch ( input.LA(1) ) {
                case LEFTSQUARE:
                    {
                    alt25=1;
                    }
                    break;
            }

            switch (alt25) {
                case 1 :
                    // com/dyuproject/protostuff/parser/ProtoParser.g:550:12: enum_options[proto, enumGroup, v]
                    {
                    pushFollow(FOLLOW_enum_options_in_enum_field2190);
                    enum_options130=enum_options(proto, enumGroup, v);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, enum_options130.getTree());

                    }
                    break;

            }

            SEMICOLON131=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_enum_field2195); if (state.failed) return retval;

            }

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

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }