#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "config.h"
#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winhelp.h"
#include "wine/debug.h"

Include dependency graph for macro.lex.yy.c:

Classes
struct	yy_buffer_state

struct	yy_trans_info

struct	lex_data

Macros
#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_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 yyrestart(yyin )

#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 yy_flush_buffer(YY_CURRENT_BUFFER )

#define	yy_new_buffer yy_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 yytext

#define	YY_DO_BEFORE_ACTION

#define	YY_NUM_RULES 14

#define	YY_END_OF_BUFFER 15

#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	YY_INPUT(buf, result, max_size) if ((result = lex_data->macroptr ? 1 : 0)) buf[0] = lex_data->macroptr++;

#define	INITIAL 0

#define	quote 1

#define	YY_EXTRA_TYPE void *

#define	YY_READ_BUF_SIZE 8192

#define	ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)

#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 yylex (void)

#define	YY_USER_ACTION

#define	YY_BREAK break;

#define	YY_RULE_SETUP YY_USER_ACTION

#define	YY_EXIT_FAILURE 2

#define	yyless(n)

#define	YYTABLES_NAME "yytables"

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_state *	YY_BUFFER_STATE

typedef size_t	yy_size_t

typedef unsigned char	YY_CHAR

typedef int	yy_state_type

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)

static void	yyensure_buffer_stack (void)

static void	yy_load_buffer_state (void)

static void	yy_init_buffer (YY_BUFFER_STATE b, FILE *file)

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)

void *	yyalloc (yy_size_t)

void *	yyrealloc (void *, yy_size_t)

void	yyfree (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[])

	WINE_DEFAULT_DEBUG_CHANNEL (winhelp)

static int	yy_init_globals (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)

FILE *	yyget_in (void)

void	yyset_in (FILE *in_str)

FILE *	yyget_out (void)

void	yyset_out (FILE *out_str)

yy_size_t	yyget_leng (void)

char *	yyget_text (void)

int	yyget_lineno (void)

void	yyset_lineno (int line_number)

int	yywrap (void)

int	yylex (void)

	if (!(yy_init))

	while (1)

static void	yy_fatal_error (yyconst char *msg)

static const char *	ts (int t)

static int	MACRO_CallBoolFunc (void fn, const char args, void **ret)

static int	MACRO_CheckArgs (void pa[], unsigned max, const char args)

static int	MACRO_CallVoidFunc (void fn, const char args)

BOOL	MACRO_ExecuteMacro (WINHELP_WINDOW *window, LPCSTR macro)

WINHELP_WINDOW *	MACRO_CurrentWindow (void)

Variables
yy_size_t	yyleng

FILE *	yyin = (FILE *) 0

FILE *	yyout = (FILE *) 0

static size_t	yy_buffer_stack_top = 0

static size_t	yy_buffer_stack_max = 0

static YY_BUFFER_STATE *	yy_buffer_stack = 0

static char	yy_hold_char

static yy_size_t	yy_n_chars

static char *	yy_c_buf_p = (char *) 0

static int	yy_init = 0

static int	yy_start = 0

static int	yy_did_buffer_switch_on_eof

int	yylineno = 1

char *	yytext

static yyconst flex_int16_t	yy_accept [28]

static yyconst flex_int32_t	yy_ec [256]

static yyconst flex_int32_t	yy_meta [15]

static yyconst flex_int16_t	yy_base [33]

static yyconst flex_int16_t	yy_def [33]

static yyconst flex_int16_t	yy_nxt [77]

static yyconst flex_int16_t	yy_chk [77]

static yy_state_type	yy_last_accepting_state

static char *	yy_last_accepting_cpos

int	yy_flex_debug = 0

static struct lex_data *	lex_data = NULL

struct lexret	yylval

	YY_DECL

register char *	yy_cp

register char *	yy_bp

register int	yy_act

Macro Definition Documentation

◆ BEGIN

#define BEGIN (yy_start) = 1 + 2 *

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

◆ ECHO

#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)

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

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN 0

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

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE 1

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

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH 2

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

◆ FLEX_BETA

#define FLEX_BETA

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

◆ FLEX_SCANNER

#define FLEX_SCANNER

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

◆ FLEXINT_H

#define FLEXINT_H

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

◆ INITIAL

#define INITIAL 0

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

◆ INT16_MAX

#define INT16_MAX (32767)

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

◆ INT16_MIN

#define INT16_MIN (-32767-1)

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

◆ INT32_MAX

#define INT32_MAX (2147483647)

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

◆ INT32_MIN

#define INT32_MIN (-2147483647-1)

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

◆ INT8_MAX

#define INT8_MAX (127)

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

◆ INT8_MIN

#define INT8_MIN (-128)

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

◆ quote

#define quote 1

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

◆ REJECT

#define REJECT reject_used_but_not_detected

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

◆ UINT16_MAX

#define UINT16_MAX (65535U)

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

◆ UINT32_MAX

#define UINT32_MAX (4294967295U)

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

◆ UINT8_MAX

#define UINT8_MAX (255U)

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

◆ unput

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

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

◆ YY_AT_BOL

#define YY_AT_BOL ( ) (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

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

◆ YY_BREAK

#define YY_BREAK break;

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

◆ YY_BUF_SIZE

#define YY_BUF_SIZE 16384

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

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING 2

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

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW 0

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

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL 1

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

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

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

◆ YY_CURRENT_BUFFER_LVALUE

#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

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

◆ YY_DECL

#define YY_DECL int yylex (void)

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

◆ YY_DECL_IS_OURS

#define YY_DECL_IS_OURS 1

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

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
    yyleng = (size_t) (yy_cp - yy_bp); \
    (yy_hold_char) = *yy_cp; \
    *yy_cp = '\0'; \
    (yy_c_buf_p) = yy_cp;

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

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER 15

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

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR 0

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

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE 2

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

◆ YY_EXTRA_TYPE

#define YY_EXTRA_TYPE void *

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

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR ( msg ) yy_fatal_error( msg )

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

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION 2

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

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION 5

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

◆ YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION 37

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

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )

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

◆ YY_INPUT

#define YY_INPUT	(	buf,
		result,
		max_size
	)	if ((result = lex_data->macroptr ? 1 : 0)) buf[0] = lex_data->macroptr++;

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

◆ YY_INT_ALIGNED

#define YY_INT_ALIGNED short int

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

◆ YY_LESS_LINENO

#define YY_LESS_LINENO ( n )

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

◆ YY_MORE_ADJ

#define YY_MORE_ADJ 0

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

◆ yy_new_buffer

#define yy_new_buffer yy_create_buffer

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

◆ YY_NEW_FILE

#define YY_NEW_FILE yyrestart(yyin )

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

◆ YY_NO_INPUT

#define YY_NO_INPUT 1

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

