coach_lang_tok.cc

在LINUX下运行的仿真机器人服务器源代码

            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 61:
YY_RULE_SETUP
#line 128 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::FreeKick_Opp;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 62:
YY_RULE_SETUP
#line 130 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::CornerKick_Our;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 63:
YY_RULE_SETUP
#line 132 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::CornerKick_Opp;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 64:
YY_RULE_SETUP
#line 134 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::GoalKick_Our;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 65:
YY_RULE_SETUP
#line 136 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::GoalKick_Opp;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 66:
YY_RULE_SETUP
#line 138 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::GoalieCatch_Our;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 67:
YY_RULE_SETUP
#line 140 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::GoalieCatch_Opp;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 68:
YY_RULE_SETUP
#line 142 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::AfterGoal_Our;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 69:
YY_RULE_SETUP
#line 144 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::clang::AfterGoal_Opp;
            return RCSS_CLANG_PLAY_MODE; }
	YY_BREAK
case 70:
YY_RULE_SETUP
#line 148 "coach_lang_tok.ll"
{ return RCSS_CLANG_TIME; }
	YY_BREAK
case 71:
YY_RULE_SETUP
#line 149 "coach_lang_tok.ll"
{ return RCSS_CLANG_OPP_GOAL; }
	YY_BREAK
case 72:
YY_RULE_SETUP
#line 150 "coach_lang_tok.ll"
{ return RCSS_CLANG_OUR_GOAL; }
	YY_BREAK
case 73:
YY_RULE_SETUP
#line 151 "coach_lang_tok.ll"
{ return RCSS_CLANG_GOAL_DIFF; }
	YY_BREAK
case 74:
YY_RULE_SETUP
#line 153 "coach_lang_tok.ll"
{ return RCSS_CLANG_UNUM; }
	YY_BREAK
case 75:
YY_RULE_SETUP
#line 155 "coach_lang_tok.ll"
{ return RCSS_CLANG_PASS; }
	YY_BREAK
case 76:
YY_RULE_SETUP
#line 156 "coach_lang_tok.ll"
{ return RCSS_CLANG_DRIBBLE; }
	YY_BREAK
case 77:
YY_RULE_SETUP
#line 157 "coach_lang_tok.ll"
{ return RCSS_CLANG_SHOOT; }
	YY_BREAK
case 78:
YY_RULE_SETUP
#line 158 "coach_lang_tok.ll"
{ return RCSS_CLANG_HOLD; }
	YY_BREAK
case 79:
YY_RULE_SETUP
#line 159 "coach_lang_tok.ll"
{ return RCSS_CLANG_INTERCEPT; }
	YY_BREAK
case 80:
YY_RULE_SETUP
#line 160 "coach_lang_tok.ll"
{ return RCSS_CLANG_TACKLE; }
	YY_BREAK
case 81:
YY_RULE_SETUP
#line 162 "coach_lang_tok.ll"
{ return RCSS_CLANG_RULE; }
	YY_BREAK
case 82:
YY_RULE_SETUP
#line 163 "coach_lang_tok.ll"
{ *M_lexed_val = true; return RCSS_CLANG_ON_OFF; }
	YY_BREAK
case 83:
YY_RULE_SETUP
#line 164 "coach_lang_tok.ll"
{ *M_lexed_val = false; return RCSS_CLANG_ON_OFF; }
	YY_BREAK
case 84:
YY_RULE_SETUP
#line 165 "coach_lang_tok.ll"
{ return RCSS_CLANG_ALL; }
	YY_BREAK
case 85:
YY_RULE_SETUP
#line 166 "coach_lang_tok.ll"
{ return RCSS_CLANG_DEL; }
	YY_BREAK
case 86:
YY_RULE_SETUP
#line 167 "coach_lang_tok.ll"
{ return RCSS_CLANG_DEFRULE; }
	YY_BREAK
case 87:
YY_RULE_SETUP
#line 168 "coach_lang_tok.ll"
{ return RCSS_CLANG_MODEL; }
	YY_BREAK
case 88:
YY_RULE_SETUP
#line 169 "coach_lang_tok.ll"
{ return RCSS_CLANG_DIREC; }
	YY_BREAK
case 89:
YY_RULE_SETUP
#line 172 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::CompOp::less();
            return RCSS_CLANG_L; }
	YY_BREAK
case 90:
YY_RULE_SETUP
#line 174 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::CompOp::lessEqual();
            return RCSS_CLANG_LE; }
	YY_BREAK
case 91:
YY_RULE_SETUP
#line 176 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::CompOp::equal();
            return RCSS_CLANG_E; }
	YY_BREAK
case 92:
YY_RULE_SETUP
#line 178 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::CompOp::notEqual();
            return RCSS_CLANG_NE; }
	YY_BREAK
case 93:
YY_RULE_SETUP
#line 180 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::CompOp::greaterEqual();
            return RCSS_CLANG_GE; }
	YY_BREAK
case 94:
YY_RULE_SETUP
#line 182 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::CompOp::greater();
            return RCSS_CLANG_G; }
	YY_BREAK
case 95:
YY_RULE_SETUP
#line 185 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::ArithOp::plus();
             return RCSS_CLANG_PLUS; }
	YY_BREAK
case 96:
YY_RULE_SETUP
#line 187 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::ArithOp::minus();
            return RCSS_CLANG_MINUS; }
	YY_BREAK
case 97:
YY_RULE_SETUP
#line 189 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::ArithOp::mult();
            return RCSS_CLANG_MULT; }
	YY_BREAK
