ReactOS  0.4.13-dev-257-gfabbd7c
macro.lex.yy.h File Reference
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
Include dependency graph for macro.lex.yy.h:

Go to the source code of this file.

Classes

struct  yy_buffer_state
 

Macros

#define yyIN_HEADER   1
 
#define YY_INT_ALIGNED   short int
 
#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_BUF_SIZE   16384
 
#define YY_TYPEDEF_YY_BUFFER_STATE
 
#define YY_TYPEDEF_YY_SIZE_T
 
#define YY_STRUCT_YY_BUFFER_STATE
 
#define yytext_ptr   yytext
 
#define YY_EXTRA_TYPE   void *
 
#define YY_READ_BUF_SIZE   8192
 
#define YY_START_STACK_INCR   25
 
#define YY_DECL_IS_OURS   1
 
#define YY_DECL   int yylex (void)
 

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
 

Functions

void yyrestart (FILE *input_file)
 
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
 
YY_BUFFER_STATE yy_create_buffer (FILE *file, int size)
 
void yy_delete_buffer (YY_BUFFER_STATE b)
 
void yy_flush_buffer (YY_BUFFER_STATE b)
 
void yypush_buffer_state (YY_BUFFER_STATE new_buffer)
 
void yypop_buffer_state (void)
 
YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size)
 
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str)
 
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes, yy_size_t len)
 
voidyyalloc (yy_size_t)
 
voidyyrealloc (void *, yy_size_t)
 
void yyfree (void *)
 
int yylex_destroy (void)
 
int yyget_debug (void)
 
void yyset_debug (int debug_flag)
 
YY_EXTRA_TYPE yyget_extra (void)
 
void yyset_extra (YY_EXTRA_TYPE user_defined)
 
FILEyyget_in (void)
 
void yyset_in (FILE *in_str)
 
FILEyyget_out (void)
 
void yyset_out (FILE *out_str)
 
yy_size_t yyget_leng (void)
 
charyyget_text (void)
 
int yyget_lineno (void)
 
void yyset_lineno (int line_number)
 
int yywrap (void)
 
int yylex (void)
 

Variables

yy_size_t yyleng
 
FILEyyin
 
FILEyyout
 
int yylineno
 
charyytext
 

Macro Definition Documentation

◆ FLEX_BETA

#define FLEX_BETA

Definition at line 18 of file macro.lex.yy.h.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 13 of file macro.lex.yy.h.

◆ FLEXINT_H

#define FLEXINT_H

Definition at line 34 of file macro.lex.yy.h.

◆ INT16_MAX

#define INT16_MAX   (32767)

Definition at line 76 of file macro.lex.yy.h.

◆ INT16_MIN

#define INT16_MIN   (-32767-1)

Definition at line 67 of file macro.lex.yy.h.

◆ INT32_MAX

#define INT32_MAX   (2147483647)

Definition at line 79 of file macro.lex.yy.h.

◆ INT32_MIN

#define INT32_MIN   (-2147483647-1)

Definition at line 70 of file macro.lex.yy.h.

◆ INT8_MAX

#define INT8_MAX   (127)

Definition at line 73 of file macro.lex.yy.h.

◆ INT8_MIN

#define INT8_MIN   (-128)

Definition at line 64 of file macro.lex.yy.h.

◆ UINT16_MAX

#define UINT16_MAX   (65535U)

Definition at line 85 of file macro.lex.yy.h.

◆ UINT32_MAX

#define UINT32_MAX   (4294967295U)

Definition at line 88 of file macro.lex.yy.h.

◆ UINT8_MAX

#define UINT8_MAX   (255U)

Definition at line 82 of file macro.lex.yy.h.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 118 of file macro.lex.yy.h.

◆ YY_DECL

#define YY_DECL   int yylex (void)

Definition at line 298 of file macro.lex.yy.h.

◆ YY_DECL_IS_OURS

#define YY_DECL_IS_OURS   1

Definition at line 294 of file macro.lex.yy.h.

◆ YY_EXTRA_TYPE

#define YY_EXTRA_TYPE   void *

Definition at line 224 of file macro.lex.yy.h.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 14 of file macro.lex.yy.h.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 15 of file macro.lex.yy.h.