◆ YY_NO_UNISTD_H

#define YY_NO_UNISTD_H

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

◆ YY_NULL

#define YY_NULL 0

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

◆ YY_NUM_RULES

#define YY_NUM_RULES 14

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

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE 8192

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

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

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

◆ YY_RULE_SETUP

#define YY_RULE_SETUP YY_USER_ACTION

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

◆ YY_SC_TO_UI

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

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

◆ yy_set_bol

#define yy_set_bol ( at_bol )

Value:

{ \
    if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (); \
        YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
    } \
    YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    }

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

◆ yy_set_interactive

#define yy_set_interactive ( is_interactive )

Value:

{ \
    if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (); \
        YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
    } \
    YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    }

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

◆ YY_START

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

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

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR 25

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

◆ YY_STATE_BUF_SIZE

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

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

◆ YY_STATE_EOF

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

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

◆ YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

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

◆ YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

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

◆ YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

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

◆ YY_USER_ACTION

#define YY_USER_ACTION

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

◆ yyconst

#define yyconst

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

◆ yyless [1/2]

#define yyless ( n )

Value:

do \
        { \
        /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        *yy_cp = (yy_hold_char); \
        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 yytext again */ \
        } \
    while ( 0 )

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

◆ yyless [2/2]

#define yyless ( n )

Value:

do \
        { \
        /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        yytext[yyleng] = (yy_hold_char); \
        (yy_c_buf_p) = yytext + yyless_macro_arg; \
        (yy_hold_char) = *(yy_c_buf_p); \
        *(yy_c_buf_p) = '\0'; \
        yyleng = yyless_macro_arg; \
        } \
    while ( 0 )

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

◆ yymore

#define yymore ( ) yymore_used_but_not_detected

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

◆ YYSTATE

#define YYSTATE YY_START

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

◆ YYTABLES_NAME

#define YYTABLES_NAME "yytables"

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

◆ yyterminate

#define yyterminate ( ) return YY_NULL

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

◆ yytext_ptr

#define yytext_ptr yytext

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

Typedef Documentation

◆ flex_int16_t

typedef short int flex_int16_t

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

◆ flex_int32_t

typedef int flex_int32_t

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

◆ flex_int8_t

typedef signed char flex_int8_t

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

◆ flex_uint16_t

typedef unsigned short int flex_uint16_t

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

◆ flex_uint32_t

typedef unsigned int flex_uint32_t

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

◆ flex_uint8_t

typedef unsigned char flex_uint8_t

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

◆ YY_BUFFER_STATE

typedef struct yy_buffer_state* YY_BUFFER_STATE

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

◆ YY_CHAR

typedef unsigned char YY_CHAR

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

◆ yy_size_t

typedef size_t yy_size_t

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

◆ yy_state_type

typedef int yy_state_type

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

Function Documentation

◆ if()

if ( ! yy_init )

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

         {
         (yy_init) = 1;
 
 #ifdef YY_USER_INIT
         YY_USER_INIT;
 #endif
 
         if ( ! (yy_start) )
             (yy_start) = 1; /* first start state */
 
         if ( ! yyin )
             yyin = stdin;
 
         if ( ! yyout )
             yyout = stdout;
 
         if ( ! YY_CURRENT_BUFFER ) {
             yyensure_buffer_stack ();
             YY_CURRENT_BUFFER_LVALUE =
                 yy_create_buffer(yyin,YY_BUF_SIZE );
         }
 
         yy_load_buffer_state( );
         }

◆ MACRO_CallBoolFunc()

static int MACRO_CallBoolFunc	(	void *	fn,
		const char *	args,
		void **	ret
	)

static

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

 {
     void*       pa[2];
     int         idx = MACRO_CheckArgs(pa, ARRAY_SIZE(pa), args);
 
     if (idx < 0) return 0;
     if (!fn)     return 1;
 
     WINE_TRACE("calling with %u pmts\n", idx);
 
     switch (strlen(args))
     {
     case 0:
     {
         BOOL (WINAPI *func)(void) = fn;
         *ret = (void *)(ULONG_PTR)func();
         break;
     }
     case 1:
     {
         BOOL (WINAPI *func)(void *) = fn;
         *ret = (void *)(ULONG_PTR)func( pa[0]);
         break;
     }
     default: WINE_FIXME("NIY\n");
     }
 
     return 1;
 }

Referenced by MACRO_CheckArgs().

◆ MACRO_CallVoidFunc()

static int MACRO_CallVoidFunc	(	void *	fn,
		const char *	args
	)

static

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

 {
     void*       pa[6];
     int         idx = MACRO_CheckArgs(pa, ARRAY_SIZE(pa), args);
 
     if (idx < 0) return 0;
     if (!fn)     return 1;
 
     WINE_TRACE("calling %p with %u pmts\n", fn, idx);
 
     switch (strlen(args))
     {
     case 0:
     {
         void (WINAPI *func)(void) = fn;
         func();
         break;
     }
     case 1:
     {
         void (WINAPI *func)(void*) = fn;
         func( pa[0] );
         break;
     }
     case 2:
     {
         void (WINAPI *func)(void*,void*) = fn;
         func( pa[0], pa[1] );
         break;
     }
     case 3:
     {
         void (WINAPI *func)(void*,void*,void*) = fn;
         func( pa[0], pa[1], pa[2] );
         break;
     }
     case 4:
     {
         void (WINAPI *func)(void*,void*,void*,void*) = fn;
         func( pa[0], pa[1], pa[2], pa[3] );
         break;
     }
     case 5:
     {
         void (WINAPI *func)(void*,void*,void*,void*,void*) = fn;
         func( pa[0], pa[1], pa[2], pa[3], pa[4] );
         break;
     }
     case 6:
     {
         void (WINAPI *func)(void*,void*,void*,void*,void*,void*) = fn;
         func( pa[0], pa[1], pa[2], pa[3], pa[4], pa[5] );
         break;
     }
     default: WINE_FIXME("NIY\n");
     }
 
     return 1;
 }

Referenced by MACRO_ExecuteMacro().

◆ MACRO_CheckArgs()

static int MACRO_CheckArgs	(	void *	pa[],
		unsigned	max,
		const char *	args
	)

