#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
#include <limits.h>
#include "wpp_private.h"
#include "ppy.tab.h"

Include dependency graph for ppl.yy.c:

Classes
struct	yy_buffer_state

struct	yy_trans_info

struct	bufferstackentry

struct	macexpstackentry

Macros
#define	YY_INT_ALIGNED short int

#define	yy_create_buffer ppy__create_buffer

#define	yy_delete_buffer ppy__delete_buffer

#define	yy_scan_buffer ppy__scan_buffer

#define	yy_scan_string ppy__scan_string

#define	yy_scan_bytes ppy__scan_bytes

#define	yy_init_buffer ppy__init_buffer

#define	yy_flush_buffer ppy__flush_buffer

#define	yy_load_buffer_state ppy__load_buffer_state

#define	yy_switch_to_buffer ppy__switch_to_buffer

#define	yypush_buffer_state ppy_push_buffer_state

#define	yypop_buffer_state ppy_pop_buffer_state

#define	yyensure_buffer_stack ppy_ensure_buffer_stack

#define	yy_flex_debug ppy__flex_debug

#define	yyin ppy_in

#define	yyleng ppy_leng

#define	yylex ppy_lex

#define	yylineno ppy_lineno

#define	yyout ppy_out

#define	yyrestart ppy_restart

#define	yytext ppy_text

#define	yywrap ppy_wrap

#define	yyalloc ppy_alloc

#define	yyrealloc ppy_realloc

#define	yyfree ppy_free

#define	FLEX_SCANNER

#define	YY_FLEX_MAJOR_VERSION 2

#define	YY_FLEX_MINOR_VERSION 6

#define	YY_FLEX_SUBMINOR_VERSION 4

#define	FLEX_BETA

#define	ppy__create_buffer_ALREADY_DEFINED

#define	ppy__delete_buffer_ALREADY_DEFINED

#define	ppy__scan_buffer_ALREADY_DEFINED

#define	ppy__scan_string_ALREADY_DEFINED

#define	ppy__scan_bytes_ALREADY_DEFINED

#define	ppy__init_buffer_ALREADY_DEFINED

#define	ppy__flush_buffer_ALREADY_DEFINED

#define	ppy__load_buffer_state_ALREADY_DEFINED

#define	ppy__switch_to_buffer_ALREADY_DEFINED

#define	ppy_push_buffer_state_ALREADY_DEFINED

#define	ppy_pop_buffer_state_ALREADY_DEFINED

#define	ppy_ensure_buffer_stack_ALREADY_DEFINED

#define	ppy_lex_ALREADY_DEFINED

#define	ppy_restart_ALREADY_DEFINED

#define	yylex_init ppy_lex_init

#define	yylex_init_extra ppy_lex_init_extra

#define	yylex_destroy ppy_lex_destroy

#define	yyget_debug ppy_get_debug

#define	yyset_debug ppy_set_debug

#define	yyget_extra ppy_get_extra

#define	yyset_extra ppy_set_extra

#define	yyget_in ppy_get_in

#define	yyset_in ppy_set_in

#define	yyget_out ppy_get_out

#define	yyset_out ppy_set_out

#define	yyget_leng ppy_get_leng

#define	yyget_text ppy_get_text

#define	yyget_lineno ppy_get_lineno

#define	yyset_lineno ppy_set_lineno

#define	ppy_wrap_ALREADY_DEFINED

#define	ppy_alloc_ALREADY_DEFINED

#define	ppy_realloc_ALREADY_DEFINED

#define	ppy_free_ALREADY_DEFINED

#define	ppy_text_ALREADY_DEFINED

#define	ppy_leng_ALREADY_DEFINED

#define	ppy_in_ALREADY_DEFINED

#define	ppy_out_ALREADY_DEFINED

#define	ppy__flex_debug_ALREADY_DEFINED

#define	ppy_lineno_ALREADY_DEFINED

#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	SIZE_MAX (~(size_t)0)

#define	yyconst const

#define	yynoreturn

#define	YY_NULL 0

#define	YY_SC_TO_UI(c) ((YY_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	YY_LINENO_REWIND_TO(ptr)

#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 145

#define	YY_END_OF_BUFFER 146

#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_READ_BUF_SIZE 65536 /* So we read most of a file at once */

#define	yy_current_state() YY_START

#define	yy_pp_state(x) yy_pop_state(); yy_push_state(x)

#define	YY_USER_ACTION pp_status.char_number+=ppy_leng;

#define	MAXBUFFERSTACK 128 /* Nesting more than 128 includes or macro expansion textss is insane */

#define	ALLOCBLOCKSIZE (1 << 10) /* Allocate these chunks at a time for string-buffers */

#define	MAXMACEXPSTACK 128 /* Nesting more than 128 macro expansions is insane */

#define	MACROPARENTHESES() (top_macro()->parentheses)

#define	YY_INPUT(buf, result, max_size)

#define	BUFFERINITIALCAPACITY 256

#define	INITIAL 0

#define	pp_pp 1

#define	pp_eol 2

#define	pp_inc 3

#define	pp_dqs 4

#define	pp_sqs 5

#define	pp_iqs 6

#define	pp_comment 7

#define	pp_def 8

#define	pp_define 9

#define	pp_macro 10

#define	pp_mbody 11

#define	pp_macign 12

#define	pp_macscan 13

#define	pp_macexp 14

#define	pp_if 15

#define	pp_ifd 16

#define	pp_ifignored 17

#define	pp_endif 18

#define	pp_line 19

#define	pp_defined 20

#define	pp_ignore 21

#define	RCINCL 22

#define	YY_EXTRA_TYPE void *

#define	ECHO do { if (fwrite( yytext, (size_t) 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_BREAK /LINTED/break;

#define	YY_RULE_SETUP

#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 flex_uint8_t	YY_CHAR

typedef int	yy_state_type

typedef struct bufferstackentry	bufferstackentry_t

typedef struct macexpstackentry	macexpstackentry_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)

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 (const char *yy_str)

YY_BUFFER_STATE	yy_scan_bytes (const char *bytes, int 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 yynoreturn	yy_fatal_error (const char *msg)

static void	newline (int)

static int	make_number (int radix, YYSTYPE val, const char str, int len)

static void	put_buffer (const char *s, int len)

static void	push_buffer (pp_entry_t ppp, char filename, char *incname, int pop)

static bufferstackentry_t *	pop_buffer (void)

static void	new_string (void)

static void	add_string (const char *str, int len)

static char *	get_string (void)

static void	put_string (void)

static int	string_start (void)

static void	push_macro (pp_entry_t *ppp)

static macexpstackentry_t *	top_macro (void)

static macexpstackentry_t *	pop_macro (void)

static void	free_macro (macexpstackentry_t *mep)

static void	add_text_to_macro (const char *text, int len)

static void	macro_add_arg (int last)

static void	macro_add_expansion (void)

static void	expand_special (pp_entry_t *ppp)

static void	expand_define (pp_entry_t *ppp)

static void	expand_macro (macexpstackentry_t *mep)

void WINAPIV	pp_writestring (const char *format,...)

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)

int	yyget_leng (void)

char *	yyget_text (void)

int	yyget_lineno (void)

void	yyset_lineno (int _line_number)

int	yywrap (void)

static void	yy_push_state (int _new_state)

static void	yy_pop_state (void)

static int	yy_top_state (void)

int	yylex (void)

	if (!(yy_init))

static void	add_text (const char *str, int len)