◆ YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION   37

Definition at line 16 of file macro.lex.yy.h.

◆ YY_INT_ALIGNED

#define YY_INT_ALIGNED   short int

Definition at line 9 of file macro.lex.yy.h.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 282 of file macro.lex.yy.h.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 287 of file macro.lex.yy.h.

◆ YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 136 of file macro.lex.yy.h.

◆ YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 122 of file macro.lex.yy.h.

◆ YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 127 of file macro.lex.yy.h.

◆ yyconst

#define yyconst

Definition at line 113 of file macro.lex.yy.h.

◆ yyIN_HEADER

#define yyIN_HEADER   1

Definition at line 3 of file macro.lex.yy.h.

◆ yytext_ptr

#define yytext_ptr   yytext

Definition at line 207 of file macro.lex.yy.h.

Typedef Documentation

◆ flex_int16_t

Definition at line 56 of file macro.lex.yy.h.

◆ flex_int32_t

typedef int flex_int32_t

Definition at line 57 of file macro.lex.yy.h.

◆ flex_int8_t

Definition at line 55 of file macro.lex.yy.h.

◆ flex_uint16_t

typedef unsigned short int flex_uint16_t

Definition at line 59 of file macro.lex.yy.h.

◆ flex_uint32_t

typedef unsigned int flex_uint32_t

Definition at line 60 of file macro.lex.yy.h.

◆ flex_uint8_t

typedef unsigned char flex_uint8_t

Definition at line 58 of file macro.lex.yy.h.

◆ YY_BUFFER_STATE

Definition at line 123 of file macro.lex.yy.h.

◆ yy_size_t

typedef size_t yy_size_t

Definition at line 128 of file macro.lex.yy.h.

Function Documentation

◆ yy_create_buffer()

YY_BUFFER_STATE yy_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 1351 of file macro.lex.yy.c.

1352 {
1354 
1355  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1356  if ( ! b )
1357  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1358 
1359  b->yy_buf_size = size;
1360 
1361  /* yy_ch_buf has to be 2 characters longer than the size given because
1362  * we need to put in 2 end-of-buffer characters.
1363  */
1364  b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1365  if ( ! b->yy_ch_buf )
1366  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1367 
1368  b->yy_is_our_buffer = 1;
1369 
1370  yy_init_buffer(b,file );
1371 
1372  return b;
1373 }
#define YY_FATAL_ERROR(msg)
Definition: macro.lex.yy.c:670
void * yyalloc(yy_size_t)
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLsizeiptr size
Definition: glext.h:5919
static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
struct yy_buffer_state * YY_BUFFER_STATE
Definition: macro.lex.yy.c:154
Definition: fci.c:126

Referenced by if(), and yyrestart().

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Destroy the buffer.

Parameters
ba buffer created with yy_create_buffer()

Definition at line 1379 of file macro.lex.yy.c.

1380 {
1381 
1382  if ( ! b )
1383  return;
1384 
1385  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1387 
1388  if ( b->yy_is_our_buffer )
1389  yyfree((void *) b->yy_ch_buf );
1390 
1391  yyfree((void *) b );
1392 }
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
void yyfree(void *)
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
struct yy_buffer_state * YY_BUFFER_STATE
Definition: macro.lex.yy.c:154
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

Referenced by yylex_destroy(), and yypop_buffer_state().

◆ yy_flush_buffer()

void yy_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 1426 of file macro.lex.yy.c.

1427 {
1428  if ( ! b )
1429  return;
1430 
1431  b->yy_n_chars = 0;
1432 
1433  /* We always need two end-of-buffer characters. The first causes
1434  * a transition to the end-of-buffer state. The second causes
1435  * a jam in that state.
1436  */
1437  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1438  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1439 
1440  b->yy_buf_pos = &b->yy_ch_buf[0];
1441 
1442  b->yy_at_bol = 1;
1443  b->yy_buffer_status = YY_BUFFER_NEW;
1444 
1445  if ( b == YY_CURRENT_BUFFER )
1447 }
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define YY_END_OF_BUFFER_CHAR
Definition: macro.lex.yy.c:141
#define YY_BUFFER_NEW
Definition: macro.lex.yy.c:236
static void yy_load_buffer_state(void)
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