static

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

 {
     int t;
     unsigned int len = 0, idx = 0;
 
     WINE_TRACE("Checking %s\n", debugstr_a(args));
 
     if (yylex() != '(') {WINE_WARN("missing (\n");return -1;}
 
     if (*args)
     {
         len = strlen(args);
         for (;;)
         {
             t = yylex();
             WINE_TRACE("Got %s <=> %c\n", debugstr_a(ts(t)), *args);
 
             switch (*args)
             {
             case 'S': 
                 if (t != STRING)
                 {WINE_WARN("missing S\n");return -1;}
                 pa[idx] = (void*)yylval.string;  
                 break;
             case 'U':
             case 'I':
                 if (t != INTEGER)
                 {WINE_WARN("missing U\n");return -1;}   
                 pa[idx] = LongToPtr(yylval.integer);
                 break;
             case 'B':
                 if (t != BOOL_FUNCTION) 
                 {WINE_WARN("missing B\n");return -1;}   
                 if (MACRO_CallBoolFunc(yylval.function, yylval.proto, &pa[idx]) == 0)
                     return -1;
                 break;
             default: 
                 WINE_WARN("unexpected %s while args is %c\n", debugstr_a(ts(t)), *args);
                 return -1;
             }
             idx++;
             if (*++args == '\0') break;
             t = yylex();
             if (t == ')') goto CheckArgs_end;
             if (t != ',') {WINE_WARN("missing ,\n");return -1;}
             if (idx >= max) {WINE_FIXME("stack overflow (%d)\n", max);return -1;}
         }
     }
     if (yylex() != ')') {WINE_WARN("missing )\n");return -1;}
 
 CheckArgs_end:
     while (len > idx) pa[--len] = NULL;
     return idx;
 }

Referenced by MACRO_CallBoolFunc(), and MACRO_CallVoidFunc().

◆ MACRO_CurrentWindow()

WINHELP_WINDOW* MACRO_CurrentWindow ( void )

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

 {
     return lex_data ? lex_data->window : Globals.active_win;
 }

Referenced by MACRO_About(), MACRO_Back(), MACRO_BackFlush(), MACRO_BrowseButtons(), MACRO_ChangeButtonBinding(), MACRO_Contents(), MACRO_CreateButton(), MACRO_DisableButton(), MACRO_EnableButton(), MACRO_HelpOn(), MACRO_IfThen(), MACRO_IfThenElse(), MACRO_JumpHash(), MACRO_Next(), MACRO_Prev(), MACRO_Print(), MACRO_SetHelpOnFile(), and MACRO_SetPopupColor().

◆ MACRO_ExecuteMacro()

BOOL MACRO_ExecuteMacro	(	WINHELP_WINDOW *	window,
		LPCSTR	macro
	)

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

 {
     struct lex_data     curr_lex_data, *prev_lex_data;
     BOOL ret = TRUE;
     int t;
 
     WINE_TRACE("%s\n", debugstr_a(macro));
 
     prev_lex_data = lex_data;
     lex_data = &curr_lex_data;
 
     memset(lex_data, 0, sizeof(*lex_data));
     lex_data->macroptr = macro;
     lex_data->window = WINHELP_GrabWindow(window);
 
     while ((t = yylex()) != EMPTY)
     {
         switch (t)
         {
         case VOID_FUNCTION:
             WINE_TRACE("got type void func(%s)\n", debugstr_a(yylval.proto));
             MACRO_CallVoidFunc(yylval.function, yylval.proto);
             break;
         case BOOL_FUNCTION:
             WINE_WARN("got type bool func(%s)\n", debugstr_a(yylval.proto));
             break;
         default:
             WINE_WARN("got unexpected type %s\n", debugstr_a(ts(t)));
             YY_FLUSH_BUFFER;
             ret = FALSE;
             goto done;
         }
         switch (t = yylex())
         {
         case EMPTY:     goto done;
         case ';':       break;
         default:        ret = FALSE; YY_FLUSH_BUFFER; goto done;
         }
     }
 
 done:
     for (t = 0; t < lex_data->cache_used; t++)
         HeapFree(GetProcessHeap(), 0, lex_data->cache_string[t]);
     lex_data = prev_lex_data;
     WINHELP_ReleaseWindow(window);
 
     return ret;
 }

Referenced by MACRO_IfThen(), MACRO_IfThenElse(), WINHELP_CreateHelpWindow(), WINHELP_HandleTextMouse(), and WINHELP_MainWndProc().

◆ ts()

static const char* ts ( int t )

static

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

 {
     static char c[2] = {0,0};
 
     switch (t)
     {
     case EMPTY: return "EMPTY";
     case VOID_FUNCTION: return "VOID_FUNCTION";
     case BOOL_FUNCTION: return "BOOL_FUNCTION";
     case INTEGER: return "INTEGER";
     case STRING: return "STRING";
     case IDENTIFIER: return "IDENTIFIER";
     default: c[0] = (char)t; return c;
     }
 }

Referenced by dct12(), dct36(), emit_set_ts(), HLPFILE_BrowseParagraph(), HTTPREQ_QueryOption(), LsDate(), MACRO_CheckArgs(), MACRO_ExecuteMacro(), NtQueryInformationToken(), rdp5_process(), SeQueryInformationToken(), Mapdesc::subdivide(), tcp_syn_build_options(), test_startSession(), UDFBuildLongAllocDescs(), and UDFBuildShortAllocDescs().

◆ while()

