ReactOS  0.4.14-dev-114-gc8cbd56
parser.yy.c File Reference
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "config.h"
#include "wine/port.h"
#include <ctype.h>
#include <assert.h>
#include <limits.h>
#include "widl.h"
#include "utils.h"
#include "parser.h"
#include "wine/wpp.h"
#include "parser.tab.h"
Include dependency graph for parser.yy.c:

Go to the source code of this file.

Classes

struct  yy_buffer_state
 
struct  yy_trans_info
 
struct  keyword
 
struct  imports
 

Macros

#define YY_INT_ALIGNED   short int
 
#define yy_create_buffer   parser__create_buffer
 
#define yy_delete_buffer   parser__delete_buffer
 
#define yy_flex_debug   parser__flex_debug
 
#define yy_init_buffer   parser__init_buffer
 
#define yy_flush_buffer   parser__flush_buffer
 
#define yy_load_buffer_state   parser__load_buffer_state
 
#define yy_switch_to_buffer   parser__switch_to_buffer
 
#define yyin   parser_in
 
#define yyleng   parser_leng
 
#define yylex   parser_lex
 
#define yylineno   parser_lineno
 
#define yyout   parser_out
 
#define yyrestart   parser_restart
 
#define yytext   parser_text
 
#define yywrap   parser_wrap
 
#define yyalloc   parser_alloc
 
#define yyrealloc   parser_realloc
 
#define yyfree   parser_free
 
#define FLEX_SCANNER
 
#define YY_FLEX_MAJOR_VERSION   2
 
#define YY_FLEX_MINOR_VERSION   5
 
#define YY_FLEX_SUBMINOR_VERSION   37
 
#define FLEX_BETA
 
#define FLEXINT_H
 
#define INT8_MIN   (-128)
 
#define INT16_MIN   (-32767-1)
 
#define INT32_MIN   (-2147483647-1)
 
#define INT8_MAX   (127)
 
#define INT16_MAX   (32767)
 
#define INT32_MAX   (2147483647)
 
#define UINT8_MAX   (255U)
 
#define UINT16_MAX   (65535U)
 
#define UINT32_MAX   (4294967295U)
 
#define yyconst
 
#define YY_NULL   0
 
#define YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
 
#define BEGIN   (yy_start) = 1 + 2 *
 
#define YY_START   (((yy_start) - 1) / 2)
 
#define YYSTATE   YY_START
 
#define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
 
#define YY_NEW_FILE   parser_restart(parser_in )
 
#define YY_END_OF_BUFFER_CHAR   0
 
#define YY_BUF_SIZE   16384
 
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 
#define YY_TYPEDEF_YY_BUFFER_STATE
 
#define YY_TYPEDEF_YY_SIZE_T
 
#define EOB_ACT_CONTINUE_SCAN   0
 
#define EOB_ACT_END_OF_FILE   1
 
#define EOB_ACT_LAST_MATCH   2
 
#define YY_LESS_LINENO(n)
 
#define yyless(n)
 
#define unput(c)   yyunput( c, (yytext_ptr) )
 
#define YY_STRUCT_YY_BUFFER_STATE
 
#define YY_BUFFER_NEW   0
 
#define YY_BUFFER_NORMAL   1
 
#define YY_BUFFER_EOF_PENDING   2
 
#define YY_CURRENT_BUFFER
 
#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
 
#define YY_FLUSH_BUFFER   parser__flush_buffer(YY_CURRENT_BUFFER )
 
#define yy_new_buffer   parser__create_buffer
 
#define yy_set_interactive(is_interactive)
 
#define yy_set_bol(at_bol)
 
#define YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
#define yytext_ptr   parser_text
 
#define YY_DO_BEFORE_ACTION
 
#define YY_NUM_RULES   41
 
#define YY_END_OF_BUFFER   42
 
#define REJECT   reject_used_but_not_detected
 
#define yymore()   yymore_used_but_not_detected
 
#define YY_MORE_ADJ   0
 
#define YY_RESTORE_YY_MORE_OFFSET
 
#define YY_NO_INPUT   1
 
#define YY_NO_UNISTD_H
 
#define MAX_IMPORT_DEPTH   20
 
#define INITIAL   0
 
#define QUOTE   1
 
#define WSTRQUOTE   2
 
#define ATTR   3
 
#define PP_LINE   4
 
#define PP_PRAGMA   5
 
#define SQUOTE   6
 
#define YY_EXTRA_TYPE   void *
 
#define YY_READ_BUF_SIZE   8192
 
#define ECHO   do { if (fwrite( parser_text, parser_leng, 1, parser_out )) {} } while (0)
 
#define YY_INPUT(buf, result, max_size)
 
#define yyterminate()   return YY_NULL
 
#define YY_START_STACK_INCR   25
 
#define YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
 
#define YY_DECL_IS_OURS   1
 
#define YY_DECL   int parser_lex (void)
 
#define YY_USER_ACTION
 
#define YY_BREAK   break;
 
#define YY_RULE_SETUP
 
#define YY_EXIT_FAILURE   2
 
#define yyless(n)
 
#define YYTABLES_NAME   "yytables"
 
#define NKEYWORDS   (sizeof(keywords)/sizeof(keywords[0]))
 
#define KWP(p)   ((const struct keyword *)(p))
 

Typedefs

typedef signed char flex_int8_t
 
typedef short int flex_int16_t
 
typedef int flex_int32_t
 
typedef unsigned char flex_uint8_t
 
typedef unsigned short int flex_uint16_t
 
typedef unsigned int flex_uint32_t
 
typedef struct yy_buffer_stateYY_BUFFER_STATE
 
typedef size_t yy_size_t
 
typedef unsigned char YY_CHAR
 
typedef int yy_state_type
 

Functions

void parser_restart (FILE *input_file)
 
void parser__switch_to_buffer (YY_BUFFER_STATE new_buffer)
 
YY_BUFFER_STATE parser__create_buffer (FILE *file, int size)
 
void parser__delete_buffer (YY_BUFFER_STATE b)
 
void parser__flush_buffer (YY_BUFFER_STATE b)
 
void parser_push_buffer_state (YY_BUFFER_STATE new_buffer)
 
void parser_pop_buffer_state (void)
 
static void parser_ensure_buffer_stack (void)
 
static void parser__load_buffer_state (void)
 
static void parser__init_buffer (YY_BUFFER_STATE b, FILE *file)
 
YY_BUFFER_STATE parser__scan_buffer (char *base, yy_size_t size)
 
YY_BUFFER_STATE parser__scan_string (yyconst char *yy_str)
 
YY_BUFFER_STATE parser__scan_bytes (yyconst char *bytes, yy_size_t len)
 
voidparser_alloc (yy_size_t)
 
voidparser_realloc (void *, yy_size_t)
 
void parser_free (void *)
 
static yy_state_type yy_get_previous_state (void)
 
static yy_state_type yy_try_NUL_trans (yy_state_type current_state)
 
static int yy_get_next_buffer (void)
 
static void yy_fatal_error (yyconst char msg[])
 
static void addcchar (char c)
 
static charget_buffered_cstring (void)
 
static int kw_token (const char *kw)
 
static int attr_token (const char *kw)
 
static void switch_to_acf (void)
 
static unsigned int xstrtoul (const char *nptr, char **endptr, int base)
 
UUIDparse_uuid (const char *u)
 
static int yy_init_globals (void)
 
int parser_lex_destroy (void)
 
int parser_get_debug (void)
 
void parser_set_debug (int debug_flag)
 
YY_EXTRA_TYPE parser_get_extra (void)
 
void parser_set_extra (YY_EXTRA_TYPE user_defined)
 
FILEparser_get_in (void)
 
void parser_set_in (FILE *in_str)
 
FILEparser_get_out (void)
 
void parser_set_out (FILE *out_str)
 
yy_size_t parser_get_leng (void)
 
charparser_get_text (void)
 
int parser_get_lineno (void)
 
void parser_set_lineno (int line_number)
 
int parser_wrap (void)
 
static void yy_push_state (int new_state)
 
static void yy_pop_state (void)
 
int parser_lex (void)
 
 if (!(yy_init))
 
 while (1)
 
static void yy_fatal_error (yyconst char *msg)
 
static int kw_cmp_func (const void *s1, const void *s2)
 
void pop_import (void)
 
int do_import (char *fname)
 
void abort_import (void)
 
static void warning_disable (int warning)
 
static void warning_enable (int warning)
 
int do_warning (char *toggle, warning_list_t *wnum)
 
int is_warning_enabled (int warning)
 

Variables

yy_size_t parser_leng
 
FILEparser_in = (FILE *) 0
 
FILEparser_out = (FILE *) 0
 
static size_t yy_buffer_stack_top = 0
 
static size_t yy_buffer_stack_max = 0
 
static YY_BUFFER_STATEyy_buffer_stack = 0
 
static char yy_hold_char
 
static yy_size_t yy_n_chars
 
static charyy_c_buf_p = (char *) 0
 
static int yy_init = 0
 
static int yy_start = 0
 
static int yy_did_buffer_switch_on_eof
 
int parser_lineno = 1
 
charparser_text
 
static yyconst flex_int16_t yy_accept [210]
 
static yyconst flex_int32_t yy_ec [256]
 
static yyconst flex_int32_t yy_meta [51]
 
static yyconst flex_int16_t yy_base [251]
 
static yyconst flex_int16_t yy_def [251]
 
static yyconst flex_int16_t yy_nxt [728]
 
static yyconst flex_int16_t yy_chk [728]
 
static yy_state_type yy_last_accepting_state
 
static charyy_last_accepting_cpos
 
int parser__flex_debug = 0
 
static charcbuffer
 
static int cbufidx
 
static int cbufalloc = 0
 
static warning_list_tdisabled_warnings = NULL
 
struct {
   YY_BUFFER_STATE   state
 
   char *   input_name
 
   int   line_number
 
   char *   temp_name
 
import_stack [MAX_IMPORT_DEPTH]
 
int import_stack_ptr = 0
 
static int yy_start_stack_ptr = 0
 
static int yy_start_stack_depth = 0
 
static intyy_start_stack = NULL
 
 YY_DECL
 
register charyy_cp
 
register charyy_bp
 
register int yy_act
 
static const struct keyword keywords []
 
static const struct keyword attr_keywords []
 
struct importsfirst_import
 

Macro Definition Documentation

◆ ATTR

#define ATTR   3

Definition at line 823 of file parser.yy.c.

◆ BEGIN

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 145 of file parser.yy.c.

◆ ECHO

#define ECHO   do { if (fwrite( parser_text, parser_leng, 1, parser_out )) {} } while (0)

Definition at line 919 of file parser.yy.c.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 185 of file parser.yy.c.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 186 of file parser.yy.c.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 187 of file parser.yy.c.

◆ FLEX_BETA

#define FLEX_BETA

Definition at line 33 of file parser.yy.c.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 28 of file parser.yy.c.

◆ FLEXINT_H

#define FLEXINT_H

Definition at line 49 of file parser.yy.c.

◆ INITIAL

#define INITIAL   0

Definition at line 820 of file parser.yy.c.

◆ INT16_MAX

#define INT16_MAX   (32767)

Definition at line 91 of file parser.yy.c.

◆ INT16_MIN

#define INT16_MIN   (-32767-1)

Definition at line 82 of file parser.yy.c.

◆ INT32_MAX

#define INT32_MAX   (2147483647)

Definition at line 94 of file parser.yy.c.

◆ INT32_MIN

#define INT32_MIN   (-2147483647-1)

Definition at line 85 of file parser.yy.c.

◆ INT8_MAX

#define INT8_MAX   (127)

Definition at line 88 of file parser.yy.c.

◆ INT8_MIN

#define INT8_MIN   (-128)

Definition at line 79 of file parser.yy.c.

◆ KWP

#define KWP (   p)    ((const struct keyword *)(p))

Definition at line 2577 of file parser.yy.c.

◆ MAX_IMPORT_DEPTH

#define MAX_IMPORT_DEPTH   20

Definition at line 771 of file parser.yy.c.

◆ NKEYWORDS

#define NKEYWORDS   (sizeof(keywords)/sizeof(keywords[0]))

Definition at line 2453 of file parser.yy.c.

◆ PP_LINE

#define PP_LINE   4

Definition at line 824 of file parser.yy.c.

◆ PP_PRAGMA

#define PP_PRAGMA   5

Definition at line 825 of file parser.yy.c.

◆ QUOTE

#define QUOTE   1

Definition at line 821 of file parser.yy.c.

◆ REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 699 of file parser.yy.c.

◆ SQUOTE

#define SQUOTE   6

Definition at line 826 of file parser.yy.c.

◆ UINT16_MAX

#define UINT16_MAX   (65535U)

Definition at line 100 of file parser.yy.c.

◆ UINT32_MAX

#define UINT32_MAX   (4294967295U)

Definition at line 103 of file parser.yy.c.

◆ UINT8_MAX

#define UINT8_MAX   (255U)

Definition at line 97 of file parser.yy.c.

◆ unput

#define unput (   c)    yyunput( c, (yytext_ptr) )

Definition at line 205 of file parser.yy.c.

◆ WSTRQUOTE

#define WSTRQUOTE   2

Definition at line 822 of file parser.yy.c.

◆ YY_AT_BOL

#define YY_AT_BOL ( )    (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 351 of file parser.yy.c.

◆ YY_BREAK

#define YY_BREAK   break;

Definition at line 998 of file parser.yy.c.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 164 of file parser.yy.c.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 267 of file parser.yy.c.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 255 of file parser.yy.c.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 256 of file parser.yy.c.

◆ yy_create_buffer

#define yy_create_buffer   parser__create_buffer

Definition at line 9 of file parser.yy.c.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER
Value:
: NULL)
smooth NULL
Definition: ftsmooth.c:416
static YY_BUFFER_STATE * yy_buffer_stack
Definition: parser.yy.c:275
static size_t yy_buffer_stack_top
Definition: parser.yy.c:273