Referenced by yy_init_buffer().

◆ yy_scan_buffer()

YY_BUFFER_STATE yy_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 1553 of file macro.lex.yy.c.

1554 {
1556 
1557  if ( size < 2 ||
1560  /* They forgot to leave room for the EOB's. */
1561  return 0;
1562 
1563  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1564  if ( ! b )
1565  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1566 
1567  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1568  b->yy_buf_pos = b->yy_ch_buf = base;
1569  b->yy_is_our_buffer = 0;
1570  b->yy_input_file = 0;
1571  b->yy_n_chars = b->yy_buf_size;
1572  b->yy_is_interactive = 0;
1573  b->yy_at_bol = 1;
1574  b->yy_fill_buffer = 0;
1575  b->yy_buffer_status = YY_BUFFER_NEW;
1576 
1578 
1579  return b;
1580 }
#define YY_FATAL_ERROR(msg)
Definition: macro.lex.yy.c:670
GLuint base
Definition: 3dtext.c:35
void * yyalloc(yy_size_t)
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLsizeiptr size
Definition: glext.h:5919
#define YY_END_OF_BUFFER_CHAR
Definition: macro.lex.yy.c:141
#define YY_BUFFER_NEW
Definition: macro.lex.yy.c:236
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
struct yy_buffer_state * YY_BUFFER_STATE
Definition: macro.lex.yy.c:154

Referenced by yy_scan_bytes().

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char bytes,
yy_size_t  len 
)

Setup the input buffer state to scan the given bytes. The next call to yylex() 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 1603 of file macro.lex.yy.c.

1604 {
1606  char *buf;
1607  yy_size_t n;
1608  yy_size_t i;
1609 
1610  /* Get memory for full buffer, including space for trailing EOB's. */
1611  n = _yybytes_len + 2;
1612  buf = (char *) yyalloc(n );
1613  if ( ! buf )
1614  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1615 
1616  for ( i = 0; i < _yybytes_len; ++i )
1617  buf[i] = yybytes[i];
1618 
1619  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1620 
1621  b = yy_scan_buffer(buf,n );
1622  if ( ! b )
1623  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1624 
1625  /* It's okay to grow etc. this buffer, and we should throw it
1626  * away when we're done.
1627  */
1628  b->yy_is_our_buffer = 1;
1629 
1630  return b;
1631 }
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_FATAL_ERROR(msg)
Definition: macro.lex.yy.c:670
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
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
void * yyalloc(yy_size_t)
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define YY_END_OF_BUFFER_CHAR
Definition: macro.lex.yy.c:141

Referenced by yy_scan_string().

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char yy_str)

Setup the input buffer state to scan a string. The next call to yylex() 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 yy_scan_bytes() instead.

Definition at line 1590 of file macro.lex.yy.c.

1591 {
1592 
1593  return yy_scan_bytes(yystr,strlen(yystr) );
1594 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, yy_size_t len)

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Switch to a different input buffer.

Parameters
new_bufferThe new input buffer.

Definition at line 1306 of file macro.lex.yy.c.

1307 {
1308 
1309  /* TODO. We should be able to replace this entire function body
1310  * with
1311  * yypop_buffer_state();
1312  * yypush_buffer_state(new_buffer);
1313  */
1315  if ( YY_CURRENT_BUFFER == new_buffer )
1316  return;
1317 
1318  if ( YY_CURRENT_BUFFER )
1319  {
1320  /* Flush out information for old buffer. */
1321  *(yy_c_buf_p) = (yy_hold_char);
1322  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1323  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1324  }
1325 
1326  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1328 
1329  /* We don't actually know whether we did this switch during
1330  * EOF (yywrap()) processing, but the only time this flag
1331  * is looked at is after yywrap() is called, so it's safe
1332  * to go ahead and always set it.
1333  */
1335 }
static char * yy_c_buf_p
Definition: macro.lex.yy.c:279
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
static void yyensure_buffer_stack(void)
static int yy_did_buffer_switch_on_eof
Definition: macro.lex.yy.c:286
static yy_size_t yy_n_chars
Definition: macro.lex.yy.c:275
static void yy_load_buffer_state(void)
static char yy_hold_char
Definition: macro.lex.yy.c:274
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