static mtext_t *	add_expand_text (mtext_t mtp, macexpstackentry_t mep, int *nnl)

void	pp_do_include (char *fname, int type)

void	pp_push_ignore_state (void)

void	pp_pop_ignore_state (void)

Variables
int	yyleng

FILE *	yyin = NULL

FILE *	yyout = NULL

static size_t	yy_buffer_stack_top = 0

static size_t	yy_buffer_stack_max = 0

static YY_BUFFER_STATE *	yy_buffer_stack = NULL

static char	yy_hold_char

static int	yy_n_chars

static char *	yy_c_buf_p = NULL

static int	yy_init = 0

static int	yy_start = 0

static int	yy_did_buffer_switch_on_eof

int	yylineno = 1

char *	yytext

static const flex_int16_t	yy_accept [421]

static const YY_CHAR	yy_ec [256]

static const YY_CHAR	yy_meta [50]

static const flex_int16_t	yy_base [467]

static const flex_int16_t	yy_def [467]

static const flex_int16_t	yy_nxt [1970]

static const flex_int16_t	yy_chk [1970]

static yy_state_type	yy_last_accepting_state

static char *	yy_last_accepting_cpos

int	yy_flex_debug = 0

static int	ncontinuations

static int	strbuf_idx = 0

static int	strbuf_alloc = 0

static char *	strbuffer = NULL

static int	str_startline

static macexpstackentry_t *	macexpstack [MAXMACEXPSTACK]

static int	macexpstackidx = 0

static bufferstackentry_t	bufferstack [MAXBUFFERSTACK]

static int	bufferstackidx = 0

include_state_t	pp_incl_state

includelogicentry_t *	pp_includelogiclist = NULL

static int	yy_start_stack_ptr = 0

static int	yy_start_stack_depth = 0

static int *	yy_start_stack = NULL

	YY_DECL

char *	yy_cp

char *	yy_bp

int	yy_act

static int	curdef_alloc = 0

static char *	curdef_text = NULL

Macro Definition Documentation

◆ ALLOCBLOCKSIZE

#define ALLOCBLOCKSIZE (1 << 10) /* Allocate these chunks at a time for string-buffers */

Definition at line 1468 of file ppl.yy.c.

◆ BEGIN

#define BEGIN (yy_start) = 1 + 2 *

Definition at line 377 of file ppl.yy.c.

◆ BUFFERINITIALCAPACITY

#define BUFFERINITIALCAPACITY 256

Definition at line 1554 of file ppl.yy.c.

◆ ECHO

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

Definition at line 1731 of file ppl.yy.c.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN 0

Definition at line 421 of file ppl.yy.c.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE 1

Definition at line 422 of file ppl.yy.c.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH 2

Definition at line 423 of file ppl.yy.c.

◆ FLEX_BETA

#define FLEX_BETA

Definition at line 39 of file ppl.yy.c.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 34 of file ppl.yy.c.

◆ FLEXINT_H

#define FLEXINT_H

Definition at line 289 of file ppl.yy.c.

◆ INITIAL

#define INITIAL 0

Definition at line 1606 of file ppl.yy.c.

◆ INT16_MAX

#define INT16_MAX (32767)

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

◆ INT16_MIN

#define INT16_MIN (-32767-1)

Definition at line 322 of file ppl.yy.c.

◆ INT32_MAX

#define INT32_MAX (2147483647)

Definition at line 334 of file ppl.yy.c.

◆ INT32_MIN

#define INT32_MIN (-2147483647-1)

Definition at line 325 of file ppl.yy.c.

◆ INT8_MAX

#define INT8_MAX (127)

Definition at line 328 of file ppl.yy.c.

◆ INT8_MIN

#define INT8_MIN (-128)

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

◆ MACROPARENTHESES

#define MACROPARENTHESES ( ) (top_macro()->parentheses)

Definition at line 1490 of file ppl.yy.c.

◆ MAXBUFFERSTACK

#define MAXBUFFERSTACK 128 /* Nesting more than 128 includes or macro expansion textss is insane */

Definition at line 1451 of file ppl.yy.c.

◆ MAXMACEXPSTACK

#define MAXMACEXPSTACK 128 /* Nesting more than 128 macro expansions is insane */

Definition at line 1476 of file ppl.yy.c.

◆ pp_comment

#define pp_comment 7

Definition at line 1613 of file ppl.yy.c.

◆ pp_def

#define pp_def 8

Definition at line 1614 of file ppl.yy.c.

◆ pp_define

#define pp_define 9

Definition at line 1615 of file ppl.yy.c.

◆ pp_defined

#define pp_defined 20

Definition at line 1626 of file ppl.yy.c.

◆ pp_dqs

#define pp_dqs 4

Definition at line 1610 of file ppl.yy.c.

◆ pp_endif

#define pp_endif 18

Definition at line 1624 of file ppl.yy.c.

◆ pp_eol

#define pp_eol 2

Definition at line 1608 of file ppl.yy.c.

◆ pp_if

#define pp_if 15

Definition at line 1621 of file ppl.yy.c.

◆ pp_ifd

#define pp_ifd 16

Definition at line 1622 of file ppl.yy.c.

◆ pp_ifignored

#define pp_ifignored 17

Definition at line 1623 of file ppl.yy.c.

◆ pp_ignore

#define pp_ignore 21

Definition at line 1627 of file ppl.yy.c.

◆ pp_inc

#define pp_inc 3

Definition at line 1609 of file ppl.yy.c.

◆ pp_iqs

#define pp_iqs 6

Definition at line 1612 of file ppl.yy.c.

◆ pp_line

#define pp_line 19

Definition at line 1625 of file ppl.yy.c.

◆ pp_macexp

#define pp_macexp 14

Definition at line 1620 of file ppl.yy.c.

◆ pp_macign

#define pp_macign 12

Definition at line 1618 of file ppl.yy.c.

◆ pp_macro

#define pp_macro 10

Definition at line 1616 of file ppl.yy.c.

◆ pp_macscan

#define pp_macscan 13

Definition at line 1619 of file ppl.yy.c.

◆ pp_mbody

#define pp_mbody 11

Definition at line 1617 of file ppl.yy.c.

◆ pp_pp

#define pp_pp 1

Definition at line 1607 of file ppl.yy.c.

◆ pp_sqs

#define pp_sqs 5

Definition at line 1611 of file ppl.yy.c.

◆ ppy__create_buffer_ALREADY_DEFINED

#define ppy__create_buffer_ALREADY_DEFINED

Definition at line 43 of file ppl.yy.c.

◆ ppy__delete_buffer_ALREADY_DEFINED

#define ppy__delete_buffer_ALREADY_DEFINED

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

◆ ppy__flex_debug_ALREADY_DEFINED

#define ppy__flex_debug_ALREADY_DEFINED

Definition at line 265 of file ppl.yy.c.

◆ ppy__flush_buffer_ALREADY_DEFINED

#define ppy__flush_buffer_ALREADY_DEFINED

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

◆ ppy__init_buffer_ALREADY_DEFINED

#define ppy__init_buffer_ALREADY_DEFINED

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

◆ ppy__load_buffer_state_ALREADY_DEFINED

#define ppy__load_buffer_state_ALREADY_DEFINED

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

◆ ppy__scan_buffer_ALREADY_DEFINED

#define ppy__scan_buffer_ALREADY_DEFINED

Definition at line 55 of file ppl.yy.c.

◆ ppy__scan_bytes_ALREADY_DEFINED

