/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifdef YY_USE_PROTOS #define YY_PROTO(proto) proto #else #define YY_PROTO(proto) () #endif
/* Returned upon end-of-file. */ #define YY_NULL 0
/* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index. If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast.
*/ #define YY_SC_TO_UI(c) ((unsignedint)(unsignedchar)c)
/* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN.
*/ #define BEGIN yy_start = 1 + 2 *
/* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility.
*/ #define YY_START ((yy_start - 1) / 2) #define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */ #define YY_NEW_FILE yyrestart(yyin)
#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */ #define YY_BUF_SIZE 16384
/* The funky do-while in the following #define is used to turn the definition * int a single C statement (which needs a semi-colon terminator). This * avoids problems with code like: * * if ( condition_holds ) * yyless( 5 ); * else * do_something_else(); * * Prior to using the do-while the compiler would get upset at the * "else" because it interpreted the "if" statement as being all * done when it reached the ';' after the yyless() call.
*/
/* Return all but the first 'n' matched characters back to the input stream. */
#define yyless(n) \ do { \ /* Undo effects of setting up yytext. */ \
*yy_cp = yy_hold_char; \
YY_RESTORE_YY_MORE_OFFSET \
yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} while (0)
#define unput(c) yyunput(c, yytext_ptr)
/* The following is because we cannot portably get our hands on size_t * (without autoconf's help, which isn't available because we want * flex-generated scanners to compile on their own).
*/ typedefunsignedint yy_size_t;
struct yy_buffer_state {
FILE *yy_input_file;
char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */
/* Size of input buffer in bytes, not including room for EOB * characters.
*/
yy_size_t yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB * characters.
*/ int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it.
*/ int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline.
*/ int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not.
*/ int yy_at_bol;
/* Whether to try to fill the input buffer when we reach the * end of it.
*/ int yy_fill_buffer;
int yy_buffer_status; #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as YY_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via yyrestart()), so that the user can continue scanning by * just pointing yyin at a new input file.
*/ #define YY_BUFFER_EOF_PENDING 2
};
static YY_BUFFER_STATE yy_current_buffer = 0;
/* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state".
*/ #define YY_CURRENT_BUFFER yy_current_buffer
/* yy_hold_char holds the character lost when yytext is formed. */ staticchar yy_hold_char;
staticint yy_n_chars; /* number of characters read into yy_ch_buf */
int yyleng;
/* Points to current character in buffer. */ staticchar *yy_c_buf_p = (char *)0; staticint yy_init = 1; /* whether we need to initialize */ staticint yy_start = 0; /* start state number */
/* Flag which is used to allow yywrap()'s to do buffer switches * instead of setting up a fresh yyin. A bit of a hack ...
*/ staticint yy_did_buffer_switch_on_eof;
#ifdef YY_MALLOC_DECL
YY_MALLOC_DECL #else #if __STDC__ #ifndef __cplusplus #include <stdlib.h> #endif #else /* Just try to get by without declaring the routines. This will fail * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) * or sizeof(void*) != sizeof(int).
*/ #endif #endif
/* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #define YY_READ_BUF_SIZE 8192 #endif
/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite().
*/ #define ECHO (void)fwrite(yytext, yyleng, 1, yyout) #endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, * is returned in "result".
*/ #ifndef YY_INPUT #define YY_INPUT(buf, result, max_size) \ if (yy_current_buffer->yy_is_interactive) { \ int c = '*', n; \ for (n = 0; n < max_size && \
(c = getc(yyin)) != EOF && c != '\n'; \
++n) \
buf[n] = (char)c; \ if (c == '\n') \
buf[n++] = (char)c; \ if (c == EOF && ferror(yyin)) \
YY_FATAL_ERROR("input in flex scanner failed"); \
result = n; \
} elseif (((result = fread(buf, 1, max_size, yyin)) == 0) && \
ferror(yyin)) \
YY_FATAL_ERROR("input in flex scanner failed"); #endif
/* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements.
*/ #ifndef yyterminate #define yyterminate() return YY_NULL #endif
/* Number of entries by which start-condition stack grows. */ #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR 25 #endif
/* Default declaration of generated scanner - a define so the user can * easily add parameters.
*/ #ifndef YY_DECL #define YY_DECL int yylex YY_PROTO((void)) #endif
/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up.
*/ #ifndef YY_USER_ACTION #define YY_USER_ACTION #endif
/* Code executed at the end of each rule. */ #ifndef YY_BREAK #define YY_BREAK break; #endif
yy_find_action:
yy_act = yy_accept[yy_current_state]; if (yy_act == 0) { /* have to back up */
yy_cp = yy_last_accepting_cpos;
yy_current_state = yy_last_accepting_state;
yy_act = yy_accept[yy_current_state];
}
YY_DO_BEFORE_ACTION;
do_action: /* This label is used only to access EOF actions. */
switch (yy_act) { /* beginning of action switch */ case0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */
*yy_cp = yy_hold_char;
yy_cp = yy_last_accepting_cpos;
yy_current_state = yy_last_accepting_state; goto yy_find_action;
case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int)(yy_cp - yytext_ptr) - 1;
/* Undo the effects of YY_DO_BEFORE_ACTION. */
*yy_cp = yy_hold_char;
YY_RESTORE_YY_MORE_OFFSET
if (yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * yylex(). If so, then we have to assure * consistency between yy_current_buffer and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source.
*/
yy_n_chars = yy_current_buffer->yy_n_chars;
yy_current_buffer->yy_input_file = yyin;
yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
}
/* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input().
*/ if (yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars]) { /* This was really a NUL. */
yy_state_type yy_next_state;
/* 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).
*/
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;
default:
YY_FATAL_ERROR( "fatal flex scanner internal error--no action found");
} /* end of action switch */
} /* end of scanning one token */
} /* end of yylex */
/* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file
*/
if (yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1])
YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed");
if (yy_current_buffer->yy_fill_buffer == 0) { /* Don't try to fill the buffer, so this is an EOF. */ if (yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1) { /* We matched a single character, the EOB, so * treat this as a final EOF.
*/ return EOB_ACT_END_OF_FILE;
}
else { /* We matched some text prior to the EOB, first * process it.
*/ return EOB_ACT_LAST_MATCH;
}
}
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (int)(yy_c_buf_p - yytext_ptr) - 1;
for (i = 0; i < number_to_move; ++i)
*(dest++) = *(source++);
if (yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF
*/
yy_current_buffer->yy_n_chars = yy_n_chars = 0;
else { int num_to_read =
yy_current_buffer->yy_buf_size - number_to_move - 1;
while (num_to_read <= 0) { /* Not enough room in the buffer - grow it. */ #ifdef YY_USES_REJECT
YY_FATAL_ERROR( "input buffer overflow, can't enlarge buffer because scanner uses REJECT"); #else
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = yy_current_buffer;
int yy_c_buf_p_offset =
(int)(yy_c_buf_p - b->yy_ch_buf);
if (b->yy_is_our_buffer) { int new_size = b->yy_buf_size * 2;
/* undo effects of setting up yytext */
*yy_cp = yy_hold_char;
if (yy_cp < yy_current_buffer->yy_ch_buf + 2) { /* need to shift things up to make room */ /* +2 for EOB chars. */ registerint number_to_move = yy_n_chars + 2; registerchar *dest = &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2]; registerchar *source =
&yy_current_buffer->yy_ch_buf[number_to_move];
while (source > yy_current_buffer->yy_ch_buf)
*--dest = *--source;
if (*yy_c_buf_p == YY_END_OF_BUFFER_CHAR) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer.
*/ if (yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars]) /* This was really a NUL. */
*yy_c_buf_p = '\0';
else { /* need more input */ int offset = yy_c_buf_p - yytext_ptr;
++yy_c_buf_p;
switch (yy_get_next_buffer()) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE.
*/
/* Reset buffer status. */
yyrestart(yyin);
/* fall through */
case EOB_ACT_END_OF_FILE: { if (yywrap()) return EOF;
if (yy_current_buffer) { /* Flush out information for old buffer. */
*yy_c_buf_p = yy_hold_char;
yy_current_buffer->yy_buf_pos = yy_c_buf_p;
yy_current_buffer->yy_n_chars = yy_n_chars;
}
/* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it.
*/
yy_did_buffer_switch_on_eof = 1;
}
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE
yy_create_buffer(FILE *file, int size) #else
YY_BUFFER_STATE
yy_create_buffer(file, size)
FILE *file; int size; #endif
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE)yy_flex_alloc(sizeof(struct yy_buffer_state)); if (!b)
YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters.
*/
b->yy_ch_buf = (char *)yy_flex_alloc(b->yy_buf_size + 2); if (!b->yy_ch_buf)
YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
b->yy_is_our_buffer = 1;
yy_init_buffer(b, file);
return b;
}
#ifdef YY_USE_PROTOS void
yy_delete_buffer(YY_BUFFER_STATE b) #else void yy_delete_buffer(b)
YY_BUFFER_STATE b; #endif
{ if (!b) return;
if (b == yy_current_buffer)
yy_current_buffer = (YY_BUFFER_STATE)0;
if (b->yy_is_our_buffer)
yy_flex_free((void *)b->yy_ch_buf);
/* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
#ifndef YY_NO_SCAN_BYTES #ifdef YY_USE_PROTOS
YY_BUFFER_STATE
yy_scan_bytes(yyconst char *bytes, int len) #else
YY_BUFFER_STATE
yy_scan_bytes(bytes, len)
yyconst char *bytes; int len; #endif
{
YY_BUFFER_STATE b; char *buf;
yy_size_t n; int i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = len + 2;
buf = (char *)yy_flex_alloc(n); if (!buf)
YY_FATAL_ERROR("out of dynamic memory in yy_scan_bytes()");
for (i = 0; i < len; ++i)
buf[i] = bytes[i];
buf[len] = buf[len + 1] = YY_END_OF_BUFFER_CHAR;
b = yy_scan_buffer(buf, n); if (!b)
YY_FATAL_ERROR("bad buffer in yy_scan_bytes()");
/* It's okay to grow etc. this buffer, and we should throw it * away when we're done.
*/
b->yy_is_our_buffer = 1;
#ifdef YY_USE_PROTOS staticvoid *
yy_flex_realloc(void *ptr, yy_size_t size) #else staticvoid *yy_flex_realloc(ptr, size) void *ptr;
yy_size_t size; #endif
{ /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment.
*/ return (void *)realloc((char *)ptr, size);
}
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.46Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-06-06)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
