Lines Matching +full:an +full:- +full:1585
18 /* First, we deal with platform-specific or compiler-specific issues. */
33 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
61 #define INT8_MIN (-128)
64 #define INT16_MIN (-32767-1)
67 #define INT32_MIN (-2147483647-1)
107 /* Returned upon end-of-file. */
110 /* Promotes a possibly negative, possibly signed char to an
111 * integer in range [0..255] for use as an array index.
116 * but we do it the disgusting crufty way forced on us by the ()-less
124 #define YY_START (((yy_start) - 1) / 2)
135 /* On IA-64, the buffer size is 16k, not 8k.
179 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
204 /* Whether we "own" the buffer - i.e., we know we created it,
210 /* Whether this is an "interactive" input source; if so, and
235 /* When an EOF's been seen but there's still some text to process
239 * possible backing-up.
253 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
265 * NULL or when we need an lvalue. For internal use only.
313 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
322 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
324 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
348 * corresponding action - sets up yytext.
352 (yytext_ptr) -= (yy_more_len); \
353 yyleng = (int) (yy_cp - (yytext_ptr)); \
2265 87, 87, 1596, 1593, 1571, 1580, 1573, 1574, 1575, 1585,
2268 1593, 1597, 87, 1605, 87, 87, 1585, 87, 4117, 87,
3650 1582, 1573, 1583, 1574, 1572, 0, 1584, 1585, 1589, 1575,
3651 1590, 1576, 0, 1580, 1575, 1580, 1585, 1586, 1579, 1579,
3654 1592, 1588, 1586, 1584, 1585, 1589, 1590, 1590, 1591, 1587,
4415 * configlexer.lex - lexical analyzer for unbound config file
4417 * Copyright (c) 2001-2006, NLnet Labs. All rights reserved
4423 /* because flex keeps having sign-unsigned compare problems that are unfixed*/
4425 #pragma GCC diagnostic ignored "-Wsign-compare"
4495 if(cfg_parser->chroot && strncmp(filename, cfg_parser->chroot,
4496 strlen(cfg_parser->chroot)) == 0) {
4497 filename += strlen(cfg_parser->chroot);
4515 s->filename = cfg_parser->filename;
4516 s->line = cfg_parser->line;
4517 s->buffer = YY_CURRENT_BUFFER;
4518 s->inc_toplevel = inc_toplevel;
4519 s->next = config_include_stack;
4521 cfg_parser->filename = nm;
4522 cfg_parser->line = 1;
4550 if(cfg_parser->chroot && strncmp(filename, cfg_parser->chroot,
4551 strlen(cfg_parser->chroot)) == 0) {
4552 filename += strlen(cfg_parser->chroot);
4564 for(i=(int)g.gl_pathc-1; i>=0; i--) {
4578 --inc_depth;
4580 free(cfg_parser->filename);
4581 cfg_parser->filename = s->filename;
4582 cfg_parser->line = s->line;
4584 yy_switch_to_buffer(s->buffer);
4585 config_include_stack = s->next;
4586 inc_toplevel = s->inc_toplevel;
4595 yy_current_buffer->yy_ch_buf[0] = ((at_bol)?'\n':' '); \
4622 /* Special case for "unistd.h", since it is non-ANSI. We include it way
4624 * The user has a chance to override it with an option.
4636 These are made visible to non-reentrant scanners for convenience. */
4700 /* On IA-64, the buffer size is 16k, not 8k */
4709 /* This used to be an fputs(), but since the string might contain NUL's,
4720 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
4751 /* No semi-colon after return; correct usage is to write "yyterminate();" -
4752 * we don't want an extra ';' after the "return" because that will cause
4759 /* Number of entries by which start-condition stack grows. */
4771 /* Default declaration of generated scanner - a define so the user can
4836 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
4841 (yy_more_len) = (int) ((yy_c_buf_p) - (yytext_ptr));
6830 { LEXOUT(("NL\n")); cfg_parser->line++; }
6842 if(--num_args == 0) { BEGIN(INITIAL); }
6856 cfg_parser->line++; BEGIN(INITIAL); }
6863 if(--num_args == 0) { BEGIN(INITIAL); }
6865 yytext[yyleng - 1] = '\0';
6882 if(--num_args == 0) { BEGIN(INITIAL); }
6896 cfg_parser->line++; BEGIN(INITIAL); }
6903 if(--num_args == 0) { BEGIN(INITIAL); }
6905 yytext[yyleng - 1] = '\0';
6935 { LEXOUT(("NL\n")); cfg_parser->line++;}
6968 cfg_parser->line++; BEGIN(inc_prev); }
6975 yytext[yyleng - 1] = '\0';
6996 /* include-toplevel: directive */
7020 { LEXOUT(("NL\n")); cfg_parser->line++; }
7055 cfg_parser->line++; BEGIN(inc_prev);
7063 yytext[yyleng - 1] = '\0';
7073 if(--num_args == 0) { BEGIN(INITIAL); }
7100 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
7106 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
7115 * back-up) that will match for the new input source.
7117 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
7118 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
7119 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
7126 * end-of-buffer state). Contrast this with the test
7129 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
7179 * YY_NULL, it'll still work - another
7208 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
7221 "fatal flex scanner internal error--no action found" );
7227 /* yy_get_next_buffer - try to read in a new buffer
7229 * Returns a code representing an action:
7230 * EOB_ACT_LAST_MATCH -
7231 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
7232 * EOB_ACT_END_OF_FILE - end of file
7236 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
7241 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
7243 "fatal flex scanner internal error--end of buffer missed" );
7245 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
7246 { /* Don't try to fill the buffer, so this is an EOF. */
7247 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
7267 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
7272 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
7273 /* don't do the read, it's not guaranteed to return an EOF,
7274 * just force an EOF
7276 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
7281 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
7284 { /* Not enough room in the buffer - grow it. */
7290 (int) ((yy_c_buf_p) - b->yy_ch_buf);
7292 if ( b->yy_is_our_buffer )
7294 int new_size = b->yy_buf_size * 2;
7297 b->yy_buf_size += b->yy_buf_size / 8;
7299 b->yy_buf_size *= 2;
7301 b->yy_ch_buf = (char *)
7303 yyrealloc( (void *) b->yy_ch_buf,
7304 (yy_size_t) (b->yy_buf_size + 2) );
7308 b->yy_ch_buf = NULL;
7310 if ( ! b->yy_ch_buf )
7312 "fatal error - scanner input buffer overflow" );
7314 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
7316 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
7317 number_to_move - 1;
7325 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
7328 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
7342 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
7350 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
7353 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
7354 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
7355 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
7357 /* "- 2" to take care of EOB's */
7358 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
7362 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
7363 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
7365 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
7370 /* yy_get_previous_state - get the state just before the EOB char was reached */
7399 /* yy_try_NUL_trans - try to make a transition on the NUL character
7449 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
7455 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
7497 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
7543 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
7544 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
7560 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
7561 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
7562 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
7566 /** Allocate and initialize an input buffer state.
7580 b->yy_buf_size = size;
7583 * we need to put in 2 end-of-buffer characters.
7585 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
7586 if ( ! b->yy_ch_buf )
7589 b->yy_is_our_buffer = 1;
7609 if ( b->yy_is_our_buffer )
7610 yyfree( (void *) b->yy_ch_buf );
7626 b->yy_input_file = file;
7627 b->yy_fill_buffer = 1;
7634 b->yy_bs_lineno = 1;
7635 b->yy_bs_column = 0;
7638 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
7652 b->yy_n_chars = 0;
7654 /* We always need two end-of-buffer characters. The first causes
7655 * a transition to the end-of-buffer state. The second causes
7658 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
7659 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
7661 b->yy_buf_pos = &b->yy_ch_buf[0];
7663 b->yy_at_bol = 1;
7664 b->yy_buffer_status = YY_BUFFER_NEW;
7688 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
7689 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
7714 --(yy_buffer_stack_top);
7732 * scanner will even need a stack. We use 2 instead of 1 to avoid an
7749 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
7768 /** Setup the input buffer state to scan directly from a user-specified character buffer.
7779 base[size-2] != YY_END_OF_BUFFER_CHAR ||
7780 base[size-1] != YY_END_OF_BUFFER_CHAR )
7788 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
7789 b->yy_buf_pos = b->yy_ch_buf = base;
7790 b->yy_is_our_buffer = 0;
7791 b->yy_input_file = NULL;
7792 b->yy_n_chars = b->yy_buf_size;
7793 b->yy_is_interactive = 0;
7794 b->yy_at_bol = 1;
7795 b->yy_fill_buffer = 0;
7796 b->yy_buffer_status = YY_BUFFER_NEW;
7805 * @param yystr a NUL-terminated string to scan
7849 b->yy_is_our_buffer = 1;
7963 /* Initialization is the same as for the non-reentrant scanner.
7989 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
8004 /* Reset the globals. This is important in a non-reentrant scanner so the next time
8049 * as though doing an assignment.