Referenced by yy_scan_buffer().

◆ yyalloc()

Definition at line 1814 of file macro.lex.yy.c.

1815 {
1816  return (void *) malloc( size );
1817 }
GLsizeiptr size
Definition: glext.h:5919
#define malloc
Definition: debug_ros.c:4

Referenced by yy_create_buffer(), yy_scan_buffer(), yy_scan_bytes(), and yyensure_buffer_stack().

◆ yyfree()

void yyfree ( void )

Definition at line 1831 of file macro.lex.yy.c.

1832 {
1833  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1834 }
#define free
Definition: debug_ros.c:5
static PVOID ptr
Definition: dispmode.c:27

Referenced by yy_delete_buffer(), and yylex_destroy().

◆ yyget_debug()

int yyget_debug ( void  )

Definition at line 1730 of file macro.lex.yy.c.

1731 {
1732  return yy_flex_debug;
1733 }
int yy_flex_debug
Definition: macro.lex.yy.c:462

◆ yyget_extra()

YY_EXTRA_TYPE yyget_extra ( void  )

◆ yyget_in()

FILE* yyget_in ( void  )

Get the input stream.

Definition at line 1674 of file macro.lex.yy.c.

1675 {
1676  return yyin;
1677 }
FILE * yyin
Definition: macro.lex.yy.c:338

◆ yyget_leng()

yy_size_t yyget_leng ( void  )

Get the length of the current token.

Definition at line 1690 of file macro.lex.yy.c.

1691 {
1692  return yyleng;
1693 }
yy_size_t yyleng
Definition: macro.lex.yy.c:276

◆ yyget_lineno()

int yyget_lineno ( void  )

Get the current line number.

Definition at line 1665 of file macro.lex.yy.c.

1666 {
1667 
1668  return yylineno;
1669 }
int yylineno
Definition: macro.lex.yy.c:344

◆ yyget_out()

FILE* yyget_out ( void  )

Get the output stream.

Definition at line 1682 of file macro.lex.yy.c.

1683 {
1684  return yyout;
1685 }
FILE * yyout
Definition: macro.lex.yy.c:338

◆ yyget_text()

char* yyget_text ( void  )

Get the current token.

Definition at line 1699 of file macro.lex.yy.c.

1700 {
1701  return yytext;
1702 }
char * yytext
Definition: macro.lex.yy.c:471

◆ yylex()

int yylex ( void  )

◆ yylex_destroy()

int yylex_destroy ( void  )

Definition at line 1769 of file macro.lex.yy.c.

1770 {
1771 
1772  /* Pop the buffer stack, destroying each element. */
1773  while(YY_CURRENT_BUFFER){
1777  }
1778 
1779  /* Destroy the stack itself. */
1780  yyfree((yy_buffer_stack) );
1781  (yy_buffer_stack) = NULL;
1782 
1783  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1784  * yylex() is called, initialization will occur. */
1785  yy_init_globals( );
1786 
1787  return 0;
1788 }
void yy_delete_buffer(YY_BUFFER_STATE b)
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
smooth NULL
Definition: ftsmooth.c:416
void yyfree(void *)
static int yy_init_globals(void)
static YY_BUFFER_STATE * yy_buffer_stack
Definition: macro.lex.yy.c:256
void yypop_buffer_state(void)
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

◆ yypop_buffer_state()

void yypop_buffer_state ( void  )

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

Definition at line 1485 of file macro.lex.yy.c.

1486 {
1487  if (!YY_CURRENT_BUFFER)
1488  return;
1489 
1492  if ((yy_buffer_stack_top) > 0)
1493  --(yy_buffer_stack_top);
1494 
1495  if (YY_CURRENT_BUFFER) {
1498  }
1499 }
void yy_delete_buffer(YY_BUFFER_STATE b)
static size_t yy_buffer_stack_top
Definition: macro.lex.yy.c:254
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
smooth NULL
Definition: ftsmooth.c:416
static int yy_did_buffer_switch_on_eof
Definition: macro.lex.yy.c:286
static void yy_load_buffer_state(void)
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

Referenced by yylex_destroy().