while ( 1 )

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

         {
         yy_cp = (yy_c_buf_p);
 
         /* Support of yytext. */
         *yy_cp = (yy_hold_char);
 
         /* yy_bp points to the position in yy_ch_buf of the start of
          * the current run.
          */
         yy_bp = yy_cp;
 
         yy_current_state = (yy_start);
 yy_match:
         do
             {
             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
             if ( yy_accept[yy_current_state] )
                 {
                 (yy_last_accepting_state) = yy_current_state;
                 (yy_last_accepting_cpos) = yy_cp;
                 }
             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                 {
                 yy_current_state = (int) yy_def[yy_current_state];
                 if ( yy_current_state >= 28 )
                     yy_c = yy_meta[(unsigned int) yy_c];
                 }
             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
             ++yy_cp;
             }
         while ( yy_current_state != 27 );
         yy_cp = (yy_last_accepting_cpos);
         yy_current_state = (yy_last_accepting_state);
 
 yy_find_action:
         yy_act = yy_accept[yy_current_state];
 
         YY_DO_BEFORE_ACTION;
 
 do_action:  /* This label is used only to access EOF actions. */
 
         switch ( yy_act )
     { /* beginning of action switch */
             case 0: /* must back up */
             /* undo the effects of YY_DO_BEFORE_ACTION */
             *yy_cp = (yy_hold_char);
             yy_cp = (yy_last_accepting_cpos);
             yy_current_state = (yy_last_accepting_state);
             goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
 #line 60 "macro.lex.l"
 yylval.integer = strtol(yytext, NULL, 10);  return INTEGER;
     YY_BREAK
 case 2:
 YY_RULE_SETUP
 #line 61 "macro.lex.l"
 yylval.integer = strtol(yytext, NULL, 16);  return INTEGER;
     YY_BREAK
 case 3:
 YY_RULE_SETUP
 #line 63 "macro.lex.l"
 return MACRO_Lookup(yytext, &yylval);
     YY_BREAK
 case 4:
 #line 66 "macro.lex.l"
 case 5:
 #line 67 "macro.lex.l"
 case 6:
 #line 68 "macro.lex.l"
 case 7:
 #line 69 "macro.lex.l"
 case 8:
 #line 70 "macro.lex.l"
 case 9:
 YY_RULE_SETUP
 #line 70 "macro.lex.l"
 {
     if (lex_data->quote_stk_idx == 0 ||
         (yytext[0] == '\"' && lex_data->quote_stack[lex_data->quote_stk_idx - 1] != '\"') ||
         (yytext[0] == '`'))
     {
         /* opening a new one */
         if (lex_data->quote_stk_idx == 0)
         {
             assert(lex_data->cache_used < ARRAY_SIZE(lex_data->cache_string));
             lex_data->strptr = lex_data->cache_string[lex_data->cache_used] = HeapAlloc(GetProcessHeap(), 0, strlen(lex_data->macroptr) + 1);
             yylval.string = lex_data->strptr;
             lex_data->cache_used++;
             BEGIN(quote);
         }
         else *lex_data->strptr++ = yytext[0];
         lex_data->quote_stack[lex_data->quote_stk_idx++] = yytext[0];
         assert(lex_data->quote_stk_idx < ARRAY_SIZE(lex_data->quote_stack));
     }
     else
     {
         if (yytext[0] == '`') assert(0);
         /* close the current quote */
         if (--lex_data->quote_stk_idx == 0)
         {
             BEGIN INITIAL;
             *lex_data->strptr++ = '\0';
             return STRING;
         }
         else *lex_data->strptr++ = yytext[0];
     }
 }
     YY_BREAK
 case 10:
 YY_RULE_SETUP
 #line 102 "macro.lex.l"
 *lex_data->strptr++ = yytext[0];
     YY_BREAK
 case 11:
 YY_RULE_SETUP
 #line 103 "macro.lex.l"
 *lex_data->strptr++ = yytext[1];
     YY_BREAK
 case YY_STATE_EOF(quote):
 #line 104 "macro.lex.l"
 return 0;
     YY_BREAK
 case 12:
 YY_RULE_SETUP
 #line 106 "macro.lex.l"
 
     YY_BREAK
 case 13:
 YY_RULE_SETUP
 #line 107 "macro.lex.l"
 return yytext[0];
     YY_BREAK
 case 14:
 YY_RULE_SETUP
 #line 108 "macro.lex.l"
 ECHO;
     YY_BREAK
 #line 881 "macro.lex.yy.c"
 case YY_STATE_EOF(INITIAL):
     yyterminate();
 
     case YY_END_OF_BUFFER:
         {
         /* Amount of text matched not including the EOB char. */
         int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
         /* Undo the effects of YY_DO_BEFORE_ACTION. */
         *yy_cp = (yy_hold_char);
         YY_RESTORE_YY_MORE_OFFSET
 
         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
             {
             /* We're scanning a new file or input source.  It's
              * possible that this happened because the user
              * just pointed yyin at a new source and called
              * yylex().  If so, then we have to assure
              * consistency between YY_CURRENT_BUFFER and our
              * globals.  Here is the right place to do so, because
              * this is the first action (other than possibly a
              * back-up) that will match for the new input source.
              */
             (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
             YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
             }
 
         /* Note that here we test for yy_c_buf_p "<=" to the position
          * of the first EOB in the buffer, since yy_c_buf_p will
          * already have been incremented past the NUL character
          * (since all states make transitions on EOB to the
          * end-of-buffer state).  Contrast this with the test
          * in input().
          */
         if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
             { /* This was really a NUL. */
             yy_state_type yy_next_state;
 
             (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
             yy_current_state = yy_get_previous_state(  );
 
             /* Okay, we're now positioned to make the NUL
              * transition.  We couldn't have
              * yy_get_previous_state() go ahead and do it
              * for us because it doesn't know how to deal
              * with the possibility of jamming (and we don't
              * want to build jamming into it because then it
              * will run more slowly).
              */
 
             yy_next_state = yy_try_NUL_trans( yy_current_state );
 
             yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
             if ( yy_next_state )
                 {
                 /* Consume the NUL. */
                 yy_cp = ++(yy_c_buf_p);
                 yy_current_state = yy_next_state;
                 goto yy_match;
                 }
 
             else
                 {
                 yy_cp = (yy_last_accepting_cpos);
                 yy_current_state = (yy_last_accepting_state);
                 goto yy_find_action;
                 }
             }
 
         else switch ( yy_get_next_buffer(  ) )
             {
             case EOB_ACT_END_OF_FILE:
                 {
                 (yy_did_buffer_switch_on_eof) = 0;
 
                 if ( yywrap( ) )
                     {
                     /* Note: because we've taken care in
                      * yy_get_next_buffer() to have set up
                      * yytext, we can now set up
                      * yy_c_buf_p so that if some total
                      * hoser (like flex itself) wants to
                      * call the scanner after we return the
                      * YY_NULL, it'll still work - another
                      * YY_NULL will get returned.
                      */
                     (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
                     yy_act = YY_STATE_EOF(YY_START);
                     goto do_action;
                     }
 
                 else
                     {
                     if ( ! (yy_did_buffer_switch_on_eof) )
                         YY_NEW_FILE;
                     }
                 break;
                 }
 
             case EOB_ACT_CONTINUE_SCAN:
                 (yy_c_buf_p) =
                     (yytext_ptr) + yy_amount_of_matched_text;
 
                 yy_current_state = yy_get_previous_state(  );
 
                 yy_cp = (yy_c_buf_p);
                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                 goto yy_match;
 
             case EOB_ACT_LAST_MATCH:
                 (yy_c_buf_p) =
                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
                 yy_current_state = yy_get_previous_state(  );
 
                 yy_cp = (yy_c_buf_p);
                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                 goto yy_find_action;
             }
         break;
         }
 
     default:
         YY_FATAL_ERROR(
             "fatal flex scanner internal error--no action found" );
     } /* end of action switch */
         } /* end of scanning one token */

Referenced by _DibFunction(), add_delete_inode_extref(), add_dirent_to_buf(), arith_decode(), BmpFrameDecode_ReadRLE4(), BmpFrameDecode_ReadRLE8(), CabinetExtractFile(), cmyk_ycck_convert(), codeview_add_type_enum_field_list(), codeview_add_type_struct_field_list(), ConDrvChangeScreenBufferAttributes(), ConDrvFillConsoleOutput(), ConDrvWriteConsoleOutputString(), convert_hex_csv_to_hex(), CreateUsbChildDeviceObject(), deflate(), delete_stat_item(), DrawTextFromClipboard(), duplicate_extents(), EfiVmCloseProtocol(), EfiVmOpenProtocol(), Ext2ReadGroupDescriptors(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), ext3_delete_entry(), FFSSetRenameInfo(), fill_pnpentity(), find_revoke_record(), fixup_buffer_cr(), FltRegisterFilter(), FrLdrGetKernelBase(), GetDmiString(), gl_DrawArrays(), GuiConsoleInputThread(), HalpAcpiGetTableFromBios(), Heap32First(), InfFindNextMatchLine(), InfGetMultiSzField(), InfpGetMultiSzField(), int_upsample(), IntSetClassMenuName(), load_chunk_root(), load_mesh_data(), MiInsertInSystemSpace(), MmAlterRegion(), NtfsReadAttribute(), ObQueryNameString(), open_fcb(), ParseSMBiosTables(), partial_stripe_read(), PciFindParentPciFdoExtension(), PciFindPdoByLocation(), pdb_process_symbol_imports(), pre_process_data(), prepare_raid5_write(), prepare_raid6_write(), process_data_simple_main(), query_filesystems(), read_data(), RfsdDirectoryCallback(), RfsdSetRenameInfo(), rgb1_gray_convert(), rgb_gray_convert(), rgb_ycc_convert(), RtlNumberOfSetBits(), ScanForUnpartitionedDiskSpace(), scrub_raid6_stripe(), search_dirblock(), send_inode_extref(), send_inode_ref(), SetDiskSignature(), SetupDiDestroyDriverInfoList(), SetupDiEnumDeviceInterfaces(), sinc_hex_vari_process(), sinc_mono_vari_process(), sinc_multichan_vari_process(), sinc_quad_vari_process(), sinc_stereo_vari_process(), SmpApiLoop(), stabs_pts_read_range_value(), TIFFReadDirectoryFindFieldInfo(), UnhandledExceptionFilter(), unzReadCurrentFile(), USBPORT_ParseConfigurationDescriptor(), vfatReleaseFCB(), VgaInterpretCmdStream(), write_metadata_items(), xsltCheckExtPrefix(), xsltCheckExtURI(), xsltGetKey(), xsltInitAllDocKeys(), xsltInitCtxtKey(), xsltInitCtxtKeys(), xsltInitDocKeyTable(), xsltRegisterExtPrefix(), XXH64_digest_endian(), ycc_rgb_convert(), and ycck_cmyk_convert().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( winhelp )

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The 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.

 {
     YY_BUFFER_STATE b;
     
     b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
     if ( ! b )
         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
     b->yy_buf_size = size;
 
     /* yy_ch_buf has to be 2 characters longer than the size given because
      * we need to put in 2 end-of-buffer characters.
      */
     b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
     if ( ! b->yy_ch_buf )
         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
     b->yy_is_our_buffer = 1;
 
     yy_init_buffer(b,file );
 
     return b;
 }

Referenced by if(), and yyrestart().

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE b )

Destroy the buffer.

Parameters

b	a buffer created with yy_create_buffer()

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

 {
     
     if ( ! b )
         return;
 
     if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
         YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
     if ( b->yy_is_our_buffer )
         yyfree((void *) b->yy_ch_buf  );
 
     yyfree((void *) b  );
 }

Referenced by yylex_destroy(), and yypop_buffer_state().

◆ 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 1637 of file macro.lex.yy.c.

 {
         (void) fprintf( stderr, "%s\n", msg );
     exit( YY_EXIT_FAILURE );
 }

◆ 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

b	the buffer state to be flushed, usually `YY_CURRENT_BUFFER`.

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

 {
         if ( ! b )
         return;
 
     b->yy_n_chars = 0;
 
     /* We always need two end-of-buffer characters.  The first causes
      * a transition to the end-of-buffer state.  The second causes
      * a jam in that state.
      */
     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 
     b->yy_buf_pos = &b->yy_ch_buf[0];
 
     b->yy_at_bol = 1;
     b->yy_buffer_status = YY_BUFFER_NEW;
 
     if ( b == YY_CURRENT_BUFFER )
         yy_load_buffer_state( );
 }

Referenced by yy_init_buffer().

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( void )

static

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

 {
         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
     register char *source = (yytext_ptr);
     register int number_to_move, i;
     int ret_val;
 
     if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
         YY_FATAL_ERROR(
         "fatal flex scanner internal error--end of buffer missed" );
 
     if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
         { /* Don't try to fill the buffer, so this is an EOF. */
         if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
             {
             /* We matched a single character, the EOB, so
              * treat this as a final EOF.
              */
             return EOB_ACT_END_OF_FILE;
             }
 
         else
             {
             /* We matched some text prior to the EOB, first
              * process it.
              */
             return EOB_ACT_LAST_MATCH;
             }
         }
 
     /* Try to read more data. */
 
     /* First move last chars to start of buffer. */
     number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 
     for ( i = 0; i < number_to_move; ++i )
         *(dest++) = *(source++);
 
     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
         /* don't do the read, it's not guaranteed to return an EOF,
          * just force an EOF
          */
         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
     else
         {
             yy_size_t num_to_read =
             YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
         while ( num_to_read <= 0 )
             { /* Not enough room in the buffer - grow it. */
 
             /* just a shorter name for the current buffer */
             YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
 
             int yy_c_buf_p_offset =
                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
 
             if ( b->yy_is_our_buffer )
                 {
                 yy_size_t new_size = b->yy_buf_size * 2;
 
                 if ( new_size <= 0 )
                     b->yy_buf_size += b->yy_buf_size / 8;
                 else
                     b->yy_buf_size *= 2;
 
                 b->yy_ch_buf = (char *)
                     /* Include room in for 2 EOB chars. */
                     yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                 }
             else
                 /* Can't grow it, we don't own it. */
                 b->yy_ch_buf = 0;
 
             if ( ! b->yy_ch_buf )
                 YY_FATAL_ERROR(
                 "fatal error - scanner input buffer overflow" );
 
             (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
             num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                         number_to_move - 1;
 
             }
 
         if ( num_to_read > YY_READ_BUF_SIZE )
             num_to_read = YY_READ_BUF_SIZE;
 
         /* Read in more data. */
         YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
             (yy_n_chars), num_to_read );
 
         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
         }
 
     if ( (yy_n_chars) == 0 )
         {
         if ( number_to_move == YY_MORE_ADJ )
             {
             ret_val = EOB_ACT_END_OF_FILE;
             yyrestart(yyin  );
             }
 
         else
             {
             ret_val = EOB_ACT_LAST_MATCH;
             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                 YY_BUFFER_EOF_PENDING;
             }
         }
 
     else
         ret_val = EOB_ACT_CONTINUE_SCAN;
 
     if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
         /* Extend the array by 50%, plus the number we really need. */
         yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
         if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
             YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
     }
 
     (yy_n_chars) += number_to_move;
     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
     (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
     return ret_val;
 }

Referenced by while().

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( void )

static

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

 {
     register yy_state_type yy_current_state;
     register char *yy_cp;
     
     yy_current_state = (yy_start);
 
     for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
         {
         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
         if ( yy_accept[yy_current_state] )
             {
             (yy_last_accepting_state) = yy_current_state;
             (yy_last_accepting_cpos) = yy_cp;
             }
         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
             {
             yy_current_state = (int) yy_def[yy_current_state];
             if ( yy_current_state >= 28 )
                 yy_c = yy_meta[(unsigned int) yy_c];
             }
         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
         }
 
     return yy_current_state;
 }

Referenced by while().

◆ yy_init_buffer()

static void yy_init_buffer	(	YY_BUFFER_STATE	b,
		FILE *	file
	)

static

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

 {
     int oerrno = errno;
     
     yy_flush_buffer(b );
 
     b->yy_input_file = file;
     b->yy_fill_buffer = 1;
 
     /* If b is the current buffer, then yy_init_buffer was _probably_
      * called from yyrestart() or through yy_get_next_buffer.
      * In that case, we don't want to reset the lineno or column.
      */
     if (b != YY_CURRENT_BUFFER){
         b->yy_bs_lineno = 1;
         b->yy_bs_column = 0;
     }
 
         b->yy_is_interactive = 0;
     
     errno = oerrno;
 }

Referenced by yy_create_buffer(), and yyrestart().

◆ yy_init_globals()

static int yy_init_globals ( void )

static

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

 {
         /* Initialization is the same as for the non-reentrant scanner.
      * This function is called from yylex_destroy(), so don't allocate here.
      */
 
     (yy_buffer_stack) = 0;
     (yy_buffer_stack_top) = 0;
     (yy_buffer_stack_max) = 0;
     (yy_c_buf_p) = (char *) 0;
     (yy_init) = 0;
     (yy_start) = 0;
 
 /* Defined in main.c */
 #ifdef YY_STDINIT
     yyin = stdin;
     yyout = stdout;
 #else
     yyin = (FILE *) 0;
     yyout = (FILE *) 0;
 #endif
 
     /* For future reference: Set errno on error, since we are called by
      * yylex_init()
      */
     return 0;
 }

Referenced by yylex_destroy().

◆ yy_load_buffer_state()

static void yy_load_buffer_state ( void )

static

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

 {
         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
     (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
     yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
     (yy_hold_char) = *(yy_c_buf_p);
 }

Referenced by if(), yy_flush_buffer(), yy_switch_to_buffer(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().

◆ 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

base	the character buffer
size	the size in bytes of the character buffer

Returns: the newly allocated buffer state object.

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

 {
     YY_BUFFER_STATE b;
     
     if ( size < 2 ||
          base[size-2] != YY_END_OF_BUFFER_CHAR ||
          base[size-1] != YY_END_OF_BUFFER_CHAR )
         /* They forgot to leave room for the EOB's. */
         return 0;
 
     b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
     if ( ! b )
         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
     b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
     b->yy_buf_pos = b->yy_ch_buf = base;
     b->yy_is_our_buffer = 0;
     b->yy_input_file = 0;
     b->yy_n_chars = b->yy_buf_size;
     b->yy_is_interactive = 0;
     b->yy_at_bol = 1;
     b->yy_fill_buffer = 0;
     b->yy_buffer_status = YY_BUFFER_NEW;
 
     yy_switch_to_buffer(b  );
 
     return b;
 }

Referenced by yy_scan_bytes().

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes	(	yyconst char *	yybytes,
		yy_size_t	_yybytes_len
	)

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

Parameters

yybytes	the byte buffer to scan
_yybytes_len	the 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.

 {
     YY_BUFFER_STATE b;
     char *buf;
     yy_size_t n;
     yy_size_t i;
     
     /* Get memory for full buffer, including space for trailing EOB's. */
     n = _yybytes_len + 2;
     buf = (char *) yyalloc(n  );
     if ( ! buf )
         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
     for ( i = 0; i < _yybytes_len; ++i )
         buf[i] = yybytes[i];
 
     buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
     b = yy_scan_buffer(buf,n );
     if ( ! b )
         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
     /* It's okay to grow etc. this buffer, and we should throw it
      * away when we're done.
      */
     b->yy_is_our_buffer = 1;
 
     return b;
 }

Referenced by yy_scan_string().

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char * yystr )

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

Parameters

yystr a 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.

 {
     
     return yy_scan_bytes(yystr,strlen(yystr) );
 }

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer )

Switch to a different input buffer.

Parameters

new_buffer The new input buffer.

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

 {
     
     /* TODO. We should be able to replace this entire function body
      * with
      *      yypop_buffer_state();
      *      yypush_buffer_state(new_buffer);
      */
     yyensure_buffer_stack ();
     if ( YY_CURRENT_BUFFER == new_buffer )
         return;
 
     if ( YY_CURRENT_BUFFER )
         {
         /* Flush out information for old buffer. */
         *(yy_c_buf_p) = (yy_hold_char);
         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
         }
 
     YY_CURRENT_BUFFER_LVALUE = new_buffer;
     yy_load_buffer_state( );
 
     /* We don't actually know whether we did this switch during
      * EOF (yywrap()) processing, but the only time this flag
      * is looked at is after yywrap() is called, so it's safe
      * to go ahead and always set it.
      */
     (yy_did_buffer_switch_on_eof) = 1;
 }

Referenced by yy_scan_buffer().

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type current_state )

static

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

 {
     register int yy_is_jam;
         register char *yy_cp = (yy_c_buf_p);
 
     register YY_CHAR yy_c = 1;
     if ( yy_accept[yy_current_state] )
         {
         (yy_last_accepting_state) = yy_current_state;
         (yy_last_accepting_cpos) = yy_cp;
         }
     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
         {
         yy_current_state = (int) yy_def[yy_current_state];
         if ( yy_current_state >= 28 )
             yy_c = yy_meta[(unsigned int) yy_c];
         }
     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
     yy_is_jam = (yy_current_state == 27);
 
         return yy_is_jam ? 0 : yy_current_state;
 }

Referenced by while().

◆ yyalloc()

void * yyalloc ( yy_size_t size )

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

 {
     return (void *) malloc( size );
 }

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

◆ yyensure_buffer_stack()

static void yyensure_buffer_stack ( void )

static

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

 {
     yy_size_t num_to_alloc;
     
     if (!(yy_buffer_stack)) {
 
         /* First allocation is just for 2 elements, since we don't know if this
          * scanner will even need a stack. We use 2 instead of 1 to avoid an
          * immediate realloc on the next call.
          */
         num_to_alloc = 1;
         (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
                                 );
         if ( ! (yy_buffer_stack) )
             YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
                                   
         memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                 
         (yy_buffer_stack_max) = num_to_alloc;
         (yy_buffer_stack_top) = 0;
         return;
     }
 
     if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
 
         /* Increase the buffer to prepare for a possible push. */
         int grow_size = 8 /* arbitrary grow size */;
 
         num_to_alloc = (yy_buffer_stack_max) + grow_size;
         (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
                                 ((yy_buffer_stack),
                                 num_to_alloc * sizeof(struct yy_buffer_state*)
                                 );
         if ( ! (yy_buffer_stack) )
             YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 
         /* zero only the new slots.*/
         memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
         (yy_buffer_stack_max) = num_to_alloc;
     }
 }

Referenced by if(), yy_switch_to_buffer(), yypush_buffer_state(), and yyrestart().

◆ yyfree()

void yyfree ( void * ptr )

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

 {
     free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
 }

Referenced by yy_delete_buffer(), and yylex_destroy().

◆ yyget_debug()

int yyget_debug ( void )

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

 {
         return yy_flex_debug;
 }

◆ 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.

 {
         return yyin;
 }

◆ 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.

 {
         return yyleng;
 }

◆ yyget_lineno()

int yyget_lineno ( void )

Get the current line number.

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

 {
         
     return yylineno;
 }

◆ yyget_out()

FILE * yyget_out ( void )

Get the output stream.

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

 {
         return yyout;
 }

◆ yyget_text()

char * yyget_text ( void )

Get the current token.

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

 {
         return yytext;
 }

◆ yylex()

int yylex ( void )

Referenced by MACRO_CheckArgs(), and MACRO_ExecuteMacro().

◆ yylex_destroy()

int yylex_destroy ( void )

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

 {
     
     /* Pop the buffer stack, destroying each element. */
     while(YY_CURRENT_BUFFER){
         yy_delete_buffer(YY_CURRENT_BUFFER  );
         YY_CURRENT_BUFFER_LVALUE = NULL;
         yypop_buffer_state();
     }
 
     /* Destroy the stack itself. */
     yyfree((yy_buffer_stack) );
     (yy_buffer_stack) = NULL;
 
     /* Reset the globals. This is important in a non-reentrant scanner so the next time
      * yylex() is called, initialization will occur. */
     yy_init_globals( );
 
     return 0;
 }

◆ 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.

 {
         if (!YY_CURRENT_BUFFER)
         return;
 
     yy_delete_buffer(YY_CURRENT_BUFFER );
     YY_CURRENT_BUFFER_LVALUE = NULL;
     if ((yy_buffer_stack_top) > 0)
         --(yy_buffer_stack_top);
 
     if (YY_CURRENT_BUFFER) {
         yy_load_buffer_state( );
         (yy_did_buffer_switch_on_eof) = 1;
     }
 }

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_buffer The new state.

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

 {
         if (new_buffer == NULL)
         return;
 
     yyensure_buffer_stack();
 
     /* This block is copied from yy_switch_to_buffer. */
     if ( YY_CURRENT_BUFFER )
         {
         /* Flush out information for old buffer. */
         *(yy_c_buf_p) = (yy_hold_char);
         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
         }
 
     /* Only push if top exists. Otherwise, replace top. */
     if (YY_CURRENT_BUFFER)
         (yy_buffer_stack_top)++;
     YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
     /* copied from yy_switch_to_buffer. */
     yy_load_buffer_state( );
     (yy_did_buffer_switch_on_eof) = 1;
 }

◆ yyrealloc()

void * yyrealloc	(	void *	ptr,
		yy_size_t	size
	)

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

 {
     /* The cast to (char *) in the following accommodates both
      * implementations that use char* generic pointers, and those
      * that use void* generic pointers.  It works with the latter
      * because both ANSI C and C++ allow castless assignment from
      * any pointer type to void*, and deal with argument conversions
      * as though doing an assignment.
      */
     return (void *) realloc( (char *) ptr, size );
 }

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_file A readable stream.

Note: This function does not reset the start condition to INITIAL .

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

 {
     
     if ( ! YY_CURRENT_BUFFER ){
         yyensure_buffer_stack ();
         YY_CURRENT_BUFFER_LVALUE =
             yy_create_buffer(yyin,YY_BUF_SIZE );
     }
 
     yy_init_buffer(YY_CURRENT_BUFFER,input_file );
     yy_load_buffer_state( );
 }

Referenced by yy_get_next_buffer().

◆ yyset_debug()

void yyset_debug ( int debug_flag )

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

 {
         yy_flex_debug = bdebug ;
 }

◆ 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_str A readable stream.

See also: yy_switch_to_buffer

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

 {
         yyin = in_str ;
 }

◆ 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.

 {
     
     yylineno = line_number;
 }

◆ yyset_out()

void yyset_out ( FILE * out_str )

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

 {
         yyout = out_str ;
 }

◆ yywrap()

int yywrap ( void )

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

2104 { return 1; }

Referenced by while().

Variable Documentation

◆ lex_data

struct lex_data* lex_data = NULL

static

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

Referenced by MACRO_ExecuteMacro().

◆ yy_accept

yyconst flex_int16_t yy_accept[28]

static

Initial value:

=
    {   0,
        0,    0,    0,    0,   15,   13,   14,   12,    5,    6,
       13,    1,    1,    3,    4,   10,    8,    9,   10,    7,
        1,    1,    0,    3,   11,    2,    0
    }

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

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

◆ yy_act

register int yy_act

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

Referenced by while().

◆ yy_base

yyconst flex_int16_t yy_base[33]

static

Initial value:

=
    {   0,
        0,    0,   13,   25,   25,   62,   62,   62,   62,   62,
       12,   13,   14,    0,   62,   62,   62,   62,    0,   62,
        6,   24,    0,    0,   62,    0,   62,   38,   42,   45,
       51,   55
    }

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

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

◆ yy_bp

register char * yy_bp

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

Referenced by while().

◆ yy_buffer_stack

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

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

Referenced by yy_init_globals(), yyensure_buffer_stack(), and yylex_destroy().

◆ yy_buffer_stack_max

size_t yy_buffer_stack_max = 0

static

capacity of stack.

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

Referenced by yy_init_globals(), and yyensure_buffer_stack().

◆ yy_buffer_stack_top

size_t yy_buffer_stack_top = 0

static

index of top of stack.

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

Referenced by yy_init_globals(), yyensure_buffer_stack(), yypop_buffer_state(), and yypush_buffer_state().

◆ yy_c_buf_p

char* yy_c_buf_p = (char *) 0

static

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

Referenced by while(), yy_get_next_buffer(), yy_get_previous_state(), yy_init_globals(), yy_load_buffer_state(), yy_switch_to_buffer(), yy_try_NUL_trans(), and yypush_buffer_state().

◆ yy_chk

yyconst flex_int16_t yy_chk[77]

static

Initial value:

=
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    3,   21,    3,    3,   11,   11,
       13,   13,   12,    3,    5,    3,    4,    0,    4,    4,
       22,   22,    0,    0,    0,    4,    0,    4,   28,   28,
       28,   28,   28,   28,   29,    0,   29,   30,   30,   30,
       30,   31,    0,   31,   31,   31,   31,   32,    0,    0,
       32,   27,   27,   27,   27,   27,   27,   27,   27,   27,
       27,   27,   27,   27,   27,   27
    }

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

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

