parser.c
changeset 11 9aa5114326e8
parent 9 bdf20e6eefd7
equal deleted inserted replaced
10:d07309450285 11:9aa5114326e8
    28 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    28 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    29 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    29 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    30 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    30 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    31 */
    31 */
    32 
    32 
    33 /*
    33 #include "volta.h"
    34 Squid docs:
    34 
    35 ---------------------------------------------------------------------------
    35 
    36 TAG: url_rewrite_program
    36 #line 141 "parser.rl"
    37 Specify the location of the executable for the URL rewriter.
    37 
    38 Since they can perform almost any function there isn't one included.
    38 
    39 
    39 #line 40 "parser.c"
    40 For each requested URL rewriter will receive on line with the format
    40 static const int redirector_start = 1;
    41 
    41 static const int redirector_first_final = 85;
    42 URL <SP> client_ip "/" fqdn <SP> user <SP> method [<SP> kvpairs]<NL>
    42 static const int redirector_error = 0;
    43 
    43 
    44 In the future, the rewriter interface will be extended with
    44 static const int redirector_en_main = 1;
    45 key=value pairs ("kvpairs" shown above).  Rewriter programs
    45 
    46 should be prepared to receive and possibly ignore additional
    46 
    47 whitespace-separated tokens on each input line.
    47 #line 143 "parser.rl"
    48 
    48 
    49 And the rewriter may return a rewritten URL. The other components of
    49 /* 
    50 the request line does not need to be returned (ignored if they are).
    50  * Tokenize an incoming line from squid, returning a parsed and populated
    51 
    51  * structure to make redirection decisions against.  This pointer should
    52 The rewriter can also indicate that a client-side redirect should
    52  * be freed using cleanup_request() after use.
    53 be performed to the new URL. This is done by prefixing the returned
    53  * 
    54 URL with "301:" (moved permanently) or 302: (moved temporarily).
    54  * Squid documentation about redirectors:
    55 
    55  * ---------------------------------------------------------------------------
    56 By default, a URL rewriter is not used.
    56  * TAG: url_rewrite_program
    57 ---------------------------------------------------------------------------
    57  * Specify the location of the executable for the URL rewriter.
       
    58  * Since they can perform almost any function there isn't one included.
       
    59  * 
       
    60  * For each requested URL rewriter will receive on line with the format
       
    61  * 
       
    62  * URL <SP> client_ip "/" fqdn <SP> user <SP> method [<SP> kvpairs]<NL>
       
    63  * 
       
    64  * In the future, the rewriter interface will be extended with
       
    65  * key=value pairs ("kvpairs" shown above).  Rewriter programs
       
    66  * should be prepared to receive and possibly ignore additional
       
    67  * whitespace-separated tokens on each input line.
       
    68  * 
       
    69  * And the rewriter may return a rewritten URL. The other components of
       
    70  * the request line does not need to be returned (ignored if they are).
       
    71  * 
       
    72  * The rewriter can also indicate that a client-side redirect should
       
    73  * be performed to the new URL. This is done by prefixing the returned
       
    74  * URL with "301:" (moved permanently) or 302: (moved temporarily).
       
    75  * 
       
    76  * By default, a URL rewriter is not used.
       
    77  * ---------------------------------------------------------------------------
    58 */
    78 */
    59 
    79 request *
    60 #include "volta.h"
    80 parse( char *line )
    61 
       
    62 
       
    63 #line 80 "parser.rl"
       
    64 
       
    65 
       
    66 #line 67 "parser.c"
       
    67 static const int redirector_start = 1;
       
    68 static const int redirector_first_final = 13;
       
    69 static const int redirector_error = 0;
       
    70 
       
    71 static const int redirector_en_main = 1;
       
    72 
       
    73 
       
    74 #line 82 "parser.rl"
       
    75 
       
    76 /*
       
    77 %%{
       
    78 	machine redirector;
       
    79 
       
    80 	action yay {
       
    81 		printf( "I saw: %s", p+1 );
       
    82 	}
       
    83 
       
    84 	# http://, ftp://, https://, etc
       
    85 	proto = alpha{3,5} . '://';
       
    86 
       
    87 	# http://mahlon:password@example.com or http://mahlon@example.com
       
    88     #       username              optional password
       
    89 	creds = ( alnum | [+._\-] )+ . ( ':' . any+ )? . '@';
       
    90 
       
    91 	main := ( proto . creds ) | proto @yay '\n';
       
    92 }%%
       
    93 %% write data;
       
    94 */
       
    95 
       
    96 
       
    97 /*
       
    98 %%{
       
    99 	machine foo;
       
   100 
       
   101 	OPEN = 0;
       
   102 	CLOSE = 1;
       
   103 
       
   104 	main :=
       
   105 		start:
       
   106 		door_closed: (
       
   107 			OPEN -> door_open -> final
       
   108 		),
       
   109 		door_open: (
       
   110 			CLOSE -> door_closed
       
   111 		);
       
   112 }%%
       
   113 */
       
   114 
       
   115 struct request *
       
   116 parse( char *p )
       
   117 {
    81 {
   118    	/* initial machine state */
    82    	/* machine required vars */
   119 	short int cs = 0;
    83 	int  cs   = 0;
   120 
    84 	char *p   = line;
   121 	/* the client request object */
    85 	char *pe  = p + strlen(p);
   122 	request c_request;
    86 	char *eof = NULL;
   123 	request *cp_request = &c_request;
    87 
   124 
    88 	/* the client request pointer */
   125 	/*
    89 	unsigned char valid = 0;
   126 	char ip[ INET_ADDRSTRLEN ];
    90 	request *p_request = init_request();
   127 	inet_pton( AF_INET, "127.0.0.1", &cp_request->ip );
       
   128 	inet_ntop( AF_INET, &cp_request->ip, ip, INET_ADDRSTRLEN );
       
   129 	*/
       
   130 
       
   131 	/* initalize state machine with current line */
       
   132 	char *pe = p + strlen(p) + 1;
       
   133 
    91 
   134 	/* enter state machine */
    92 	/* enter state machine */
   135 	
    93 	
   136 #line 137 "parser.c"
    94 #line 95 "parser.c"
   137 	{
    95 	{
   138 	cs = redirector_start;
    96 	cs = redirector_start;
   139 	}
    97 	}
   140 
    98 
   141 #line 143 "parser.rl"
    99 #line 189 "parser.rl"
   142 	
   100 	
   143 #line 144 "parser.c"
   101 #line 102 "parser.c"
   144 	{
   102 	{
   145 	if ( p == pe )
   103 	if ( p == pe )
   146 		goto _test_eof;
   104 		goto _test_eof;
   147 	switch ( cs )
   105 	switch ( cs )
   148 	{
   106 	{
   149 case 1:
   107 case 1:
   150 	if ( (*p) > 90 ) {
   108 	if ( (*p) < 65 ) {
       
   109 		if ( 48 <= (*p) && (*p) <= 57 )
       
   110 			goto tr1;
       
   111 	} else if ( (*p) > 90 ) {
   151 		if ( 97 <= (*p) && (*p) <= 122 )
   112 		if ( 97 <= (*p) && (*p) <= 122 )
   152 			goto st2;
   113 			goto tr2;
   153 	} else if ( (*p) >= 65 )
   114 	} else
   154 		goto st2;
   115 		goto tr2;
       
   116 	goto tr0;
       
   117 tr0:
       
   118 #line 46 "parser.rl"
       
   119 	{ debug( 3, LOC, "Unable to parse scheme.\n" ); }
       
   120 #line 50 "parser.rl"
       
   121 	{ debug( 3, LOC, "Unable to parse hostname.\n" ); }
       
   122 #line 37 "parser.rl"
       
   123 	{ valid = 0; }
   155 	goto st0;
   124 	goto st0;
       
   125 tr3:
       
   126 #line 37 "parser.rl"
       
   127 	{ valid = 0; }
       
   128 	goto st0;
       
   129 tr11:
       
   130 #line 46 "parser.rl"
       
   131 	{ debug( 3, LOC, "Unable to parse scheme.\n" ); }
       
   132 #line 50 "parser.rl"
       
   133 	{ debug( 3, LOC, "Unable to parse hostname.\n" ); }
       
   134 #line 64 "parser.rl"
       
   135 	{ debug( 3, LOC, "Unable to parse the client IP address.\n" ); }
       
   136 #line 37 "parser.rl"
       
   137 	{ valid = 0; }
       
   138 	goto st0;
       
   139 tr14:
       
   140 #line 64 "parser.rl"
       
   141 	{ debug( 3, LOC, "Unable to parse the client IP address.\n" ); }
       
   142 #line 37 "parser.rl"
       
   143 	{ valid = 0; }
       
   144 	goto st0;
       
   145 tr35:
       
   146 #line 60 "parser.rl"
       
   147 	{ debug( 3, LOC, "Unable to parse method.\n" ); }
       
   148 #line 37 "parser.rl"
       
   149 	{ valid = 0; }
       
   150 	goto st0;
       
   151 tr49:
       
   152 #line 50 "parser.rl"
       
   153 	{ debug( 3, LOC, "Unable to parse hostname.\n" ); }
       
   154 #line 37 "parser.rl"
       
   155 	{ valid = 0; }
       
   156 	goto st0;
       
   157 tr92:
       
   158 #line 46 "parser.rl"
       
   159 	{ debug( 3, LOC, "Unable to parse scheme.\n" ); }
       
   160 #line 37 "parser.rl"
       
   161 	{ valid = 0; }
       
   162 	goto st0;
       
   163 #line 164 "parser.c"
   156 st0:
   164 st0:
   157 cs = 0;
   165 cs = 0;
   158 	goto _out;
   166 	goto _out;
       
   167 tr1:
       
   168 #line 48 "parser.rl"
       
   169 	{ p_request->tokens.host_start  = p; }
       
   170 	goto st2;
   159 st2:
   171 st2:
   160 	if ( ++p == pe )
   172 	if ( ++p == pe )
   161 		goto _test_eof2;
   173 		goto _test_eof2;
   162 case 2:
   174 case 2:
   163 	if ( (*p) > 90 ) {
   175 #line 176 "parser.c"
   164 		if ( 97 <= (*p) && (*p) <= 122 )
   176 	switch( (*p) ) {
   165 			goto st3;
   177 		case 32: goto tr4;
   166 	} else if ( (*p) >= 65 )
   178 		case 45: goto st32;
   167 		goto st3;
   179 		case 46: goto st34;
   168 	goto st0;
   180 		case 47: goto tr7;
       
   181 		case 58: goto tr9;
       
   182 		case 95: goto st32;
       
   183 	}
       
   184 	if ( (*p) < 48 ) {
       
   185 		if ( 9 <= (*p) && (*p) <= 13 )
       
   186 			goto tr4;
       
   187 	} else if ( (*p) > 57 ) {
       
   188 		if ( (*p) > 90 ) {
       
   189 			if ( 97 <= (*p) && (*p) <= 122 )
       
   190 				goto st33;
       
   191 		} else if ( (*p) >= 65 )
       
   192 			goto st33;
       
   193 	} else
       
   194 		goto st2;
       
   195 	goto tr3;
       
   196 tr4:
       
   197 #line 49 "parser.rl"
       
   198 	{ p_request->tokens.host_length = p - ( *pe + p_request->tokens.host_start ); }
       
   199 #line 55 "parser.rl"
       
   200 	{ p_request->tokens.path_start  = p; }
       
   201 #line 56 "parser.rl"
       
   202 	{ p_request->tokens.path_length = p - ( *pe + p_request->tokens.path_start ); }
       
   203 	goto st3;
   169 st3:
   204 st3:
   170 	if ( ++p == pe )
   205 	if ( ++p == pe )
   171 		goto _test_eof3;
   206 		goto _test_eof3;
   172 case 3:
   207 case 3:
   173 	if ( (*p) > 90 ) {
   208 #line 209 "parser.c"
       
   209 	if ( (*p) < 65 ) {
       
   210 		if ( 48 <= (*p) && (*p) <= 57 )
       
   211 			goto tr12;
       
   212 	} else if ( (*p) > 90 ) {
   174 		if ( 97 <= (*p) && (*p) <= 122 )
   213 		if ( 97 <= (*p) && (*p) <= 122 )
   175 			goto st4;
   214 			goto tr13;
   176 	} else if ( (*p) >= 65 )
   215 	} else
   177 		goto st4;
   216 		goto tr13;
   178 	goto st0;
   217 	goto tr11;
       
   218 tr12:
       
   219 #line 39 "parser.rl"
       
   220 	{
       
   221 		debug( 1, LOC, "Channel ID found in redirector input.  Set 'url_rewrite_concurrency' to '0' in squid.\n" );
       
   222 		{p++; cs = 4; goto _out;}
       
   223 	}
       
   224 #line 48 "parser.rl"
       
   225 	{ p_request->tokens.host_start  = p; }
       
   226 #line 62 "parser.rl"
       
   227 	{ p_request->tokens.c_ip_start  = p; }
       
   228 	goto st4;
   179 st4:
   229 st4:
   180 	if ( ++p == pe )
   230 	if ( ++p == pe )
   181 		goto _test_eof4;
   231 		goto _test_eof4;
   182 case 4:
   232 case 4:
   183 	if ( (*p) == 58 )
   233 #line 234 "parser.c"
   184 		goto st5;
   234 	switch( (*p) ) {
   185 	if ( (*p) > 90 ) {
   235 		case 32: goto tr15;
   186 		if ( 97 <= (*p) && (*p) <= 122 )
   236 		case 45: goto st32;
   187 			goto st11;
   237 		case 46: goto st42;
   188 	} else if ( (*p) >= 65 )
   238 		case 47: goto tr7;
   189 		goto st11;
   239 		case 58: goto tr9;
   190 	goto st0;
   240 		case 95: goto st32;
       
   241 	}
       
   242 	if ( (*p) < 48 ) {
       
   243 		if ( 9 <= (*p) && (*p) <= 13 )
       
   244 			goto tr15;
       
   245 	} else if ( (*p) > 57 ) {
       
   246 		if ( (*p) > 90 ) {
       
   247 			if ( 97 <= (*p) && (*p) <= 122 )
       
   248 				goto st33;
       
   249 		} else if ( (*p) >= 65 )
       
   250 			goto st33;
       
   251 	} else
       
   252 		goto st75;
       
   253 	goto tr14;
       
   254 tr15:
       
   255 #line 49 "parser.rl"
       
   256 	{ p_request->tokens.host_length = p - ( *pe + p_request->tokens.host_start ); }
       
   257 #line 55 "parser.rl"
       
   258 	{ p_request->tokens.path_start  = p; }
       
   259 #line 56 "parser.rl"
       
   260 	{ p_request->tokens.path_length = p - ( *pe + p_request->tokens.path_start ); }
       
   261 	goto st5;
       
   262 tr51:
       
   263 #line 56 "parser.rl"
       
   264 	{ p_request->tokens.path_length = p - ( *pe + p_request->tokens.path_start ); }
       
   265 	goto st5;
       
   266 tr53:
       
   267 #line 53 "parser.rl"
       
   268 	{ p_request->tokens.port_length = p - ( *pe + p_request->tokens.port_start ); }
       
   269 #line 55 "parser.rl"
       
   270 	{ p_request->tokens.path_start  = p; }
       
   271 #line 56 "parser.rl"
       
   272 	{ p_request->tokens.path_length = p - ( *pe + p_request->tokens.path_start ); }
       
   273 	goto st5;
   191 st5:
   274 st5:
   192 	if ( ++p == pe )
   275 	if ( ++p == pe )
   193 		goto _test_eof5;
   276 		goto _test_eof5;
   194 case 5:
   277 case 5:
   195 	if ( (*p) == 47 )
   278 #line 279 "parser.c"
   196 		goto st6;
   279 	if ( 48 <= (*p) && (*p) <= 57 )
   197 	goto st0;
   280 		goto tr18;
       
   281 	goto tr14;
       
   282 tr18:
       
   283 #line 62 "parser.rl"
       
   284 	{ p_request->tokens.c_ip_start  = p; }
       
   285 	goto st6;
   198 st6:
   286 st6:
   199 	if ( ++p == pe )
   287 	if ( ++p == pe )
   200 		goto _test_eof6;
   288 		goto _test_eof6;
   201 case 6:
   289 case 6:
   202 	if ( (*p) == 47 )
   290 #line 291 "parser.c"
   203 		goto tr7;
   291 	if ( (*p) == 46 )
   204 	goto st0;
   292 		goto st7;
   205 tr7:
   293 	if ( 48 <= (*p) && (*p) <= 57 )
   206 #line 68 "parser.rl"
   294 		goto st30;
   207 	{
   295 	goto tr14;
   208 		printf( "I saw: %s", p+1 );
       
   209 	}
       
   210 	goto st7;
       
   211 st7:
   296 st7:
   212 	if ( ++p == pe )
   297 	if ( ++p == pe )
   213 		goto _test_eof7;
   298 		goto _test_eof7;
   214 case 7:
   299 case 7:
   215 #line 216 "parser.c"
   300 	if ( 48 <= (*p) && (*p) <= 57 )
   216 	switch( (*p) ) {
       
   217 		case 10: goto st13;
       
   218 		case 43: goto st8;
       
   219 		case 95: goto st8;
       
   220 	}
       
   221 	if ( (*p) < 48 ) {
       
   222 		if ( 45 <= (*p) && (*p) <= 46 )
       
   223 			goto st8;
       
   224 	} else if ( (*p) > 57 ) {
       
   225 		if ( (*p) > 90 ) {
       
   226 			if ( 97 <= (*p) && (*p) <= 122 )
       
   227 				goto st8;
       
   228 		} else if ( (*p) >= 65 )
       
   229 			goto st8;
       
   230 	} else
       
   231 		goto st8;
   301 		goto st8;
   232 	goto st0;
   302 	goto tr14;
       
   303 st8:
       
   304 	if ( ++p == pe )
       
   305 		goto _test_eof8;
       
   306 case 8:
       
   307 	if ( (*p) == 46 )
       
   308 		goto st9;
       
   309 	if ( 48 <= (*p) && (*p) <= 57 )
       
   310 		goto st28;
       
   311 	goto tr14;
       
   312 st9:
       
   313 	if ( ++p == pe )
       
   314 		goto _test_eof9;
       
   315 case 9:
       
   316 	if ( 48 <= (*p) && (*p) <= 57 )
       
   317 		goto st10;
       
   318 	goto tr14;
       
   319 st10:
       
   320 	if ( ++p == pe )
       
   321 		goto _test_eof10;
       
   322 case 10:
       
   323 	if ( (*p) == 46 )
       
   324 		goto st11;
       
   325 	if ( 48 <= (*p) && (*p) <= 57 )
       
   326 		goto st26;
       
   327 	goto tr14;
       
   328 st11:
       
   329 	if ( ++p == pe )
       
   330 		goto _test_eof11;
       
   331 case 11:
       
   332 	if ( 48 <= (*p) && (*p) <= 57 )
       
   333 		goto st12;
       
   334 	goto tr14;
       
   335 st12:
       
   336 	if ( ++p == pe )
       
   337 		goto _test_eof12;
       
   338 case 12:
       
   339 	if ( (*p) == 47 )
       
   340 		goto tr28;
       
   341 	if ( 48 <= (*p) && (*p) <= 57 )
       
   342 		goto st24;
       
   343 	goto tr3;
       
   344 tr28:
       
   345 #line 63 "parser.rl"
       
   346 	{ p_request->tokens.c_ip_length = p - ( *pe + p_request->tokens.c_ip_start ); }
       
   347 	goto st13;
   233 st13:
   348 st13:
   234 	if ( ++p == pe )
   349 	if ( ++p == pe )
   235 		goto _test_eof13;
   350 		goto _test_eof13;
   236 case 13:
   351 case 13:
   237 	goto st0;
   352 #line 353 "parser.c"
   238 st8:
   353 	if ( (*p) == 45 )
   239 	if ( ++p == pe )
       
   240 		goto _test_eof8;
       
   241 case 8:
       
   242 	switch( (*p) ) {
       
   243 		case 43: goto st8;
       
   244 		case 58: goto st9;
       
   245 		case 64: goto st13;
       
   246 		case 95: goto st8;
       
   247 	}
       
   248 	if ( (*p) < 48 ) {
       
   249 		if ( 45 <= (*p) && (*p) <= 46 )
       
   250 			goto st8;
       
   251 	} else if ( (*p) > 57 ) {
       
   252 		if ( (*p) > 90 ) {
       
   253 			if ( 97 <= (*p) && (*p) <= 122 )
       
   254 				goto st8;
       
   255 		} else if ( (*p) >= 65 )
       
   256 			goto st8;
       
   257 	} else
       
   258 		goto st8;
       
   259 	goto st0;
       
   260 st9:
       
   261 	if ( ++p == pe )
       
   262 		goto _test_eof9;
       
   263 case 9:
       
   264 	goto st10;
       
   265 st10:
       
   266 	if ( ++p == pe )
       
   267 		goto _test_eof10;
       
   268 case 10:
       
   269 	if ( (*p) == 64 )
       
   270 		goto st14;
   354 		goto st14;
   271 	goto st10;
   355 	if ( (*p) < 65 ) {
       
   356 		if ( 48 <= (*p) && (*p) <= 57 )
       
   357 			goto st21;
       
   358 	} else if ( (*p) > 90 ) {
       
   359 		if ( 97 <= (*p) && (*p) <= 122 )
       
   360 			goto st21;
       
   361 	} else
       
   362 		goto st21;
       
   363 	goto tr3;
   272 st14:
   364 st14:
   273 	if ( ++p == pe )
   365 	if ( ++p == pe )
   274 		goto _test_eof14;
   366 		goto _test_eof14;
   275 case 14:
   367 case 14:
   276 	if ( (*p) == 64 )
   368 	if ( (*p) == 32 )
   277 		goto st14;
   369 		goto st15;
   278 	goto st10;
   370 	if ( 9 <= (*p) && (*p) <= 13 )
   279 st11:
   371 		goto st15;
   280 	if ( ++p == pe )
   372 	goto tr3;
   281 		goto _test_eof11;
   373 st15:
   282 case 11:
   374 	if ( ++p == pe )
   283 	if ( (*p) == 58 )
   375 		goto _test_eof15;
   284 		goto st5;
   376 case 15:
   285 	if ( (*p) > 90 ) {
   377 	switch( (*p) ) {
       
   378 		case 33: goto st16;
       
   379 		case 59: goto st16;
       
   380 		case 61: goto st16;
       
   381 		case 95: goto st16;
       
   382 		case 126: goto st16;
       
   383 	}
       
   384 	if ( (*p) < 48 ) {
       
   385 		if ( 36 <= (*p) && (*p) <= 46 )
       
   386 			goto st16;
       
   387 	} else if ( (*p) > 57 ) {
       
   388 		if ( (*p) > 90 ) {
       
   389 			if ( 97 <= (*p) && (*p) <= 122 )
       
   390 				goto st16;
       
   391 		} else if ( (*p) >= 65 )
       
   392 			goto st16;
       
   393 	} else
       
   394 		goto st16;
       
   395 	goto tr3;
       
   396 st16:
       
   397 	if ( ++p == pe )
       
   398 		goto _test_eof16;
       
   399 case 16:
       
   400 	switch( (*p) ) {
       
   401 		case 32: goto st17;
       
   402 		case 33: goto st16;
       
   403 		case 59: goto st16;
       
   404 		case 61: goto st16;
       
   405 		case 95: goto st16;
       
   406 		case 126: goto st16;
       
   407 	}
       
   408 	if ( (*p) < 48 ) {
       
   409 		if ( (*p) > 13 ) {
       
   410 			if ( 36 <= (*p) && (*p) <= 46 )
       
   411 				goto st16;
       
   412 		} else if ( (*p) >= 9 )
       
   413 			goto st17;
       
   414 	} else if ( (*p) > 57 ) {
       
   415 		if ( (*p) > 90 ) {
       
   416 			if ( 97 <= (*p) && (*p) <= 122 )
       
   417 				goto st16;
       
   418 		} else if ( (*p) >= 65 )
       
   419 			goto st16;
       
   420 	} else
       
   421 		goto st16;
       
   422 	goto tr3;
       
   423 st17:
       
   424 	if ( ++p == pe )
       
   425 		goto _test_eof17;
       
   426 case 17:
       
   427 	if ( 65 <= (*p) && (*p) <= 90 )
       
   428 		goto tr36;
       
   429 	goto tr35;
       
   430 tr36:
       
   431 #line 58 "parser.rl"
       
   432 	{ p_request->tokens.meth_start  = p; }
       
   433 	goto st18;
       
   434 st18:
       
   435 	if ( ++p == pe )
       
   436 		goto _test_eof18;
       
   437 case 18:
       
   438 #line 439 "parser.c"
       
   439 	switch( (*p) ) {
       
   440 		case 10: goto tr39;
       
   441 		case 32: goto tr37;
       
   442 	}
       
   443 	if ( (*p) > 13 ) {
       
   444 		if ( 65 <= (*p) && (*p) <= 90 )
       
   445 			goto st18;
       
   446 	} else if ( (*p) >= 9 )
       
   447 		goto tr37;
       
   448 	goto st0;
       
   449 tr37:
       
   450 #line 59 "parser.rl"
       
   451 	{ p_request->tokens.meth_length = p - ( *pe + p_request->tokens.meth_start ); }
       
   452 	goto st19;
       
   453 st19:
       
   454 	if ( ++p == pe )
       
   455 		goto _test_eof19;
       
   456 case 19:
       
   457 #line 458 "parser.c"
       
   458 	goto st20;
       
   459 st20:
       
   460 	if ( ++p == pe )
       
   461 		goto _test_eof20;
       
   462 case 20:
       
   463 	if ( (*p) == 10 )
       
   464 		goto tr42;
       
   465 	goto st20;
       
   466 tr42:
       
   467 #line 36 "parser.rl"
       
   468 	{ valid = 1; }
       
   469 	goto st85;
       
   470 st85:
       
   471 	if ( ++p == pe )
       
   472 		goto _test_eof85;
       
   473 case 85:
       
   474 #line 475 "parser.c"
       
   475 	if ( (*p) == 10 )
       
   476 		goto tr42;
       
   477 	goto st20;
       
   478 tr39:
       
   479 #line 59 "parser.rl"
       
   480 	{ p_request->tokens.meth_length = p - ( *pe + p_request->tokens.meth_start ); }
       
   481 #line 36 "parser.rl"
       
   482 	{ valid = 1; }
       
   483 	goto st86;
       
   484 st86:
       
   485 	if ( ++p == pe )
       
   486 		goto _test_eof86;
       
   487 case 86:
       
   488 #line 489 "parser.c"
       
   489 	goto st20;
       
   490 st21:
       
   491 	if ( ++p == pe )
       
   492 		goto _test_eof21;
       
   493 case 21:
       
   494 	switch( (*p) ) {
       
   495 		case 32: goto st15;
       
   496 		case 45: goto st22;
       
   497 		case 46: goto st23;
       
   498 		case 95: goto st22;
       
   499 	}
       
   500 	if ( (*p) < 48 ) {
       
   501 		if ( 9 <= (*p) && (*p) <= 13 )
       
   502 			goto st15;
       
   503 	} else if ( (*p) > 57 ) {
       
   504 		if ( (*p) > 90 ) {
       
   505 			if ( 97 <= (*p) && (*p) <= 122 )
       
   506 				goto st21;
       
   507 		} else if ( (*p) >= 65 )
       
   508 			goto st21;
       
   509 	} else
       
   510 		goto st21;
       
   511 	goto tr3;
       
   512 st22:
       
   513 	if ( ++p == pe )
       
   514 		goto _test_eof22;
       
   515 case 22:
       
   516 	switch( (*p) ) {
       
   517 		case 45: goto st22;
       
   518 		case 95: goto st22;
       
   519 	}
       
   520 	if ( (*p) < 65 ) {
       
   521 		if ( 48 <= (*p) && (*p) <= 57 )
       
   522 			goto st21;
       
   523 	} else if ( (*p) > 90 ) {
   286 		if ( 97 <= (*p) && (*p) <= 122 )
   524 		if ( 97 <= (*p) && (*p) <= 122 )
   287 			goto st12;
   525 			goto st21;
   288 	} else if ( (*p) >= 65 )
   526 	} else
   289 		goto st12;
   527 		goto st21;
   290 	goto st0;
   528 	goto tr3;
   291 st12:
   529 st23:
   292 	if ( ++p == pe )
   530 	if ( ++p == pe )
   293 		goto _test_eof12;
   531 		goto _test_eof23;
   294 case 12:
   532 case 23:
   295 	if ( (*p) == 58 )
   533 	if ( (*p) == 32 )
   296 		goto st5;
   534 		goto st15;
   297 	goto st0;
   535 	if ( (*p) < 48 ) {
       
   536 		if ( 9 <= (*p) && (*p) <= 13 )
       
   537 			goto st15;
       
   538 	} else if ( (*p) > 57 ) {
       
   539 		if ( (*p) > 90 ) {
       
   540 			if ( 97 <= (*p) && (*p) <= 122 )
       
   541 				goto st21;
       
   542 		} else if ( (*p) >= 65 )
       
   543 			goto st21;
       
   544 	} else
       
   545 		goto st21;
       
   546 	goto tr3;
       
   547 st24:
       
   548 	if ( ++p == pe )
       
   549 		goto _test_eof24;
       
   550 case 24:
       
   551 	if ( (*p) == 47 )
       
   552 		goto tr28;
       
   553 	if ( 48 <= (*p) && (*p) <= 57 )
       
   554 		goto st25;
       
   555 	goto tr3;
       
   556 st25:
       
   557 	if ( ++p == pe )
       
   558 		goto _test_eof25;
       
   559 case 25:
       
   560 	if ( (*p) == 47 )
       
   561 		goto tr28;
       
   562 	goto tr3;
       
   563 st26:
       
   564 	if ( ++p == pe )
       
   565 		goto _test_eof26;
       
   566 case 26:
       
   567 	if ( (*p) == 46 )
       
   568 		goto st11;
       
   569 	if ( 48 <= (*p) && (*p) <= 57 )
       
   570 		goto st27;
       
   571 	goto tr14;
       
   572 st27:
       
   573 	if ( ++p == pe )
       
   574 		goto _test_eof27;
       
   575 case 27:
       
   576 	if ( (*p) == 46 )
       
   577 		goto st11;
       
   578 	goto tr14;
       
   579 st28:
       
   580 	if ( ++p == pe )
       
   581 		goto _test_eof28;
       
   582 case 28:
       
   583 	if ( (*p) == 46 )
       
   584 		goto st9;
       
   585 	if ( 48 <= (*p) && (*p) <= 57 )
       
   586 		goto st29;
       
   587 	goto tr14;
       
   588 st29:
       
   589 	if ( ++p == pe )
       
   590 		goto _test_eof29;
       
   591 case 29:
       
   592 	if ( (*p) == 46 )
       
   593 		goto st9;
       
   594 	goto tr14;
       
   595 st30:
       
   596 	if ( ++p == pe )
       
   597 		goto _test_eof30;
       
   598 case 30:
       
   599 	if ( (*p) == 46 )
       
   600 		goto st7;
       
   601 	if ( 48 <= (*p) && (*p) <= 57 )
       
   602 		goto st31;
       
   603 	goto tr14;
       
   604 st31:
       
   605 	if ( ++p == pe )
       
   606 		goto _test_eof31;
       
   607 case 31:
       
   608 	if ( (*p) == 46 )
       
   609 		goto st7;
       
   610 	goto tr14;
       
   611 st32:
       
   612 	if ( ++p == pe )
       
   613 		goto _test_eof32;
       
   614 case 32:
       
   615 	switch( (*p) ) {
       
   616 		case 45: goto st32;
       
   617 		case 95: goto st32;
       
   618 	}
       
   619 	if ( (*p) < 65 ) {
       
   620 		if ( 48 <= (*p) && (*p) <= 57 )
       
   621 			goto st33;
       
   622 	} else if ( (*p) > 90 ) {
       
   623 		if ( 97 <= (*p) && (*p) <= 122 )
       
   624 			goto st33;
       
   625 	} else
       
   626 		goto st33;
       
   627 	goto tr49;
       
   628 tr99:
       
   629 #line 45 "parser.rl"
       
   630 	{ p_request->tokens.scheme_length = p - ( *pe + p_request->tokens.scheme_start ); }
       
   631 #line 48 "parser.rl"
       
   632 	{ p_request->tokens.host_start  = p; }
       
   633 	goto st33;
       
   634 st33:
       
   635 	if ( ++p == pe )
       
   636 		goto _test_eof33;
       
   637 case 33:
       
   638 #line 639 "parser.c"
       
   639 	switch( (*p) ) {
       
   640 		case 32: goto tr15;
       
   641 		case 45: goto st32;
       
   642 		case 46: goto st34;
       
   643 		case 47: goto tr7;
       
   644 		case 58: goto tr9;
       
   645 		case 95: goto st32;
       
   646 	}
       
   647 	if ( (*p) < 48 ) {
       
   648 		if ( 9 <= (*p) && (*p) <= 13 )
       
   649 			goto tr15;
       
   650 	} else if ( (*p) > 57 ) {
       
   651 		if ( (*p) > 90 ) {
       
   652 			if ( 97 <= (*p) && (*p) <= 122 )
       
   653 				goto st33;
       
   654 		} else if ( (*p) >= 65 )
       
   655 			goto st33;
       
   656 	} else
       
   657 		goto st33;
       
   658 	goto tr3;
       
   659 st34:
       
   660 	if ( ++p == pe )
       
   661 		goto _test_eof34;
       
   662 case 34:
       
   663 	switch( (*p) ) {
       
   664 		case 32: goto tr15;
       
   665 		case 47: goto tr7;
       
   666 		case 58: goto tr9;
       
   667 	}
       
   668 	if ( (*p) < 48 ) {
       
   669 		if ( 9 <= (*p) && (*p) <= 13 )
       
   670 			goto tr15;
       
   671 	} else if ( (*p) > 57 ) {
       
   672 		if ( (*p) > 90 ) {
       
   673 			if ( 97 <= (*p) && (*p) <= 122 )
       
   674 				goto st33;
       
   675 		} else if ( (*p) >= 65 )
       
   676 			goto st33;
       
   677 	} else
       
   678 		goto st33;
       
   679 	goto tr3;
       
   680 tr7:
       
   681 #line 49 "parser.rl"
       
   682 	{ p_request->tokens.host_length = p - ( *pe + p_request->tokens.host_start ); }
       
   683 #line 55 "parser.rl"
       
   684 	{ p_request->tokens.path_start  = p; }
       
   685 	goto st35;
       
   686 tr54:
       
   687 #line 53 "parser.rl"
       
   688 	{ p_request->tokens.port_length = p - ( *pe + p_request->tokens.port_start ); }
       
   689 #line 55 "parser.rl"
       
   690 	{ p_request->tokens.path_start  = p; }
       
   691 	goto st35;
       
   692 st35:
       
   693 	if ( ++p == pe )
       
   694 		goto _test_eof35;
       
   695 case 35:
       
   696 #line 697 "parser.c"
       
   697 	if ( (*p) == 32 )
       
   698 		goto tr51;
       
   699 	if ( 9 <= (*p) && (*p) <= 13 )
       
   700 		goto tr51;
       
   701 	goto st35;
       
   702 tr9:
       
   703 #line 49 "parser.rl"
       
   704 	{ p_request->tokens.host_length = p - ( *pe + p_request->tokens.host_start ); }
       
   705 #line 52 "parser.rl"
       
   706 	{ p_request->tokens.port_start  = p; }
       
   707 	goto st36;
       
   708 st36:
       
   709 	if ( ++p == pe )
       
   710 		goto _test_eof36;
       
   711 case 36:
       
   712 #line 713 "parser.c"
       
   713 	if ( 48 <= (*p) && (*p) <= 57 )
       
   714 		goto st37;
       
   715 	goto tr3;
       
   716 st37:
       
   717 	if ( ++p == pe )
       
   718 		goto _test_eof37;
       
   719 case 37:
       
   720 	switch( (*p) ) {
       
   721 		case 32: goto tr53;
       
   722 		case 47: goto tr54;
       
   723 	}
       
   724 	if ( (*p) > 13 ) {
       
   725 		if ( 48 <= (*p) && (*p) <= 57 )
       
   726 			goto st38;
       
   727 	} else if ( (*p) >= 9 )
       
   728 		goto tr53;
       
   729 	goto tr3;
       
   730 st38:
       
   731 	if ( ++p == pe )
       
   732 		goto _test_eof38;
       
   733 case 38:
       
   734 	switch( (*p) ) {
       
   735 		case 32: goto tr53;
       
   736 		case 47: goto tr54;
       
   737 	}
       
   738 	if ( (*p) > 13 ) {
       
   739 		if ( 48 <= (*p) && (*p) <= 57 )
       
   740 			goto st39;
       
   741 	} else if ( (*p) >= 9 )
       
   742 		goto tr53;
       
   743 	goto tr3;
       
   744 st39:
       
   745 	if ( ++p == pe )
       
   746 		goto _test_eof39;
       
   747 case 39:
       
   748 	switch( (*p) ) {
       
   749 		case 32: goto tr53;
       
   750 		case 47: goto tr54;
       
   751 	}
       
   752 	if ( (*p) > 13 ) {
       
   753 		if ( 48 <= (*p) && (*p) <= 57 )
       
   754 			goto st40;
       
   755 	} else if ( (*p) >= 9 )
       
   756 		goto tr53;
       
   757 	goto tr3;
       
   758 st40:
       
   759 	if ( ++p == pe )
       
   760 		goto _test_eof40;
       
   761 case 40:
       
   762 	switch( (*p) ) {
       
   763 		case 32: goto tr53;
       
   764 		case 47: goto tr54;
       
   765 	}
       
   766 	if ( (*p) > 13 ) {
       
   767 		if ( 48 <= (*p) && (*p) <= 57 )
       
   768 			goto st41;
       
   769 	} else if ( (*p) >= 9 )
       
   770 		goto tr53;
       
   771 	goto tr3;
       
   772 st41:
       
   773 	if ( ++p == pe )
       
   774 		goto _test_eof41;
       
   775 case 41:
       
   776 	switch( (*p) ) {
       
   777 		case 32: goto tr53;
       
   778 		case 47: goto tr54;
       
   779 	}
       
   780 	if ( 9 <= (*p) && (*p) <= 13 )
       
   781 		goto tr53;
       
   782 	goto tr3;
       
   783 st42:
       
   784 	if ( ++p == pe )
       
   785 		goto _test_eof42;
       
   786 case 42:
       
   787 	switch( (*p) ) {
       
   788 		case 32: goto tr15;
       
   789 		case 47: goto tr7;
       
   790 		case 58: goto tr9;
       
   791 	}
       
   792 	if ( (*p) < 48 ) {
       
   793 		if ( 9 <= (*p) && (*p) <= 13 )
       
   794 			goto tr15;
       
   795 	} else if ( (*p) > 57 ) {
       
   796 		if ( (*p) > 90 ) {
       
   797 			if ( 97 <= (*p) && (*p) <= 122 )
       
   798 				goto st33;
       
   799 		} else if ( (*p) >= 65 )
       
   800 			goto st33;
       
   801 	} else
       
   802 		goto st43;
       
   803 	goto tr14;
       
   804 st43:
       
   805 	if ( ++p == pe )
       
   806 		goto _test_eof43;
       
   807 case 43:
       
   808 	switch( (*p) ) {
       
   809 		case 32: goto tr15;
       
   810 		case 45: goto st32;
       
   811 		case 46: goto st44;
       
   812 		case 47: goto tr7;
       
   813 		case 58: goto tr9;
       
   814 		case 95: goto st32;
       
   815 	}
       
   816 	if ( (*p) < 48 ) {
       
   817 		if ( 9 <= (*p) && (*p) <= 13 )
       
   818 			goto tr15;
       
   819 	} else if ( (*p) > 57 ) {
       
   820 		if ( (*p) > 90 ) {
       
   821 			if ( 97 <= (*p) && (*p) <= 122 )
       
   822 				goto st33;
       
   823 		} else if ( (*p) >= 65 )
       
   824 			goto st33;
       
   825 	} else
       
   826 		goto st73;
       
   827 	goto tr14;
       
   828 st44:
       
   829 	if ( ++p == pe )
       
   830 		goto _test_eof44;
       
   831 case 44:
       
   832 	switch( (*p) ) {
       
   833 		case 32: goto tr15;
       
   834 		case 47: goto tr7;
       
   835 		case 58: goto tr9;
       
   836 	}
       
   837 	if ( (*p) < 48 ) {
       
   838 		if ( 9 <= (*p) && (*p) <= 13 )
       
   839 			goto tr15;
       
   840 	} else if ( (*p) > 57 ) {
       
   841 		if ( (*p) > 90 ) {
       
   842 			if ( 97 <= (*p) && (*p) <= 122 )
       
   843 				goto st33;
       
   844 		} else if ( (*p) >= 65 )
       
   845 			goto st33;
       
   846 	} else
       
   847 		goto st45;
       
   848 	goto tr14;
       
   849 st45:
       
   850 	if ( ++p == pe )
       
   851 		goto _test_eof45;
       
   852 case 45:
       
   853 	switch( (*p) ) {
       
   854 		case 32: goto tr15;
       
   855 		case 45: goto st32;
       
   856 		case 46: goto st46;
       
   857 		case 47: goto tr7;
       
   858 		case 58: goto tr9;
       
   859 		case 95: goto st32;
       
   860 	}
       
   861 	if ( (*p) < 48 ) {
       
   862 		if ( 9 <= (*p) && (*p) <= 13 )
       
   863 			goto tr15;
       
   864 	} else if ( (*p) > 57 ) {
       
   865 		if ( (*p) > 90 ) {
       
   866 			if ( 97 <= (*p) && (*p) <= 122 )
       
   867 				goto st33;
       
   868 		} else if ( (*p) >= 65 )
       
   869 			goto st33;
       
   870 	} else
       
   871 		goto st71;
       
   872 	goto tr14;
       
   873 st46:
       
   874 	if ( ++p == pe )
       
   875 		goto _test_eof46;
       
   876 case 46:
       
   877 	switch( (*p) ) {
       
   878 		case 32: goto tr15;
       
   879 		case 47: goto tr7;
       
   880 		case 58: goto tr9;
       
   881 	}
       
   882 	if ( (*p) < 48 ) {
       
   883 		if ( 9 <= (*p) && (*p) <= 13 )
       
   884 			goto tr15;
       
   885 	} else if ( (*p) > 57 ) {
       
   886 		if ( (*p) > 90 ) {
       
   887 			if ( 97 <= (*p) && (*p) <= 122 )
       
   888 				goto st33;
       
   889 		} else if ( (*p) >= 65 )
       
   890 			goto st33;
       
   891 	} else
       
   892 		goto st47;
       
   893 	goto tr14;
       
   894 st47:
       
   895 	if ( ++p == pe )
       
   896 		goto _test_eof47;
       
   897 case 47:
       
   898 	switch( (*p) ) {
       
   899 		case 32: goto tr15;
       
   900 		case 45: goto st32;
       
   901 		case 46: goto st34;
       
   902 		case 47: goto tr66;
       
   903 		case 58: goto tr9;
       
   904 		case 95: goto st32;
       
   905 	}
       
   906 	if ( (*p) < 48 ) {
       
   907 		if ( 9 <= (*p) && (*p) <= 13 )
       
   908 			goto tr15;
       
   909 	} else if ( (*p) > 57 ) {
       
   910 		if ( (*p) > 90 ) {
       
   911 			if ( 97 <= (*p) && (*p) <= 122 )
       
   912 				goto st33;
       
   913 		} else if ( (*p) >= 65 )
       
   914 			goto st33;
       
   915 	} else
       
   916 		goto st69;
       
   917 	goto tr3;
       
   918 tr66:
       
   919 #line 49 "parser.rl"
       
   920 	{ p_request->tokens.host_length = p - ( *pe + p_request->tokens.host_start ); }
       
   921 #line 55 "parser.rl"
       
   922 	{ p_request->tokens.path_start  = p; }
       
   923 #line 63 "parser.rl"
       
   924 	{ p_request->tokens.c_ip_length = p - ( *pe + p_request->tokens.c_ip_start ); }
       
   925 	goto st48;
       
   926 st48:
       
   927 	if ( ++p == pe )
       
   928 		goto _test_eof48;
       
   929 case 48:
       
   930 #line 931 "parser.c"
       
   931 	switch( (*p) ) {
       
   932 		case 32: goto tr51;
       
   933 		case 45: goto st49;
       
   934 	}
       
   935 	if ( (*p) < 48 ) {
       
   936 		if ( 9 <= (*p) && (*p) <= 13 )
       
   937 			goto tr51;
       
   938 	} else if ( (*p) > 57 ) {
       
   939 		if ( (*p) > 90 ) {
       
   940 			if ( 97 <= (*p) && (*p) <= 122 )
       
   941 				goto st66;
       
   942 		} else if ( (*p) >= 65 )
       
   943 			goto st66;
       
   944 	} else
       
   945 		goto st66;
       
   946 	goto st35;
       
   947 st49:
       
   948 	if ( ++p == pe )
       
   949 		goto _test_eof49;
       
   950 case 49:
       
   951 	if ( (*p) == 32 )
       
   952 		goto tr70;
       
   953 	if ( 9 <= (*p) && (*p) <= 13 )
       
   954 		goto tr70;
       
   955 	goto st35;
       
   956 tr70:
       
   957 #line 56 "parser.rl"
       
   958 	{ p_request->tokens.path_length = p - ( *pe + p_request->tokens.path_start ); }
       
   959 	goto st50;
       
   960 st50:
       
   961 	if ( ++p == pe )
       
   962 		goto _test_eof50;
       
   963 case 50:
       
   964 #line 965 "parser.c"
       
   965 	switch( (*p) ) {
       
   966 		case 33: goto st16;
       
   967 		case 59: goto st16;
       
   968 		case 61: goto st16;
       
   969 		case 95: goto st16;
       
   970 		case 126: goto st16;
       
   971 	}
       
   972 	if ( (*p) < 48 ) {
       
   973 		if ( 36 <= (*p) && (*p) <= 46 )
       
   974 			goto st16;
       
   975 	} else if ( (*p) > 57 ) {
       
   976 		if ( (*p) > 90 ) {
       
   977 			if ( 97 <= (*p) && (*p) <= 122 )
       
   978 				goto st16;
       
   979 		} else if ( (*p) >= 65 )
       
   980 			goto st16;
       
   981 	} else
       
   982 		goto tr71;
       
   983 	goto tr14;
       
   984 tr71:
       
   985 #line 62 "parser.rl"
       
   986 	{ p_request->tokens.c_ip_start  = p; }
       
   987 	goto st51;
       
   988 st51:
       
   989 	if ( ++p == pe )
       
   990 		goto _test_eof51;
       
   991 case 51:
       
   992 #line 993 "parser.c"
       
   993 	switch( (*p) ) {
       
   994 		case 32: goto st17;
       
   995 		case 33: goto st16;
       
   996 		case 46: goto st52;
       
   997 		case 59: goto st16;
       
   998 		case 61: goto st16;
       
   999 		case 95: goto st16;
       
  1000 		case 126: goto st16;
       
  1001 	}
       
  1002 	if ( (*p) < 48 ) {
       
  1003 		if ( (*p) > 13 ) {
       
  1004 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1005 				goto st16;
       
  1006 		} else if ( (*p) >= 9 )
       
  1007 			goto st17;
       
  1008 	} else if ( (*p) > 57 ) {
       
  1009 		if ( (*p) > 90 ) {
       
  1010 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1011 				goto st16;
       
  1012 		} else if ( (*p) >= 65 )
       
  1013 			goto st16;
       
  1014 	} else
       
  1015 		goto st64;
       
  1016 	goto tr14;
       
  1017 st52:
       
  1018 	if ( ++p == pe )
       
  1019 		goto _test_eof52;
       
  1020 case 52:
       
  1021 	switch( (*p) ) {
       
  1022 		case 32: goto st17;
       
  1023 		case 33: goto st16;
       
  1024 		case 59: goto st16;
       
  1025 		case 61: goto st16;
       
  1026 		case 95: goto st16;
       
  1027 		case 126: goto st16;
       
  1028 	}
       
  1029 	if ( (*p) < 48 ) {
       
  1030 		if ( (*p) > 13 ) {
       
  1031 			if ( 36 <= (*p) && (*p) <= 46 )
       
  1032 				goto st16;
       
  1033 		} else if ( (*p) >= 9 )
       
  1034 			goto st17;
       
  1035 	} else if ( (*p) > 57 ) {
       
  1036 		if ( (*p) > 90 ) {
       
  1037 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1038 				goto st16;
       
  1039 		} else if ( (*p) >= 65 )
       
  1040 			goto st16;
       
  1041 	} else
       
  1042 		goto st53;
       
  1043 	goto tr14;
       
  1044 st53:
       
  1045 	if ( ++p == pe )
       
  1046 		goto _test_eof53;
       
  1047 case 53:
       
  1048 	switch( (*p) ) {
       
  1049 		case 32: goto st17;
       
  1050 		case 33: goto st16;
       
  1051 		case 46: goto st54;
       
  1052 		case 59: goto st16;
       
  1053 		case 61: goto st16;
       
  1054 		case 95: goto st16;
       
  1055 		case 126: goto st16;
       
  1056 	}
       
  1057 	if ( (*p) < 48 ) {
       
  1058 		if ( (*p) > 13 ) {
       
  1059 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1060 				goto st16;
       
  1061 		} else if ( (*p) >= 9 )
       
  1062 			goto st17;
       
  1063 	} else if ( (*p) > 57 ) {
       
  1064 		if ( (*p) > 90 ) {
       
  1065 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1066 				goto st16;
       
  1067 		} else if ( (*p) >= 65 )
       
  1068 			goto st16;
       
  1069 	} else
       
  1070 		goto st62;
       
  1071 	goto tr14;
       
  1072 st54:
       
  1073 	if ( ++p == pe )
       
  1074 		goto _test_eof54;
       
  1075 case 54:
       
  1076 	switch( (*p) ) {
       
  1077 		case 32: goto st17;
       
  1078 		case 33: goto st16;
       
  1079 		case 59: goto st16;
       
  1080 		case 61: goto st16;
       
  1081 		case 95: goto st16;
       
  1082 		case 126: goto st16;
       
  1083 	}
       
  1084 	if ( (*p) < 48 ) {
       
  1085 		if ( (*p) > 13 ) {
       
  1086 			if ( 36 <= (*p) && (*p) <= 46 )
       
  1087 				goto st16;
       
  1088 		} else if ( (*p) >= 9 )
       
  1089 			goto st17;
       
  1090 	} else if ( (*p) > 57 ) {
       
  1091 		if ( (*p) > 90 ) {
       
  1092 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1093 				goto st16;
       
  1094 		} else if ( (*p) >= 65 )
       
  1095 			goto st16;
       
  1096 	} else
       
  1097 		goto st55;
       
  1098 	goto tr14;
       
  1099 st55:
       
  1100 	if ( ++p == pe )
       
  1101 		goto _test_eof55;
       
  1102 case 55:
       
  1103 	switch( (*p) ) {
       
  1104 		case 32: goto st17;
       
  1105 		case 33: goto st16;
       
  1106 		case 46: goto st56;
       
  1107 		case 59: goto st16;
       
  1108 		case 61: goto st16;
       
  1109 		case 95: goto st16;
       
  1110 		case 126: goto st16;
       
  1111 	}
       
  1112 	if ( (*p) < 48 ) {
       
  1113 		if ( (*p) > 13 ) {
       
  1114 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1115 				goto st16;
       
  1116 		} else if ( (*p) >= 9 )
       
  1117 			goto st17;
       
  1118 	} else if ( (*p) > 57 ) {
       
  1119 		if ( (*p) > 90 ) {
       
  1120 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1121 				goto st16;
       
  1122 		} else if ( (*p) >= 65 )
       
  1123 			goto st16;
       
  1124 	} else
       
  1125 		goto st60;
       
  1126 	goto tr14;
       
  1127 st56:
       
  1128 	if ( ++p == pe )
       
  1129 		goto _test_eof56;
       
  1130 case 56:
       
  1131 	switch( (*p) ) {
       
  1132 		case 32: goto st17;
       
  1133 		case 33: goto st16;
       
  1134 		case 59: goto st16;
       
  1135 		case 61: goto st16;
       
  1136 		case 95: goto st16;
       
  1137 		case 126: goto st16;
       
  1138 	}
       
  1139 	if ( (*p) < 48 ) {
       
  1140 		if ( (*p) > 13 ) {
       
  1141 			if ( 36 <= (*p) && (*p) <= 46 )
       
  1142 				goto st16;
       
  1143 		} else if ( (*p) >= 9 )
       
  1144 			goto st17;
       
  1145 	} else if ( (*p) > 57 ) {
       
  1146 		if ( (*p) > 90 ) {
       
  1147 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1148 				goto st16;
       
  1149 		} else if ( (*p) >= 65 )
       
  1150 			goto st16;
       
  1151 	} else
       
  1152 		goto st57;
       
  1153 	goto tr14;
       
  1154 st57:
       
  1155 	if ( ++p == pe )
       
  1156 		goto _test_eof57;
       
  1157 case 57:
       
  1158 	switch( (*p) ) {
       
  1159 		case 32: goto st17;
       
  1160 		case 33: goto st16;
       
  1161 		case 47: goto tr28;
       
  1162 		case 59: goto st16;
       
  1163 		case 61: goto st16;
       
  1164 		case 95: goto st16;
       
  1165 		case 126: goto st16;
       
  1166 	}
       
  1167 	if ( (*p) < 48 ) {
       
  1168 		if ( (*p) > 13 ) {
       
  1169 			if ( 36 <= (*p) && (*p) <= 46 )
       
  1170 				goto st16;
       
  1171 		} else if ( (*p) >= 9 )
       
  1172 			goto st17;
       
  1173 	} else if ( (*p) > 57 ) {
       
  1174 		if ( (*p) > 90 ) {
       
  1175 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1176 				goto st16;
       
  1177 		} else if ( (*p) >= 65 )
       
  1178 			goto st16;
       
  1179 	} else
       
  1180 		goto st58;
       
  1181 	goto tr3;
       
  1182 st58:
       
  1183 	if ( ++p == pe )
       
  1184 		goto _test_eof58;
       
  1185 case 58:
       
  1186 	switch( (*p) ) {
       
  1187 		case 32: goto st17;
       
  1188 		case 33: goto st16;
       
  1189 		case 47: goto tr28;
       
  1190 		case 59: goto st16;
       
  1191 		case 61: goto st16;
       
  1192 		case 95: goto st16;
       
  1193 		case 126: goto st16;
       
  1194 	}
       
  1195 	if ( (*p) < 48 ) {
       
  1196 		if ( (*p) > 13 ) {
       
  1197 			if ( 36 <= (*p) && (*p) <= 46 )
       
  1198 				goto st16;
       
  1199 		} else if ( (*p) >= 9 )
       
  1200 			goto st17;
       
  1201 	} else if ( (*p) > 57 ) {
       
  1202 		if ( (*p) > 90 ) {
       
  1203 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1204 				goto st16;
       
  1205 		} else if ( (*p) >= 65 )
       
  1206 			goto st16;
       
  1207 	} else
       
  1208 		goto st59;
       
  1209 	goto tr3;
       
  1210 st59:
       
  1211 	if ( ++p == pe )
       
  1212 		goto _test_eof59;
       
  1213 case 59:
       
  1214 	switch( (*p) ) {
       
  1215 		case 32: goto st17;
       
  1216 		case 33: goto st16;
       
  1217 		case 47: goto tr28;
       
  1218 		case 59: goto st16;
       
  1219 		case 61: goto st16;
       
  1220 		case 95: goto st16;
       
  1221 		case 126: goto st16;
       
  1222 	}
       
  1223 	if ( (*p) < 36 ) {
       
  1224 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1225 			goto st17;
       
  1226 	} else if ( (*p) > 57 ) {
       
  1227 		if ( (*p) > 90 ) {
       
  1228 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1229 				goto st16;
       
  1230 		} else if ( (*p) >= 65 )
       
  1231 			goto st16;
       
  1232 	} else
       
  1233 		goto st16;
       
  1234 	goto tr3;
       
  1235 st60:
       
  1236 	if ( ++p == pe )
       
  1237 		goto _test_eof60;
       
  1238 case 60:
       
  1239 	switch( (*p) ) {
       
  1240 		case 32: goto st17;
       
  1241 		case 33: goto st16;
       
  1242 		case 46: goto st56;
       
  1243 		case 59: goto st16;
       
  1244 		case 61: goto st16;
       
  1245 		case 95: goto st16;
       
  1246 		case 126: goto st16;
       
  1247 	}
       
  1248 	if ( (*p) < 48 ) {
       
  1249 		if ( (*p) > 13 ) {
       
  1250 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1251 				goto st16;
       
  1252 		} else if ( (*p) >= 9 )
       
  1253 			goto st17;
       
  1254 	} else if ( (*p) > 57 ) {
       
  1255 		if ( (*p) > 90 ) {
       
  1256 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1257 				goto st16;
       
  1258 		} else if ( (*p) >= 65 )
       
  1259 			goto st16;
       
  1260 	} else
       
  1261 		goto st61;
       
  1262 	goto tr14;
       
  1263 st61:
       
  1264 	if ( ++p == pe )
       
  1265 		goto _test_eof61;
       
  1266 case 61:
       
  1267 	switch( (*p) ) {
       
  1268 		case 32: goto st17;
       
  1269 		case 33: goto st16;
       
  1270 		case 46: goto st56;
       
  1271 		case 59: goto st16;
       
  1272 		case 61: goto st16;
       
  1273 		case 95: goto st16;
       
  1274 		case 126: goto st16;
       
  1275 	}
       
  1276 	if ( (*p) < 48 ) {
       
  1277 		if ( (*p) > 13 ) {
       
  1278 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1279 				goto st16;
       
  1280 		} else if ( (*p) >= 9 )
       
  1281 			goto st17;
       
  1282 	} else if ( (*p) > 57 ) {
       
  1283 		if ( (*p) > 90 ) {
       
  1284 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1285 				goto st16;
       
  1286 		} else if ( (*p) >= 65 )
       
  1287 			goto st16;
       
  1288 	} else
       
  1289 		goto st16;
       
  1290 	goto tr14;
       
  1291 st62:
       
  1292 	if ( ++p == pe )
       
  1293 		goto _test_eof62;
       
  1294 case 62:
       
  1295 	switch( (*p) ) {
       
  1296 		case 32: goto st17;
       
  1297 		case 33: goto st16;
       
  1298 		case 46: goto st54;
       
  1299 		case 59: goto st16;
       
  1300 		case 61: goto st16;
       
  1301 		case 95: goto st16;
       
  1302 		case 126: goto st16;
       
  1303 	}
       
  1304 	if ( (*p) < 48 ) {
       
  1305 		if ( (*p) > 13 ) {
       
  1306 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1307 				goto st16;
       
  1308 		} else if ( (*p) >= 9 )
       
  1309 			goto st17;
       
  1310 	} else if ( (*p) > 57 ) {
       
  1311 		if ( (*p) > 90 ) {
       
  1312 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1313 				goto st16;
       
  1314 		} else if ( (*p) >= 65 )
       
  1315 			goto st16;
       
  1316 	} else
       
  1317 		goto st63;
       
  1318 	goto tr14;
       
  1319 st63:
       
  1320 	if ( ++p == pe )
       
  1321 		goto _test_eof63;
       
  1322 case 63:
       
  1323 	switch( (*p) ) {
       
  1324 		case 32: goto st17;
       
  1325 		case 33: goto st16;
       
  1326 		case 46: goto st54;
       
  1327 		case 59: goto st16;
       
  1328 		case 61: goto st16;
       
  1329 		case 95: goto st16;
       
  1330 		case 126: goto st16;
       
  1331 	}
       
  1332 	if ( (*p) < 48 ) {
       
  1333 		if ( (*p) > 13 ) {
       
  1334 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1335 				goto st16;
       
  1336 		} else if ( (*p) >= 9 )
       
  1337 			goto st17;
       
  1338 	} else if ( (*p) > 57 ) {
       
  1339 		if ( (*p) > 90 ) {
       
  1340 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1341 				goto st16;
       
  1342 		} else if ( (*p) >= 65 )
       
  1343 			goto st16;
       
  1344 	} else
       
  1345 		goto st16;
       
  1346 	goto tr14;
       
  1347 st64:
       
  1348 	if ( ++p == pe )
       
  1349 		goto _test_eof64;
       
  1350 case 64:
       
  1351 	switch( (*p) ) {
       
  1352 		case 32: goto st17;
       
  1353 		case 33: goto st16;
       
  1354 		case 46: goto st52;
       
  1355 		case 59: goto st16;
       
  1356 		case 61: goto st16;
       
  1357 		case 95: goto st16;
       
  1358 		case 126: goto st16;
       
  1359 	}
       
  1360 	if ( (*p) < 48 ) {
       
  1361 		if ( (*p) > 13 ) {
       
  1362 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1363 				goto st16;
       
  1364 		} else if ( (*p) >= 9 )
       
  1365 			goto st17;
       
  1366 	} else if ( (*p) > 57 ) {
       
  1367 		if ( (*p) > 90 ) {
       
  1368 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1369 				goto st16;
       
  1370 		} else if ( (*p) >= 65 )
       
  1371 			goto st16;
       
  1372 	} else
       
  1373 		goto st65;
       
  1374 	goto tr14;
       
  1375 st65:
       
  1376 	if ( ++p == pe )
       
  1377 		goto _test_eof65;
       
  1378 case 65:
       
  1379 	switch( (*p) ) {
       
  1380 		case 32: goto st17;
       
  1381 		case 33: goto st16;
       
  1382 		case 46: goto st52;
       
  1383 		case 59: goto st16;
       
  1384 		case 61: goto st16;
       
  1385 		case 95: goto st16;
       
  1386 		case 126: goto st16;
       
  1387 	}
       
  1388 	if ( (*p) < 48 ) {
       
  1389 		if ( (*p) > 13 ) {
       
  1390 			if ( 36 <= (*p) && (*p) <= 45 )
       
  1391 				goto st16;
       
  1392 		} else if ( (*p) >= 9 )
       
  1393 			goto st17;
       
  1394 	} else if ( (*p) > 57 ) {
       
  1395 		if ( (*p) > 90 ) {
       
  1396 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1397 				goto st16;
       
  1398 		} else if ( (*p) >= 65 )
       
  1399 			goto st16;
       
  1400 	} else
       
  1401 		goto st16;
       
  1402 	goto tr14;
       
  1403 st66:
       
  1404 	if ( ++p == pe )
       
  1405 		goto _test_eof66;
       
  1406 case 66:
       
  1407 	switch( (*p) ) {
       
  1408 		case 32: goto tr70;
       
  1409 		case 45: goto st67;
       
  1410 		case 46: goto st68;
       
  1411 		case 95: goto st67;
       
  1412 	}
       
  1413 	if ( (*p) < 48 ) {
       
  1414 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1415 			goto tr70;
       
  1416 	} else if ( (*p) > 57 ) {
       
  1417 		if ( (*p) > 90 ) {
       
  1418 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1419 				goto st66;
       
  1420 		} else if ( (*p) >= 65 )
       
  1421 			goto st66;
       
  1422 	} else
       
  1423 		goto st66;
       
  1424 	goto st35;
       
  1425 st67:
       
  1426 	if ( ++p == pe )
       
  1427 		goto _test_eof67;
       
  1428 case 67:
       
  1429 	switch( (*p) ) {
       
  1430 		case 32: goto tr51;
       
  1431 		case 45: goto st67;
       
  1432 		case 95: goto st67;
       
  1433 	}
       
  1434 	if ( (*p) < 48 ) {
       
  1435 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1436 			goto tr51;
       
  1437 	} else if ( (*p) > 57 ) {
       
  1438 		if ( (*p) > 90 ) {
       
  1439 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1440 				goto st66;
       
  1441 		} else if ( (*p) >= 65 )
       
  1442 			goto st66;
       
  1443 	} else
       
  1444 		goto st66;
       
  1445 	goto st35;
       
  1446 st68:
       
  1447 	if ( ++p == pe )
       
  1448 		goto _test_eof68;
       
  1449 case 68:
       
  1450 	if ( (*p) == 32 )
       
  1451 		goto tr70;
       
  1452 	if ( (*p) < 48 ) {
       
  1453 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1454 			goto tr70;
       
  1455 	} else if ( (*p) > 57 ) {
       
  1456 		if ( (*p) > 90 ) {
       
  1457 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1458 				goto st66;
       
  1459 		} else if ( (*p) >= 65 )
       
  1460 			goto st66;
       
  1461 	} else
       
  1462 		goto st66;
       
  1463 	goto st35;
       
  1464 st69:
       
  1465 	if ( ++p == pe )
       
  1466 		goto _test_eof69;
       
  1467 case 69:
       
  1468 	switch( (*p) ) {
       
  1469 		case 32: goto tr15;
       
  1470 		case 45: goto st32;
       
  1471 		case 46: goto st34;
       
  1472 		case 47: goto tr66;
       
  1473 		case 58: goto tr9;
       
  1474 		case 95: goto st32;
       
  1475 	}
       
  1476 	if ( (*p) < 48 ) {
       
  1477 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1478 			goto tr15;
       
  1479 	} else if ( (*p) > 57 ) {
       
  1480 		if ( (*p) > 90 ) {
       
  1481 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1482 				goto st33;
       
  1483 		} else if ( (*p) >= 65 )
       
  1484 			goto st33;
       
  1485 	} else
       
  1486 		goto st70;
       
  1487 	goto tr3;
       
  1488 st70:
       
  1489 	if ( ++p == pe )
       
  1490 		goto _test_eof70;
       
  1491 case 70:
       
  1492 	switch( (*p) ) {
       
  1493 		case 32: goto tr15;
       
  1494 		case 45: goto st32;
       
  1495 		case 46: goto st34;
       
  1496 		case 47: goto tr66;
       
  1497 		case 58: goto tr9;
       
  1498 		case 95: goto st32;
       
  1499 	}
       
  1500 	if ( (*p) < 48 ) {
       
  1501 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1502 			goto tr15;
       
  1503 	} else if ( (*p) > 57 ) {
       
  1504 		if ( (*p) > 90 ) {
       
  1505 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1506 				goto st33;
       
  1507 		} else if ( (*p) >= 65 )
       
  1508 			goto st33;
       
  1509 	} else
       
  1510 		goto st33;
       
  1511 	goto tr3;
       
  1512 st71:
       
  1513 	if ( ++p == pe )
       
  1514 		goto _test_eof71;
       
  1515 case 71:
       
  1516 	switch( (*p) ) {
       
  1517 		case 32: goto tr15;
       
  1518 		case 45: goto st32;
       
  1519 		case 46: goto st46;
       
  1520 		case 47: goto tr7;
       
  1521 		case 58: goto tr9;
       
  1522 		case 95: goto st32;
       
  1523 	}
       
  1524 	if ( (*p) < 48 ) {
       
  1525 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1526 			goto tr15;
       
  1527 	} else if ( (*p) > 57 ) {
       
  1528 		if ( (*p) > 90 ) {
       
  1529 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1530 				goto st33;
       
  1531 		} else if ( (*p) >= 65 )
       
  1532 			goto st33;
       
  1533 	} else
       
  1534 		goto st72;
       
  1535 	goto tr14;
       
  1536 st72:
       
  1537 	if ( ++p == pe )
       
  1538 		goto _test_eof72;
       
  1539 case 72:
       
  1540 	switch( (*p) ) {
       
  1541 		case 32: goto tr15;
       
  1542 		case 45: goto st32;
       
  1543 		case 46: goto st46;
       
  1544 		case 47: goto tr7;
       
  1545 		case 58: goto tr9;
       
  1546 		case 95: goto st32;
       
  1547 	}
       
  1548 	if ( (*p) < 48 ) {
       
  1549 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1550 			goto tr15;
       
  1551 	} else if ( (*p) > 57 ) {
       
  1552 		if ( (*p) > 90 ) {
       
  1553 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1554 				goto st33;
       
  1555 		} else if ( (*p) >= 65 )
       
  1556 			goto st33;
       
  1557 	} else
       
  1558 		goto st33;
       
  1559 	goto tr14;
       
  1560 st73:
       
  1561 	if ( ++p == pe )
       
  1562 		goto _test_eof73;
       
  1563 case 73:
       
  1564 	switch( (*p) ) {
       
  1565 		case 32: goto tr15;
       
  1566 		case 45: goto st32;
       
  1567 		case 46: goto st44;
       
  1568 		case 47: goto tr7;
       
  1569 		case 58: goto tr9;
       
  1570 		case 95: goto st32;
       
  1571 	}
       
  1572 	if ( (*p) < 48 ) {
       
  1573 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1574 			goto tr15;
       
  1575 	} else if ( (*p) > 57 ) {
       
  1576 		if ( (*p) > 90 ) {
       
  1577 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1578 				goto st33;
       
  1579 		} else if ( (*p) >= 65 )
       
  1580 			goto st33;
       
  1581 	} else
       
  1582 		goto st74;
       
  1583 	goto tr14;
       
  1584 st74:
       
  1585 	if ( ++p == pe )
       
  1586 		goto _test_eof74;
       
  1587 case 74:
       
  1588 	switch( (*p) ) {
       
  1589 		case 32: goto tr15;
       
  1590 		case 45: goto st32;
       
  1591 		case 46: goto st44;
       
  1592 		case 47: goto tr7;
       
  1593 		case 58: goto tr9;
       
  1594 		case 95: goto st32;
       
  1595 	}
       
  1596 	if ( (*p) < 48 ) {
       
  1597 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1598 			goto tr15;
       
  1599 	} else if ( (*p) > 57 ) {
       
  1600 		if ( (*p) > 90 ) {
       
  1601 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1602 				goto st33;
       
  1603 		} else if ( (*p) >= 65 )
       
  1604 			goto st33;
       
  1605 	} else
       
  1606 		goto st33;
       
  1607 	goto tr14;
       
  1608 st75:
       
  1609 	if ( ++p == pe )
       
  1610 		goto _test_eof75;
       
  1611 case 75:
       
  1612 	switch( (*p) ) {
       
  1613 		case 32: goto tr15;
       
  1614 		case 45: goto st32;
       
  1615 		case 46: goto st42;
       
  1616 		case 47: goto tr7;
       
  1617 		case 58: goto tr9;
       
  1618 		case 95: goto st32;
       
  1619 	}
       
  1620 	if ( (*p) < 48 ) {
       
  1621 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1622 			goto tr15;
       
  1623 	} else if ( (*p) > 57 ) {
       
  1624 		if ( (*p) > 90 ) {
       
  1625 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1626 				goto st33;
       
  1627 		} else if ( (*p) >= 65 )
       
  1628 			goto st33;
       
  1629 	} else
       
  1630 		goto st76;
       
  1631 	goto tr14;
       
  1632 st76:
       
  1633 	if ( ++p == pe )
       
  1634 		goto _test_eof76;
       
  1635 case 76:
       
  1636 	switch( (*p) ) {
       
  1637 		case 32: goto tr15;
       
  1638 		case 45: goto st32;
       
  1639 		case 46: goto st42;
       
  1640 		case 47: goto tr7;
       
  1641 		case 58: goto tr9;
       
  1642 		case 95: goto st32;
       
  1643 	}
       
  1644 	if ( (*p) < 48 ) {
       
  1645 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1646 			goto tr15;
       
  1647 	} else if ( (*p) > 57 ) {
       
  1648 		if ( (*p) > 90 ) {
       
  1649 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1650 				goto st33;
       
  1651 		} else if ( (*p) >= 65 )
       
  1652 			goto st33;
       
  1653 	} else
       
  1654 		goto st33;
       
  1655 	goto tr14;
       
  1656 tr2:
       
  1657 #line 44 "parser.rl"
       
  1658 	{ p_request->tokens.scheme_start  = p; }
       
  1659 #line 48 "parser.rl"
       
  1660 	{ p_request->tokens.host_start  = p; }
       
  1661 	goto st77;
       
  1662 tr13:
       
  1663 #line 39 "parser.rl"
       
  1664 	{
       
  1665 		debug( 1, LOC, "Channel ID found in redirector input.  Set 'url_rewrite_concurrency' to '0' in squid.\n" );
       
  1666 		{p++; cs = 77; goto _out;}
       
  1667 	}
       
  1668 #line 44 "parser.rl"
       
  1669 	{ p_request->tokens.scheme_start  = p; }
       
  1670 #line 48 "parser.rl"
       
  1671 	{ p_request->tokens.host_start  = p; }
       
  1672 	goto st77;
       
  1673 st77:
       
  1674 	if ( ++p == pe )
       
  1675 		goto _test_eof77;
       
  1676 case 77:
       
  1677 #line 1678 "parser.c"
       
  1678 	switch( (*p) ) {
       
  1679 		case 32: goto tr15;
       
  1680 		case 45: goto st32;
       
  1681 		case 46: goto st34;
       
  1682 		case 47: goto tr7;
       
  1683 		case 58: goto tr9;
       
  1684 		case 95: goto st32;
       
  1685 	}
       
  1686 	if ( (*p) < 48 ) {
       
  1687 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1688 			goto tr15;
       
  1689 	} else if ( (*p) > 57 ) {
       
  1690 		if ( (*p) > 90 ) {
       
  1691 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1692 				goto st78;
       
  1693 		} else if ( (*p) >= 65 )
       
  1694 			goto st78;
       
  1695 	} else
       
  1696 		goto st33;
       
  1697 	goto tr92;
       
  1698 st78:
       
  1699 	if ( ++p == pe )
       
  1700 		goto _test_eof78;
       
  1701 case 78:
       
  1702 	switch( (*p) ) {
       
  1703 		case 32: goto tr15;
       
  1704 		case 45: goto st32;
       
  1705 		case 46: goto st34;
       
  1706 		case 47: goto tr7;
       
  1707 		case 58: goto tr9;
       
  1708 		case 95: goto st32;
       
  1709 	}
       
  1710 	if ( (*p) < 48 ) {
       
  1711 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1712 			goto tr15;
       
  1713 	} else if ( (*p) > 57 ) {
       
  1714 		if ( (*p) > 90 ) {
       
  1715 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1716 				goto st79;
       
  1717 		} else if ( (*p) >= 65 )
       
  1718 			goto st79;
       
  1719 	} else
       
  1720 		goto st33;
       
  1721 	goto tr92;
       
  1722 st79:
       
  1723 	if ( ++p == pe )
       
  1724 		goto _test_eof79;
       
  1725 case 79:
       
  1726 	switch( (*p) ) {
       
  1727 		case 32: goto tr15;
       
  1728 		case 45: goto st32;
       
  1729 		case 46: goto st34;
       
  1730 		case 47: goto tr7;
       
  1731 		case 58: goto tr95;
       
  1732 		case 95: goto st32;
       
  1733 	}
       
  1734 	if ( (*p) < 48 ) {
       
  1735 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1736 			goto tr15;
       
  1737 	} else if ( (*p) > 57 ) {
       
  1738 		if ( (*p) > 90 ) {
       
  1739 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1740 				goto st83;
       
  1741 		} else if ( (*p) >= 65 )
       
  1742 			goto st83;
       
  1743 	} else
       
  1744 		goto st33;
       
  1745 	goto tr92;
       
  1746 tr95:
       
  1747 #line 49 "parser.rl"
       
  1748 	{ p_request->tokens.host_length = p - ( *pe + p_request->tokens.host_start ); }
       
  1749 #line 52 "parser.rl"
       
  1750 	{ p_request->tokens.port_start  = p; }
       
  1751 	goto st80;
       
  1752 st80:
       
  1753 	if ( ++p == pe )
       
  1754 		goto _test_eof80;
       
  1755 case 80:
       
  1756 #line 1757 "parser.c"
       
  1757 	if ( (*p) == 47 )
       
  1758 		goto st81;
       
  1759 	if ( 48 <= (*p) && (*p) <= 57 )
       
  1760 		goto st37;
       
  1761 	goto tr92;
       
  1762 st81:
       
  1763 	if ( ++p == pe )
       
  1764 		goto _test_eof81;
       
  1765 case 81:
       
  1766 	if ( (*p) == 47 )
       
  1767 		goto st82;
       
  1768 	goto tr92;
       
  1769 st82:
       
  1770 	if ( ++p == pe )
       
  1771 		goto _test_eof82;
       
  1772 case 82:
       
  1773 	if ( (*p) < 65 ) {
       
  1774 		if ( 48 <= (*p) && (*p) <= 57 )
       
  1775 			goto tr99;
       
  1776 	} else if ( (*p) > 90 ) {
       
  1777 		if ( 97 <= (*p) && (*p) <= 122 )
       
  1778 			goto tr99;
       
  1779 	} else
       
  1780 		goto tr99;
       
  1781 	goto tr49;
       
  1782 st83:
       
  1783 	if ( ++p == pe )
       
  1784 		goto _test_eof83;
       
  1785 case 83:
       
  1786 	switch( (*p) ) {
       
  1787 		case 32: goto tr15;
       
  1788 		case 45: goto st32;
       
  1789 		case 46: goto st34;
       
  1790 		case 47: goto tr7;
       
  1791 		case 58: goto tr95;
       
  1792 		case 95: goto st32;
       
  1793 	}
       
  1794 	if ( (*p) < 48 ) {
       
  1795 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1796 			goto tr15;
       
  1797 	} else if ( (*p) > 57 ) {
       
  1798 		if ( (*p) > 90 ) {
       
  1799 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1800 				goto st84;
       
  1801 		} else if ( (*p) >= 65 )
       
  1802 			goto st84;
       
  1803 	} else
       
  1804 		goto st33;
       
  1805 	goto tr92;
       
  1806 st84:
       
  1807 	if ( ++p == pe )
       
  1808 		goto _test_eof84;
       
  1809 case 84:
       
  1810 	switch( (*p) ) {
       
  1811 		case 32: goto tr15;
       
  1812 		case 45: goto st32;
       
  1813 		case 46: goto st34;
       
  1814 		case 47: goto tr7;
       
  1815 		case 58: goto tr95;
       
  1816 		case 95: goto st32;
       
  1817 	}
       
  1818 	if ( (*p) < 48 ) {
       
  1819 		if ( 9 <= (*p) && (*p) <= 13 )
       
  1820 			goto tr15;
       
  1821 	} else if ( (*p) > 57 ) {
       
  1822 		if ( (*p) > 90 ) {
       
  1823 			if ( 97 <= (*p) && (*p) <= 122 )
       
  1824 				goto st33;
       
  1825 		} else if ( (*p) >= 65 )
       
  1826 			goto st33;
       
  1827 	} else
       
  1828 		goto st33;
       
  1829 	goto tr92;
   298 	}
  1830 	}
   299 	_test_eof2: cs = 2; goto _test_eof; 
  1831 	_test_eof2: cs = 2; goto _test_eof; 
   300 	_test_eof3: cs = 3; goto _test_eof; 
  1832 	_test_eof3: cs = 3; goto _test_eof; 
   301 	_test_eof4: cs = 4; goto _test_eof; 
  1833 	_test_eof4: cs = 4; goto _test_eof; 
   302 	_test_eof5: cs = 5; goto _test_eof; 
  1834 	_test_eof5: cs = 5; goto _test_eof; 
   303 	_test_eof6: cs = 6; goto _test_eof; 
  1835 	_test_eof6: cs = 6; goto _test_eof; 
   304 	_test_eof7: cs = 7; goto _test_eof; 
  1836 	_test_eof7: cs = 7; goto _test_eof; 
   305 	_test_eof13: cs = 13; goto _test_eof; 
       
   306 	_test_eof8: cs = 8; goto _test_eof; 
  1837 	_test_eof8: cs = 8; goto _test_eof; 
   307 	_test_eof9: cs = 9; goto _test_eof; 
  1838 	_test_eof9: cs = 9; goto _test_eof; 
   308 	_test_eof10: cs = 10; goto _test_eof; 
  1839 	_test_eof10: cs = 10; goto _test_eof; 
   309 	_test_eof14: cs = 14; goto _test_eof; 
       
   310 	_test_eof11: cs = 11; goto _test_eof; 
  1840 	_test_eof11: cs = 11; goto _test_eof; 
   311 	_test_eof12: cs = 12; goto _test_eof; 
  1841 	_test_eof12: cs = 12; goto _test_eof; 
       
  1842 	_test_eof13: cs = 13; goto _test_eof; 
       
  1843 	_test_eof14: cs = 14; goto _test_eof; 
       
  1844 	_test_eof15: cs = 15; goto _test_eof; 
       
  1845 	_test_eof16: cs = 16; goto _test_eof; 
       
  1846 	_test_eof17: cs = 17; goto _test_eof; 
       
  1847 	_test_eof18: cs = 18; goto _test_eof; 
       
  1848 	_test_eof19: cs = 19; goto _test_eof; 
       
  1849 	_test_eof20: cs = 20; goto _test_eof; 
       
  1850 	_test_eof85: cs = 85; goto _test_eof; 
       
  1851 	_test_eof86: cs = 86; goto _test_eof; 
       
  1852 	_test_eof21: cs = 21; goto _test_eof; 
       
  1853 	_test_eof22: cs = 22; goto _test_eof; 
       
  1854 	_test_eof23: cs = 23; goto _test_eof; 
       
  1855 	_test_eof24: cs = 24; goto _test_eof; 
       
  1856 	_test_eof25: cs = 25; goto _test_eof; 
       
  1857 	_test_eof26: cs = 26; goto _test_eof; 
       
  1858 	_test_eof27: cs = 27; goto _test_eof; 
       
  1859 	_test_eof28: cs = 28; goto _test_eof; 
       
  1860 	_test_eof29: cs = 29; goto _test_eof; 
       
  1861 	_test_eof30: cs = 30; goto _test_eof; 
       
  1862 	_test_eof31: cs = 31; goto _test_eof; 
       
  1863 	_test_eof32: cs = 32; goto _test_eof; 
       
  1864 	_test_eof33: cs = 33; goto _test_eof; 
       
  1865 	_test_eof34: cs = 34; goto _test_eof; 
       
  1866 	_test_eof35: cs = 35; goto _test_eof; 
       
  1867 	_test_eof36: cs = 36; goto _test_eof; 
       
  1868 	_test_eof37: cs = 37; goto _test_eof; 
       
  1869 	_test_eof38: cs = 38; goto _test_eof; 
       
  1870 	_test_eof39: cs = 39; goto _test_eof; 
       
  1871 	_test_eof40: cs = 40; goto _test_eof; 
       
  1872 	_test_eof41: cs = 41; goto _test_eof; 
       
  1873 	_test_eof42: cs = 42; goto _test_eof; 
       
  1874 	_test_eof43: cs = 43; goto _test_eof; 
       
  1875 	_test_eof44: cs = 44; goto _test_eof; 
       
  1876 	_test_eof45: cs = 45; goto _test_eof; 
       
  1877 	_test_eof46: cs = 46; goto _test_eof; 
       
  1878 	_test_eof47: cs = 47; goto _test_eof; 
       
  1879 	_test_eof48: cs = 48; goto _test_eof; 
       
  1880 	_test_eof49: cs = 49; goto _test_eof; 
       
  1881 	_test_eof50: cs = 50; goto _test_eof; 
       
  1882 	_test_eof51: cs = 51; goto _test_eof; 
       
  1883 	_test_eof52: cs = 52; goto _test_eof; 
       
  1884 	_test_eof53: cs = 53; goto _test_eof; 
       
  1885 	_test_eof54: cs = 54; goto _test_eof; 
       
  1886 	_test_eof55: cs = 55; goto _test_eof; 
       
  1887 	_test_eof56: cs = 56; goto _test_eof; 
       
  1888 	_test_eof57: cs = 57; goto _test_eof; 
       
  1889 	_test_eof58: cs = 58; goto _test_eof; 
       
  1890 	_test_eof59: cs = 59; goto _test_eof; 
       
  1891 	_test_eof60: cs = 60; goto _test_eof; 
       
  1892 	_test_eof61: cs = 61; goto _test_eof; 
       
  1893 	_test_eof62: cs = 62; goto _test_eof; 
       
  1894 	_test_eof63: cs = 63; goto _test_eof; 
       
  1895 	_test_eof64: cs = 64; goto _test_eof; 
       
  1896 	_test_eof65: cs = 65; goto _test_eof; 
       
  1897 	_test_eof66: cs = 66; goto _test_eof; 
       
  1898 	_test_eof67: cs = 67; goto _test_eof; 
       
  1899 	_test_eof68: cs = 68; goto _test_eof; 
       
  1900 	_test_eof69: cs = 69; goto _test_eof; 
       
  1901 	_test_eof70: cs = 70; goto _test_eof; 
       
  1902 	_test_eof71: cs = 71; goto _test_eof; 
       
  1903 	_test_eof72: cs = 72; goto _test_eof; 
       
  1904 	_test_eof73: cs = 73; goto _test_eof; 
       
  1905 	_test_eof74: cs = 74; goto _test_eof; 
       
  1906 	_test_eof75: cs = 75; goto _test_eof; 
       
  1907 	_test_eof76: cs = 76; goto _test_eof; 
       
  1908 	_test_eof77: cs = 77; goto _test_eof; 
       
  1909 	_test_eof78: cs = 78; goto _test_eof; 
       
  1910 	_test_eof79: cs = 79; goto _test_eof; 
       
  1911 	_test_eof80: cs = 80; goto _test_eof; 
       
  1912 	_test_eof81: cs = 81; goto _test_eof; 
       
  1913 	_test_eof82: cs = 82; goto _test_eof; 
       
  1914 	_test_eof83: cs = 83; goto _test_eof; 
       
  1915 	_test_eof84: cs = 84; goto _test_eof; 
   312 
  1916 
   313 	_test_eof: {}
  1917 	_test_eof: {}
       
  1918 	if ( p == eof )
       
  1919 	{
       
  1920 	switch ( cs ) {
       
  1921 	case 2: 
       
  1922 	case 12: 
       
  1923 	case 13: 
       
  1924 	case 14: 
       
  1925 	case 15: 
       
  1926 	case 16: 
       
  1927 	case 19: 
       
  1928 	case 21: 
       
  1929 	case 22: 
       
  1930 	case 23: 
       
  1931 	case 24: 
       
  1932 	case 25: 
       
  1933 	case 33: 
       
  1934 	case 34: 
       
  1935 	case 35: 
       
  1936 	case 36: 
       
  1937 	case 37: 
       
  1938 	case 38: 
       
  1939 	case 39: 
       
  1940 	case 40: 
       
  1941 	case 41: 
       
  1942 	case 47: 
       
  1943 	case 48: 
       
  1944 	case 49: 
       
  1945 	case 57: 
       
  1946 	case 58: 
       
  1947 	case 59: 
       
  1948 	case 66: 
       
  1949 	case 67: 
       
  1950 	case 68: 
       
  1951 	case 69: 
       
  1952 	case 70: 
       
  1953 #line 37 "parser.rl"
       
  1954 	{ valid = 0; }
       
  1955 	break;
       
  1956 	case 77: 
       
  1957 	case 78: 
       
  1958 	case 79: 
       
  1959 	case 80: 
       
  1960 	case 81: 
       
  1961 	case 83: 
       
  1962 	case 84: 
       
  1963 #line 46 "parser.rl"
       
  1964 	{ debug( 3, LOC, "Unable to parse scheme.\n" ); }
       
  1965 #line 37 "parser.rl"
       
  1966 	{ valid = 0; }
       
  1967 	break;
       
  1968 	case 32: 
       
  1969 	case 82: 
       
  1970 #line 50 "parser.rl"
       
  1971 	{ debug( 3, LOC, "Unable to parse hostname.\n" ); }
       
  1972 #line 37 "parser.rl"
       
  1973 	{ valid = 0; }
       
  1974 	break;
       
  1975 	case 17: 
       
  1976 #line 60 "parser.rl"
       
  1977 	{ debug( 3, LOC, "Unable to parse method.\n" ); }
       
  1978 #line 37 "parser.rl"
       
  1979 	{ valid = 0; }
       
  1980 	break;
       
  1981 	case 4: 
       
  1982 	case 5: 
       
  1983 	case 6: 
       
  1984 	case 7: 
       
  1985 	case 8: 
       
  1986 	case 9: 
       
  1987 	case 10: 
       
  1988 	case 11: 
       
  1989 	case 26: 
       
  1990 	case 27: 
       
  1991 	case 28: 
       
  1992 	case 29: 
       
  1993 	case 30: 
       
  1994 	case 31: 
       
  1995 	case 42: 
       
  1996 	case 43: 
       
  1997 	case 44: 
       
  1998 	case 45: 
       
  1999 	case 46: 
       
  2000 	case 50: 
       
  2001 	case 51: 
       
  2002 	case 52: 
       
  2003 	case 53: 
       
  2004 	case 54: 
       
  2005 	case 55: 
       
  2006 	case 56: 
       
  2007 	case 60: 
       
  2008 	case 61: 
       
  2009 	case 62: 
       
  2010 	case 63: 
       
  2011 	case 64: 
       
  2012 	case 65: 
       
  2013 	case 71: 
       
  2014 	case 72: 
       
  2015 	case 73: 
       
  2016 	case 74: 
       
  2017 	case 75: 
       
  2018 	case 76: 
       
  2019 #line 64 "parser.rl"
       
  2020 	{ debug( 3, LOC, "Unable to parse the client IP address.\n" ); }
       
  2021 #line 37 "parser.rl"
       
  2022 	{ valid = 0; }
       
  2023 	break;
       
  2024 	case 1: 
       
  2025 #line 46 "parser.rl"
       
  2026 	{ debug( 3, LOC, "Unable to parse scheme.\n" ); }
       
  2027 #line 50 "parser.rl"
       
  2028 	{ debug( 3, LOC, "Unable to parse hostname.\n" ); }
       
  2029 #line 37 "parser.rl"
       
  2030 	{ valid = 0; }
       
  2031 	break;
       
  2032 	case 3: 
       
  2033 #line 46 "parser.rl"
       
  2034 	{ debug( 3, LOC, "Unable to parse scheme.\n" ); }
       
  2035 #line 50 "parser.rl"
       
  2036 	{ debug( 3, LOC, "Unable to parse hostname.\n" ); }
       
  2037 #line 64 "parser.rl"
       
  2038 	{ debug( 3, LOC, "Unable to parse the client IP address.\n" ); }
       
  2039 #line 37 "parser.rl"
       
  2040 	{ valid = 0; }
       
  2041 	break;
       
  2042 #line 2043 "parser.c"
       
  2043 	}
       
  2044 	}
       
  2045 
   314 	_out: {}
  2046 	_out: {}
   315 	}
  2047 	}
   316 
  2048 
   317 #line 144 "parser.rl"
  2049 #line 190 "parser.rl"
   318 
  2050 
   319 	/* reset the request */
  2051 	/* If we were given an invalid line, bail early */
   320 	/* c_request = reset_request; */
  2052 	if ( valid == 0 ) {
   321 	return( cp_request );
  2053 		free( p_request ), p_request = NULL;
       
  2054 		debug( 3, LOC, "Invalid line (%d), skipped\n", v.timer.lines + 1 );
       
  2055 		debug( 4, LOC, "%s", line );
       
  2056 		return( NULL );
       
  2057 	}
       
  2058 
       
  2059 	(void)populate_request( p_request );
       
  2060 	return( p_request );
   322 }
  2061 }
   323 
  2062 
       
  2063 
       
  2064 /*
       
  2065  * Initialize and return a pointer to a new request object.
       
  2066  *
       
  2067  */
       
  2068 request *
       
  2069 init_request( void )
       
  2070 {
       
  2071 	request *p_request = NULL;
       
  2072 	if ( (p_request = malloc( sizeof(request) )) == NULL ) {
       
  2073 		debug( 1, LOC, "Unable to allocate memory for request struct: %s\n", strerror(errno) );
       
  2074 		return( NULL );
       
  2075 	}
       
  2076 	p_request->scheme    = NULL;
       
  2077 	p_request->host      = NULL;
       
  2078 	p_request->port      = NULL;
       
  2079 	p_request->path      = NULL;
       
  2080 	p_request->user      = NULL;
       
  2081 	p_request->method    = NULL;
       
  2082 	p_request->client_ip = NULL;
       
  2083 
       
  2084 	p_request->tokens.scheme_start = NULL;
       
  2085 	p_request->tokens.host_start   = NULL;
       
  2086 	p_request->tokens.port_start   = NULL;
       
  2087 	p_request->tokens.path_start   = NULL;
       
  2088 	p_request->tokens.meth_start   = NULL;
       
  2089 	p_request->tokens.c_ip_start   = NULL;
       
  2090 
       
  2091 	p_request->tokens.scheme_length = 0;
       
  2092 	p_request->tokens.host_length   = 0;
       
  2093 	p_request->tokens.port_length   = 0;
       
  2094 	p_request->tokens.path_length   = 0;
       
  2095 	p_request->tokens.meth_length   = 0;
       
  2096 	p_request->tokens.c_ip_length   = 0;
       
  2097 
       
  2098 	return p_request;
       
  2099 }
       
  2100 
       
  2101 
       
  2102 /*
       
  2103  * Take the previously parsed token locations and copy them into the request struct.
       
  2104  *
       
  2105  */
       
  2106 void
       
  2107 populate_request( struct request *p_request )
       
  2108 {
       
  2109 	p_request->scheme =
       
  2110 		copy_string_token( p_request->tokens.scheme_start, p_request->tokens.scheme_length );
       
  2111 	p_request->host =
       
  2112 		copy_string_token( p_request->tokens.host_start, p_request->tokens.host_length );
       
  2113 	p_request->port =
       
  2114 		copy_string_token( p_request->tokens.port_start, p_request->tokens.port_length );
       
  2115 	p_request->path =
       
  2116 		copy_string_token( p_request->tokens.path_start, p_request->tokens.path_length );
       
  2117 	p_request->method =
       
  2118 		copy_string_token( p_request->tokens.meth_start, p_request->tokens.meth_length );
       
  2119 	p_request->client_ip =
       
  2120 		copy_ipv4_token( p_request->tokens.c_ip_start, p_request->tokens.c_ip_length );
       
  2121 
       
  2122 	return;
       
  2123 }
       
  2124 
       
  2125 
       
  2126 /*
       
  2127  * Release memory used by request struct.
       
  2128  *
       
  2129  */
       
  2130 void
       
  2131 cleanup_request( struct request *p_request )
       
  2132 {
       
  2133 	if ( p_request == NULL ) return;
       
  2134 
       
  2135 	free( p_request->scheme );
       
  2136 	free( p_request->host );
       
  2137 	free( p_request->port );
       
  2138 	free( p_request->path );
       
  2139 	free( p_request->method );
       
  2140 	free( p_request->client_ip );
       
  2141 
       
  2142 	free( p_request ), p_request = NULL;
       
  2143 
       
  2144 	return;
       
  2145 }
       
  2146