◆ yypush_buffer_state()

void yypush_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 1455 of file macro.lex.yy.c.

1456 {
1457  if (new_buffer == NULL)
1458  return;
1459 
1461 
1462  /* This block is copied from yy_switch_to_buffer. */
1463  if ( YY_CURRENT_BUFFER )
1464  {
1465  /* Flush out information for old buffer. */
1466  *(yy_c_buf_p) = (yy_hold_char);
1467  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1468  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1469  }
1470 
1471  /* Only push if top exists. Otherwise, replace top. */
1472  if (YY_CURRENT_BUFFER)
1473  (yy_buffer_stack_top)++;
1474  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1475 
1476  /* copied from yy_switch_to_buffer. */
1479 }
static size_t yy_buffer_stack_top
Definition: macro.lex.yy.c:254
static char * yy_c_buf_p
Definition: macro.lex.yy.c:279
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
static void yyensure_buffer_stack(void)
smooth NULL
Definition: ftsmooth.c:416
static int yy_did_buffer_switch_on_eof
Definition: macro.lex.yy.c:286
static yy_size_t yy_n_chars
Definition: macro.lex.yy.c:275
static void yy_load_buffer_state(void)
static char yy_hold_char
Definition: macro.lex.yy.c:274
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

◆ yyrealloc()

void* yyrealloc ( void ,
yy_size_t   
)

Definition at line 1819 of file macro.lex.yy.c.

1820 {
1821  /* The cast to (char *) in the following accommodates both
1822  * implementations that use char* generic pointers, and those
1823  * that use void* generic pointers. It works with the latter
1824  * because both ANSI C and C++ allow castless assignment from
1825  * any pointer type to void*, and deal with argument conversions
1826  * as though doing an assignment.
1827  */
1828  return (void *) realloc( (char *) ptr, size );
1829 }
#define realloc
Definition: debug_ros.c:6
static PVOID ptr
Definition: dispmode.c:27
GLsizeiptr size
Definition: glext.h:5919

Referenced by yy_get_next_buffer(), and yyensure_buffer_stack().

◆ yyrestart()

void yyrestart ( 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 1289 of file macro.lex.yy.c.

1290 {
1291 
1292  if ( ! YY_CURRENT_BUFFER ){
1296  }
1297 
1298  yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1300 }
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
static void yyensure_buffer_stack(void)
FILE * yyin
Definition: macro.lex.yy.c:338
#define YY_BUF_SIZE
Definition: macro.lex.yy.c:145
static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
static void yy_load_buffer_state(void)
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264

Referenced by yy_get_next_buffer().

◆ yyset_debug()

void yyset_debug ( int  debug_flag)

Definition at line 1735 of file macro.lex.yy.c.

1736 {
1737  yy_flex_debug = bdebug ;
1738 }
int yy_flex_debug
Definition: macro.lex.yy.c:462

◆ yyset_extra()

void yyset_extra ( YY_EXTRA_TYPE  user_defined)

◆ yyset_in()

void yyset_in ( FILE in_str)

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

Parameters
in_strA readable stream.
See also
yy_switch_to_buffer

Definition at line 1720 of file macro.lex.yy.c.

1721 {
1722  yyin = in_str ;
1723 }
FILE * yyin
Definition: macro.lex.yy.c:338

◆ yyset_lineno()

void yyset_lineno ( int  line_number)

Set the current line number.

Parameters
line_number

Definition at line 1708 of file macro.lex.yy.c.

1709 {
1710 
1712 }
int line_number
Definition: parser.yy.c:775
int yylineno
Definition: macro.lex.yy.c:344

◆ yyset_out()

void yyset_out ( FILE out_str)

Definition at line 1725 of file macro.lex.yy.c.

1726 {
1727  yyout = out_str ;
1728 }
FILE * yyout
Definition: macro.lex.yy.c:338

◆ yywrap()

int yywrap ( void  )

Definition at line 2104 of file macro.lex.yy.c.

2104 { return 1; }

Referenced by while().

Variable Documentation

◆ yyin

FILE* yyin

◆ yyleng

yy_size_t yyleng

◆ yylineno

int yylineno

◆ yyout

FILE * yyout

◆ yytext

char* yytext