#define ppy__scan_bytes_ALREADY_DEFINED

Definition at line 67 of file ppl.yy.c.

◆ ppy__scan_string_ALREADY_DEFINED

#define ppy__scan_string_ALREADY_DEFINED

Definition at line 61 of file ppl.yy.c.

◆ ppy__switch_to_buffer_ALREADY_DEFINED

#define ppy__switch_to_buffer_ALREADY_DEFINED

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

◆ ppy_alloc_ALREADY_DEFINED

#define ppy_alloc_ALREADY_DEFINED

Definition at line 223 of file ppl.yy.c.

◆ ppy_ensure_buffer_stack_ALREADY_DEFINED

#define ppy_ensure_buffer_stack_ALREADY_DEFINED

Definition at line 109 of file ppl.yy.c.

◆ ppy_free_ALREADY_DEFINED

#define ppy_free_ALREADY_DEFINED

Definition at line 235 of file ppl.yy.c.

◆ ppy_in_ALREADY_DEFINED

#define ppy_in_ALREADY_DEFINED

Definition at line 253 of file ppl.yy.c.

◆ ppy_leng_ALREADY_DEFINED

#define ppy_leng_ALREADY_DEFINED

Definition at line 247 of file ppl.yy.c.

◆ ppy_lex_ALREADY_DEFINED

#define ppy_lex_ALREADY_DEFINED

Definition at line 115 of file ppl.yy.c.

◆ ppy_lineno_ALREADY_DEFINED

#define ppy_lineno_ALREADY_DEFINED

Definition at line 271 of file ppl.yy.c.

◆ ppy_out_ALREADY_DEFINED

#define ppy_out_ALREADY_DEFINED

Definition at line 259 of file ppl.yy.c.

◆ ppy_pop_buffer_state_ALREADY_DEFINED

#define ppy_pop_buffer_state_ALREADY_DEFINED

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

◆ ppy_push_buffer_state_ALREADY_DEFINED

#define ppy_push_buffer_state_ALREADY_DEFINED

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

◆ ppy_realloc_ALREADY_DEFINED

#define ppy_realloc_ALREADY_DEFINED

Definition at line 229 of file ppl.yy.c.

◆ ppy_restart_ALREADY_DEFINED

#define ppy_restart_ALREADY_DEFINED

Definition at line 121 of file ppl.yy.c.

◆ ppy_text_ALREADY_DEFINED

#define ppy_text_ALREADY_DEFINED

Definition at line 241 of file ppl.yy.c.

◆ ppy_wrap_ALREADY_DEFINED

#define ppy_wrap_ALREADY_DEFINED

Definition at line 217 of file ppl.yy.c.

◆ RCINCL

#define RCINCL 22

Definition at line 1628 of file ppl.yy.c.

◆ REJECT

#define REJECT reject_used_but_not_detected

Definition at line 1273 of file ppl.yy.c.

◆ SIZE_MAX

#define SIZE_MAX (~(size_t)0)

Definition at line 347 of file ppl.yy.c.

◆ UINT16_MAX

#define UINT16_MAX (65535U)

Definition at line 340 of file ppl.yy.c.

◆ UINT32_MAX

#define UINT32_MAX (4294967295U)

Definition at line 343 of file ppl.yy.c.

◆ UINT8_MAX

#define UINT8_MAX (255U)

Definition at line 337 of file ppl.yy.c.

◆ unput

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

Definition at line 441 of file ppl.yy.c.

◆ YY_AT_BOL

#define YY_AT_BOL ( ) (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 582 of file ppl.yy.c.

◆ YY_BREAK

#define YY_BREAK /*LINTED*/break;

Definition at line 1810 of file ppl.yy.c.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE 16384

Definition at line 399 of file ppl.yy.c.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING 2

Definition at line 503 of file ppl.yy.c.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW 0

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

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL 1

Definition at line 492 of file ppl.yy.c.

◆ yy_create_buffer

#define yy_create_buffer ppy__create_buffer

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

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER

Value:

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

Definition at line 519 of file ppl.yy.c.

◆ YY_CURRENT_BUFFER_LVALUE

#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 525 of file ppl.yy.c.

◆ yy_current_state

#define yy_current_state ( ) YY_START

Definition at line 1440 of file ppl.yy.c.

◆ YY_DECL

#define YY_DECL int yylex (void)

Definition at line 1798 of file ppl.yy.c.

◆ YY_DECL_IS_OURS

#define YY_DECL_IS_OURS 1

Definition at line 1794 of file ppl.yy.c.

◆ yy_delete_buffer

#define yy_delete_buffer ppy__delete_buffer

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

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Value:

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

Definition at line 608 of file ppl.yy.c.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER 146

Definition at line 615 of file ppl.yy.c.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR 0

Definition at line 388 of file ppl.yy.c.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE 2

◆ YY_EXTRA_TYPE

#define YY_EXTRA_TYPE void *

Definition at line 1639 of file ppl.yy.c.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR ( msg ) yy_fatal_error( msg )

Definition at line 1785 of file ppl.yy.c.

◆ yy_flex_debug

#define yy_flex_debug ppy__flex_debug

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

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION 2

Definition at line 35 of file ppl.yy.c.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION 6

Definition at line 36 of file ppl.yy.c.

◆ YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION 4

Definition at line 37 of file ppl.yy.c.

◆ yy_flush_buffer

#define yy_flush_buffer ppy__flush_buffer

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

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )

Definition at line 553 of file ppl.yy.c.

◆ yy_init_buffer

#define yy_init_buffer ppy__init_buffer

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

◆ YY_INPUT

#define YY_INPUT	(	buf,
		result,
		max_size
	)

Value:

{                                    \
            result = wpp_read(pp_status.file, buf, max_size); \
    }

Definition at line 1549 of file ppl.yy.c.

◆ YY_INT_ALIGNED

#define YY_INT_ALIGNED short int

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

◆ YY_LESS_LINENO

#define YY_LESS_LINENO ( n )

Definition at line 425 of file ppl.yy.c.

◆ YY_LINENO_REWIND_TO

#define YY_LINENO_REWIND_TO ( ptr )

Definition at line 426 of file ppl.yy.c.

◆ yy_load_buffer_state

#define yy_load_buffer_state ppy__load_buffer_state

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

◆ YY_MORE_ADJ

#define YY_MORE_ADJ 0

Definition at line 1275 of file ppl.yy.c.

◆ yy_new_buffer

#define yy_new_buffer yy_create_buffer

Definition at line 563 of file ppl.yy.c.

◆ YY_NEW_FILE

#define YY_NEW_FILE yyrestart( yyin )

Definition at line 387 of file ppl.yy.c.

◆ YY_NO_INPUT

#define YY_NO_INPUT 1

Definition at line 1394 of file ppl.yy.c.

◆ YY_NO_UNISTD_H

#define YY_NO_UNISTD_H

Definition at line 1426 of file ppl.yy.c.

◆ YY_NULL

#define YY_NULL 0

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

◆ YY_NUM_RULES

#define YY_NUM_RULES 145

Definition at line 614 of file ppl.yy.c.

◆ yy_pp_state

#define yy_pp_state ( x ) yy_pop_state(); yy_push_state(x)

Definition at line 1441 of file ppl.yy.c.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE 65536 /* So we read most of a file at once */

Definition at line 1438 of file ppl.yy.c.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 1276 of file ppl.yy.c.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP

Value:

