scanner.c

tinyos-2.x.rar

#line 68 "scanner.l"
{ return T_AdvRouterAddr; }
	YY_BREAK
case 26:
YY_RULE_SETUP
#line 69 "scanner.l"
{ return T_AdvHomeAgentFlag; }
	YY_BREAK
case 27:
YY_RULE_SETUP
#line 70 "scanner.l"
{ return T_AdvIntervalOpt; }
	YY_BREAK
case 28:
YY_RULE_SETUP
#line 71 "scanner.l"
{ return T_AdvHomeAgentInfo; }
	YY_BREAK
case 29:
YY_RULE_SETUP
#line 72 "scanner.l"
{ return T_UnicastOnly; }
	YY_BREAK
case 30:
YY_RULE_SETUP
#line 74 "scanner.l"
{ return T_Base6to4Interface; }
	YY_BREAK
case 31:
YY_RULE_SETUP
#line 76 "scanner.l"
{ return T_HomeAgentPreference; }
	YY_BREAK
case 32:
YY_RULE_SETUP
#line 77 "scanner.l"
{ return T_HomeAgentLifetime; }
	YY_BREAK
case 33:
YY_RULE_SETUP
#line 79 "scanner.l"
{ return T_AdvRoutePreference; }
	YY_BREAK
case 34:
YY_RULE_SETUP
#line 80 "scanner.l"
{ return T_AdvRouteLifetime; }
	YY_BREAK
case 35:
YY_RULE_SETUP
#line 82 "scanner.l"
{ return T_AdvRDNSSPreference; }
	YY_BREAK
case 36:
YY_RULE_SETUP
#line 83 "scanner.l"
{ return T_AdvRDNSSOpenFlag; }
	YY_BREAK
case 37:
YY_RULE_SETUP
#line 84 "scanner.l"
{ return T_AdvRDNSSLifetime; }
	YY_BREAK
case 38:
YY_RULE_SETUP
#line 86 "scanner.l"
{ return T_MinDelayBetweenRAs; }
	YY_BREAK
case 39:
YY_RULE_SETUP
#line 88 "scanner.l"
{ return T_AdvMobRtrSupportFlag; }
	YY_BREAK
case 40:
YY_RULE_SETUP
#line 90 "scanner.l"
{
			static struct in6_addr addr;
			int i;
				
			i = inet_pton(AF_INET6, yytext, &addr);

			dlog(LOG_DEBUG, 4, "inet_pton returned %d", i);

			/* BSD API draft and NRL's code don't aggree on
			 * this. the draft specifies a return value of 1 on 
			 * success, NRL's code returns the address length in 
			 * bytes on success (16 for an IPv6 address)
			 */
			if (i < 1) {
				flog(LOG_ERR, "invalid address in %s, line %d", conf_file,
					num_lines);
				return T_BAD_TOKEN;
			}

			yylval.addr = &addr;
			return IPV6ADDR;
		}
	YY_BREAK
case 41:
YY_RULE_SETUP
#line 113 "scanner.l"
{
			unsigned long lnum;
			char *endp;
			lnum = strtoul(yytext, &endp, 10);
			if (*yytext == '\0' || *endp != '\0')
				return T_BAD_TOKEN;
			if (lnum > 0xFFFFFFFFUL)
				return T_BAD_TOKEN;	/* XXX */
			yylval.num = lnum;
			return NUMBER;
		}
	YY_BREAK
case 42:
YY_RULE_SETUP
#line 125 "scanner.l"
{ yylval.snum = atoi(yytext); return SIGNEDNUMBER; }
	YY_BREAK
case 43:
YY_RULE_SETUP
#line 127 "scanner.l"
{ yylval.dec = atof(yytext); return DECIMAL; }
	YY_BREAK
case 44:
YY_RULE_SETUP
#line 129 "scanner.l"
{ return INFINITY; }
	YY_BREAK
case 45:
YY_RULE_SETUP
#line 131 "scanner.l"
{ yylval.bool = 1; return SWITCH; }
	YY_BREAK
case 46:
YY_RULE_SETUP
#line 133 "scanner.l"
{ yylval.bool = 0; return SWITCH; }
	YY_BREAK
case 47:
YY_RULE_SETUP
#line 135 "scanner.l"
{ yylval.snum = -1; return SIGNEDNUMBER; }
	YY_BREAK
case 48:
YY_RULE_SETUP
#line 137 "scanner.l"
{ yylval.snum = 0; return SIGNEDNUMBER; }
	YY_BREAK
case 49:
YY_RULE_SETUP
#line 139 "scanner.l"
{ yylval.snum = 1; return SIGNEDNUMBER; }
	YY_BREAK
case 50:
YY_RULE_SETUP
#line 141 "scanner.l"
{
			static char name[IFNAMSIZ];
				
			strncpy(name, yytext, IFNAMSIZ-1);
			name[IFNAMSIZ-1] = '\0';
			yylval.str = name;
			return STRING;
		}
	YY_BREAK
case 51:
YY_RULE_SETUP
#line 150 "scanner.l"
{ return *yytext; }
	YY_BREAK
case 52:
YY_RULE_SETUP
#line 152 "scanner.l"
{ return T_BAD_TOKEN; }
	YY_BREAK
case 53:
YY_RULE_SETUP
#line 153 "scanner.l"
ECHO;
	YY_BREAK
#line 1410 "lex.yy.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_LVALUE->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_LVALUE->yy_n_chars;
			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
			YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->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 (void)
{
    	register char *dest = YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	if ( YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->yy_n_chars = (yy_n_chars) = 0;

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

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */

			/* 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. */
					yyrealloc((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_LVALUE->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;