Definition at line 283 of file parser.yy.c.

◆ YY_CURRENT_BUFFER_LVALUE

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 290 of file parser.yy.c.

◆ YY_DECL

#define YY_DECL   int parser_lex (void)

Definition at line 986 of file parser.yy.c.

◆ YY_DECL_IS_OURS

#define YY_DECL_IS_OURS   1

Definition at line 982 of file parser.yy.c.

◆ yy_delete_buffer

#define yy_delete_buffer   parser__delete_buffer

Definition at line 10 of file parser.yy.c.

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION
Value:
parser_leng = (size_t) (yy_cp - yy_bp); \
*yy_cp = '\0'; \
register char * yy_cp
Definition: parser.yy.c:1012
__kernel_size_t size_t
Definition: linux.h:237
register char * yy_bp
Definition: parser.yy.c:1012
static char yy_hold_char
Definition: parser.yy.c:293
#define yytext_ptr
Definition: parser.yy.c:366
static char * yy_c_buf_p
Definition: parser.yy.c:298

Definition at line 376 of file parser.yy.c.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   42

Definition at line 384 of file parser.yy.c.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 160 of file parser.yy.c.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 2165 of file parser.yy.c.

◆ YY_EXTRA_TYPE

#define YY_EXTRA_TYPE   void *

Definition at line 837 of file parser.yy.c.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 973 of file parser.yy.c.

◆ yy_flex_debug

#define yy_flex_debug   parser__flex_debug

Definition at line 11 of file parser.yy.c.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file parser.yy.c.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file parser.yy.c.

◆ YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION   37

Definition at line 31 of file parser.yy.c.

◆ yy_flush_buffer

#define yy_flush_buffer   parser__flush_buffer

Definition at line 13 of file parser.yy.c.

◆ YY_FLUSH_BUFFER

Definition at line 319 of file parser.yy.c.

◆ yy_init_buffer

#define yy_init_buffer   parser__init_buffer

Definition at line 12 of file parser.yy.c.

◆ YY_INPUT

