case 48:YY_RULE_SETUP#line 122 "mwmlex.l"{ return BTN4_CLICK2_TOK; }	YY_BREAKcase 49:YY_RULE_SETUP#line 123 "mwmlex.l"{ return BTN5_DOWN_TOK; }	YY_BREAKcase 50:YY_RULE_SETUP#line 124 "mwmlex.l"{ return BTN5_UP_TOK; }	YY_BREAKcase 51:YY_RULE_SETUP#line 125 "mwmlex.l"{ return BTN5_CLICK_TOK; }	YY_BREAKcase 52:YY_RULE_SETUP#line 126 "mwmlex.l"{ return BTN5_CLICK2_TOK; }	YY_BREAKcase 53:YY_RULE_SETUP#line 127 "mwmlex.l"{ return FBEEP_TOK; }	YY_BREAKcase 54:YY_RULE_SETUP#line 128 "mwmlex.l"{ return FCIRCLE_DOWN_TOK; }	YY_BREAKcase 55:YY_RULE_SETUP#line 129 "mwmlex.l"{ return FCIRCLE_UP_TOK; }	YY_BREAKcase 56:YY_RULE_SETUP#line 130 "mwmlex.l"{ return FEXEC_TOK; }	YY_BREAKcase 57:YY_RULE_SETUP#line 131 "mwmlex.l"{ return FFOCUS_COLOR_TOK; }	YY_BREAKcase 58:YY_RULE_SETUP#line 132 "mwmlex.l"{ return FFOCUS_KEY_TOK; }	YY_BREAKcase 59:YY_RULE_SETUP#line 133 "mwmlex.l"{ return FKILL_TOK; }	YY_BREAKcase 60:YY_RULE_SETUP#line 134 "mwmlex.l"{ return FLOWER_TOK; }	YY_BREAKcase 61:YY_RULE_SETUP#line 135 "mwmlex.l"{ return FMAXIMIZE_TOK; }	YY_BREAKcase 62:YY_RULE_SETUP#line 136 "mwmlex.l"{ return FMENU_TOK; }	YY_BREAKcase 63:YY_RULE_SETUP#line 137 "mwmlex.l"{ return FMINIMIZE_TOK; }	YY_BREAKcase 64:YY_RULE_SETUP#line 138 "mwmlex.l"{ return FMOVE_TOK; }	YY_BREAKcase 65:YY_RULE_SETUP#line 139 "mwmlex.l"{ return FNEXT_CMAP_TOK; }	YY_BREAKcase 66:YY_RULE_SETUP#line 140 "mwmlex.l"{ return FNEXT_KEY_TOK; }	YY_BREAKcase 67:YY_RULE_SETUP#line 141 "mwmlex.l"{ return FNOP_TOK; }	YY_BREAKcase 68:YY_RULE_SETUP#line 142 "mwmlex.l"{ return FNORMALIZE_TOK; }	YY_BREAKcase 69:YY_RULE_SETUP#line 143 "mwmlex.l"{ return FNORMANDRAISE_TOK; }	YY_BREAKcase 70:YY_RULE_SETUP#line 144 "mwmlex.l"{ return FPACK_ICONS_TOK; }	YY_BREAKcase 71:YY_RULE_SETUP#line 145 "mwmlex.l"{ return FPASS_KEYS_TOK; }	YY_BREAKcase 72:YY_RULE_SETUP#line 146 "mwmlex.l"{ return FPOST_WMENU_TOK; }	YY_BREAKcase 73:YY_RULE_SETUP#line 147 "mwmlex.l"{ return FPREV_CMAP_TOK; }	YY_BREAKcase 74:YY_RULE_SETUP#line 148 "mwmlex.l"{ return FPREV_KEY_TOK; }	YY_BREAKcase 75:YY_RULE_SETUP#line 149 "mwmlex.l"{ return FQUIT_MWM_TOK; }	YY_BREAKcase 76:YY_RULE_SETUP#line 150 "mwmlex.l"{ return FRAISE_TOK; }	YY_BREAKcase 77:YY_RULE_SETUP#line 151 "mwmlex.l"{ return FRAISE_LOWER_TOK; }	YY_BREAKcase 78:YY_RULE_SETUP#line 152 "mwmlex.l"{ return FREFRESH_TOK; }	YY_BREAKcase 79:YY_RULE_SETUP#line 153 "mwmlex.l"{ return FREFRESH_WIN_TOK; }	YY_BREAKcase 80:YY_RULE_SETUP#line 154 "mwmlex.l"{ return FRESIZE_TOK; }	YY_BREAKcase 81:YY_RULE_SETUP#line 155 "mwmlex.l"{ return FRESTART_TOK; }	YY_BREAKcase 82:YY_RULE_SETUP#line 156 "mwmlex.l"{ return FRESTORE_TOK; }	YY_BREAKcase 83:YY_RULE_SETUP#line 157 "mwmlex.l"{ return FRESTOREANDRAISE_TOK; }	YY_BREAKcase 84:YY_RULE_SETUP#line 158 "mwmlex.l"{ return FSCREEN_TOK; }	YY_BREAKcase 85:YY_RULE_SETUP#line 159 "mwmlex.l"{ return FSEND_MSG_TOK; }	YY_BREAKcase 86:YY_RULE_SETUP#line 160 "mwmlex.l"{ return FSEPARATOR_TOK; }	YY_BREAKcase 87:YY_RULE_SETUP#line 161 "mwmlex.l"{ return FSET_BEHAVIOR_TOK; }	YY_BREAKcase 88:YY_RULE_SETUP#line 162 "mwmlex.l"{ return FTITLE_TOK; }	YY_BREAKcase 89:YY_RULE_SETUP#line 163 "mwmlex.l"{ return FWINDOWLIST_TOK; }	YY_BREAKcase 90:YY_RULE_SETUP#line 164 "mwmlex.l"{ return FDESK_TOK; }	YY_BREAKcase 91:YY_RULE_SETUP#line 165 "mwmlex.l"{ return FTOGGLE_PAGE_TOK; }	YY_BREAKcase 92:YY_RULE_SETUP#line 166 "mwmlex.l"{ return FGOTO_PAGE_TOK; }	YY_BREAKcase 93:YY_RULE_SETUP#line 167 "mwmlex.l"{ yylval.string = dupquot(yytext); return STRING_TOK; }	YY_BREAKcase 94:YY_RULE_SETUP#line 168 "mwmlex.l"{ yylval.string = dupstr(yytext); return STRING_TOK; }	YY_BREAKcase 95:YY_RULE_SETUP#line 169 "mwmlex.l"{ return yytext[0]; }	YY_BREAKcase 96:YY_RULE_SETUP#line 170 "mwmlex.l"ECHO;	YY_BREAK#line 1409 "mwmlex.c"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 *//* 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 */static int 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 )				{				int new_size = b->yy_buf_size * 2;				if ( new_size <= 0 )					b->yy_buf_size += b->yy_buf_size / 8;				else					b->yy_buf_size *= 2;				b->yy_ch_buf = (char *)					/* Include room in for 2 EOB chars. */					yy_flex_realloc( (void *) b->yy_ch_buf,							 b->yy_buf_size + 2 );				}			else				/* Can't grow it, we don't own it. */				b->yy_ch_buf = 0;			if ( ! b->yy_ch_buf )				YY_FATAL_ERROR(				"fatal error - scanner input buffer overflow" );			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];			num_to_read = yy_current_buffer->yy_buf_size -						number_to_move - 1;#endif			}		if ( num_to_read > YY_READ_BUF_SIZE )			num_to_read = YY_READ_BUF_SIZE;		/* Read in more data. */		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),			yy_n_chars, num_to_read );		yy_current_buffer->yy_n_chars = yy_n_chars;		}	if ( yy_n_chars == 0 )		{		if ( number_to_move == YY_MORE_ADJ )			{			ret_val = EOB_ACT_END_OF_FILE;			yyrestart( yyin );			}		else			{			ret_val = EOB_ACT_LAST_MATCH;			yy_current_buffer->yy_buffer_status =				YY_BUFFER_EOF_PENDING;			}		}	else		ret_val = EOB_ACT_CONTINUE_SCAN;	yy_n_chars += number_to_move;	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];	return ret_val;	}/* yy_get_previous_state - get the state just before the EOB char was reached */static yy_state_type yy_get_previous_state()	{	register yy_state_type yy_current_state;	register char *yy_cp;	yy_current_state = yy_start;	yy_current_state += YY_AT_BOL();	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )		{		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);		if ( yy_accept[yy_current_state] )			{			yy_last_accepting_state = yy_current_state;			yy_last_accepting_cpos = yy_cp;			}		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )			{			yy_current_state = (int) yy_def[yy_current_state];			if ( yy_current_state >= 455 )				yy_c = yy_meta[(unsigned int) yy_c];			}		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];		}	return yy_current_state;	}/* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis *	next_state = yy_try_NUL_trans( current_state ); */#ifdef YY_USE_PROTOSstatic yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )#elsestatic yy_state_type yy_try_NUL_trans( yy_current_state )yy_state_type yy_current_state;#endif	{	register int yy_is_jam;	register char *yy_cp = yy_c_buf_p;	register YY_CHAR yy_c = 1;	if ( yy_accept[yy_current_state] )		{		yy_last_accepting_state = yy_current_state;		yy_last_accepting_cpos = yy_cp;		}	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )		{		yy_current_state = (int) yy_def[yy_current_state];		if ( yy_current_state >= 455 )			yy_c = yy_meta[(unsigned int) yy_c];		}	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	yy_is_jam = (yy_current_state == 454);	return yy_is_jam ? 0 : yy_current_state;	}