if ( yyleng > 0 ) \
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
                (yytext[yyleng - 1] == '\n'); \
    YY_USER_ACTION

Definition at line 1813 of file ppl.yy.c.

◆ YY_SC_TO_UI

#define YY_SC_TO_UI ( c ) ((YY_CHAR) (c))

Definition at line 371 of file ppl.yy.c.

◆ yy_scan_buffer

#define yy_scan_buffer ppy__scan_buffer

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

◆ yy_scan_bytes

#define yy_scan_bytes ppy__scan_bytes

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

◆ yy_scan_string

#define yy_scan_string ppy__scan_string

Definition at line 12 of file ppl.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 573 of file ppl.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 564 of file ppl.yy.c.

◆ YY_START

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

Definition at line 382 of file ppl.yy.c.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR 25

Definition at line 1780 of file ppl.yy.c.

◆ YY_STATE_BUF_SIZE

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

Definition at line 405 of file ppl.yy.c.

◆ YY_STATE_EOF

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

Definition at line 385 of file ppl.yy.c.

◆ YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 444 of file ppl.yy.c.

◆ yy_switch_to_buffer

#define yy_switch_to_buffer ppy__switch_to_buffer

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

◆ YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 408 of file ppl.yy.c.

◆ YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 413 of file ppl.yy.c.

◆ YY_USER_ACTION

#define YY_USER_ACTION pp_status.char_number+=ppy_leng;

Definition at line 1446 of file ppl.yy.c.

◆ yyalloc

#define yyalloc ppy_alloc

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

◆ yyconst

#define yyconst const

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

◆ yyensure_buffer_stack

#define yyensure_buffer_stack ppy_ensure_buffer_stack

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

◆ yyfree

#define yyfree ppy_free

Definition at line 32 of file ppl.yy.c.

◆ yyget_debug

#define yyget_debug ppy_get_debug

Definition at line 147 of file ppl.yy.c.

◆ yyget_extra

#define yyget_extra ppy_get_extra

Definition at line 159 of file ppl.yy.c.

◆ yyget_in

#define yyget_in ppy_get_in

Definition at line 171 of file ppl.yy.c.

◆ yyget_leng

#define yyget_leng ppy_get_leng

Definition at line 195 of file ppl.yy.c.

◆ yyget_lineno

#define yyget_lineno ppy_get_lineno

Definition at line 207 of file ppl.yy.c.

◆ yyget_out

#define yyget_out ppy_get_out

Definition at line 183 of file ppl.yy.c.

◆ yyget_text

#define yyget_text ppy_get_text

Definition at line 201 of file ppl.yy.c.

◆ yyin

#define yyin ppy_in

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

◆ yyleng

#define yyleng ppy_leng

Definition at line 23 of file ppl.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 429 of file ppl.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 429 of file ppl.yy.c.

◆ yylex

#define yylex ppy_lex

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

◆ yylex_destroy

#define yylex_destroy ppy_lex_destroy

Definition at line 141 of file ppl.yy.c.

◆ yylex_init

#define yylex_init ppy_lex_init

Definition at line 129 of file ppl.yy.c.

◆ yylex_init_extra

#define yylex_init_extra ppy_lex_init_extra

Definition at line 135 of file ppl.yy.c.

◆ yylineno

#define yylineno ppy_lineno

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

◆ yymore

#define yymore ( ) yymore_used_but_not_detected

Definition at line 1274 of file ppl.yy.c.

◆ yynoreturn

#define yynoreturn

Definition at line 362 of file ppl.yy.c.

◆ yyout

#define yyout ppy_out

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

◆ yypop_buffer_state

#define yypop_buffer_state ppy_pop_buffer_state

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

◆ yypush_buffer_state

#define yypush_buffer_state ppy_push_buffer_state

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

◆ yyrealloc

#define yyrealloc ppy_realloc

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

◆ yyrestart

#define yyrestart ppy_restart

Definition at line 27 of file ppl.yy.c.

◆ yyset_debug

#define yyset_debug ppy_set_debug

Definition at line 153 of file ppl.yy.c.

◆ yyset_extra

#define yyset_extra ppy_set_extra

Definition at line 165 of file ppl.yy.c.

◆ yyset_in

#define yyset_in ppy_set_in

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

◆ yyset_lineno

#define yyset_lineno ppy_set_lineno

Definition at line 213 of file ppl.yy.c.

◆ yyset_out

#define yyset_out ppy_set_out

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

◆ YYSTATE

#define YYSTATE YY_START

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

◆ YYTABLES_NAME

#define YYTABLES_NAME "yytables"

◆ yyterminate

#define yyterminate ( ) return YY_NULL

Definition at line 1775 of file ppl.yy.c.

◆ yytext

#define yytext ppy_text

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

◆ yytext_ptr

#define yytext_ptr yytext

Definition at line 598 of file ppl.yy.c.

◆ yywrap

#define yywrap ppy_wrap

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

Typedef Documentation

◆ bufferstackentry_t

typedef struct bufferstackentry bufferstackentry_t

◆ flex_int16_t

typedef short int flex_int16_t

Definition at line 311 of file ppl.yy.c.

◆ flex_int32_t

typedef int flex_int32_t

Definition at line 312 of file ppl.yy.c.

◆ flex_int8_t

typedef signed char flex_int8_t

Definition at line 310 of file ppl.yy.c.

◆ flex_uint16_t

typedef unsigned short int flex_uint16_t

Definition at line 314 of file ppl.yy.c.

◆ flex_uint32_t

typedef unsigned int flex_uint32_t

Definition at line 315 of file ppl.yy.c.

◆ flex_uint8_t

typedef unsigned char flex_uint8_t

Definition at line 313 of file ppl.yy.c.

◆ macexpstackentry_t

typedef struct macexpstackentry macexpstackentry_t

◆ YY_BUFFER_STATE

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 409 of file ppl.yy.c.

◆ YY_CHAR

typedef flex_uint8_t YY_CHAR

Definition at line 585 of file ppl.yy.c.

◆ yy_size_t

typedef size_t yy_size_t

Definition at line 414 of file ppl.yy.c.

◆ yy_state_type

typedef int yy_state_type

Definition at line 589 of file ppl.yy.c.

Function Documentation

◆ add_expand_text()

static mtext_t* add_expand_text	(	mtext_t *	mtp,
		macexpstackentry_t *	mep,
		int *	nnl
	)

static