◆ yy_cp

register char* yy_cp

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

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

◆ YY_DECL

YY_DECL

Initial value:

{

register yy_state_type yy_current_state

yy_current_state

#define yy_current_state()

Definition: ppl.yy.c:1235

yy_state_type

int yy_state_type

Definition: macro.lex.yy.c:340

The main scanner function which does all the work.

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

◆ yy_def

yyconst flex_int16_t yy_def[33]

static

Initial value:

=
    {   0,
       27,    1,   28,   28,   27,   27,   27,   27,   27,   27,
       27,   29,   27,   30,   27,   27,   27,   27,   31,   27,
       29,   27,   32,   30,   27,   32,    0,   27,   27,   27,
       27,   27
    }

Definition at line 426 of file macro.lex.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

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

Referenced by while(), yy_switch_to_buffer(), yypop_buffer_state(), and yypush_buffer_state().

◆ yy_ec

yyconst flex_int32_t yy_ec[256]

static

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

Referenced by while(), and yy_get_previous_state().

◆ yy_flex_debug

int yy_flex_debug = 0

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

Referenced by yyget_debug(), and yyset_debug().

◆ yy_hold_char

char yy_hold_char

static

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

Referenced by while(), yy_load_buffer_state(), yy_switch_to_buffer(), and yypush_buffer_state().

◆ yy_init

int yy_init = 0

static

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

Referenced by if(), and yy_init_globals().

◆ yy_last_accepting_cpos

char* yy_last_accepting_cpos

static

Definition at line 459 of file macro.lex.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 458 of file macro.lex.yy.c.

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

◆ yy_meta

yyconst flex_int32_t yy_meta[15]

static

Initial value:

=
    {   0,
        1,    2,    1,    1,    1,    1,    3,    3,    4,    5,
        1,    4,    1,    6
    }

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

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

◆ yy_n_chars

yy_size_t yy_n_chars

static

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

Referenced by while(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), and yypush_buffer_state().

◆ yy_nxt

yyconst flex_int16_t yy_nxt[77]

static

Initial value:

=
    {   0,
        6,    7,    8,    9,   10,   11,   12,   13,   14,   14,
        6,    6,   15,   14,    7,   23,   17,   18,   21,   22,
       22,   22,   23,   19,   27,   20,    7,   27,   17,   18,
       22,   22,   27,   27,   27,   19,   27,   20,   16,   16,
       16,   16,   16,   16,   22,   27,   22,   24,   24,   24,
       24,   25,   27,   25,   25,   25,   25,   26,   27,   27,
       26,    5,   27,   27,   27,   27,   27,   27,   27,   27,
       27,   27,   27,   27,   27,   27
    }

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

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

◆ yy_start

int yy_start = 0

static

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

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

◆ yyin

FILE* yyin = (FILE *) 0

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

Referenced by if(), while(), yy_get_next_buffer(), yy_init_globals(), yy_load_buffer_state(), yyget_in(), yyrestart(), and yyset_in().

◆ yyleng

yy_size_t yyleng

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

Referenced by yyget_leng().

◆ yylineno

int yylineno = 1

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

Referenced by yyget_lineno(), and yyset_lineno().

◆ yylval

struct lexret yylval

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

Referenced by MACRO_CheckArgs(), MACRO_ExecuteMacro(), and while().

◆ yyout

FILE * yyout = (FILE *) 0

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

Referenced by if(), yy_init_globals(), yyget_out(), and yyset_out().

◆ yytext

char* yytext

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

Referenced by while(), and yyget_text().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ BEGIN

◆ ECHO

◆ EOB_ACT_CONTINUE_SCAN

◆ EOB_ACT_END_OF_FILE

◆ EOB_ACT_LAST_MATCH

◆ FLEX_BETA

◆ FLEX_SCANNER

◆ FLEXINT_H

◆ INITIAL

◆ INT16_MAX

◆ INT16_MIN

◆ INT32_MAX

◆ INT32_MIN

◆ INT8_MAX

◆ INT8_MIN

◆ quote

◆ REJECT

◆ UINT16_MAX

◆ UINT32_MAX

◆ UINT8_MAX

◆ unput

◆ YY_AT_BOL

◆ YY_BREAK

◆ YY_BUF_SIZE

◆ YY_BUFFER_EOF_PENDING

◆ YY_BUFFER_NEW

◆ YY_BUFFER_NORMAL

◆ YY_CURRENT_BUFFER

◆ YY_CURRENT_BUFFER_LVALUE

◆ YY_DECL

◆ YY_DECL_IS_OURS

◆ YY_DO_BEFORE_ACTION

◆ YY_END_OF_BUFFER

◆ YY_END_OF_BUFFER_CHAR

◆ YY_EXIT_FAILURE

◆ YY_EXTRA_TYPE

◆ YY_FATAL_ERROR

◆ YY_FLEX_MAJOR_VERSION

◆ YY_FLEX_MINOR_VERSION

◆ YY_FLEX_SUBMINOR_VERSION

◆ YY_FLUSH_BUFFER

◆ YY_INPUT

◆ YY_INT_ALIGNED

◆ YY_LESS_LINENO

◆ YY_MORE_ADJ

◆ yy_new_buffer

◆ YY_NEW_FILE

◆ YY_NO_INPUT

◆ YY_NO_UNISTD_H

◆ YY_NULL

◆ YY_NUM_RULES

◆ YY_READ_BUF_SIZE

◆ YY_RESTORE_YY_MORE_OFFSET

◆ YY_RULE_SETUP

◆ YY_SC_TO_UI

◆ yy_set_bol

◆ yy_set_interactive

◆ YY_START

◆ YY_START_STACK_INCR

◆ YY_STATE_BUF_SIZE

◆ YY_STATE_EOF

◆ YY_STRUCT_YY_BUFFER_STATE

◆ YY_TYPEDEF_YY_BUFFER_STATE

◆ YY_TYPEDEF_YY_SIZE_T

◆ YY_USER_ACTION

◆ yyconst

◆ yyless [1/2]

◆ yyless [2/2]

◆ yymore

◆ YYSTATE

◆ YYTABLES_NAME

◆ yyterminate

◆ yytext_ptr

Typedef Documentation