#define YY_INPUT (   buf,
  result,
  max_size 
)
Value:
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \
int c = '*'; \
size_t n; \
for ( n = 0; n < max_size && \
(c = getc( parser_in )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \
if ( c == '\n' ) \
buf[n++] = (char) c; \
if ( c == EOF && ferror( parser_in ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
result = n; \
} \
else \
{ \
errno=0; \
while ( (result = fread(buf, 1, max_size, parser_in))==0 && ferror(parser_in)) \
{ \
if( errno != EINTR) \
{ \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
break; \
} \
errno=0; \
clearerr(parser_in); \
} \
}\
\
_Check_return_ _CRTIMP int __cdecl ferror(_In_ FILE *_File)
FILE * parser_in
Definition: parser.yy.c:357
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define EINTR
Definition: acclib.h:80
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
GLdouble n
Definition: glext.h:7729
_Check_return_ _CRTIMP int __cdecl getc(_Inout_ FILE *_File)
int errno
_Check_return_opt_ _CRTIMP size_t __cdecl fread(_Out_writes_bytes_(_ElementSize *_Count) void *_DstBuf, _In_ size_t _ElementSize, _In_ size_t _Count, _Inout_ FILE *_File)
static INT max_size
Definition: history.c:51
unsigned char
Definition: typeof.h:29
const GLubyte * c
Definition: glext.h:8905
#define EOF
Definition: stdio.h:24
#define c
Definition: ke_i.h:80
GLuint64EXT * result
Definition: glext.h:11304

Definition at line 926 of file parser.yy.c.

◆ YY_INT_ALIGNED

#define YY_INT_ALIGNED   short int

Definition at line 5 of file parser.yy.c.

◆ YY_LESS_LINENO

#define YY_LESS_LINENO (   n)

Definition at line 189 of file parser.yy.c.

◆ yy_load_buffer_state

#define yy_load_buffer_state   parser__load_buffer_state

Definition at line 14 of file parser.yy.c.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ   0

Definition at line 701 of file parser.yy.c.

◆ yy_new_buffer

#define yy_new_buffer   parser__create_buffer

Definition at line 329 of file parser.yy.c.

◆ YY_NEW_FILE

#define YY_NEW_FILE   parser_restart(parser_in )

Definition at line 158 of file parser.yy.c.

◆ YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 724 of file parser.yy.c.

◆ YY_NO_UNISTD_H

#define YY_NO_UNISTD_H

Definition at line 747 of file parser.yy.c.

◆ YY_NULL

#define YY_NULL   0

Definition at line 132 of file parser.yy.c.

◆ YY_NUM_RULES

#define YY_NUM_RULES   41

Definition at line 383 of file parser.yy.c.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 911 of file parser.yy.c.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 702 of file parser.yy.c.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP
Value:
if ( parser_leng > 0 ) \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
(parser_text[parser_leng - 1] == '\n'); \
YY_USER_ACTION
char * parser_text
Definition: parser.yy.c:703
yy_size_t parser_leng
Definition: parser.yy.c:295

Definition at line 1001 of file parser.yy.c.

◆ YY_SC_TO_UI

#define YY_SC_TO_UI (   c)    ((unsigned int) (unsigned char) c)

Definition at line 139 of file parser.yy.c.

◆ yy_set_bol

#define yy_set_bol (   at_bol)
Value:
{ \
if ( ! YY_CURRENT_BUFFER ){\
parser_ensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
parser__create_buffer(parser_in,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
FILE * parser_in
Definition: parser.yy.c:357
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_BUF_SIZE
Definition: parser.yy.c:164

Definition at line 341 of file parser.yy.c.

◆ yy_set_interactive

#define yy_set_interactive (   is_interactive)
Value:
{ \
if ( ! YY_CURRENT_BUFFER ){ \
parser_ensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
parser__create_buffer(parser_in,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
FILE * parser_in
Definition: parser.yy.c:357
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_BUF_SIZE
Definition: parser.yy.c:164

Definition at line 331 of file parser.yy.c.

◆ YY_START

#define YY_START   (((yy_start) - 1) / 2)

Definition at line 151 of file parser.yy.c.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 968 of file parser.yy.c.

◆ YY_STATE_BUF_SIZE

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 169 of file parser.yy.c.

◆ YY_STATE_EOF

#define YY_STATE_EOF (   state)    (YY_END_OF_BUFFER + state + 1)

Definition at line 155 of file parser.yy.c.

◆ YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 208 of file parser.yy.c.

◆ yy_switch_to_buffer

#define yy_switch_to_buffer   parser__switch_to_buffer

Definition at line 15 of file parser.yy.c.

◆ YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 172 of file parser.yy.c.

◆ YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 177 of file parser.yy.c.

◆ YY_USER_ACTION

#define YY_USER_ACTION

Definition at line 993 of file parser.yy.c.

◆ yyalloc

Definition at line 24 of file parser.yy.c.

◆ yyconst

#define yyconst

Definition at line 128 of file parser.yy.c.

◆ yyfree

#define yyfree   parser_free

Definition at line 26 of file parser.yy.c.

◆ yyin

#define yyin   parser_in

Definition at line 16 of file parser.yy.c.

◆ yyleng

#define yyleng   parser_leng

Definition at line 17 of file parser.yy.c.

◆ yyless [1/2]

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up parser_text. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
YY_RESTORE_YY_MORE_OFFSET \
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up parser_text again */ \
} \
while ( 0 )
register char * yy_cp
Definition: parser.yy.c:1012
GLdouble n
Definition: glext.h:7729
#define YY_MORE_ADJ
Definition: parser.yy.c:701
register char * yy_bp
Definition: parser.yy.c:1012
static char yy_hold_char
Definition: parser.yy.c:293
static char * yy_c_buf_p
Definition: parser.yy.c:298

Definition at line 2177 of file parser.yy.c.

◆ yyless [2/2]

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up parser_text. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
parser_text[parser_leng] = (yy_hold_char); \
(yy_c_buf_p) = parser_text + yyless_macro_arg; \
*(yy_c_buf_p) = '\0'; \
parser_leng = yyless_macro_arg; \
} \
while ( 0 )
char * parser_text
Definition: parser.yy.c:703
GLdouble n
Definition: glext.h:7729
yy_size_t parser_leng
Definition: parser.yy.c:295
static char yy_hold_char
Definition: parser.yy.c:293
static char * yy_c_buf_p
Definition: parser.yy.c:298

Definition at line 2177 of file parser.yy.c.

◆ yylex

#define yylex   parser_lex

Definition at line 18 of file parser.yy.c.

◆ yylineno

#define yylineno   parser_lineno

Definition at line 19 of file parser.yy.c.

◆ yymore

#define yymore ( )    yymore_used_but_not_detected

Definition at line 700 of file parser.yy.c.

◆ yyout

#define yyout   parser_out

Definition at line 20 of file parser.yy.c.

◆ yyrealloc

#define yyrealloc   parser_realloc

Definition at line 25 of file parser.yy.c.

◆ yyrestart

#define yyrestart   parser_restart

Definition at line 21 of file parser.yy.c.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 152 of file parser.yy.c.

◆ YYTABLES_NAME

#define YYTABLES_NAME   "yytables"

Definition at line 2375 of file parser.yy.c.

◆ yyterminate

#define yyterminate ( )    return YY_NULL

Definition at line 963 of file parser.yy.c.

◆ yytext

#define yytext   parser_text

Definition at line 22 of file parser.yy.c.

◆ yytext_ptr

#define yytext_ptr   parser_text

Definition at line 366 of file parser.yy.c.

◆ yywrap

#define yywrap   parser_wrap

Definition at line 23 of file parser.yy.c.

Typedef Documentation

◆ flex_int16_t

Definition at line 71 of file parser.yy.c.

◆ flex_int32_t

typedef int flex_int32_t

Definition at line 72 of file parser.yy.c.

◆ flex_int8_t

Definition at line 70 of file parser.yy.c.

◆ flex_uint16_t

typedef unsigned short int flex_uint16_t

Definition at line 74 of file parser.yy.c.

◆ flex_uint32_t

typedef unsigned int flex_uint32_t

Definition at line 75 of file parser.yy.c.

◆ flex_uint8_t

typedef unsigned char flex_uint8_t

Definition at line 73 of file parser.yy.c.

◆ YY_BUFFER_STATE

Definition at line 173 of file parser.yy.c.

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 355 of file parser.yy.c.

◆ yy_size_t

typedef size_t yy_size_t

Definition at line 178 of file parser.yy.c.

◆ yy_state_type

typedef int yy_state_type

Definition at line 359 of file parser.yy.c.

Function Documentation

◆ abort_import()

void abort_import ( void  )

Definition at line 2705 of file parser.yy.c.

2706 {
2707  int ptr;
2708 
2709  for (ptr=0; ptr<import_stack_ptr; ptr++)
2711 }
#define unlink
Definition: syshdrs.h:54
static PVOID ptr
Definition: dispmode.c:27
struct @4030 import_stack[MAX_IMPORT_DEPTH]
int import_stack_ptr
Definition: parser.yy.c:778
char * temp_name
Definition: parser.yy.c:776

Referenced by rm_tempfile().

◆ addcchar()

static void addcchar ( char  c)
static

Definition at line 2610 of file parser.yy.c.

2611 {
2612  if(cbufidx >= cbufalloc)
2613  {
2614  cbufalloc += 1024;
2615  cbuffer = xrealloc(cbuffer, cbufalloc * sizeof(cbuffer[0]));
2616  if(cbufalloc > 65536)
2617  parser_warning("Reallocating string buffer larger than 64kB\n");
2618  }
2619  cbuffer[cbufidx++] = c;
2620 }
static int cbufidx
Definition: parser.yy.c:761
static int cbufalloc
Definition: parser.yy.c:762
void * xrealloc(void *oldmem, size_t size)
Definition: uimain.c:736
static char * cbuffer
Definition: parser.yy.c:760
#define c
Definition: ke_i.h:80
int parser_warning(const char *s,...)
Definition: utils.c:94

Referenced by get_buffered_cstring(), and while().

◆ attr_token()

static int attr_token ( const char kw)
static

Definition at line 2597 of file parser.yy.c.

2598 {
2599  struct keyword key, *kwp;
2600  key.kw = kw;
2601  kwp = bsearch(&key, attr_keywords, sizeof(attr_keywords)/sizeof(attr_keywords[0]),
2602  sizeof(attr_keywords[0]), kw_cmp_func);
2603  if (kwp) {
2604  parser_lval.str = xstrdup(kwp->kw);
2605  return kwp->token;
2606  }
2607  return kw_token(kw);
2608 }
static const struct keyword attr_keywords[]
Definition: parser.yy.c:2458
int token
Definition: parser.yy.c:2390
static int kw_token(const char *kw)
Definition: parser.yy.c:2584
struct cond_str str
Definition: cond.tab.c:267
static int kw_cmp_func(const void *s1, const void *s2)
Definition: parser.yy.c:2579
YYSTYPE parser_lval
const char * kw
Definition: parser.yy.c:2389
char * xstrdup(const char *s)
Definition: uimain.c:768
Definition: path.c:42
#define bsearch

Referenced by while().

◆ do_import()

int do_import ( char fname)

Definition at line 2650 of file parser.yy.c.

2651 {
2652  FILE *f;
2653  char *path, *name;
2654  struct imports *import;
2655  int ptr = import_stack_ptr;
2656  int ret, fd;
2657 
2658  import = first_import;
2659  while (import && strcmp(import->name, fname))
2660  import = import->next;
2661  if (import) return 0; /* already imported */
2662 
2663  import = xmalloc(sizeof(struct imports));
2664  import->name = xstrdup(fname);
2665  import->next = first_import;
2666  first_import = import;
2667 
2668  /* don't search for a file name with a path in the include directories,
2669  * for compatibility with MIDL */
2670  if (strchr( fname, '/' ) || strchr( fname, '\\' ))
2671  path = xstrdup( fname );
2672  else if (!(path = wpp_find_include( fname, input_name )))
2673  error_loc("Unable to open include file %s\n", fname);
2674 
2676  error_loc("Exceeded max import depth\n");
2677 
2678  import_stack[ptr].temp_name = temp_name;
2679  import_stack[ptr].input_name = input_name;
2680  import_stack[ptr].line_number = line_number;
2681  import_stack_ptr++;
2682  input_name = path;
2683  line_number = 1;
2684 
2685  name = xstrdup( "widl.XXXXXX" );
2686  if((fd = mkstemps( name, 0 )) == -1)
2687  error("Could not generate a temp name from %s\n", name);
2688 
2689  temp_name = name;
2690  if (!(f = fdopen(fd, "wt")))
2691  error("Could not open fd %s for writing\n", name);
2692 
2693  ret = wpp_parse( path, f );
2694  fclose( f );
2695  if (ret) exit(1);
2696 
2697  if((f = fopen(temp_name, "r")) == NULL)
2698  error_loc("Unable to open %s\n", temp_name);
2699 
2702  return 1;
2703 }
#define error(str)
Definition: mkdosfs.c:1605
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
GLsizei const GLchar ** path
Definition: glext.h:7234
#define MAX_IMPORT_DEPTH
Definition: parser.yy.c:771
char * wpp_find_include(const char *name, const char *parent_name)
Definition: preproc.c:509
static int fd
Definition: io.c:51
int line_number
Definition: parser.yy.c:775
void parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: parser.yy.c:1805
void * xmalloc(int size)
Definition: uimain.c:747
static PVOID ptr
Definition: dispmode.c:27
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
#define YY_BUF_SIZE
Definition: parser.yy.c:164
GLfloat f
Definition: glext.h:7540
struct @4030 import_stack[MAX_IMPORT_DEPTH]
YY_BUFFER_STATE parser__create_buffer(FILE *file, int size)
Definition: parser.yy.c:1850
int import_stack_ptr
Definition: parser.yy.c:778
int ret
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
#define f
Definition: ke_i.h:83
Definition: services.c:325
_Check_return_ _CRTIMP FILE *__cdecl fdopen(_In_ int _FileHandle, _In_z_ const char *_Format)
int mkstemps(char *template, int suffix_len)
Definition: mkstemps.c:73
char * temp_name
Definition: parser.yy.c:776
struct imports * first_import
char * strchr(const char *String, int ch)
Definition: utclib.c:501
Definition: name.c:36
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
void exit(int exitcode)
Definition: _exit.c:33
char * xstrdup(const char *s)
Definition: uimain.c:768
int wpp_parse(const char *input, FILE *output)
Definition: wpp.c:184
char * input_name
Definition: parser.yy.c:774
GLuint const GLchar * name
Definition: glext.h:6031

◆ do_warning()

int do_warning ( char toggle,
warning_list_t wnum 
)

Definition at line 2768 of file parser.yy.c.

2769 {
2770  warning_t *warning, *next;
2771  int ret = 1;
2772  if(!disabled_warnings)
2773  {
2776  }
2777 
2778  if(!strcmp(toggle, "disable"))
2780  warning_disable(warning->num);
2781  else if(!strcmp(toggle, "enable"))
2783  warning_enable(warning->num);
2784  else
2785  ret = 0;
2786 
2788  free(warning);
2789  return ret;
2790 }
#define free
Definition: debug_ros.c:5
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
void * xmalloc(int size)
Definition: uimain.c:747
static warning_list_t * disabled_warnings
Definition: parser.yy.c:769
static void warning_disable(int warning)
Definition: parser.yy.c:2745
static void warning_enable(int warning)
Definition: parser.yy.c:2756
int ret
uint32_t entry
Definition: isohybrid.c:63
static unsigned __int64 next
Definition: rand_nt.c:6
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define warning(s)
Definition: debug.h:71

Referenced by yyparse().

◆ get_buffered_cstring()

static char * get_buffered_cstring ( void  )
static

Definition at line 2622 of file parser.yy.c.

2623 {
2624  addcchar(0);
2625  return xstrdup(cbuffer);
2626 }
static void addcchar(char c)
Definition: parser.yy.c:2610
static char * cbuffer
Definition: parser.yy.c:760
char * xstrdup(const char *s)
Definition: uimain.c:768

Referenced by while().

◆ if()

if ( yy_init)

Definition at line 1019 of file parser.yy.c.

1020  {
1021  (yy_init) = 1;
1022 
1023 #ifdef YY_USER_INIT
1024  YY_USER_INIT;
1025 #endif
1026 
1027  if ( ! (yy_start) )
1028  (yy_start) = 1; /* first start state */
1029 
1030  if ( ! parser_in )
1031  parser_in = stdin;
1032 
1033  if ( ! parser_out )
1034  parser_out = stdout;
1035 
1036  if ( ! YY_CURRENT_BUFFER ) {
1040  }
1041 
1043  }
FILE * parser_out
Definition: parser.yy.c:357
static int yy_init
Definition: parser.yy.c:299
FILE * parser_in
Definition: parser.yy.c:357
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
FILE * stdin
FILE * stdout
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
#define YY_BUF_SIZE
Definition: parser.yy.c:164
static void parser_ensure_buffer_stack(void)
Definition: parser.yy.c:2003
YY_BUFFER_STATE parser__create_buffer(FILE *file, int size)
Definition: parser.yy.c:1850
static int yy_start
Definition: parser.yy.c:300

◆ is_warning_enabled()

int is_warning_enabled ( int  warning)

Definition at line 2792 of file parser.yy.c.

2793 {
2794  warning_t *warning_entry;
2795  if(!disabled_warnings)
2796  return 1;
2798  if(warning_entry->num == warning)
2799  return 0;
2800  return 1;
2801 }
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
static warning_list_t * disabled_warnings
Definition: parser.yy.c:769
uint32_t entry
Definition: isohybrid.c:63
#define warning(s)
Definition: debug.h:71

Referenced by ctl2_alloc_guid().

◆ kw_cmp_func()

static int kw_cmp_func ( const void s1,
const void s2 
)
static

Definition at line 2579 of file parser.yy.c.

2580 {
2581  return strcmp(KWP(s1)->kw, KWP(s2)->kw);
2582 }
struct S2 s2
#define KWP(p)
Definition: parser.yy.c:2577
struct S1 s1
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by attr_token(), and kw_token().

◆ kw_token()

static int kw_token ( const char kw)
static

Definition at line 2584 of file parser.yy.c.

2585 {
2586  struct keyword key, *kwp;
2587  key.kw = kw;
2588  kwp = bsearch(&key, keywords, NKEYWORDS, sizeof(keywords[0]), kw_cmp_func);
2589  if (kwp && (winrt_mode || kwp->token != tNAMESPACE)) {
2590  parser_lval.str = xstrdup(kwp->kw);
2591  return kwp->token;
2592  }
2594  return is_type(kw) ? aKNOWNTYPE : aIDENTIFIER;
2595 }
static const struct keyword keywords[]
Definition: parser.yy.c:2394
int is_type(const char *name)
Definition: parser.tab.c:6173
int token
Definition: parser.yy.c:2390
struct cond_str str
Definition: cond.tab.c:267
static int kw_cmp_func(const void *s1, const void *s2)
Definition: parser.yy.c:2579
YYSTYPE parser_lval
const char * kw
Definition: parser.yy.c:2389
#define NKEYWORDS
Definition: parser.yy.c:2453
char * xstrdup(const char *s)
Definition: uimain.c:768
int winrt_mode
Definition: widl.c:129
Definition: path.c:42
#define bsearch

Referenced by attr_token(), and while().

◆ parse_uuid()

UUID* parse_uuid ( const char u)

Definition at line 793 of file parser.yy.c.

794 {
795  UUID* uuid = xmalloc(sizeof(UUID));
796  char b[3];
797  /* it would be nice to use UuidFromStringA */
798  uuid->Data1 = strtoul(u, NULL, 16);
799  uuid->Data2 = strtoul(u+9, NULL, 16);
800  uuid->Data3 = strtoul(u+14, NULL, 16);
801  b[2] = 0;
802  memcpy(b, u+19, 2); uuid->Data4[0] = strtoul(b, NULL, 16);
803  memcpy(b, u+21, 2); uuid->Data4[1] = strtoul(b, NULL, 16);
804  memcpy(b, u+24, 2); uuid->Data4[2] = strtoul(b, NULL, 16);
805  memcpy(b, u+26, 2); uuid->Data4[3] = strtoul(b, NULL, 16);
806  memcpy(b, u+28, 2); uuid->Data4[4] = strtoul(b, NULL, 16);
807  memcpy(b, u+30, 2); uuid->Data4[5] = strtoul(b, NULL, 16);
808  memcpy(b, u+32, 2); uuid->Data4[6] = strtoul(b, NULL, 16);
809  memcpy(b, u+34, 2); uuid->Data4[7] = strtoul(b, NULL, 16);
810  return uuid;
811 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
UINT32 strtoul(const char *String, char **Terminator, UINT32 Base)
Definition: utclib.c:696
void * xmalloc(int size)
Definition: uimain.c:747
smooth NULL
Definition: ftsmooth.c:416
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Definition: msctf.idl:510

Referenced by while(), and yyparse().

◆ parser__create_buffer()

YY_BUFFER_STATE parser__create_buffer ( FILE file,
int  size 
)

Allocate and initialize an input buffer state.

Parameters
fileA readable stream.
sizeThe character buffer size in bytes. When in doubt, use YY_BUF_SIZE.
Returns
the allocated buffer state.

Definition at line 1850 of file parser.yy.c.

1851 {
1853 
1854  b = (YY_BUFFER_STATE) parser_alloc(sizeof( struct yy_buffer_state ) );
1855  if ( ! b )
1856  YY_FATAL_ERROR( "out of dynamic memory in parser__create_buffer()" );
1857 
1858  b->yy_buf_size = size;
1859 
1860  /* yy_ch_buf has to be 2 characters longer than the size given because
1861  * we need to put in 2 end-of-buffer characters.
1862  */
1863  b->yy_ch_buf = (char *) parser_alloc(b->yy_buf_size + 2 );
1864  if ( ! b->yy_ch_buf )
1865  YY_FATAL_ERROR( "out of dynamic memory in parser__create_buffer()" );
1866 
1867  b->yy_is_our_buffer = 1;
1868 
1870 
1871  return b;
1872 }
static void parser__init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: parser.yy.c:1897
struct yy_buffer_state * YY_BUFFER_STATE
Definition: parser.yy.c:173
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLsizeiptr size
Definition: glext.h:5919
void * parser_alloc(yy_size_t)
Definition: parser.yy.c:2353
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973
Definition: fci.c:126

Referenced by do_import(), if(), parser_restart(), and switch_to_acf().

◆ parser__delete_buffer()

void parser__delete_buffer ( YY_BUFFER_STATE  b)

Destroy the buffer.

Parameters
ba buffer created with parser__create_buffer()

Definition at line 1878 of file parser.yy.c.

1879 {
1880 
1881  if ( ! b )
1882  return;
1883 
1884  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1886 
1887  if ( b->yy_is_our_buffer )
1888  parser_free((void *) b->yy_ch_buf );
1889 
1890  parser_free((void *) b );
1891 }
void parser_free(void *)
Definition: parser.yy.c:2370
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
struct yy_buffer_state * YY_BUFFER_STATE
Definition: parser.yy.c:173
GLboolean GLboolean GLboolean b
Definition: glext.h:6204

Referenced by parser_lex_destroy(), parser_pop_buffer_state(), and pop_import().

◆ parser__flush_buffer()

void parser__flush_buffer ( YY_BUFFER_STATE  b)

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters
bthe buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 1925 of file parser.yy.c.

1926 {
1927  if ( ! b )
1928  return;
1929 
1930  b->yy_n_chars = 0;
1931 
1932  /* We always need two end-of-buffer characters. The first causes
1933  * a transition to the end-of-buffer state. The second causes
1934  * a jam in that state.
1935  */
1936  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1937  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1938 
1939  b->yy_buf_pos = &b->yy_ch_buf[0];
1940 
1941  b->yy_at_bol = 1;
1942  b->yy_buffer_status = YY_BUFFER_NEW;
1943 
1944  if ( b == YY_CURRENT_BUFFER )
1946 }
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_END_OF_BUFFER_CHAR
Definition: parser.yy.c:160
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define YY_BUFFER_NEW
Definition: parser.yy.c:255

Referenced by parser__init_buffer().

◆ parser__init_buffer()

static void parser__init_buffer ( YY_BUFFER_STATE  b,
FILE file 
)
static

Definition at line 1897 of file parser.yy.c.

1899 {
1900  int oerrno = errno;
1901 
1903 
1904  b->yy_input_file = file;
1905  b->yy_fill_buffer = 1;
1906 
1907  /* If b is the current buffer, then parser__init_buffer was _probably_
1908  * called from parser_restart() or through yy_get_next_buffer.
1909  * In that case, we don't want to reset the lineno or column.
1910  */
1911  if (b != YY_CURRENT_BUFFER){
1912  b->yy_bs_lineno = 1;
1913  b->yy_bs_column = 0;
1914  }
1915 
1916  b->yy_is_interactive = 0;
1917 
1918  errno = oerrno;
1919 }
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
int errno
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
const char file[]
Definition: icontest.c:11
void parser__flush_buffer(YY_BUFFER_STATE b)
Definition: parser.yy.c:1925

Referenced by parser__create_buffer(), and parser_restart().

◆ parser__load_buffer_state()

static void parser__load_buffer_state ( void  )
static

Definition at line 1836 of file parser.yy.c.

1837 {
1838  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1839  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1840  parser_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1841  (yy_hold_char) = *(yy_c_buf_p);
1842 }
FILE * parser_in
Definition: parser.yy.c:357
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
static yy_size_t yy_n_chars
Definition: parser.yy.c:294
static char yy_hold_char
Definition: parser.yy.c:293
#define yytext_ptr
Definition: parser.yy.c:366
static char * yy_c_buf_p
Definition: parser.yy.c:298

Referenced by if(), parser__flush_buffer(), parser__switch_to_buffer(), parser_pop_buffer_state(), parser_push_buffer_state(), and parser_restart().

◆ parser__scan_buffer()

YY_BUFFER_STATE parser__scan_buffer ( char base,
yy_size_t  size 
)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters
basethe character buffer
sizethe size in bytes of the character buffer
Returns
the newly allocated buffer state object.

Definition at line 2052 of file parser.yy.c.

2053 {
2055 
2056  if ( size < 2 ||
2059  /* They forgot to leave room for the EOB's. */
2060  return 0;
2061 
2062  b = (YY_BUFFER_STATE) parser_alloc(sizeof( struct yy_buffer_state ) );
2063  if ( ! b )
2064  YY_FATAL_ERROR( "out of dynamic memory in parser__scan_buffer()" );
2065 
2066  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2067  b->yy_buf_pos = b->yy_ch_buf = base;
2068  b->yy_is_our_buffer = 0;
2069  b->yy_input_file = 0;
2070  b->yy_n_chars = b->yy_buf_size;
2071  b->yy_is_interactive = 0;
2072  b->yy_at_bol = 1;
2073  b->yy_fill_buffer = 0;
2074  b->yy_buffer_status = YY_BUFFER_NEW;
2075 
2077 
2078  return b;
2079 }
#define YY_END_OF_BUFFER_CHAR
Definition: parser.yy.c:160
void parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: parser.yy.c:1805
GLuint base
Definition: 3dtext.c:35
struct yy_buffer_state * YY_BUFFER_STATE
Definition: parser.yy.c:173
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLsizeiptr size
Definition: glext.h:5919
void * parser_alloc(yy_size_t)
Definition: parser.yy.c:2353
#define YY_BUFFER_NEW
Definition: parser.yy.c:255
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973

Referenced by parser__scan_bytes().

◆ parser__scan_bytes()

YY_BUFFER_STATE parser__scan_bytes ( yyconst char yybytes,
yy_size_t  _yybytes_len 
)

Setup the input buffer state to scan the given bytes. The next call to parser_lex() will scan from a copy of bytes.

Parameters
yybytesthe byte buffer to scan
_yybytes_lenthe number of bytes in the buffer pointed to by bytes.
Returns
the newly allocated buffer state object.

Definition at line 2102 of file parser.yy.c.

2103 {
2105  char *buf;
2106  yy_size_t n;
2107  yy_size_t i;
2108 
2109  /* Get memory for full buffer, including space for trailing EOB's. */
2110  n = _yybytes_len + 2;
2111  buf = (char *) parser_alloc(n );
2112  if ( ! buf )
2113  YY_FATAL_ERROR( "out of dynamic memory in parser__scan_bytes()" );
2114 
2115  for ( i = 0; i < _yybytes_len; ++i )
2116  buf[i] = yybytes[i];
2117 
2118  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2119 
2120  b = parser__scan_buffer(buf,n );
2121  if ( ! b )
2122  YY_FATAL_ERROR( "bad buffer in parser__scan_bytes()" );
2123 
2124  /* It's okay to grow etc. this buffer, and we should throw it
2125  * away when we're done.
2126  */
2127  b->yy_is_our_buffer = 1;
2128 
2129  return b;
2130 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLdouble n
Definition: glext.h:7729
size_t yy_size_t
Definition: macro.lex.yy.c:159
#define YY_END_OF_BUFFER_CHAR
Definition: parser.yy.c:160
YY_BUFFER_STATE parser__scan_buffer(char *base, yy_size_t size)
Definition: parser.yy.c:2052
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
void * parser_alloc(yy_size_t)
Definition: parser.yy.c:2353
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973

Referenced by parser__scan_string().

◆ parser__scan_string()

YY_BUFFER_STATE parser__scan_string ( yyconst char yystr)

Setup the input buffer state to scan a string. The next call to parser_lex() will scan from a copy of str.

Parameters
yystra NUL-terminated string to scan
Returns
the newly allocated buffer state object.
Note
If you want to scan bytes that may contain NUL values, then use parser__scan_bytes() instead.

Definition at line 2089 of file parser.yy.c.

2090 {
2091 
2092  return parser__scan_bytes(yystr,strlen(yystr) );
2093 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
YY_BUFFER_STATE parser__scan_bytes(yyconst char *bytes, yy_size_t len)
Definition: parser.yy.c:2102

◆ parser__switch_to_buffer()

void parser__switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Switch to a different input buffer.

Parameters
new_bufferThe new input buffer.

Definition at line 1805 of file parser.yy.c.

1806 {
1807 
1808  /* TODO. We should be able to replace this entire function body
1809  * with
1810  * parser_pop_buffer_state();
1811  * parser_push_buffer_state(new_buffer);
1812  */
1814  if ( YY_CURRENT_BUFFER == new_buffer )
1815  return;
1816 
1817  if ( YY_CURRENT_BUFFER )
1818  {
1819  /* Flush out information for old buffer. */
1820  *(yy_c_buf_p) = (yy_hold_char);
1821  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1822  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1823  }
1824 
1825  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1827 
1828  /* We don't actually know whether we did this switch during
1829  * EOF (parser_wrap()) processing, but the only time this flag
1830  * is looked at is after parser_wrap() is called, so it's safe
1831  * to go ahead and always set it.
1832  */
1834 }
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
static int yy_did_buffer_switch_on_eof
Definition: parser.yy.c:305
static yy_size_t yy_n_chars
Definition: parser.yy.c:294
static void parser_ensure_buffer_stack(void)
Definition: parser.yy.c:2003
static char yy_hold_char
Definition: parser.yy.c:293
static char * yy_c_buf_p
Definition: parser.yy.c:298

Referenced by do_import(), parser__scan_buffer(), pop_import(), and switch_to_acf().

◆ parser_alloc()

void * parser_alloc ( yy_size_t  size)

Definition at line 2353 of file parser.yy.c.

2354 {
2355  return (void *) malloc( size );
2356 }
GLsizeiptr size
Definition: glext.h:5919
#define malloc
Definition: debug_ros.c:4

Referenced by parser__create_buffer(), parser__scan_buffer(), parser__scan_bytes(), parser_ensure_buffer_stack(), and yy_push_state().

◆ parser_ensure_buffer_stack()

static void parser_ensure_buffer_stack ( void  )
static

Definition at line 2003 of file parser.yy.c.

2004 {
2005  yy_size_t num_to_alloc;
2006 
2007  if (!(yy_buffer_stack)) {
2008 
2009  /* First allocation is just for 2 elements, since we don't know if this
2010  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2011  * immediate realloc on the next call.
2012  */
2013  num_to_alloc = 1;
2015  (num_to_alloc * sizeof(struct yy_buffer_state*)
2016  );
2017  if ( ! (yy_buffer_stack) )
2018  YY_FATAL_ERROR( "out of dynamic memory in parser_ensure_buffer_stack()" );
2019 
2020  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2021 
2022  (yy_buffer_stack_max) = num_to_alloc;
2023  (yy_buffer_stack_top) = 0;
2024  return;
2025  }
2026 
2027  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2028 
2029  /* Increase the buffer to prepare for a possible push. */
2030  int grow_size = 8 /* arbitrary grow size */;
2031 
2032  num_to_alloc = (yy_buffer_stack_max) + grow_size;
2034  ((yy_buffer_stack),
2035  num_to_alloc * sizeof(struct yy_buffer_state*)
2036  );
2037  if ( ! (yy_buffer_stack) )
2038  YY_FATAL_ERROR( "out of dynamic memory in parser_ensure_buffer_stack()" );
2039 
2040  /* zero only the new slots.*/
2041  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2042  (yy_buffer_stack_max) = num_to_alloc;
2043  }
2044 }
void * parser_realloc(void *, yy_size_t)
Definition: parser.yy.c:2358
size_t yy_size_t
Definition: macro.lex.yy.c:159
static YY_BUFFER_STATE * yy_buffer_stack
Definition: parser.yy.c:275
static size_t yy_buffer_stack_top
Definition: parser.yy.c:273
void * parser_alloc(yy_size_t)
Definition: parser.yy.c:2353
static size_t yy_buffer_stack_max
Definition: parser.yy.c:274
#define memset(x, y, z)
Definition: compat.h:39
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973

Referenced by if(), parser__switch_to_buffer(), parser_push_buffer_state(), and parser_restart().

◆ parser_free()

void parser_free ( void ptr)

Definition at line 2370 of file parser.yy.c.

2371 {
2372  free( (char *) ptr ); /* see parser_realloc() for (char *) cast */
2373 }
#define free
Definition: debug_ros.c:5
static PVOID ptr
Definition: dispmode.c:27

Referenced by parser__delete_buffer(), and parser_lex_destroy().

◆ parser_get_debug()

int parser_get_debug ( void  )

Definition at line 2261 of file parser.yy.c.

2262 {
2263  return parser__flex_debug;
2264 }
int parser__flex_debug
Definition: parser.yy.c:694

◆ parser_get_extra()

YY_EXTRA_TYPE parser_get_extra ( void  )

◆ parser_get_in()

FILE * parser_get_in ( void  )

Get the input stream.

Definition at line 2205 of file parser.yy.c.

2206 {
2207  return parser_in;
2208 }
FILE * parser_in
Definition: parser.yy.c:357

◆ parser_get_leng()

yy_size_t parser_get_leng ( void  )

Get the length of the current token.

Definition at line 2221 of file parser.yy.c.

2222 {
2223  return parser_leng;
2224 }
yy_size_t parser_leng
Definition: parser.yy.c:295

◆ parser_get_lineno()

int parser_get_lineno ( void  )

Get the current line number.

Definition at line 2196 of file parser.yy.c.

2197 {
2198 
2199  return parser_lineno;
2200 }
int parser_lineno
Definition: parser.yy.c:363

◆ parser_get_out()

FILE * parser_get_out ( void  )

Get the output stream.

Definition at line 2213 of file parser.yy.c.

2214 {
2215  return parser_out;
2216 }
FILE * parser_out
Definition: parser.yy.c:357

◆ parser_get_text()

char * parser_get_text ( void  )

Get the current token.

Definition at line 2230 of file parser.yy.c.

2231 {
2232  return parser_text;
2233 }
char * parser_text
Definition: parser.yy.c:703

◆ parser_lex()

int parser_lex ( void  )

◆ parser_lex_destroy()

int parser_lex_destroy ( void  )

Definition at line 2304 of file parser.yy.c.

2305 {
2306 
2307  /* Pop the buffer stack, destroying each element. */
2308  while(YY_CURRENT_BUFFER){
2312  }
2313 
2314  /* Destroy the stack itself. */
2316  (yy_buffer_stack) = NULL;
2317 
2318  /* Destroy the start condition stack. */
2320  (yy_start_stack) = NULL;
2321 
2322  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2323  * parser_lex() is called, initialization will occur. */
2324  yy_init_globals( );
2325 
2326  return 0;
2327 }
void parser_free(void *)
Definition: parser.yy.c:2370
void parser__delete_buffer(YY_BUFFER_STATE b)
Definition: parser.yy.c:1878
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
static int yy_init_globals(void)
Definition: parser.yy.c:2271
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
smooth NULL
Definition: ftsmooth.c:416
static YY_BUFFER_STATE * yy_buffer_stack
Definition: parser.yy.c:275
void parser_pop_buffer_state(void)
Definition: parser.yy.c:1984
static int * yy_start_stack
Definition: parser.yy.c:903

◆ parser_pop_buffer_state()

void parser_pop_buffer_state ( void  )

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 1984 of file parser.yy.c.

1985 {
1986  if (!YY_CURRENT_BUFFER)
1987  return;
1988 
1991  if ((yy_buffer_stack_top) > 0)
1992  --(yy_buffer_stack_top);
1993 
1994  if (YY_CURRENT_BUFFER) {
1997  }
1998 }
void parser__delete_buffer(YY_BUFFER_STATE b)
Definition: parser.yy.c:1878
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
static int yy_did_buffer_switch_on_eof
Definition: parser.yy.c:305
smooth NULL
Definition: ftsmooth.c:416
static size_t yy_buffer_stack_top
Definition: parser.yy.c:273

Referenced by parser_lex_destroy().

◆ parser_push_buffer_state()

void parser_push_buffer_state ( YY_BUFFER_STATE  new_buffer)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters
new_bufferThe new state.

Definition at line 1954 of file parser.yy.c.

1955 {
1956  if (new_buffer == NULL)
1957  return;
1958 
1960 
1961  /* This block is copied from parser__switch_to_buffer. */
1962  if ( YY_CURRENT_BUFFER )
1963  {
1964  /* Flush out information for old buffer. */
1965  *(yy_c_buf_p) = (yy_hold_char);
1966  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1967  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1968  }
1969 
1970  /* Only push if top exists. Otherwise, replace top. */
1971  if (YY_CURRENT_BUFFER)
1972  (yy_buffer_stack_top)++;
1973  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1974 
1975  /* copied from parser__switch_to_buffer. */
1978 }
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
static int yy_did_buffer_switch_on_eof
Definition: parser.yy.c:305
static yy_size_t yy_n_chars
Definition: parser.yy.c:294
smooth NULL
Definition: ftsmooth.c:416
static void parser_ensure_buffer_stack(void)
Definition: parser.yy.c:2003
static size_t yy_buffer_stack_top
Definition: parser.yy.c:273
static char yy_hold_char
Definition: parser.yy.c:293
static char * yy_c_buf_p
Definition: parser.yy.c:298

◆ parser_realloc()

void * parser_realloc ( void ptr,
yy_size_t  size 
)

Definition at line 2358 of file parser.yy.c.

2359 {
2360  /* The cast to (char *) in the following accommodates both
2361  * implementations that use char* generic pointers, and those
2362  * that use void* generic pointers. It works with the latter
2363  * because both ANSI C and C++ allow castless assignment from
2364  * any pointer type to void*, and deal with argument conversions
2365  * as though doing an assignment.
2366  */
2367  return (void *) realloc( (char *) ptr, size );
2368 }
#define realloc
Definition: debug_ros.c:6
static PVOID ptr
Definition: dispmode.c:27
GLsizeiptr size
Definition: glext.h:5919

Referenced by parser_ensure_buffer_stack(), yy_get_next_buffer(), and yy_push_state().

◆ parser_restart()

void parser_restart ( FILE input_file)

Immediately switch to a different input stream.

Parameters
input_fileA readable stream.
Note
This function does not reset the start condition to INITIAL .

Definition at line 1788 of file parser.yy.c.

1789 {
1790 
1791  if ( ! YY_CURRENT_BUFFER ){
1795  }
1796 
1799 }
static void parser__init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: parser.yy.c:1897
FILE * parser_in
Definition: parser.yy.c:357
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
#define YY_BUF_SIZE
Definition: parser.yy.c:164
static void parser_ensure_buffer_stack(void)
Definition: parser.yy.c:2003
YY_BUFFER_STATE parser__create_buffer(FILE *file, int size)
Definition: parser.yy.c:1850

Referenced by yy_get_next_buffer().

◆ parser_set_debug()

void parser_set_debug ( int  debug_flag)

Definition at line 2266 of file parser.yy.c.

2267 {
2268  parser__flex_debug = bdebug ;
2269 }
int parser__flex_debug
Definition: parser.yy.c:694

◆ parser_set_extra()

void parser_set_extra ( YY_EXTRA_TYPE  user_defined)

◆ parser_set_in()

void parser_set_in ( FILE in_str)

Set the input stream. This does not discard the current input buffer.

Parameters
in_strA readable stream.
See also
parser__switch_to_buffer

Definition at line 2251 of file parser.yy.c.

2252 {
2253  parser_in = in_str ;
2254 }
FILE * parser_in
Definition: parser.yy.c:357

◆ parser_set_lineno()

void parser_set_lineno ( int  line_number)

Set the current line number.

Parameters
line_number

Definition at line 2239 of file parser.yy.c.

2240 {
2241 
2243 }
int line_number
Definition: parser.yy.c:775
int parser_lineno
Definition: parser.yy.c:363

◆ parser_set_out()

void parser_set_out ( FILE out_str)

Definition at line 2256 of file parser.yy.c.

2257 {
2258  parser_out = out_str ;
2259 }
FILE * parser_out
Definition: parser.yy.c:357

◆ parser_wrap()

int parser_wrap ( void  )

Definition at line 2382 of file parser.yy.c.

2383 {
2384  return 1;
2385 }

Referenced by while().

◆ pop_import()

void pop_import ( void  )

Definition at line 2628 of file parser.yy.c.

2629 {
2630  int ptr = import_stack_ptr-1;
2631 
2632  fclose(parser_in);
2635  if (temp_name) {
2636  unlink(temp_name);
2637  free(temp_name);
2638  }
2639  temp_name = import_stack[ptr].temp_name;
2640  input_name = import_stack[ptr].input_name;
2641  line_number = import_stack[ptr].line_number;
2642  import_stack_ptr--;
2643 }
void parser__delete_buffer(YY_BUFFER_STATE b)
Definition: parser.yy.c:1878
FILE * parser_in
Definition: parser.yy.c:357
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define free
Definition: debug_ros.c:5
#define unlink
Definition: syshdrs.h:54
int line_number
Definition: parser.yy.c:775
void parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: parser.yy.c:1805
static PVOID ptr
Definition: dispmode.c:27
struct @4030 import_stack[MAX_IMPORT_DEPTH]
int import_stack_ptr
Definition: parser.yy.c:778
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
char * temp_name
Definition: parser.yy.c:776
YY_BUFFER_STATE state
Definition: parser.yy.c:773
char * input_name
Definition: parser.yy.c:774

Referenced by yyparse().

◆ switch_to_acf()

static void switch_to_acf ( void  )
static

Definition at line 2713 of file parser.yy.c.

2714 {
2715  int ptr = import_stack_ptr;
2716  int ret, fd;
2717  char *name;
2718  FILE *f;
2719 
2720  assert(import_stack_ptr == 0);
2721 
2722  input_name = acf_name;
2723  acf_name = NULL;
2724  line_number = 1;
2725 
2726  name = xstrdup( "widl.XXXXXX" );
2727  if((fd = mkstemps( name, 0 )) == -1)
2728  error("Could not generate a temp name from %s\n", name);
2729 
2730  temp_name = name;
2731  if (!(f = fdopen(fd, "wt")))
2732  error("Could not open fd %s for writing\n", name);
2733 
2734  ret = wpp_parse(input_name, f);
2735  fclose(f);
2736  if (ret) exit(1);
2737 
2738  if((f = fopen(temp_name, "r")) == NULL)
2739  error_loc("Unable to open %s\n", temp_name);
2740 
2743 }
#define error(str)
Definition: mkdosfs.c:1605
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
#define assert(x)
Definition: debug.h:53
static int fd
Definition: io.c:51
int line_number
Definition: parser.yy.c:775
void parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: parser.yy.c:1805
static PVOID ptr
Definition: dispmode.c:27
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
#define YY_BUF_SIZE
Definition: parser.yy.c:164
GLfloat f
Definition: glext.h:7540
struct @4030 import_stack[MAX_IMPORT_DEPTH]
YY_BUFFER_STATE parser__create_buffer(FILE *file, int size)
Definition: parser.yy.c:1850
int import_stack_ptr
Definition: parser.yy.c:778
int ret
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
#define f
Definition: ke_i.h:83
_Check_return_ _CRTIMP FILE *__cdecl fdopen(_In_ int _FileHandle, _In_z_ const char *_Format)
int mkstemps(char *template, int suffix_len)
Definition: mkstemps.c:73
char * temp_name
Definition: parser.yy.c:776
Definition: name.c:36
void exit(int exitcode)
Definition: _exit.c:33
char * xstrdup(const char *s)
Definition: uimain.c:768
char * acf_name
Definition: widl.c:135
int wpp_parse(const char *input, FILE *output)
Definition: wpp.c:184
char * input_name
Definition: parser.yy.c:774
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by while().

◆ warning_disable()

static void warning_disable ( int  warning)
static

Definition at line 2745 of file parser.yy.c.

2746 {
2747  warning_t *warning_entry;
2749  if(warning_entry->num == warning)
2750  return;
2751  warning_entry = xmalloc( sizeof(*warning_entry) );
2752  warning_entry->num = warning;
2753  list_add_tail(disabled_warnings, &warning_entry->entry);
2754 }
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
void * xmalloc(int size)
Definition: uimain.c:747
static warning_list_t * disabled_warnings
Definition: parser.yy.c:769
uint32_t entry
Definition: isohybrid.c:63
struct list entry
Definition: widltypes.h:546
#define warning(s)
Definition: debug.h:71

Referenced by do_warning().

◆ warning_enable()

static void warning_enable ( int  warning)
static

Definition at line 2756 of file parser.yy.c.

2757 {
2758  warning_t *warning_entry;
2760  if(warning_entry->num == warning)
2761  {
2762  list_remove(&warning_entry->entry);
2763  free(warning_entry);
2764  break;
2765  }
2766 }
#define free
Definition: debug_ros.c:5
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
static warning_list_t * disabled_warnings
Definition: parser.yy.c:769
uint32_t entry
Definition: isohybrid.c:63
struct list entry
Definition: widltypes.h:546
#define warning(s)
Definition: debug.h:71

Referenced by do_warning().

◆ while()

while ( )

Definition at line 1045 of file parser.yy.c.

1046  {
1047  yy_cp = (yy_c_buf_p);
1048 
1049  /* Support of parser_text. */
1050  *yy_cp = (yy_hold_char);
1051 
1052  /* yy_bp points to the position in yy_ch_buf of the start of
1053  * the current run.
1054  */
1055  yy_bp = yy_cp;
1056 
1059 yy_match:
1060  do
1061  {
1062  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1063  if ( yy_accept[yy_current_state] )
1064  {
1067  }
1068  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1069  {
1071  if ( yy_current_state >= 210 )
1072  yy_c = yy_meta[(unsigned int) yy_c];
1073  }
1074  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1075  ++yy_cp;
1076  }
1077  while ( yy_current_state != 209 );
1080 
1081 yy_find_action:
1083 
1085 
1086 do_action: /* This label is used only to access EOF actions. */
1087 
1088  switch ( yy_act )
1089  { /* beginning of action switch */
1090  case 0: /* must back up */
1091  /* undo the effects of YY_DO_BEFORE_ACTION */
1092  *yy_cp = (yy_hold_char);
1095  goto yy_find_action;
1096 
1097 case 1:
1099 #line 133 "parser.l"
1101  YY_BREAK
1102 case 2:
1104 #line 134 "parser.l"
1106  YY_BREAK
1107 case 3:
1109 #line 135 "parser.l"
1110 {
1111  int lineno;
1112  char *cptr, *fname;
1113  yy_pop_state();
1114  lineno = (int)strtol(parser_text, &cptr, 10);
1115  if(!lineno)
1116  error_loc("Malformed '#...' line-directive; invalid linenumber\n");
1117  fname = strchr(cptr, '"');
1118  if(!fname)
1119  error_loc("Malformed '#...' line-directive; missing filename\n");
1120  fname++;
1121  cptr = strchr(fname, '"');
1122  if(!cptr)
1123  error_loc("Malformed '#...' line-directive; missing terminating \"\n");
1124  *cptr = '\0';
1125  line_number = lineno - 1; /* We didn't read the newline */
1126  input_name = xstrdup(fname);
1127  }
1128  YY_BREAK
1129 case 4:
1131 #line 153 "parser.l"
1132 yyless(9); yy_pop_state(); return tCPPQUOTE;
1133  YY_BREAK
1134 case 5:
1136 #line 154 "parser.l"
1137 {
1138  if(import_stack_ptr) {
1139  if(!winrt_mode)
1140  error_loc("winrt IDL file imported in non-winrt mode\n");
1141  }else {
1142  const char *ptr = parser_text+5;
1143 
1144  winrt_mode = TRUE;
1145 
1146  while(isspace(*ptr))
1147  ptr++;
1148  if(!strncmp(ptr, "ns_prefix", 9) && (!*(ptr += 9) || isspace(*ptr)))
1150  }
1151  yy_pop_state();
1152  }
1153  YY_BREAK
1154 case 6:
1156 #line 170 "parser.l"
1158  YY_BREAK
1159 case 7:
1161 #line 171 "parser.l"
1162 return tPRAGMA_WARNING;
1163  YY_BREAK
1164 case 8:
1166 #line 172 "parser.l"
1168  YY_BREAK
1169 case 9:
1171 #line 173 "parser.l"
1172 {
1173  yy_pop_state();
1175  return aSTRING;
1176  }
1177  YY_BREAK
1178 case 10:
1180 #line 178 "parser.l"
1182  YY_BREAK
1183 case 11:
1185 #line 179 "parser.l"
1186 {
1187  yy_pop_state();
1189  return aWSTRING;
1190  }
1191  YY_BREAK
1192 case 12:
1194 #line 184 "parser.l"
1196  YY_BREAK
1197 case 13:
1199 #line 185 "parser.l"
1200 {
1201  yy_pop_state();
1203  return aSQSTRING;
1204  }
1205  YY_BREAK
1206 case 14:
1207 #line 191 "parser.l"
1208 case 15:
1210 #line 191 "parser.l"
1211 addcchar(parser_text[1]);
1212  YY_BREAK
1213 case 16:
1215 #line 192 "parser.l"
1216 addcchar(parser_text[1]);
1217  YY_BREAK
1218 case 17:
1220 #line 193 "parser.l"
1221 addcchar('\\'); addcchar(parser_text[1]);
1222  YY_BREAK
1223 case 18:
1225 #line 194 "parser.l"
1226 addcchar(parser_text[0]);
1227  YY_BREAK
1228 case 19:
1230 #line 195 "parser.l"
1231 yy_push_state(ATTR); return '[';
1232  YY_BREAK
1233 case 20:
1235 #line 196 "parser.l"
1236 yy_pop_state(); return ']';
1237  YY_BREAK
1238 case 21:
1240 #line 197 "parser.l"
1241 return attr_token(parser_text);
1242  YY_BREAK
1243 case 22:
1245 #line 198 "parser.l"
1246 {
1248  return aUUID;
1249  }
1250  YY_BREAK
1251 case 23:
1253 #line 202 "parser.l"
1254 {
1256  return aHEXNUM;
1257  }
1258  YY_BREAK
1259 case 24:
1261 #line 206 "parser.l"
1262 {
1264  return aNUM;
1265  }
1266  YY_BREAK
1267 case 25:
1269 #line 210 "parser.l"
1270 {
1272  return aDOUBLE;
1273  }
1274  YY_BREAK
1275 case 26:
1276 *yy_cp = (yy_hold_char); /* undo effects of setting up parser_text */
1277 (yy_c_buf_p) = yy_cp -= 1;
1278 YY_DO_BEFORE_ACTION; /* set up parser_text again */
1280 #line 214 "parser.l"
1281 return tSAFEARRAY;
1282  YY_BREAK
1283 case 27:
1285 #line 215 "parser.l"
1286 return kw_token(parser_text);
1287  YY_BREAK
1288 case 28:
1289 /* rule 28 can match eol */
1291 #line 216 "parser.l"
1292 line_number++;
1293  YY_BREAK
1294 case 29:
1296 #line 217 "parser.l"
1297 
1298  YY_BREAK
1299 case 30:
1301 #line 218 "parser.l"
1302 return SHL;
1303  YY_BREAK
1304 case 31:
1306 #line 219 "parser.l"
1307 return SHR;
1308  YY_BREAK
1309 case 32:
1311 #line 220 "parser.l"
1312 return MEMBERPTR;
1313  YY_BREAK
1314 case 33:
1316 #line 221 "parser.l"
1317 return EQUALITY;
1318  YY_BREAK
1319 case 34:
1321 #line 222 "parser.l"
1322 return INEQUALITY;
1323  YY_BREAK
1324 case 35:
1326 #line 223 "parser.l"
1327 return GREATEREQUAL;
1328  YY_BREAK
1329 case 36:
1331 #line 224 "parser.l"
1332 return LESSEQUAL;
1333  YY_BREAK
1334 case 37:
1336 #line 225 "parser.l"
1337 return LOGICALOR;
1338  YY_BREAK
1339 case 38:
1341 #line 226 "parser.l"
1342 return LOGICALAND;
1343  YY_BREAK
1344 case 39:
1346 #line 227 "parser.l"
1347 return ELLIPSIS;
1348  YY_BREAK
1349 case 40:
1351 #line 228 "parser.l"
1352 return parser_text[0];
1353  YY_BREAK
1354 case YY_STATE_EOF(INITIAL):
1355 case YY_STATE_EOF(QUOTE):
1356 case YY_STATE_EOF(WSTRQUOTE):
1357 case YY_STATE_EOF(ATTR):
1358 case YY_STATE_EOF(PP_LINE):
1359 case YY_STATE_EOF(PP_PRAGMA):
1360 case YY_STATE_EOF(SQUOTE):
1361 #line 229 "parser.l"
1362 {
1363  if (import_stack_ptr)
1364  return aEOF;
1365  if (acf_name)
1366  {
1367  switch_to_acf();
1368  return aACF;
1369  }
1370  yyterminate();
1371  }
1372  YY_BREAK
1373 case 41:
1375 #line 239 "parser.l"
1376 ECHO;
1377  YY_BREAK
1378 #line 1379 "parser.yy.c"
1379 
1380  case YY_END_OF_BUFFER:
1381  {
1382  /* Amount of text matched not including the EOB char. */
1383  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1384 
1385  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1386  *yy_cp = (yy_hold_char);
1388 
1389  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1390  {
1391  /* We're scanning a new file or input source. It's
1392  * possible that this happened because the user
1393  * just pointed parser_in at a new source and called
1394  * parser_lex(). If so, then we have to assure
1395  * consistency between YY_CURRENT_BUFFER and our
1396  * globals. Here is the right place to do so, because
1397  * this is the first action (other than possibly a
1398  * back-up) that will match for the new input source.
1399  */
1400  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1401  YY_CURRENT_BUFFER_LVALUE->yy_input_file = parser_in;
1402  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1403  }
1404 
1405  /* Note that here we test for yy_c_buf_p "<=" to the position
1406  * of the first EOB in the buffer, since yy_c_buf_p will
1407  * already have been incremented past the NUL character
1408  * (since all states make transitions on EOB to the
1409  * end-of-buffer state). Contrast this with the test
1410  * in input().
1411  */
1412  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1413  { /* This was really a NUL. */
1414  yy_state_type yy_next_state;
1415 
1416  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1417 
1419 
1420  /* Okay, we're now positioned to make the NUL
1421  * transition. We couldn't have
1422  * yy_get_previous_state() go ahead and do it
1423  * for us because it doesn't know how to deal
1424  * with the possibility of jamming (and we don't
1425  * want to build jamming into it because then it
1426  * will run more slowly).
1427  */
1428 
1429  yy_next_state = yy_try_NUL_trans( yy_current_state );
1430 
1432 
1433  if ( yy_next_state )
1434  {
1435  /* Consume the NUL. */
1436  yy_cp = ++(yy_c_buf_p);
1437  yy_current_state = yy_next_state;
1438  goto yy_match;
1439  }
1440 
1441  else
1442  {
1445  goto yy_find_action;
1446  }
1447  }
1448 
1449  else switch ( yy_get_next_buffer( ) )
1450  {
1451  case EOB_ACT_END_OF_FILE:
1452  {
1454 
1455  if ( parser_wrap( ) )
1456  {
1457  /* Note: because we've taken care in
1458  * yy_get_next_buffer() to have set up
1459  * parser_text, we can now set up
1460  * yy_c_buf_p so that if some total
1461  * hoser (like flex itself) wants to
1462  * call the scanner after we return the
1463  * YY_NULL, it'll still work - another
1464  * YY_NULL will get returned.
1465  */
1467 
1469  goto do_action;
1470  }
1471 
1472  else
1473  {
1474  if ( ! (yy_did_buffer_switch_on_eof) )
1475  YY_NEW_FILE;
1476  }
1477  break;
1478  }
1479 
1480  case EOB_ACT_CONTINUE_SCAN:
1481  (yy_c_buf_p) =
1482  (yytext_ptr) + yy_amount_of_matched_text;
1483 
1485 
1486  yy_cp = (yy_c_buf_p);
1488  goto yy_match;
1489 
1490  case EOB_ACT_LAST_MATCH:
1491  (yy_c_buf_p) =
1492  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1493 
1495 
1496  yy_cp = (yy_c_buf_p);
1498  goto yy_find_action;
1499  }
1500  break;
1501  }
1502 
1503  default:
1505  "fatal flex scanner internal error--no action found" );
1506  } /* end of action switch */
1507  } /* end of scanning one token */
UUID * uuid
Definition: parser.tab.c:465
#define YY_DO_BEFORE_ACTION
Definition: parser.yy.c:376
#define YY_END_OF_BUFFER
Definition: parser.yy.c:384
#define WSTRQUOTE
Definition: parser.yy.c:822
#define isspace(c)
Definition: acclib.h:69
static int cbufidx
Definition: parser.yy.c:761
#define TRUE
Definition: types.h:120
register char * yy_cp
Definition: parser.yy.c:1012
static void yy_push_state(int new_state)
Definition: parser.yy.c:2132
FILE * parser_in
Definition: parser.yy.c:357
static int attr_token(const char *kw)
Definition: parser.yy.c:2597
#define EOB_ACT_END_OF_FILE
Definition: parser.yy.c:186
#define YY_NEW_FILE
Definition: parser.yy.c:158
unsigned char YY_CHAR
Definition: macro.lex.yy.c:336
_Check_return_ double __cdecl strtod(_In_z_ const char *_Str, _Out_opt_ _Deref_post_z_ char **_EndPtr)
#define YY_STATE_EOF(state)
Definition: parser.yy.c:155
#define YY_RULE_SETUP
Definition: parser.yy.c:1001
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
char * parser_text
Definition: parser.yy.c:703
static yyconst flex_int16_t yy_chk[728]
Definition: parser.yy.c:606
#define ECHO
Definition: parser.yy.c:919
int line_number
Definition: parser.yy.c:775
#define yy_current_state()
Definition: ppl.yy.c:1235
static yy_state_type yy_get_previous_state(void)
Definition: parser.yy.c:1651
#define YY_AT_BOL()
Definition: parser.yy.c:351
#define YY_START
Definition: parser.yy.c:151
static int yy_did_buffer_switch_on_eof
Definition: parser.yy.c:305
#define YY_MORE_ADJ
Definition: parser.yy.c:701
static int kw_token(const char *kw)
Definition: parser.yy.c:2584
struct cond_str str
Definition: cond.tab.c:267
static void addcchar(char c)
Definition: parser.yy.c:2610
static yyconst flex_int16_t yy_accept[210]
Definition: parser.yy.c:392
static PVOID ptr
Definition: dispmode.c:27
static yy_size_t yy_n_chars
Definition: parser.yy.c:294
#define SQUOTE
Definition: parser.yy.c:826
void error_loc(const char *s,...)
Definition: utils.c:69
#define PP_PRAGMA
Definition: parser.yy.c:825
int yy_state_type
Definition: macro.lex.yy.c:340
smooth NULL
Definition: ftsmooth.c:416
Definition: parser.c:48
#define YY_BUFFER_NORMAL
Definition: parser.yy.c:256
YYSTYPE parser_lval
static yyconst flex_int16_t yy_nxt[728]
Definition: parser.yy.c:522
#define EOB_ACT_LAST_MATCH
Definition: parser.yy.c:187
unsigned int num
Definition: parser.tab.c:466
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
register int yy_act
Definition: parser.yy.c:1013
static char * yy_last_accepting_cpos
Definition: parser.yy.c:691
int import_stack_ptr
Definition: parser.yy.c:778
#define ATTR
Definition: parser.yy.c:823
UUID * parse_uuid(const char *u)
Definition: parser.yy.c:793
static unsigned int xstrtoul(const char *nptr, char **endptr, int base)
Definition: parser.yy.c:782
int use_abi_namespace
Definition: widl.c:130
static void switch_to_acf(void)
Definition: parser.yy.c:2713
#define PP_LINE
Definition: parser.yy.c:824
#define EOB_ACT_CONTINUE_SCAN
Definition: parser.yy.c:185
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: parser.yy.c:1684
static yyconst flex_int16_t yy_base[251]
Definition: parser.yy.c:460
#define YY_SC_TO_UI(c)
Definition: parser.yy.c:139
static void yy_pop_state(void)
Definition: parser.yy.c:2156
static int yy_start
Definition: parser.yy.c:300
register char * yy_bp
Definition: parser.yy.c:1012
#define YY_BUFFER_NEW
Definition: parser.yy.c:255
#define yyless(n)
Definition: parser.yy.c:2177
static char yy_hold_char
Definition: parser.yy.c:293
int parser_wrap(void)
Definition: parser.yy.c:2382
static char * get_buffered_cstring(void)
Definition: parser.yy.c:2622
char * strchr(const char *String, int ch)
Definition: utclib.c:501
#define yytext_ptr
Definition: parser.yy.c:366
static int yy_get_next_buffer(void)
Definition: parser.yy.c:1517
_Check_return_ long __cdecl strtol(_In_z_ const char *_Str, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
static yy_state_type yy_last_accepting_state
Definition: parser.yy.c:690
static yyconst flex_int32_t yy_ec[256]
Definition: parser.yy.c:419
#define QUOTE
Definition: parser.yy.c:821
static char * yy_c_buf_p
Definition: parser.yy.c:298
#define YY_RESTORE_YY_MORE_OFFSET
Definition: parser.yy.c:702
#define YY_BREAK
Definition: parser.yy.c:998
char * xstrdup(const char *s)
Definition: uimain.c:768
char * acf_name
Definition: widl.c:135
double dbl
Definition: parser.tab.c:263
#define INITIAL
Definition: parser.yy.c:820
static yyconst flex_int16_t yy_def[251]
Definition: parser.yy.c:491
#define yyterminate()
Definition: parser.yy.c:963
int winrt_mode
Definition: widl.c:129
static yyconst flex_int32_t yy_meta[51]
Definition: parser.yy.c:451
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
char * input_name
Definition: parser.yy.c:774

◆ xstrtoul()

static unsigned int xstrtoul ( const char nptr,
char **  endptr,
int  base 
)
static

Definition at line 782 of file parser.yy.c.

783 {
784  unsigned long val;
785 
786  errno = 0;
787  val = strtoul(nptr, endptr, base);
788  if ((val == ULONG_MAX && errno == ERANGE) || ((unsigned int)val != val))
789  error_loc("integer constant %s is too large\n", nptr);
790  return val;
791 }
UINT32 strtoul(const char *String, char **Terminator, UINT32 Base)
Definition: utclib.c:696
int errno
void error_loc(const char *s,...)
Definition: utils.c:69
GLuint GLfloat * val
Definition: glext.h:7180
#define ERANGE
Definition: acclib.h:92
#define ULONG_MAX
Definition: limits.h:44

Referenced by while().

◆ yy_fatal_error() [1/2]

static void yy_fatal_error ( yyconst char  msg[])
static

◆ yy_fatal_error() [2/2]

static void yy_fatal_error ( yyconst char msg)
static

Definition at line 2168 of file parser.yy.c.

2169 {
2170  (void) fprintf( stderr, "%s\n", msg );
2171  exit( YY_EXIT_FAILURE );
2172 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define YY_EXIT_FAILURE
Definition: parser.yy.c:2165
#define msg(x)
Definition: auth_time.c:54
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( void  )
static

Definition at line 1517 of file parser.yy.c.

1518 {
1519  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1520  register char *source = (yytext_ptr);
1521  register int number_to_move, i;
1522  int ret_val;
1523 
1524  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1526  "fatal flex scanner internal error--end of buffer missed" );
1527 
1528  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1529  { /* Don't try to fill the buffer, so this is an EOF. */
1530  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1531  {
1532  /* We matched a single character, the EOB, so
1533  * treat this as a final EOF.
1534  */
1535  return EOB_ACT_END_OF_FILE;
1536  }
1537 
1538  else
1539  {
1540  /* We matched some text prior to the EOB, first
1541  * process it.
1542  */
1543  return EOB_ACT_LAST_MATCH;
1544  }
1545  }
1546 
1547  /* Try to read more data. */
1548 
1549  /* First move last chars to start of buffer. */
1550  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1551 
1552  for ( i = 0; i < number_to_move; ++i )
1553  *(dest++) = *(source++);
1554 
1555  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1556  /* don't do the read, it's not guaranteed to return an EOF,
1557  * just force an EOF
1558  */
1559  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1560 
1561  else
1562  {
1563  yy_size_t num_to_read =
1564  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1565 
1566  while ( num_to_read <= 0 )
1567  { /* Not enough room in the buffer - grow it. */
1568 
1569  /* just a shorter name for the current buffer */
1571 
1572  int yy_c_buf_p_offset =
1573  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1574 
1575  if ( b->yy_is_our_buffer )
1576  {
1577  yy_size_t new_size = b->yy_buf_size * 2;
1578 
1579  if ( new_size <= 0 )
1580  b->yy_buf_size += b->yy_buf_size / 8;
1581  else
1582  b->yy_buf_size *= 2;
1583 
1584  b->yy_ch_buf = (char *)
1585  /* Include room in for 2 EOB chars. */
1586  parser_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1587  }
1588  else
1589  /* Can't grow it, we don't own it. */
1590  b->yy_ch_buf = 0;
1591 
1592  if ( ! b->yy_ch_buf )
1594  "fatal error - scanner input buffer overflow" );
1595 
1596  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1597 
1598  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1599  number_to_move - 1;
1600 
1601  }
1602 
1603  if ( num_to_read > YY_READ_BUF_SIZE )
1604  num_to_read = YY_READ_BUF_SIZE;
1605 
1606  /* Read in more data. */
1607  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1608  (yy_n_chars), num_to_read );
1609 
1610  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1611  }
1612 
1613  if ( (yy_n_chars) == 0 )
1614  {
1615  if ( number_to_move == YY_MORE_ADJ )
1616  {
1617  ret_val = EOB_ACT_END_OF_FILE;
1619  }
1620 
1621  else
1622  {
1623  ret_val = EOB_ACT_LAST_MATCH;
1624  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1626  }
1627  }
1628 
1629  else
1630  ret_val = EOB_ACT_CONTINUE_SCAN;
1631 
1632  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1633  /* Extend the array by 50%, plus the number we really need. */
1634  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1635  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) parser_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1636  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1637  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1638  }
1639 
1640  (yy_n_chars) += number_to_move;
1643 
1644  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1645 
1646  return ret_val;
1647 }
FILE * parser_in
Definition: parser.yy.c:357
#define EOB_ACT_END_OF_FILE
Definition: parser.yy.c:186
void * parser_realloc(void *, yy_size_t)
Definition: parser.yy.c:2358
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
size_t yy_size_t
Definition: macro.lex.yy.c:159
#define YY_END_OF_BUFFER_CHAR
Definition: parser.yy.c:160
#define YY_INPUT(buf, result, max_size)
Definition: parser.yy.c:926
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define YY_MORE_ADJ
Definition: parser.yy.c:701
static yy_size_t yy_n_chars
Definition: parser.yy.c:294
#define YY_BUFFER_EOF_PENDING
Definition: parser.yy.c:267
#define YY_READ_BUF_SIZE
Definition: parser.yy.c:911
#define EOB_ACT_LAST_MATCH
Definition: parser.yy.c:187
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define EOB_ACT_CONTINUE_SCAN
Definition: parser.yy.c:185
void parser_restart(FILE *input_file)
Definition: parser.yy.c:1788
#define yytext_ptr
Definition: parser.yy.c:366
static char * yy_c_buf_p
Definition: parser.yy.c:298
static char * dest
Definition: rtl.c:135
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by while().

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( void  )
static

Definition at line 1651 of file parser.yy.c.

1652 {
1654  register char *yy_cp;
1655 
1658 
1659  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1660  {
1661  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1662  if ( yy_accept[yy_current_state] )
1663  {
1666  }
1667  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1668  {
1670  if ( yy_current_state >= 210 )
1671  yy_c = yy_meta[(unsigned int) yy_c];
1672  }
1673  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1674  }
1675 
1676  return yy_current_state;
1677 }
register char * yy_cp
Definition: parser.yy.c:1012
unsigned char YY_CHAR
Definition: macro.lex.yy.c:336
static yyconst flex_int16_t yy_chk[728]
Definition: parser.yy.c:606
#define yy_current_state()
Definition: ppl.yy.c:1235
#define YY_AT_BOL()
Definition: parser.yy.c:351
#define YY_MORE_ADJ
Definition: parser.yy.c:701
static yyconst flex_int16_t yy_accept[210]
Definition: parser.yy.c:392
int yy_state_type
Definition: macro.lex.yy.c:340
static yyconst flex_int16_t yy_nxt[728]
Definition: parser.yy.c:522
static char * yy_last_accepting_cpos
Definition: parser.yy.c:691
static yyconst flex_int16_t yy_base[251]
Definition: parser.yy.c:460
#define YY_SC_TO_UI(c)
Definition: parser.yy.c:139
static int yy_start
Definition: parser.yy.c:300
#define yytext_ptr
Definition: parser.yy.c:366
static yy_state_type yy_last_accepting_state
Definition: parser.yy.c:690
static yyconst flex_int32_t yy_ec[256]
Definition: parser.yy.c:419
static char * yy_c_buf_p
Definition: parser.yy.c:298
static yyconst flex_int16_t yy_def[251]
Definition: parser.yy.c:491
static yyconst flex_int32_t yy_meta[51]
Definition: parser.yy.c:451
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by while().

◆ yy_init_globals()

static int yy_init_globals ( void  )
static

Definition at line 2271 of file parser.yy.c.

2272 {
2273  /* Initialization is the same as for the non-reentrant scanner.
2274  * This function is called from parser_lex_destroy(), so don't allocate here.
2275  */
2276 
2277  (yy_buffer_stack) = 0;
2278  (yy_buffer_stack_top) = 0;
2279  (yy_buffer_stack_max) = 0;
2280  (yy_c_buf_p) = (char *) 0;
2281  (yy_init) = 0;
2282  (yy_start) = 0;
2283 
2284  (yy_start_stack_ptr) = 0;
2285  (yy_start_stack_depth) = 0;
2286  (yy_start_stack) = NULL;
2287 
2288 /* Defined in main.c */
2289 #ifdef YY_STDINIT
2290  parser_in = stdin;
2291  parser_out = stdout;
2292 #else
2293  parser_in = (FILE *) 0;
2294  parser_out = (FILE *) 0;
2295 #endif
2296 
2297  /* For future reference: Set errno on error, since we are called by
2298  * parser_lex_init()
2299  */
2300  return 0;
2301 }
FILE * parser_out
Definition: parser.yy.c:357
static int yy_init
Definition: parser.yy.c:299
FILE * parser_in
Definition: parser.yy.c:357
FILE * stdin
FILE * stdout
smooth NULL
Definition: ftsmooth.c:416
static YY_BUFFER_STATE * yy_buffer_stack
Definition: parser.yy.c:275
static int yy_start_stack_ptr
Definition: parser.yy.c:901
static int yy_start_stack_depth
Definition: parser.yy.c:902
static size_t yy_buffer_stack_top
Definition: parser.yy.c:273
static int yy_start
Definition: parser.yy.c:300
static size_t yy_buffer_stack_max
Definition: parser.yy.c:274
static int * yy_start_stack
Definition: parser.yy.c:903
static char * yy_c_buf_p
Definition: parser.yy.c:298

Referenced by parser_lex_destroy().

◆ yy_pop_state()

static void yy_pop_state ( void  )
static

Definition at line 2156 of file parser.yy.c.

2157 {
2158  if ( --(yy_start_stack_ptr) < 0 )
2159  YY_FATAL_ERROR( "start-condition stack underflow" );
2160 
2162 }
#define BEGIN
Definition: parser.yy.c:145
static int yy_start_stack_ptr
Definition: parser.yy.c:901
static int * yy_start_stack
Definition: parser.yy.c:903
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973

Referenced by while().

◆ yy_push_state()

static void yy_push_state ( int  new_state)
static

Definition at line 2132 of file parser.yy.c.

2133 {
2135  {
2136  yy_size_t new_size;
2137 
2139  new_size = (yy_start_stack_depth) * sizeof( int );
2140 
2141  if ( ! (yy_start_stack) )
2142  (yy_start_stack) = (int *) parser_alloc(new_size );
2143 
2144  else
2145  (yy_start_stack) = (int *) parser_realloc((void *) (yy_start_stack),new_size );
2146 
2147  if ( ! (yy_start_stack) )
2148  YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
2149  }
2150 
2152 
2153  BEGIN(new_state);
2154 }
void * parser_realloc(void *, yy_size_t)
Definition: parser.yy.c:2358
size_t yy_size_t
Definition: macro.lex.yy.c:159
#define YY_START
Definition: parser.yy.c:151
#define BEGIN
Definition: parser.yy.c:145
static int yy_start_stack_ptr
Definition: parser.yy.c:901
static int yy_start_stack_depth
Definition: parser.yy.c:902
#define YY_START_STACK_INCR
Definition: parser.yy.c:968
void * parser_alloc(yy_size_t)
Definition: parser.yy.c:2353
static int * yy_start_stack
Definition: parser.yy.c:903
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973

Referenced by while().

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state)
static

Definition at line 1684 of file parser.yy.c.

1685 {
1686  register int yy_is_jam;
1687  register char *yy_cp = (yy_c_buf_p);
1688 
1689  register YY_CHAR yy_c = 1;
1690  if ( yy_accept[yy_current_state] )
1691  {
1694  }
1695  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1696  {
1698  if ( yy_current_state >= 210 )
1699  yy_c = yy_meta[(unsigned int) yy_c];
1700  }
1701  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1702  yy_is_jam = (yy_current_state == 209);
1703 
1704  return yy_is_jam ? 0 : yy_current_state;
1705 }
register char * yy_cp
Definition: parser.yy.c:1012
unsigned char YY_CHAR
Definition: macro.lex.yy.c:336
static yyconst flex_int16_t yy_chk[728]
Definition: parser.yy.c:606
#define yy_current_state()
Definition: ppl.yy.c:1235
static yyconst flex_int16_t yy_accept[210]
Definition: parser.yy.c:392
static yyconst flex_int16_t yy_nxt[728]
Definition: parser.yy.c:522
static char * yy_last_accepting_cpos
Definition: parser.yy.c:691
static yyconst flex_int16_t yy_base[251]
Definition: parser.yy.c:460
static yy_state_type yy_last_accepting_state
Definition: parser.yy.c:690
static char * yy_c_buf_p
Definition: parser.yy.c:298
static yyconst flex_int16_t yy_def[251]
Definition: parser.yy.c:491
static yyconst flex_int32_t yy_meta[51]
Definition: parser.yy.c:451
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by while().

Variable Documentation

◆ attr_keywords

const struct keyword attr_keywords[]
static

Definition at line 2458 of file parser.yy.c.

Referenced by attr_token().

◆ cbufalloc

int cbufalloc = 0
static

Definition at line 762 of file parser.yy.c.

Referenced by addcchar().

◆ cbuffer

char* cbuffer
static

Definition at line 760 of file parser.yy.c.

Referenced by _chm_decompress_block(), addcchar(), and get_buffered_cstring().

◆ cbufidx

int cbufidx
static

Definition at line 761 of file parser.yy.c.

Referenced by addcchar(), and while().

◆ disabled_warnings

warning_list_t* disabled_warnings = NULL
static

Definition at line 769 of file parser.yy.c.

Referenced by do_warning(), is_warning_enabled(), warning_disable(), and warning_enable().

◆ first_import

struct imports * first_import

Referenced by do_import().

◆ import_stack

struct { ... } import_stack[MAX_IMPORT_DEPTH]

◆ import_stack_ptr

int import_stack_ptr = 0

Definition at line 778 of file parser.yy.c.

Referenced by abort_import(), do_import(), pop_import(), switch_to_acf(), and while().

◆ input_name

◆ keywords

const struct keyword keywords[]
static

Definition at line 2394 of file parser.yy.c.

Referenced by kw_token().

◆ line_number

◆ parser__flex_debug

int parser__flex_debug = 0

Definition at line 694 of file parser.yy.c.

Referenced by parser_get_debug(), and parser_set_debug().

◆ parser_in

◆ parser_leng

yy_size_t parser_leng

Definition at line 295 of file parser.yy.c.

Referenced by parser_get_leng().

◆ parser_lineno

int parser_lineno = 1

Definition at line 363 of file parser.yy.c.

Referenced by parser_get_lineno(), and parser_set_lineno().

◆ parser_out

FILE * parser_out = (FILE *) 0

Definition at line 357 of file parser.yy.c.

Referenced by if(), parser_get_out(), parser_set_out(), and yy_init_globals().

◆ parser_text

char* parser_text

Definition at line 703 of file parser.yy.c.

Referenced by parser_get_text(), and while().

◆ state

Definition at line 773 of file parser.yy.c.

Referenced by pop_import().

◆ temp_name

char* temp_name

Definition at line 776 of file parser.yy.c.

Referenced by abort_import(), do_import(), pop_import(), and switch_to_acf().

◆ yy_accept

yyconst flex_int16_t yy_accept[210]
static
Initial value:
=
{ 0,
0, 0, 0, 0, 0, 0, 0, 0, 3, 3,
6, 6, 0, 0, 42, 40, 29, 28, 40, 8,
40, 12, 40, 40, 24, 24, 40, 40, 40, 27,
27, 27, 19, 40, 29, 2, 27, 18, 41, 9,
18, 11, 24, 24, 21, 21, 21, 20, 29, 2,
3, 6, 6, 6, 13, 18, 34, 38, 32, 0,
0, 24, 24, 24, 0, 30, 36, 33, 35, 31,
27, 10, 27, 37, 0, 2, 0, 2, 0, 27,
17, 15, 14, 24, 0, 21, 21, 0, 2, 2,
3, 6, 6, 6, 16, 39, 25, 24, 24, 23,
27, 0, 0, 27, 24, 0, 21, 6, 6, 0,
23, 23, 27, 0, 0, 27, 24, 0, 21, 6,
6, 0, 25, 23, 23, 27, 0, 0, 27, 24,
0, 21, 6, 5, 27, 0, 0, 27, 24, 0,
21, 6, 5, 27, 0, 0, 27, 24, 0, 21,
6, 27, 0, 1, 27, 24, 0, 21, 6, 27,
0, 27, 0, 24, 4, 0, 26, 0, 27, 0,
4, 0, 27, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 7,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 22, 0
}

Definition at line 392 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_act

register int yy_act

Definition at line 1013 of file parser.yy.c.

Referenced by while().

◆ yy_base

yyconst flex_int16_t yy_base[251]
static
Initial value:
=
{ 0,
0, 49, 49, 53, 54, 57, 90, 59, 404, 397,
138, 139, 140, 141, 399, 677, 677, 677, 381, 677,
389, 677, 378, 382, 176, 138, 48, 377, 50, 0,
387, 372, 677, 335, 151, 152, 345, 677, 677, 677,
48, 677, 213, 118, 250, 0, 378, 677, 66, 377,
0, 0, 339, 337, 677, 138, 677, 677, 677, 363,
56, 181, 129, 48, 0, 677, 677, 677, 677, 677,
0, 677, 351, 677, 156, 154, 332, 157, 325, 328,
677, 677, 677, 274, 0, 309, 0, 71, 360, 359,
0, 0, 325, 316, 677, 677, 199, 677, 677, 137,
337, 320, 317, 309, 333, 0, 368, 308, 296, 195,
191, 142, 322, 298, 300, 304, 392, 0, 427, 303,
288, 61, 230, 677, 677, 309, 299, 285, 281, 451,
0, 486, 288, 0, 296, 275, 284, 271, 510, 0,
545, 279, 0, 294, 266, 302, 269, 569, 0, 604,
263, 271, 265, 294, 254, 292, 279, 278, 239, 80,
244, 239, 0, 351, 0, 164, 677, 238, 245, 0,
0, 244, 274, 0, 273, 167, 0, 241, 262, 227,
0, 225, 0, 226, 0, 219, 0, 222, 247, 677,
0, 0, 0, 0, 246, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 677, 677, 640,
644, 648, 650, 654, 656, 660, 664, 253, 252, 251,
249, 248, 668, 242, 239, 238, 672, 234, 227, 226,
221, 219, 217, 215, 211, 208, 207, 197, 188, 180,
178, 172, 171, 169, 144, 83, 82, 78, 77, 73
}

Definition at line 460 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_bp

register char * yy_bp

Definition at line 1012 of file parser.yy.c.

Referenced by while().

◆ yy_buffer_stack

YY_BUFFER_STATE* yy_buffer_stack = 0
static

Stack as an array.

Definition at line 275 of file parser.yy.c.

Referenced by parser_ensure_buffer_stack(), parser_lex_destroy(), and yy_init_globals().

◆ yy_buffer_stack_max

size_t yy_buffer_stack_max = 0
static

capacity of stack.

Definition at line 274 of file parser.yy.c.

Referenced by parser_ensure_buffer_stack(), and yy_init_globals().

◆ yy_buffer_stack_top

size_t yy_buffer_stack_top = 0
static

index of top of stack.

Definition at line 273 of file parser.yy.c.

Referenced by parser_ensure_buffer_stack(), parser_pop_buffer_state(), parser_push_buffer_state(), and yy_init_globals().

◆ yy_c_buf_p

◆ yy_chk

yyconst flex_int16_t yy_chk[728]
static

Definition at line 606 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_cp

register char* yy_cp

Definition at line 1012 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ YY_DECL

YY_DECL
Initial value:
{
#define yy_current_state()
Definition: ppl.yy.c:1235
int yy_state_type
Definition: macro.lex.yy.c:340

The main scanner function which does all the work.

Definition at line 1010 of file parser.yy.c.

◆ yy_def

yyconst flex_int16_t yy_def[251]
static
Initial value:
=
{ 0,
209, 1, 210, 210, 210, 210, 209, 7, 211, 211,
212, 212, 210, 210, 209, 209, 209, 209, 209, 209,
209, 209, 209, 209, 209, 209, 209, 209, 209, 213,
213, 213, 209, 209, 209, 209, 213, 209, 209, 209,
214, 209, 209, 43, 215, 215, 215, 209, 209, 209,
216, 217, 217, 217, 209, 214, 209, 209, 209, 209,
209, 209, 209, 209, 218, 209, 209, 209, 209, 209,
213, 209, 213, 209, 209, 209, 209, 209, 209, 213,
209, 209, 209, 209, 219, 215, 215, 209, 209, 209,
216, 217, 217, 217, 209, 209, 209, 209, 209, 218,
213, 209, 209, 213, 209, 220, 215, 217, 217, 209,
209, 209, 213, 209, 209, 213, 209, 221, 215, 217,
217, 209, 209, 209, 209, 213, 209, 209, 213, 209,
222, 215, 217, 223, 213, 209, 209, 213, 209, 224,
215, 217, 223, 213, 209, 209, 213, 209, 225, 215,
217, 213, 209, 209, 213, 209, 209, 215, 217, 213,
209, 213, 226, 209, 227, 209, 209, 209, 213, 228,
227, 209, 213, 229, 209, 209, 230, 209, 209, 209,
231, 209, 232, 209, 233, 209, 234, 209, 209, 209,
235, 236, 237, 238, 209, 239, 240, 241, 242, 243,
244, 245, 246, 247, 248, 249, 250, 209, 0, 209,
209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
209, 209, 209, 209, 209, 209, 209, 209, 209, 209
}

Definition at line 491 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_did_buffer_switch_on_eof

int yy_did_buffer_switch_on_eof
static

◆ yy_ec

yyconst flex_int32_t yy_ec[256]
static

Definition at line 419 of file parser.yy.c.

Referenced by while(), and yy_get_previous_state().

◆ yy_hold_char

char yy_hold_char
static

◆ yy_init

int yy_init = 0
static

Definition at line 299 of file parser.yy.c.

Referenced by if(), and yy_init_globals().

◆ yy_last_accepting_cpos

char* yy_last_accepting_cpos
static

Definition at line 691 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_last_accepting_state

yy_state_type yy_last_accepting_state
static

Definition at line 690 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_meta

yyconst flex_int32_t yy_meta[51]
static
Initial value:
=
{ 0,
1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 3, 3, 1, 1, 1, 3, 3, 3,
3, 4, 4, 4, 4, 4, 4, 4, 1, 1,
1, 4, 3, 3, 3, 3, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 1
}

Definition at line 451 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_n_chars

◆ yy_nxt

yyconst flex_int16_t yy_nxt[728]
static

Definition at line 522 of file parser.yy.c.

Referenced by while(), yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_start

int yy_start = 0
static

Definition at line 300 of file parser.yy.c.

Referenced by if(), while(), yy_get_previous_state(), and yy_init_globals().

◆ yy_start_stack

int* yy_start_stack = NULL
static

Definition at line 903 of file parser.yy.c.

Referenced by parser_lex_destroy(), yy_init_globals(), yy_pop_state(), and yy_push_state().

◆ yy_start_stack_depth

int yy_start_stack_depth = 0
static

Definition at line 902 of file parser.yy.c.

Referenced by yy_init_globals(), and yy_push_state().

◆ yy_start_stack_ptr

int yy_start_stack_ptr = 0
static

Definition at line 901 of file parser.yy.c.

Referenced by yy_init_globals(), yy_pop_state(), and yy_push_state().