Definition at line 4213 of file ppl.yy.c.

 {
     char *cptr;
     char *exp;
     int tag;
     int n;
 
     if(mtp == NULL)
         return NULL;
 
     switch(mtp->type)
     {
     case exp_text:
         add_text(mtp->subst.text, strlen(mtp->subst.text));
         break;
 
     case exp_stringize:
         cptr = mep->args[mtp->subst.argidx];
         add_text("\"", 1);
         while(*cptr)
         {
             if(*cptr == '"' || *cptr == '\\')
                 add_text("\\", 1);
             add_text(cptr, 1);
             cptr++;
         }
         add_text("\"", 1);
         break;
 
     case exp_concat:
         /* Remove trailing whitespace from current expansion text */
         while(curdef_idx)
         {
             if(isspace(curdef_text[curdef_idx-1] & 0xff))
                 curdef_idx--;
             else
                 break;
         }
         /* tag current position and recursively expand the next part */
         tag = curdef_idx;
         mtp = add_expand_text(mtp->next, mep, nnl);
 
         /* Now get rid of the leading space of the expansion */
         cptr = &curdef_text[tag];
         n = curdef_idx - tag;
         while(n)
         {
             if(isspace(*cptr & 0xff))
             {
                 cptr++;
                 n--;
             }
             else
                 break;
         }
         if(cptr != &curdef_text[tag])
         {
             memmove(&curdef_text[tag], cptr, n);
             curdef_idx -= (curdef_idx - tag) - n;
         }
         break;
 
     case exp_subst:
         if((mtp->next && mtp->next->type == exp_concat) || (mtp->prev && mtp->prev->type == exp_concat))
             exp = mep->args[mtp->subst.argidx];
         else
             exp = mep->ppargs[mtp->subst.argidx];
         if(exp)
         {
             add_text(exp, strlen(exp));
             *nnl -= mep->nnls[mtp->subst.argidx];
             cptr = strchr(exp, '\n');
             while(cptr)
             {
                 *cptr = ' ';
                 cptr = strchr(cptr+1, '\n');
             }
             mep->nnls[mtp->subst.argidx] = 0;
         }
         break;
 
     default:
         pp_internal_error(__FILE__, __LINE__, "Invalid expansion type (%d) in macro expansion\n", mtp->type);
     }
     return mtp;
 }

Referenced by expand_macro().

◆ add_string()

static void add_string	(	const char *	str,
		int	len
	)

static

Definition at line 4380 of file ppl.yy.c.

 {
     int new_alloc;
     char *new_buffer;
 
     if(len == 0)
         return;
     if(strbuf_idx >= strbuf_alloc || strbuf_alloc - strbuf_idx < len)
     {
         new_alloc = strbuf_alloc + ((len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1));
         new_buffer = pp_xrealloc(strbuffer, new_alloc * sizeof(strbuffer[0]));
         if(!new_buffer)
             return;
         strbuffer = new_buffer;
         strbuf_alloc = new_alloc;
         if(strbuf_alloc > 65536)
             ppy_warning("Reallocating string buffer larger than 64kB");
     }
     memcpy(&strbuffer[strbuf_idx], str, len);
     strbuf_idx += len;
 }

◆ add_text()

static void add_text	(	const char *	str,
		int	len
	)

static

Definition at line 4191 of file ppl.yy.c.

 {
     int new_alloc;
     char *new_text;
 
     if(len == 0)
         return;
     if(curdef_idx >= curdef_alloc || curdef_alloc - curdef_idx < len)
     {
         new_alloc = curdef_alloc + ((len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1));
         new_text = pp_xrealloc(curdef_text, new_alloc * sizeof(curdef_text[0]));
         if(!new_text)
             return;
         curdef_text = new_text;
         curdef_alloc = new_alloc;
         if(curdef_alloc > 65536)
             ppy_warning("Reallocating macro-expansion buffer larger than 64kB");
     }
     memcpy(&curdef_text[curdef_idx], str, len);
     curdef_idx += len;
 }

Referenced by add_expand_text(), and expand_macro().

◆ add_text_to_macro()

static void add_text_to_macro	(	const char *	text,
		int	len
	)

static

Definition at line 4585 of file ppl.yy.c.

 {
     macexpstackentry_t *mep = top_macro();
 
     assert(mep->ppp->expanding == 0);
 
     if(mep->curargalloc - mep->curargsize <= len+1) /* +1 for '\0' */
     {
         char *new_curarg;
         int new_alloc = mep->curargalloc + ((ALLOCBLOCKSIZE > len+1) ? ALLOCBLOCKSIZE : len+1);
         new_curarg = pp_xrealloc(mep->curarg, new_alloc * sizeof(mep->curarg[0]));
         if(!new_curarg)
             return;
         mep->curarg = new_curarg;
         mep->curargalloc = new_alloc;
     }
     memcpy(mep->curarg + mep->curargsize, text, len);
     mep->curargsize += len;
     mep->curarg[mep->curargsize] = '\0';
 }

Referenced by put_buffer().

◆ expand_define()

static void expand_define ( pp_entry_t * ppp )

static

◆ expand_macro()

static void expand_macro ( macexpstackentry_t * mep )

static

Definition at line 4300 of file ppl.yy.c.

 {
     mtext_t *mtp;
     int n, k;
     char *cptr;
     int nnl = 0;
     pp_entry_t *ppp = mep->ppp;
     int nargs = mep->nargs;
 
     assert(ppp->type == def_macro);
     assert(ppp->expanding == 0);
 
     if((ppp->nargs >= 0 && nargs != ppp->nargs) || (ppp->nargs < 0 && nargs < -ppp->nargs))
     {
         ppy_error("Too %s macro arguments (%d)", nargs < abs(ppp->nargs) ? "few" : "many", nargs);
         return;
     }
 
     for(n = 0; n < nargs; n++)
         nnl += mep->nnls[n];
 
     curdef_idx = 0;
 
     for(mtp = ppp->subst.mtext; mtp; mtp = mtp->next)
     {
         if(!(mtp = add_expand_text(mtp, mep, &nnl)))
             break;
     }
 
     for(n = 0; n < nnl; n++)
         add_text("\n", 1);
 
     /* To make sure there is room and termination (see below) */
     add_text(" \0", 2);
 
     /* Strip trailing whitespace from expansion */
     for(k = curdef_idx, cptr = &curdef_text[curdef_idx-1]; k > 0; k--, cptr--)
     {
         if(!isspace(*cptr & 0xff))
             break;
     }
 
     /*
      * We must add *one* whitespace to make sure that there
      * is a token-separation after the expansion.
      */
     *(++cptr) = ' ';
     *(++cptr) = '\0';
     k++;
 
     /* Strip leading whitespace from expansion */
     for(n = 0, cptr = curdef_text; n < k; n++, cptr++)
     {
         if(!isspace(*cptr & 0xff))
             break;
     }
 
     if(k - n > 0)
     {
         push_buffer(ppp, NULL, NULL, 0);
         /*yy_scan_bytes(curdef_text + n, k - n);*/
         yy_scan_string(curdef_text + n);
     }
 }

◆ expand_special()

static void expand_special ( pp_entry_t * ppp )

static

◆ free_macro()

static void free_macro ( macexpstackentry_t * mep )

static

Definition at line 4573 of file ppl.yy.c.

 {
     int i;
 
     for(i = 0; i < mep->nargs; i++)
         free(mep->args[i]);
     free(mep->args);
     free(mep->nnls);
     free(mep->curarg);
     free(mep);
 }

◆ get_string()

static char * get_string ( void )

static

Definition at line 4402 of file ppl.yy.c.

 {
     char *str = pp_xmalloc(strbuf_idx + 1);
     if(!str)
         return NULL;
     memcpy(str, strbuffer, strbuf_idx);
     str[strbuf_idx] = '\0';
 #ifdef DEBUG
     strbuf_idx = 0;
 #endif
     return str;
 }

Referenced by create_regexp_var(), DateConstr_value(), debugstr_jsval(), JSGlobal_eval(), JSON_stringify(), jsval_copy(), jsval_release(), jsval_strict_equal(), jsval_to_variant(), less_eval(), rep_call(), stringify(), to_boolean(), to_number(), to_object(), and to_string().

◆ if()

if ( ! yy_init )

Definition at line 1827 of file ppl.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_add_arg()

static void macro_add_arg ( int last )

static