case 98:
YY_RULE_SETUP
#line 191 "coach_lang_tok.ll"
{ *M_lexed_val = rcss::util::ArithOp::div();
            return RCSS_CLANG_DIV; }
	YY_BREAK
case 99:
YY_RULE_SETUP
#line 195 "coach_lang_tok.ll"
;
	YY_BREAK
case 100:
YY_RULE_SETUP
#line 198 "coach_lang_tok.ll"
{ *M_lexed_val = atoi(yytext); return RCSS_CLANG_INT; }
	YY_BREAK
case 101:
YY_RULE_SETUP
#line 199 "coach_lang_tok.ll"
{ *M_lexed_val = atoi(yytext); return RCSS_CLANG_INT; }
	YY_BREAK
case 102:
YY_RULE_SETUP
#line 200 "coach_lang_tok.ll"
{ *M_lexed_val = atof(yytext); return RCSS_CLANG_REAL; }
	YY_BREAK
case 103:
YY_RULE_SETUP
#line 201 "coach_lang_tok.ll"
{ *M_lexed_val = atof(yytext); return RCSS_CLANG_REAL; }
	YY_BREAK
case 104:
YY_RULE_SETUP
#line 203 "coach_lang_tok.ll"
{ *M_lexed_val = yytext ;
													      return RCSS_CLANG_STR; }
	YY_BREAK
case 105:
YY_RULE_SETUP
#line 206 "coach_lang_tok.ll"
{ *M_lexed_val = yytext;
												 return RCSS_CLANG_VAR; }
	YY_BREAK
case 106:
YY_RULE_SETUP
#line 209 "coach_lang_tok.ll"
{ return RCSS_CLANG_ERROR; }
	YY_BREAK
case 107:
YY_RULE_SETUP
#line 211 "coach_lang_tok.ll"
ECHO;
	YY_BREAK
#line 1348 "coach_lang_tok.cc"
case YY_STATE_EOF(INITIAL):
	yyterminate();

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yy_hold_char;
		YY_RESTORE_YY_MORE_OFFSET

		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
			{
			/* We're scanning a new file or input source.  It's
			 * possible that this happened because the user
			 * just pointed yyin at a new source and called
			 * yylex().  If so, then we have to assure
			 * consistency between yy_current_buffer and our
			 * globals.  Here is the right place to do so, because
			 * this is the first action (other than possibly a
			 * back-up) that will match for the new input source.
			 */
			yy_n_chars = yy_current_buffer->yy_n_chars;
			yy_current_buffer->yy_input_file = yyin;
			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
			}

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state();

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state );

			yy_bp = yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
				yy_cp = yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer() )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yy_did_buffer_switch_on_eof = 0;

				if ( yywrap() )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yy_c_buf_p =
					yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state();

				yy_cp = yy_c_buf_p;
				yy_bp = yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yy_c_buf_p =
				&yy_current_buffer->yy_ch_buf[yy_n_chars];

				yy_current_state = yy_get_previous_state();

				yy_cp = yy_c_buf_p;
				yy_bp = yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of yylex */

yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
	{
	yyin = arg_yyin;
	yyout = arg_yyout;
	yy_c_buf_p = 0;
	yy_init = 1;
	yy_start = 0;
	yy_flex_debug = 0;
	yylineno = 1;	// this will only get updated if %option yylineno

	yy_did_buffer_switch_on_eof = 0;

	yy_looking_for_trail_begin = 0;
	yy_more_flag = 0;
	yy_more_len = 0;
	yy_more_offset = yy_prev_more_offset = 0;

	yy_start_stack_ptr = yy_start_stack_depth = 0;
	yy_start_stack = 0;

	yy_current_buffer = 0;

#ifdef YY_USES_REJECT
	yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
#else
	yy_state_buf = 0;
#endif
	}

yyFlexLexer::~yyFlexLexer()
	{
	delete yy_state_buf;
	yy_delete_buffer( yy_current_buffer );
	}

void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )
	{
	if ( new_in )
		{
		yy_delete_buffer( yy_current_buffer );
		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
		}

	if ( new_out )
		yyout = new_out;
	}

#ifdef YY_INTERACTIVE
int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
#else
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
	{
	if ( yyin->eof() || yyin->fail() )
		return 0;

#ifdef YY_INTERACTIVE
	yyin->get( buf[0] );

	if ( yyin->eof() )
		return 0;

	if ( yyin->bad() )
		return -1;

	return 1;

#else
	(void) yyin->read( buf, max_size );

	if ( yyin->bad() )
		return -1;
	else
		return yyin->gcount();
#endif
	}

void yyFlexLexer::LexerOutput( const char* buf, int size )
	{
	(void) yyout->write( buf, size );
	}

/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */

int yyFlexLexer::yy_get_next_buffer()
	{
	register char *dest = yy_current_buffer->yy_ch_buf;
	register char *source = yytext_ptr;
	register int number_to_move, i;
	int ret_val;

	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( yy_current_buffer->yy_fill_buffer == 0 )
		{ /* Don't try to fill the buffer, so this is an EOF. */
		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
			{
			/* We matched a single character, the EOB, so
			 * treat this as a final EOF.
			 */
			return EOB_ACT_END_OF_FILE;
			}

		else
			{
			/* We matched some text prior to the EOB, first
			 * process it.
			 */
			return EOB_ACT_LAST_MATCH;
			}
		}

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		yy_current_buffer->yy_n_chars = yy_n_chars = 0;

	else
		{
		int num_to_read =
			yy_current_buffer->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
			YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = yy_current_buffer;

			int yy_c_buf_p_offset =
				(int) (yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )