lex.c

samba最新软件

#line 120 "lex.l"
{ return kw_OPTIONAL; }
	YY_BREAK
case 53:
YY_RULE_SETUP
#line 121 "lex.l"
{ return kw_ObjectDescriptor; }
	YY_BREAK
case 54:
YY_RULE_SETUP
#line 122 "lex.l"
{ return kw_PATTERN; }
	YY_BREAK
case 55:
YY_RULE_SETUP
#line 123 "lex.l"
{ return kw_PDV; }
	YY_BREAK
case 56:
YY_RULE_SETUP
#line 124 "lex.l"
{ return kw_PLUS_INFINITY; }
	YY_BREAK
case 57:
YY_RULE_SETUP
#line 125 "lex.l"
{ return kw_PRESENT; }
	YY_BREAK
case 58:
YY_RULE_SETUP
#line 126 "lex.l"
{ return kw_PRIVATE; }
	YY_BREAK
case 59:
YY_RULE_SETUP
#line 127 "lex.l"
{ return kw_PrintableString; }
	YY_BREAK
case 60:
YY_RULE_SETUP
#line 128 "lex.l"
{ return kw_REAL; }
	YY_BREAK
case 61:
YY_RULE_SETUP
#line 129 "lex.l"
{ return kw_RELATIVE_OID; }
	YY_BREAK
case 62:
YY_RULE_SETUP
#line 130 "lex.l"
{ return kw_SEQUENCE; }
	YY_BREAK
case 63:
YY_RULE_SETUP
#line 131 "lex.l"
{ return kw_SET; }
	YY_BREAK
case 64:
YY_RULE_SETUP
#line 132 "lex.l"
{ return kw_SIZE; }
	YY_BREAK
case 65:
YY_RULE_SETUP
#line 133 "lex.l"
{ return kw_STRING; }
	YY_BREAK
case 66:
YY_RULE_SETUP
#line 134 "lex.l"
{ return kw_SYNTAX; }
	YY_BREAK
case 67:
YY_RULE_SETUP
#line 135 "lex.l"
{ return kw_T61String; }
	YY_BREAK
case 68:
YY_RULE_SETUP
#line 136 "lex.l"
{ return kw_TAGS; }
	YY_BREAK
case 69:
YY_RULE_SETUP
#line 137 "lex.l"
{ return kw_TRUE; }
	YY_BREAK
case 70:
YY_RULE_SETUP
#line 138 "lex.l"
{ return kw_TYPE_IDENTIFIER; }
	YY_BREAK
case 71:
YY_RULE_SETUP
#line 139 "lex.l"
{ return kw_TeletexString; }
	YY_BREAK
case 72:
YY_RULE_SETUP
#line 140 "lex.l"
{ return kw_UNION; }
	YY_BREAK
case 73:
YY_RULE_SETUP
#line 141 "lex.l"
{ return kw_UNIQUE; }
	YY_BREAK
case 74:
YY_RULE_SETUP
#line 142 "lex.l"
{ return kw_UNIVERSAL; }
	YY_BREAK
case 75:
YY_RULE_SETUP
#line 143 "lex.l"
{ return kw_UTCTime; }
	YY_BREAK
case 76:
YY_RULE_SETUP
#line 144 "lex.l"
{ return kw_UTF8String; }
	YY_BREAK
case 77:
YY_RULE_SETUP
#line 145 "lex.l"
{ return kw_UniversalString; }
	YY_BREAK
case 78:
YY_RULE_SETUP
#line 146 "lex.l"
{ return kw_VideotexString; }
	YY_BREAK
case 79:
YY_RULE_SETUP
#line 147 "lex.l"
{ return kw_VisibleString; }
	YY_BREAK
case 80:
YY_RULE_SETUP
#line 148 "lex.l"
{ return kw_WITH; }
	YY_BREAK
case 81:
YY_RULE_SETUP
#line 149 "lex.l"
{ return *yytext; }
	YY_BREAK
case 82:
YY_RULE_SETUP
#line 150 "lex.l"
{ return *yytext; }
	YY_BREAK
case 83:
YY_RULE_SETUP
#line 151 "lex.l"
{ return *yytext; }
	YY_BREAK
case 84:
YY_RULE_SETUP
#line 152 "lex.l"
{ return EEQUAL; }
	YY_BREAK
case 85:
YY_RULE_SETUP
#line 153 "lex.l"
{ 
			    int c, start_lineno = lineno;
			    int f = 0;
			    while((c = input()) != EOF) {
				if(f && c == '-')
				    break;
				if(c == '-') {
				    f = 1;
				    continue;
				}
				if(c == '\n') {
				    lineno++;
				    break;
				}
				f = 0;
			    }
			    if(c == EOF)
				unterminated("comment", start_lineno);
			}
	YY_BREAK
case 86:
YY_RULE_SETUP
#line 172 "lex.l"
{ 
			    int c, start_lineno = lineno;
			    int level = 1;
			    int seen_star = 0;
			    int seen_slash = 0;
			    while((c = input()) != EOF) {
				if(c == '/') {
				    if(seen_star) {
					if(--level == 0)
					    break;
					seen_star = 0;
					continue;
				    }
				    seen_slash = 1;
				    continue;
				}
				if(seen_star && c == '/') {
				    if(--level == 0)
					break;
				    seen_star = 0;
				    continue;
				}
				if(c == '*') {
				    if(seen_slash) {
					level++;
					seen_star = seen_slash = 0;
					continue;
				    } 
				    seen_star = 1;
				    continue;
				}
				seen_star = seen_slash = 0;
				if(c == '\n') {
				    lineno++;
				    continue;
				}
			    }
			    if(c == EOF)
				unterminated("comment", start_lineno);
			}
	YY_BREAK
case 87:
YY_RULE_SETUP
#line 212 "lex.l"
{ 
			    int start_lineno = lineno;
			    int c;
			    char buf[1024];
			    char *p = buf;
			    int f = 0;
			    int skip_ws = 0;
			    
			    while((c = input()) != EOF) {
				if(isspace(c) && skip_ws) {
				    if(c == '\n')
					lineno++;
				    continue;
				}
				skip_ws = 0;
				
				if(c == '"') {
				    if(f) {
					*p++ = '"';
					f = 0;
				    } else
					f = 1;
				    continue;
				}
				if(f == 1) {
				    unput(c);
				    break;
				}
				if(c == '\n') {
				    lineno++;
				    while(p > buf && isspace((unsigned char)p[-1]))
					p--;
				    skip_ws = 1;
				    continue;
				}
				*p++ = c;
			    }
			    if(c == EOF)
				unterminated("string", start_lineno);
			    *p++ = '\0';
			    fprintf(stderr, "string -- %s\n", buf);
			    yylval.name = estrdup(buf);
			    return STRING; 
			}
	YY_BREAK
case 88:
YY_RULE_SETUP
#line 257 "lex.l"
{ char *e, *y = yytext;
			  yylval.constant = strtol((const char *)yytext,
						   &e, 0);
			  if(e == y) 
			    error_message("malformed constant (%s)", yytext); 
			  else
			    return NUMBER;
			}
	YY_BREAK
case 89:
YY_RULE_SETUP
#line 265 "lex.l"
{
			  yylval.name =  estrdup ((const char *)yytext);
			  return IDENTIFIER;
			}
	YY_BREAK
case 90:
YY_RULE_SETUP
#line 269 "lex.l"
;
	YY_BREAK
case 91:
/* rule 91 can match eol */
YY_RULE_SETUP
#line 270 "lex.l"
{ ++lineno; }
	YY_BREAK
case 92:
YY_RULE_SETUP
#line 271 "lex.l"
{ return ELLIPSIS; }
	YY_BREAK
case 93:
YY_RULE_SETUP
#line 272 "lex.l"
{ return RANGE; }
	YY_BREAK
case 94:
YY_RULE_SETUP
#line 273 "lex.l"
{ error_message("Ignoring char(%c)\n", *yytext); }
	YY_BREAK
case 95:
YY_RULE_SETUP
#line 274 "lex.l"
ECHO;
	YY_BREAK
#line 1708 "lex.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 */