Definition at line 4606 of file ppl.yy.c.

 {
     int nnl = 0;
     char *cptr;
     char **new_args, **new_ppargs;
     int *new_nnls;
     macexpstackentry_t *mep = top_macro();
 
     assert(mep->ppp->expanding == 0);
 
     new_args = pp_xrealloc(mep->args, (mep->nargs+1) * sizeof(mep->args[0]));
     if(!new_args)
         return;
     mep->args = new_args;
 
     new_ppargs = pp_xrealloc(mep->ppargs, (mep->nargs+1) * sizeof(mep->ppargs[0]));
     if(!new_ppargs)
         return;
     mep->ppargs = new_ppargs;
 
     new_nnls = pp_xrealloc(mep->nnls, (mep->nargs+1) * sizeof(mep->nnls[0]));
     if(!new_nnls)
         return;
     mep->nnls = new_nnls;
 
     mep->args[mep->nargs] = pp_xstrdup(mep->curarg ? mep->curarg : "");
     if(!mep->args[mep->nargs])
         return;
     cptr = mep->args[mep->nargs]-1;
     while((cptr = strchr(cptr+1, '\n')))
     {
         nnl++;
     }
     mep->nnls[mep->nargs] = nnl;
     mep->nargs++;
     free(mep->curarg);
     mep->curargalloc = mep->curargsize = 0;
     mep->curarg = NULL;
 
     /* Each macro argument must be expanded to cope with stingize */
     if(last || mep->args[mep->nargs-1][0])
     {
         yy_push_state(pp_macexp);
         push_buffer(NULL, NULL, NULL, last ? 2 : 1);
         yy_scan_string(mep->args[mep->nargs-1]);
         /*mep->bufferstackidx = bufferstackidx;  But not nested! */
     }
 }

◆ macro_add_expansion()

static void macro_add_expansion ( void )

static

Definition at line 4655 of file ppl.yy.c.

 {
     macexpstackentry_t *mep = top_macro();
 
     assert(mep->ppp->expanding == 0);
 
     mep->ppargs[mep->nargs-1] = pp_xstrdup(mep->curarg ? mep->curarg : "");
     free(mep->curarg);
     mep->curargalloc = mep->curargsize = 0;
     mep->curarg = NULL;
 }

Referenced by pop_buffer().

◆ make_number()

static int make_number	(	int	radix,
		YYSTYPE *	val,
		const char *	str,
		int	len
	)

static

◆ new_string()

static void new_string ( void )

static

Definition at line 4370 of file ppl.yy.c.

 {
 #ifdef DEBUG
     if(strbuf_idx)
         ppy_warning("new_string: strbuf_idx != 0");
 #endif
     strbuf_idx = 0;
     str_startline = pp_status.line_number;
 }

Referenced by AppendUnicodeString(), and PerfDataGetCommandLine().

◆ newline()

static void newline ( int )

static

Referenced by check_version(), export_newline(), read_line(), read_stdin(), REGPROC_export_binary(), and str_handle_lines().

◆ pop_buffer()

static bufferstackentry_t * pop_buffer ( void )

static

Definition at line 4467 of file ppl.yy.c.

 {
     if(bufferstackidx < 0)
         pp_internal_error(__FILE__, __LINE__, "Bufferstack underflow?");
 
     if(bufferstackidx == 0)
         return NULL;
 
     bufferstackidx--;
 
     if(bufferstack[bufferstackidx].define)
         bufferstack[bufferstackidx].define->expanding = 0;
     else
     {
         includelogicentry_t *iep = NULL;
 
         if(!bufferstack[bufferstackidx].should_pop)
         {
             wpp_close(pp_status.file);
             pp_writestring("# %d \"%s\" 2\n", bufferstack[bufferstackidx].line_number, bufferstack[bufferstackidx].filename);
 
             /* We have EOF, check the include logic */
             if(pp_incl_state.state == 2 && !pp_incl_state.seen_junk && pp_incl_state.ppp)
             {
                 pp_entry_t *ppp = pplookup(pp_incl_state.ppp);
                 if(ppp)
                 {
                     iep = pp_xmalloc(sizeof(includelogicentry_t));
                     if (iep)
                     {
                         iep->ppp = ppp;
                         ppp->iep = iep;
                         iep->filename = bufferstack[bufferstackidx].include_filename;
                         iep->prev = NULL;
                         iep->next = pp_includelogiclist;
                         if(iep->next)
                             iep->next->prev = iep;
                         pp_includelogiclist = iep;
                     }
                 }
             }
             free(pp_incl_state.ppp);
             pp_incl_state   = bufferstack[bufferstackidx].incl;
 
         }
         if (bufferstack[bufferstackidx].include_filename)
         {
             free(pp_status.input);
             pp_status.input = bufferstack[bufferstackidx].filename;
         }
         pp_status.line_number = bufferstack[bufferstackidx].line_number;
         pp_status.char_number = bufferstack[bufferstackidx].char_number;
         ncontinuations = bufferstack[bufferstackidx].ncontinuations;
         if (!iep)
             free(bufferstack[bufferstackidx].include_filename);
     }
 
     pp_status.file = bufferstack[bufferstackidx].filehandle;
     ppy__switch_to_buffer(bufferstack[bufferstackidx].bufferstate);
 
     if(bufferstack[bufferstackidx].should_pop)
     {
         if(yy_current_state() == pp_macexp)
             macro_add_expansion();
         else
             pp_internal_error(__FILE__, __LINE__, "Pop buffer and state without macro expansion state");
         yy_pop_state();
     }
 
     return &bufferstack[bufferstackidx];
 }

◆ pop_macro()

static macexpstackentry_t * pop_macro ( void )

static

Definition at line 4566 of file ppl.yy.c.

 {
     if(macexpstackidx <= 0)
         pp_internal_error(__FILE__, __LINE__, "Macro expansion stack underflow\n");
     return macexpstack[--macexpstackidx];
 }

◆ pp_do_include()

void pp_do_include	(	char *	fname,
		int	type
	)

Definition at line 4687 of file ppl.yy.c.

 {
     char *newpath;
     int n;
     includelogicentry_t *iep;
     void *fp;
 
     if(!fname)
         return;
 
     for(iep = pp_includelogiclist; iep; iep = iep->next)
     {
         if(!strcmp(iep->filename, fname))
         {
             /*
              * We are done. The file was included before.
              * If the define was deleted, then this entry would have
              * been deleted too.
              */
             free(fname);
             return;
         }
     }
 
     n = strlen(fname);
 
     if(n <= 2)
     {
         ppy_error("Empty include filename");
         free(fname);
         return;
     }
 
     /* Undo the effect of the quotation */
     fname[n-1] = '\0';
 
     if((fp = pp_open_include(fname+1, type, pp_status.input, &newpath)) == NULL)
     {
         ppy_error("Unable to open include file %s", fname+1);
         free(fname);
         return;
     }
 
     fname[n-1] = *fname;    /* Redo the quotes */
     push_buffer(NULL, newpath, fname, 0);
     pp_incl_state.seen_junk = 0;
     pp_incl_state.state = 0;
     pp_incl_state.ppp = NULL;
 
     pp_status.file = fp;
     ppy__switch_to_buffer(ppy__create_buffer(NULL, YY_BUF_SIZE));
 
     pp_writestring("# 1 \"%s\" 1%s\n", newpath, type ? "" : " 3");
 }

Referenced by yyparse().

◆ pp_pop_ignore_state()

void pp_pop_ignore_state ( void )

Definition at line 4753 of file ppl.yy.c.

 {
     yy_pop_state();
 }

Referenced by pp_pop_if().

◆ pp_push_ignore_state()

void pp_push_ignore_state ( void )

Definition at line 4748 of file ppl.yy.c.

 {
     yy_push_state(pp_ignore);
 }

Referenced by pp_push_if().

◆ pp_writestring()

void WINAPIV pp_writestring	(	const char *	format,
			...
	)

Definition at line 1556 of file ppl.yy.c.

 {
     __ms_va_list valist;
     int len;
     static char *buffer;
     static int buffercapacity;
     char *new_buffer;
 
     if(buffercapacity == 0)
     {
         buffer = pp_xmalloc(BUFFERINITIALCAPACITY);
         if(buffer == NULL)
             return;
         buffercapacity = BUFFERINITIALCAPACITY;
     }
 
     __ms_va_start(valist, format);
     len = vsnprintf(buffer, buffercapacity,
             format, valist);
     __ms_va_end(valist);
         /* If the string is longer than buffersize, vsnprintf returns
          * the string length with glibc >= 2.1, -1 with glibc < 2.1 */
     while(len > buffercapacity || len < 0)
     {
         do
         {
             buffercapacity *= 2;
         } while(len > buffercapacity);
 
         new_buffer = pp_xrealloc(buffer, buffercapacity);
         if(new_buffer == NULL)
             return;
         buffer = new_buffer;
         __ms_va_start(valist, format);
         len = vsnprintf(buffer, buffercapacity,
                 format, valist);
         __ms_va_end(valist);
     }
 
     wpp_write(buffer, len);
 }

Referenced by pop_buffer(), pp_do_include(), wpp_parse(), and yyparse().

◆ push_buffer()

static void push_buffer	(	pp_entry_t *	ppp,
		char *	filename,
		char *	incname,
		int	pop
	)

static

Definition at line 4434 of file ppl.yy.c.

 {
     if(bufferstackidx >= MAXBUFFERSTACK)
         pp_internal_error(__FILE__, __LINE__, "Buffer stack overflow");
 
     memset(&bufferstack[bufferstackidx], 0, sizeof(bufferstack[0]));
     bufferstack[bufferstackidx].bufferstate = YY_CURRENT_BUFFER;
     bufferstack[bufferstackidx].filehandle  = pp_status.file;
     bufferstack[bufferstackidx].define  = ppp;
     bufferstack[bufferstackidx].line_number = pp_status.line_number;
     bufferstack[bufferstackidx].char_number = pp_status.char_number;
     bufferstack[bufferstackidx].if_depth    = pp_get_if_depth();
     bufferstack[bufferstackidx].should_pop  = pop;
     bufferstack[bufferstackidx].filename    = pp_status.input;
     bufferstack[bufferstackidx].ncontinuations  = ncontinuations;
     bufferstack[bufferstackidx].incl        = pp_incl_state;
     bufferstack[bufferstackidx].include_filename    = incname;
 
     if(ppp)
         ppp->expanding = 1;
     else if(filename)
     {
         /* These will track the ppy_error to the correct file and line */
         pp_status.line_number = 1;
         pp_status.char_number = 1;
         pp_status.input  = filename;
         ncontinuations = 0;
     }
     else if(!pop)
         pp_internal_error(__FILE__, __LINE__, "Pushing buffer without knowing where to go to");
     bufferstackidx++;
 }

Referenced by expand_macro(), macro_add_arg(), and pp_do_include().

◆ push_macro()

static void push_macro ( pp_entry_t * ppp )

static

Definition at line 4545 of file ppl.yy.c.

 {
     if(macexpstackidx >= MAXMACEXPSTACK)
     {
         ppy_error("Too many nested macros");
         return;
     }
 
     macexpstack[macexpstackidx] = pp_xmalloc(sizeof(macexpstack[0][0]));
     if(!macexpstack[macexpstackidx])
         return;
         memset( macexpstack[macexpstackidx], 0, sizeof(macexpstack[0][0]));
     macexpstack[macexpstackidx]->ppp = ppp;
     macexpstackidx++;
 }

◆ put_buffer()

static void put_buffer	(	const char *	s,
		int	len
	)

static

Definition at line 4673 of file ppl.yy.c.

 {
     if(top_macro())
         add_text_to_macro(s, len);
     else
         wpp_write(s, len);
 }

Referenced by emit_bits_e(), emit_bits_s(), and put_string().

◆ put_string()

static void put_string ( void )

static

Definition at line 4415 of file ppl.yy.c.

 {
     put_buffer(strbuffer, strbuf_idx);
 #ifdef DEBUG
     strbuf_idx = 0;
 #endif
 }

◆ string_start()

static int string_start ( void )

static

Definition at line 4423 of file ppl.yy.c.

 {
     return str_startline;
 }

◆ top_macro()

static macexpstackentry_t * top_macro ( void )

static

Definition at line 4561 of file ppl.yy.c.

 {
     return macexpstackidx > 0 ? macexpstack[macexpstackidx-1] : NULL;
 }

Referenced by add_text_to_macro(), macro_add_arg(), macro_add_expansion(), and put_buffer().

◆ 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;
 }

◆ 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  );
 }

◆ yy_fatal_error()

static void yynoreturn yy_fatal_error ( const char * msg )

static

◆ 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( );
 }

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( void )

static

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( void )

static

◆ yy_init_buffer()

static void yy_init_buffer	(	YY_BUFFER_STATE	b,
		FILE *	file
	)

static

◆ yy_init_globals()

static int yy_init_globals ( void )

static

◆ yy_load_buffer_state()

static void yy_load_buffer_state ( void )

static

◆ yy_pop_state()

static void yy_pop_state ( void )

static

Referenced by pop_buffer(), and pp_pop_ignore_state().

◆ yy_push_state()

static void yy_push_state ( int _new_state )

static

Referenced by macro_add_arg(), and pp_push_ignore_state().

◆ 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;
 }

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes	(	const char *	bytes,
		int	len
	)

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( const char * yy_str )

◆ 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;
 }

◆ yy_top_state()

static int yy_top_state ( void )

static

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type current_state )

static

◆ yyalloc()

void* yyalloc ( yy_size_t )

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

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

◆ yyensure_buffer_stack()

static void yyensure_buffer_stack ( void )

static

◆ yyfree()

void yyfree ( void * )

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

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

◆ 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()

int 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 )

◆ 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;
     }
 }

◆ 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 *	,
		yy_size_t
	)

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 );
 }

◆ 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( );
 }

◆ 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; }

Variable Documentation

◆ bufferstack

bufferstackentry_t bufferstack[MAXBUFFERSTACK]

static

Definition at line 1533 of file ppl.yy.c.

Referenced by pop_buffer(), and push_buffer().

◆ bufferstackidx

int bufferstackidx = 0

static

Definition at line 1534 of file ppl.yy.c.

Referenced by pop_buffer(), and push_buffer().

◆ curdef_alloc

int curdef_alloc = 0

static

Definition at line 4188 of file ppl.yy.c.

Referenced by add_text().

◆ curdef_text

char* curdef_text = NULL

static

Definition at line 4189 of file ppl.yy.c.

Referenced by add_expand_text(), add_text(), and expand_macro().

◆ macexpstack

macexpstackentry_t* macexpstack[MAXMACEXPSTACK]

static

Definition at line 1530 of file ppl.yy.c.

Referenced by pop_macro(), push_macro(), and top_macro().

◆ macexpstackidx

int macexpstackidx = 0

static

Definition at line 1531 of file ppl.yy.c.

Referenced by pop_macro(), push_macro(), and top_macro().

◆ ncontinuations

int ncontinuations

static

Definition at line 1523 of file ppl.yy.c.

Referenced by pop_buffer(), and push_buffer().

◆ pp_incl_state

include_state_t pp_incl_state

Initial value:

=
{
    -1,    
    NULL,  
    0,     
    0      
}

Definition at line 1539 of file ppl.yy.c.

Referenced by pop_buffer(), pp_do_include(), push_buffer(), while(), and yyparse().

◆ pp_includelogiclist

includelogicentry_t* pp_includelogiclist = NULL

Definition at line 1547 of file ppl.yy.c.

Referenced by free_pp_entry(), pop_buffer(), and pp_do_include().

◆ str_startline

int str_startline

static

Definition at line 1528 of file ppl.yy.c.

Referenced by new_string(), and string_start().

◆ strbuf_alloc

int strbuf_alloc = 0

static

Definition at line 1526 of file ppl.yy.c.

Referenced by add_string().

◆ strbuf_idx

int strbuf_idx = 0

static

Definition at line 1525 of file ppl.yy.c.

Referenced by add_string(), get_string(), new_string(), and put_string().

◆ strbuffer

char* strbuffer = NULL

static

Definition at line 1527 of file ppl.yy.c.

Referenced by add_string(), get_string(), and put_string().

◆ yy_accept

const flex_int16_t yy_accept[421]

static

Definition at line 623 of file ppl.yy.c.

◆ yy_act

int yy_act

Definition at line 1825 of file ppl.yy.c.

Referenced by while().

◆ yy_base

const flex_int16_t yy_base[467]

static

Definition at line 714 of file ppl.yy.c.

◆ yy_bp

char * yy_bp

Definition at line 1824 of file ppl.yy.c.

Referenced by while().

◆ yy_buffer_stack

YY_BUFFER_STATE* yy_buffer_stack = NULL

static

Stack as an array.

Definition at line 511 of file ppl.yy.c.

◆ yy_buffer_stack_max

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 510 of file ppl.yy.c.

◆ yy_buffer_stack_top

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 509 of file ppl.yy.c.

◆ yy_c_buf_p

char* yy_c_buf_p = NULL

static

Definition at line 533 of file ppl.yy.c.

◆ yy_chk

const flex_int16_t yy_chk[1970]

static

Definition at line 1044 of file ppl.yy.c.

◆ yy_cp

char* yy_cp

Definition at line 1824 of file ppl.yy.c.

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

◆ YY_DECL

YY_DECL

Initial value:

{

yy_state_type yy_current_state

yy_state_type

int yy_state_type

Definition: macro.lex.yy.c:340

yy_current_state

#define yy_current_state()

Definition: ppl.yy.c:1440

The main scanner function which does all the work.

Definition at line 1822 of file ppl.yy.c.

◆ yy_def

const flex_int16_t yy_def[467]

static

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

◆ yy_did_buffer_switch_on_eof

int yy_did_buffer_switch_on_eof

static

Definition at line 540 of file ppl.yy.c.

◆ yy_ec

const YY_CHAR yy_ec[256]

static

Definition at line 673 of file ppl.yy.c.

◆ yy_flex_debug

int yy_flex_debug = 0

Definition at line 1268 of file ppl.yy.c.

◆ yy_hold_char

char yy_hold_char

static

Definition at line 528 of file ppl.yy.c.

◆ yy_init

int yy_init = 0

static

Definition at line 534 of file ppl.yy.c.

Referenced by if().

◆ yy_last_accepting_cpos

char* yy_last_accepting_cpos

static

Definition at line 1265 of file ppl.yy.c.

◆ yy_last_accepting_state

yy_state_type yy_last_accepting_state

static

Definition at line 1264 of file ppl.yy.c.

◆ yy_meta

const YY_CHAR yy_meta[50]

static

Initial value:

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

Definition at line 705 of file ppl.yy.c.

◆ yy_n_chars

int yy_n_chars

static

Definition at line 529 of file ppl.yy.c.

◆ yy_nxt

const flex_int16_t yy_nxt[1970]

static

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

◆ yy_start

int yy_start = 0

static

Definition at line 535 of file ppl.yy.c.

Referenced by if().

◆ yy_start_stack

int* yy_start_stack = NULL

static

Definition at line 1708 of file ppl.yy.c.

◆ yy_start_stack_depth

int yy_start_stack_depth = 0

static

Definition at line 1707 of file ppl.yy.c.

◆ yy_start_stack_ptr

int yy_start_stack_ptr = 0

static

Definition at line 1706 of file ppl.yy.c.

◆ yyin

FILE* yyin = NULL

Definition at line 587 of file ppl.yy.c.

◆ yyleng

int yyleng

Definition at line 530 of file ppl.yy.c.

◆ yylineno

int yylineno = 1

Definition at line 592 of file ppl.yy.c.

◆ yyout

FILE * yyout = NULL

Definition at line 587 of file ppl.yy.c.

◆ yytext

char* yytext

Definition at line 1277 of file ppl.yy.c.

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ ALLOCBLOCKSIZE

◆ BEGIN

◆ BUFFERINITIALCAPACITY

◆ 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

◆ MACROPARENTHESES

◆ MAXBUFFERSTACK

◆ MAXMACEXPSTACK

◆ pp_comment

◆ pp_def

◆ pp_define

◆ pp_defined

◆ pp_dqs

◆ pp_endif

◆ pp_eol

◆ pp_if

◆ pp_ifd

◆ pp_ifignored

◆ pp_ignore

◆ pp_inc

◆ pp_iqs

◆ pp_line

◆ pp_macexp

◆ pp_macign

◆ pp_macro

◆ pp_macscan

◆ pp_mbody

◆ pp_pp

◆ pp_sqs

◆ ppy__create_buffer_ALREADY_DEFINED

◆ ppy__delete_buffer_ALREADY_DEFINED

◆ ppy__flex_debug_ALREADY_DEFINED

◆ ppy__flush_buffer_ALREADY_DEFINED

◆ ppy__init_buffer_ALREADY_DEFINED

◆ ppy__load_buffer_state_ALREADY_DEFINED

◆ ppy__scan_buffer_ALREADY_DEFINED

◆ ppy__scan_bytes_ALREADY_DEFINED

◆ ppy__scan_string_ALREADY_DEFINED

◆ ppy__switch_to_buffer_ALREADY_DEFINED

◆ ppy_alloc_ALREADY_DEFINED

◆ ppy_ensure_buffer_stack_ALREADY_DEFINED

◆ ppy_free_ALREADY_DEFINED

◆ ppy_in_ALREADY_DEFINED

◆ ppy_leng_ALREADY_DEFINED

◆ ppy_lex_ALREADY_DEFINED

◆ ppy_lineno_ALREADY_DEFINED

◆ ppy_out_ALREADY_DEFINED

◆ ppy_pop_buffer_state_ALREADY_DEFINED

◆ ppy_push_buffer_state_ALREADY_DEFINED

◆ ppy_realloc_ALREADY_DEFINED

◆ ppy_restart_ALREADY_DEFINED

◆ ppy_text_ALREADY_DEFINED

◆ ppy_wrap_ALREADY_DEFINED

◆ RCINCL

◆ REJECT

◆ SIZE_MAX

◆ UINT16_MAX

◆ UINT32_MAX

◆ UINT8_MAX

◆ unput

◆ YY_AT_BOL

◆ YY_BREAK