Flex scanner description of tokens used in AEL2 . More...

#include "asterisk.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <glob.h>
#include "asterisk/logger.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/hashtab.h"
#include "ael/ael.tab.h"
#include "asterisk/ael_structs.h"

Include dependency graph for ael_lex.c:

Go to the source code of this file.

Data Structures
struct	stackelement

struct	yy_buffer_state

struct	yy_trans_info

struct	yyguts_t

Macros
#define	ael_yywrap(n) 1

#define	argg 3

#define	ASTMM_LIBC ASTMM_REDIRECT

#define	BEGIN yyg->yy_start = 1 + 2 *

#define	brackstate 7

#define	comment 4

#define	curlystate 5

#define	ECHO fwrite( yytext, yyleng, 1, yyout )

#define	EOB_ACT_CONTINUE_SCAN 0

#define	EOB_ACT_END_OF_FILE 1

#define	EOB_ACT_LAST_MATCH 2

#define	FLEX_BETA

#define	FLEX_SCANNER

#define	FLEXINT_H

#define	GLOB_ABORTED GLOB_ABEND

#define	GLOB_BRACE 0

#define	GLOB_NOMAGIC 0

#define	INITIAL 0

#define	INT16_MAX (32767)

#define	INT16_MIN (-32767-1)

#define	INT32_MAX (2147483647)

#define	INT32_MIN (-2147483647-1)

#define	INT8_MAX (127)

#define	INT8_MIN (-128)

#define	MAX_INCLUDE_DEPTH 50

#define	paren 1

#define	REJECT reject_used_but_not_detected

#define	semic 2

#define	STORE_LOC

#define	STORE_POS

#define	UINT16_MAX (65535U)

#define	UINT32_MAX (4294967295U)

#define	UINT8_MAX (255U)

#define	unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#define	wordstate 6

#define	YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

#define	YY_BREAK break;

#define	YY_BUF_SIZE 16384

#define	YY_BUFFER_EOF_PENDING 2

#define	YY_BUFFER_NEW 0

#define	YY_BUFFER_NORMAL 1

#define	YY_CURRENT_BUFFER

#define	YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

#define	YY_DECL

#define	YY_DECL_IS_OURS 1

#define	YY_DO_BEFORE_ACTION

#define	YY_END_OF_BUFFER 77

#define	YY_END_OF_BUFFER_CHAR 0

#define	YY_EXIT_FAILURE 2

#define	YY_EXTRA_TYPE void *

#define	YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)

#define	yy_flex_debug yyg->yy_flex_debug_r

#define	YY_FLEX_MAJOR_VERSION 2

#define	YY_FLEX_MINOR_VERSION 5

#define	YY_FLEX_SUBMINOR_VERSION 35

#define	YY_FLUSH_BUFFER ael_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)

#define	YY_INPUT(buf, result, max_size)

#define	YY_INT_ALIGNED short int

#define	YY_LESS_LINENO(n)

#define	YY_MORE_ADJ yyg->yy_more_len

#define	yy_new_buffer ael_yy_create_buffer

#define	YY_NEW_FILE ael_yyrestart(yyin ,yyscanner )

#define	YY_NULL 0

#define	YY_NUM_RULES 76

#define	YY_READ_BUF_SIZE 8192

#define	YY_RESTORE_YY_MORE_OFFSET

#define	YY_RULE_SETUP YY_USER_ACTION

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

#define	yy_set_bol(at_bol)

#define	yy_set_interactive(is_interactive)

#define	YY_SKIP_YYWRAP

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

#define	YY_START_STACK_INCR 25

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

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

#define	YY_STRUCT_YY_BUFFER_STATE

#define	YY_TYPEDEF_YY_BUFFER_STATE

#define	YY_TYPEDEF_YY_SCANNER_T

#define	YY_TYPEDEF_YY_SIZE_T

#define	YY_USER_ACTION

#define	yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)

#define	yyconst

#define	yyextra yyg->yyextra_r

#define	yyin yyg->yyin_r

#define	yyleng yyg->yyleng_r

#define	yyless(n)

#define	yyless(n)

#define	yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)

#define	yylloc yyg->yylloc_r

#define	yylval yyg->yylval_r

#define	yymore() (yyg->yy_more_flag = 1)

#define	yyout yyg->yyout_r

#define	YYSTATE YY_START

#define	YYTABLES_NAME "yytables"

#define	yyterminate() return YY_NULL

#define	yytext yyg->yytext_r

#define	yytext_ptr yytext_r

Typedefs
typedef short int	flex_int16_t

typedef int	flex_int32_t

typedef signed char	flex_int8_t

typedef unsigned short int	flex_uint16_t

typedef unsigned int	flex_uint32_t

typedef unsigned char	flex_uint8_t

typedef struct yy_buffer_state *	YY_BUFFER_STATE

typedef unsigned char	YY_CHAR

typedef size_t	yy_size_t

typedef int	yy_state_type

typedef void *	yyscan_t

Functions
struct pval *	ael2_parse (char filename, int errors)

YY_BUFFER_STATE	ael_yy_create_buffer (FILE *file, int size, yyscan_t yyscanner)

void	ael_yy_delete_buffer (YY_BUFFER_STATE b, yyscan_t yyscanner)

void	ael_yy_flush_buffer (YY_BUFFER_STATE b, yyscan_t yyscanner)

static void	ael_yy_init_buffer (YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner)

static void	ael_yy_load_buffer_state (yyscan_t yyscanner)

YY_BUFFER_STATE	ael_yy_scan_buffer (char *base, yy_size_t size, yyscan_t yyscanner)

YY_BUFFER_STATE	ael_yy_scan_bytes (yyconst char *bytes, int len, yyscan_t yyscanner)

YY_BUFFER_STATE	ael_yy_scan_string (yyconst char *yy_str, yyscan_t yyscanner)

void	ael_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer, yyscan_t yyscanner)

void *	ael_yyalloc (yy_size_t, yyscan_t yyscanner)

static void	ael_yyensure_buffer_stack (yyscan_t yyscanner)

void	ael_yyfree (void *, yyscan_t yyscanner)

int	ael_yyget_column (yyscan_t yyscanner)

int	ael_yyget_debug (yyscan_t yyscanner)

YY_EXTRA_TYPE	ael_yyget_extra (yyscan_t yyscanner)

FILE *	ael_yyget_in (yyscan_t yyscanner)

int	ael_yyget_leng (yyscan_t yyscanner)

int	ael_yyget_lineno (yyscan_t yyscanner)

YYLTYPE *	ael_yyget_lloc (yyscan_t yyscanner)

YYSTYPE *	ael_yyget_lval (yyscan_t yyscanner)

FILE *	ael_yyget_out (yyscan_t yyscanner)

char *	ael_yyget_text (yyscan_t yyscanner)

int	ael_yylex (YYSTYPE yylval_param, YYLTYPE yylloc_param, yyscan_t yyscanner)

int	ael_yylex_destroy (yyscan_t yyscanner)

int	ael_yylex_init (yyscan_t *scanner)

int	ael_yylex_init_extra (YY_EXTRA_TYPE user_defined, yyscan_t *scanner)

int	ael_yyparse (struct parse_io *)

void	ael_yypop_buffer_state (yyscan_t yyscanner)

void	ael_yypush_buffer_state (YY_BUFFER_STATE new_buffer, yyscan_t yyscanner)

void *	ael_yyrealloc (void *, yy_size_t, yyscan_t yyscanner)

void	ael_yyrestart (FILE *input_file, yyscan_t yyscanner)

void	ael_yyset_column (int column_no, yyscan_t yyscanner)

void	ael_yyset_debug (int debug_flag, yyscan_t yyscanner)

void	ael_yyset_extra (YY_EXTRA_TYPE user_defined, yyscan_t yyscanner)

void	ael_yyset_in (FILE *in_str, yyscan_t yyscanner)

void	ael_yyset_lineno (int line_number, yyscan_t yyscanner)

void	ael_yyset_lloc (YYLTYPE *yylloc_param, yyscan_t yyscanner)

void	ael_yyset_lval (YYSTYPE *yylval_param, yyscan_t yyscanner)

void	ael_yyset_out (FILE *out_str, yyscan_t yyscanner)

static int	c_prevword (void)

	if (!yyg->yy_init)

static int	input (yyscan_t yyscanner)

int	isatty (int)

static int	pbcpop (char x)

static int	pbcpop2 (char x)

static int	pbcpop3 (char x)

static void	pbcpush (char x)

static void	pbcpush2 (char x)

static void	pbcpush3 (char x)

static void	pbcwhere (const char text, int line, int *col)

void	reset_argcount (yyscan_t yyscanner)

void	reset_parencount (yyscan_t yyscanner)

void	reset_semicount (yyscan_t yyscanner)

static void	setup_filestack (char fnamebuf, int fnamebuf_siz, glob_t globbuf, int globpos, yyscan_t xscan, int create)

	while (1)

static void	yy_fatal_error (yyconst char *msg, yyscan_t yyscanner)

static void	yy_fatal_error (yyconst char msg[], yyscan_t yyscanner)

static int	yy_get_next_buffer (yyscan_t yyscanner)

static yy_state_type	yy_get_previous_state (yyscan_t yyscanner)

static int	yy_init_globals (yyscan_t yyscanner)

static yy_state_type	yy_try_NUL_trans (yy_state_type current_state, yyscan_t yyscanner)

static void	yyunput (int c, char *buf_ptr, yyscan_t yyscanner)

static void	yyunput (int c, register char *yy_bp, yyscan_t yyscanner)

Variables
static struct stackelement	include_stack [MAX_INCLUDE_DEPTH]

static int	include_stack_index = 0

static int	my_col = 1

char *	my_file = 0

static int	my_lineno = 1

static int	parencount = 0

static int	parencount2 = 0

static int	parencount3 = 0

static int	pbcpos = 0

static int	pbcpos2 = 0

static int	pbcpos3 = 0

static char	pbcstack [400]

static char	pbcstack2 [400]

static char	pbcstack3 [400]

char *	prev_word

static yyconst flex_int16_t	yy_accept [285]

register int	yy_act

static yyconst flex_int16_t	yy_base [304]

register char *	yy_bp

static yyconst flex_int16_t	yy_chk [1073]

register char *	yy_cp

	YY_DECL

static yyconst flex_int16_t	yy_def [304]

static yyconst flex_int32_t	yy_ec [256]

static yyconst flex_int32_t	yy_meta [50]

static yyconst flex_int16_t	yy_nxt [1073]

struct yyguts_t *	yyg = (struct yyguts_t*)yyscanner

	yylloc = yylloc_param

	yylval = yylval_param

Detailed Description

Flex scanner description of tokens used in AEL2 .

Definition in file ael_lex.c.

Macro Definition Documentation

◆ ael_yywrap

#define ael_yywrap ( n ) 1

Definition at line 331 of file ael_lex.c.

◆ argg

#define argg 3

Definition at line 964 of file ael_lex.c.

◆ ASTMM_LIBC

#define ASTMM_LIBC ASTMM_REDIRECT

Definition at line 1 of file ael_lex.c.

◆ BEGIN

#define BEGIN yyg->yy_start = 1 + 2 *

Definition at line 145 of file ael_lex.c.

◆ brackstate

#define brackstate 7

Definition at line 968 of file ael_lex.c.

◆ comment

#define comment 4

Definition at line 965 of file ael_lex.c.

◆ curlystate

#define curlystate 5

Definition at line 966 of file ael_lex.c.

◆ ECHO

#define ECHO fwrite( yytext, yyleng, 1, yyout )

Definition at line 1111 of file ael_lex.c.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN 0

Definition at line 176 of file ael_lex.c.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE 1

Definition at line 177 of file ael_lex.c.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH 2

Definition at line 178 of file ael_lex.c.

◆ FLEX_BETA

#define FLEX_BETA

Definition at line 17 of file ael_lex.c.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 12 of file ael_lex.c.

◆ FLEXINT_H

#define FLEXINT_H

Definition at line 33 of file ael_lex.c.

◆ GLOB_ABORTED

#define GLOB_ABORTED GLOB_ABEND

Definition at line 828 of file ael_lex.c.

◆ GLOB_BRACE

#define GLOB_BRACE 0

Definition at line 831 of file ael_lex.c.

◆ GLOB_NOMAGIC

#define GLOB_NOMAGIC 0

Definition at line 834 of file ael_lex.c.

◆ INITIAL

#define INITIAL 0

Definition at line 961 of file ael_lex.c.

◆ INT16_MAX

#define INT16_MAX (32767)

Definition at line 76 of file ael_lex.c.

◆ INT16_MIN

#define INT16_MIN (-32767-1)

Definition at line 67 of file ael_lex.c.

◆ INT32_MAX

#define INT32_MAX (2147483647)

Definition at line 79 of file ael_lex.c.

◆ INT32_MIN

#define INT32_MIN (-2147483647-1)

Definition at line 70 of file ael_lex.c.

◆ INT8_MAX

#define INT8_MAX (127)

Definition at line 73 of file ael_lex.c.

◆ INT8_MIN

#define INT8_MIN (-128)

Definition at line 64 of file ael_lex.c.

◆ MAX_INCLUDE_DEPTH

#define MAX_INCLUDE_DEPTH 50

Definition at line 880 of file ael_lex.c.

◆ paren

#define paren 1

Definition at line 962 of file ael_lex.c.

◆ REJECT

#define REJECT reject_used_but_not_detected

Definition at line 764 of file ael_lex.c.

◆ semic

#define semic 2

Definition at line 963 of file ael_lex.c.

◆ STORE_LOC

#define STORE_LOC

Definition at line 948 of file ael_lex.c.

◆ STORE_POS

#define STORE_POS

Definition at line 941 of file ael_lex.c.

◆ UINT16_MAX

#define UINT16_MAX (65535U)

Definition at line 85 of file ael_lex.c.

◆ UINT32_MAX

#define UINT32_MAX (4294967295U)

Definition at line 88 of file ael_lex.c.

◆ UINT8_MAX

#define UINT8_MAX (255U)

Definition at line 82 of file ael_lex.c.

◆ unput

#define unput ( c ) yyunput( c, yyg->yytext_ptr , yyscanner )

Definition at line 196 of file ael_lex.c.

◆ wordstate

#define wordstate 6

Definition at line 967 of file ael_lex.c.

◆ YY_AT_BOL

#define YY_AT_BOL ( ) (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 327 of file ael_lex.c.

◆ YY_BREAK

#define YY_BREAK break;

Definition at line 1192 of file ael_lex.c.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE 16384

Definition at line 164 of file ael_lex.c.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING 2

Definition at line 263 of file ael_lex.c.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW 0

Definition at line 251 of file ael_lex.c.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL 1

Definition at line 252 of file ael_lex.c.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER

Value:

                          ( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)

Definition at line 274 of file ael_lex.c.

◆ YY_CURRENT_BUFFER_LVALUE

#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

Definition at line 281 of file ael_lex.c.

◆ YY_DECL

#define YY_DECL

Value:

int ael_yylex \

(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)

ael_yylex

int ael_yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner)

yyscan_t

void * yyscan_t

Definition: ael_structs.h:71

YYLTYPE

Definition: ast_expr2.h:94

YYSTYPE

Definition: ast_expr2.c:473

Definition at line 1179 of file ael_lex.c.

◆ YY_DECL_IS_OURS

#define YY_DECL_IS_OURS 1

Definition at line 1174 of file ael_lex.c.

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Definition at line 348 of file ael_lex.c.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER 77

Definition at line 357 of file ael_lex.c.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR 0

Definition at line 160 of file ael_lex.c.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE 2

Definition at line 2851 of file ael_lex.c.

◆ YY_EXTRA_TYPE

#define YY_EXTRA_TYPE void *

Definition at line 979 of file ael_lex.c.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR ( msg ) yy_fatal_error( msg , yyscanner)

Definition at line 1165 of file ael_lex.c.

◆ yy_flex_debug

#define yy_flex_debug yyg->yy_flex_debug_r

Definition at line 139 of file ael_lex.c.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION 2

Definition at line 13 of file ael_lex.c.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION 5

Definition at line 14 of file ael_lex.c.

◆ YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION 35

Definition at line 15 of file ael_lex.c.

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER ael_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)

Definition at line 295 of file ael_lex.c.

◆ YY_INPUT

#define YY_INPUT	(	buf,
		result,
		max_size
	)

Definition at line 1118 of file ael_lex.c.

◆ YY_INT_ALIGNED

#define YY_INT_ALIGNED short int

Definition at line 8 of file ael_lex.c.

◆ YY_LESS_LINENO

#define YY_LESS_LINENO ( n )

Definition at line 180 of file ael_lex.c.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ yyg->yy_more_len

Definition at line 766 of file ael_lex.c.

◆ yy_new_buffer

#define yy_new_buffer ael_yy_create_buffer

Definition at line 305 of file ael_lex.c.

◆ YY_NEW_FILE

#define YY_NEW_FILE ael_yyrestart(yyin ,yyscanner )

Definition at line 158 of file ael_lex.c.

◆ YY_NULL

#define YY_NULL 0

Definition at line 115 of file ael_lex.c.

◆ YY_NUM_RULES

#define YY_NUM_RULES 76

Definition at line 356 of file ael_lex.c.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE 8192

Definition at line 1103 of file ael_lex.c.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 767 of file ael_lex.c.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP YY_USER_ACTION

Definition at line 1195 of file ael_lex.c.

◆ YY_SC_TO_UI

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

Definition at line 122 of file ael_lex.c.

◆ yy_set_bol

#define yy_set_bol ( at_bol )

Definition at line 317 of file ael_lex.c.

◆ yy_set_interactive

#define yy_set_interactive ( is_interactive )

Definition at line 307 of file ael_lex.c.

◆ YY_SKIP_YYWRAP

#define YY_SKIP_YYWRAP

Definition at line 332 of file ael_lex.c.

◆ YY_START

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

Definition at line 151 of file ael_lex.c.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR 25

Definition at line 1160 of file ael_lex.c.

◆ YY_STATE_BUF_SIZE

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

Definition at line 169 of file ael_lex.c.

◆ YY_STATE_EOF

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

Definition at line 155 of file ael_lex.c.

◆ YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 204 of file ael_lex.c.

◆ YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 172 of file ael_lex.c.

◆ YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 126 of file ael_lex.c.

◆ YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 199 of file ael_lex.c.

◆ YY_USER_ACTION

#define YY_USER_ACTION

Definition at line 1187 of file ael_lex.c.

◆ yycolumn

#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)

Definition at line 138 of file ael_lex.c.

◆ yyconst

#define yyconst

Definition at line 111 of file ael_lex.c.

◆ yyextra

#define yyextra yyg->yyextra_r

Definition at line 134 of file ael_lex.c.

◆ yyin

#define yyin yyg->yyin_r

Definition at line 132 of file ael_lex.c.

◆ yyleng

#define yyleng yyg->yyleng_r

Definition at line 135 of file ael_lex.c.

◆ yyless [1/2]

#define yyless ( n )

Definition at line 2863 of file ael_lex.c.

◆ yyless [2/2]

#define yyless ( n )

Definition at line 2863 of file ael_lex.c.

◆ yylineno

#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)

Definition at line 137 of file ael_lex.c.

◆ yylloc

#define yylloc yyg->yylloc_r

Definition at line 1026 of file ael_lex.c.

◆ yylval

#define yylval yyg->yylval_r

Definition at line 1024 of file ael_lex.c.

◆ yymore

#define yymore ( ) (yyg->yy_more_flag = 1)

Definition at line 765 of file ael_lex.c.

◆ yyout

#define yyout yyg->yyout_r

Definition at line 133 of file ael_lex.c.

◆ YYSTATE

#define YYSTATE YY_START

Definition at line 152 of file ael_lex.c.

◆ YYTABLES_NAME

#define YYTABLES_NAME "yytables"

Definition at line 3215 of file ael_lex.c.

◆ yyterminate

#define yyterminate ( ) return YY_NULL

Definition at line 1155 of file ael_lex.c.

◆ yytext

#define yytext yyg->yytext_r

Definition at line 136 of file ael_lex.c.

◆ yytext_ptr

#define yytext_ptr yytext_r

Definition at line 338 of file ael_lex.c.

Typedef Documentation

◆ flex_int16_t

typedef short int flex_int16_t

Definition at line 55 of file ael_lex.c.

◆ flex_int32_t

typedef int flex_int32_t

Definition at line 56 of file ael_lex.c.

◆ flex_int8_t

typedef signed char flex_int8_t

Definition at line 54 of file ael_lex.c.

◆ flex_uint16_t

typedef unsigned short int flex_uint16_t

Definition at line 58 of file ael_lex.c.

◆ flex_uint32_t

typedef unsigned int flex_uint32_t

Definition at line 59 of file ael_lex.c.

◆ flex_uint8_t

typedef unsigned char flex_uint8_t

Definition at line 57 of file ael_lex.c.

◆ YY_BUFFER_STATE

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 173 of file ael_lex.c.

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 334 of file ael_lex.c.

◆ yy_size_t

typedef size_t yy_size_t

Definition at line 200 of file ael_lex.c.

◆ yy_state_type

typedef int yy_state_type

Definition at line 336 of file ael_lex.c.

◆ yyscan_t

typedef void* yyscan_t

Definition at line 127 of file ael_lex.c.

Function Documentation

◆ ael2_parse()

struct pval * ael2_parse	(	char *	filename,
		int *	errors
	)

Definition at line 3344 of file ael_lex.c.

{
    struct pval *pvalue;
    struct parse_io *io;
    char *buffer;
    struct stat stats;
    FILE *fin;
 
    /* extern int ael_yydebug; */
 
    io = calloc(sizeof(struct parse_io),1);
    /* reset the global counters */
    prev_word = 0;
    my_lineno = 1;
    include_stack_index=0;
    my_col = 0;
    /* ael_yydebug = 1; */
    ael_yylex_init(&io->scanner);
    fin = fopen(filename,"r");
    if ( !fin ) {
        ast_log(LOG_ERROR,"File %s could not be opened\n", filename);
        *errors = 1;
        return 0;
    }
    if (my_file)
        free(my_file);
    my_file = strdup(filename);
    if (stat(filename, &stats)) {
        ast_log(LOG_WARNING, "failed to populate stats from file '%s'\n", filename);
    }
    buffer = (char*)malloc(stats.st_size+2);
    if (fread(buffer, 1, stats.st_size, fin) != stats.st_size) {
        ast_log(LOG_ERROR, "fread() failed: %s\n", strerror(errno));
    }
    buffer[stats.st_size]=0;
    fclose(fin);
 
    ael_yy_scan_string (buffer ,io->scanner);
    ael_yyset_lineno(1 , io->scanner);
 
    /* ael_yyset_in (fin , io->scanner);    OLD WAY */
 
    ael_yyparse(io);
 
 
    pvalue = io->pval;
    *errors = io->syntax_error_count;
 
    ael_yylex_destroy(io->scanner);
    free(buffer);
    free(io);
 
    return pvalue;
}

References ael_yy_scan_string(), ael_yylex_destroy(), ael_yylex_init(), ael_yyparse(), ael_yyset_lineno(), ast_log, calloc, errno, free(), include_stack_index, io, LOG_ERROR, LOG_WARNING, malloc(), my_col, my_file, my_lineno, prev_word, and strdup.

Referenced by pbx_load_module().

◆ ael_yy_create_buffer()

YY_BUFFER_STATE ael_yy_create_buffer	(	FILE *	file,
		int	size,
		yyscan_t	yyscanner
	)

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`.
yyscanner	The scanner object.

Returns: the allocated buffer state.

Definition at line 2558 of file ael_lex.c.

{
    YY_BUFFER_STATE b;
    
    b = (YY_BUFFER_STATE) ael_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in ael_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 *) ael_yyalloc(b->yy_buf_size + 2 ,yyscanner );
    if ( ! b->yy_ch_buf )
        YY_FATAL_ERROR( "out of dynamic memory in ael_yy_create_buffer()" );
 
    b->yy_is_our_buffer = 1;
 
    ael_yy_init_buffer(b,file ,yyscanner);
 
    return b;
}

References ael_yy_init_buffer(), ael_yyalloc(), b, make_ari_stubs::file, and YY_FATAL_ERROR.

Referenced by ael_yyrestart(), and if().

◆ ael_yy_delete_buffer()

void ael_yy_delete_buffer	(	YY_BUFFER_STATE	b,
		yyscan_t	yyscanner
	)

Destroy the buffer.

Parameters

b	a buffer created with ael_yy_create_buffer()
yyscanner	The scanner object.

Definition at line 2586 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    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 )
        ael_yyfree((void *) b->yy_ch_buf ,yyscanner );
 
    ael_yyfree((void *) b ,yyscanner );
}

References ael_yyfree(), b, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yyg.

Referenced by ael_yylex_destroy(), ael_yypop_buffer_state(), and while().

◆ ael_yy_flush_buffer()

void ael_yy_flush_buffer	(	YY_BUFFER_STATE	b,
		yyscan_t	yyscanner
	)

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`.
yyscanner	The scanner object.

Definition at line 2639 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    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 )
        ael_yy_load_buffer_state(yyscanner );
}

References ael_yy_load_buffer_state(), b, YY_BUFFER_NEW, YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, and yyg.

Referenced by ael_yy_init_buffer().

◆ ael_yy_init_buffer()

static void ael_yy_init_buffer	(	YY_BUFFER_STATE	b,
		FILE *	file,
		yyscan_t	yyscanner
	)

static

Definition at line 2610 of file ael_lex.c.

{
    int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    ael_yy_flush_buffer(b ,yyscanner);
 
    b->yy_input_file = file;
    b->yy_fill_buffer = 1;
 
    /* If b is the current buffer, then ael_yy_init_buffer was _probably_
     * called from ael_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 = file ? (isatty( fileno(file) ) > 0) : 0;
    
    errno = oerrno;
}

References ael_yy_flush_buffer(), b, errno, make_ari_stubs::file, isatty(), YY_CURRENT_BUFFER, and yyg.

Referenced by ael_yy_create_buffer(), and ael_yyrestart().

◆ ael_yy_load_buffer_state()

static void ael_yy_load_buffer_state ( yyscan_t yyscanner )

static

Definition at line 2543 of file ael_lex.c.

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

References yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, yyg, and yyin.

Referenced by ael_yy_flush_buffer(), ael_yy_switch_to_buffer(), ael_yypop_buffer_state(), ael_yypush_buffer_state(), ael_yyrestart(), and if().

◆ ael_yy_scan_buffer()

YY_BUFFER_STATE ael_yy_scan_buffer	(	char *	base,
		yy_size_t	size,
		yyscan_t	yyscanner
	)

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
yyscanner	The scanner object.

Returns: the newly allocated buffer state object.

Definition at line 2770 of file ael_lex.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) ael_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in ael_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;
 
    ael_yy_switch_to_buffer(b ,yyscanner );
 
    return b;
}

References ael_yy_switch_to_buffer(), ael_yyalloc(), b, YY_BUFFER_NEW, YY_END_OF_BUFFER_CHAR, and YY_FATAL_ERROR.

Referenced by ael_yy_scan_bytes().

◆ ael_yy_scan_bytes()

YY_BUFFER_STATE ael_yy_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len,
		yyscan_t	yyscanner
	)

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

Parameters

bytes	the byte buffer to scan
len	the number of bytes in the buffer pointed to by bytes.
yyscanner	The scanner object.

Returns: the newly allocated buffer state object.

Definition at line 2820 of file ael_lex.c.

{
    YY_BUFFER_STATE b;
    char *buf;
    yy_size_t n;
    int i;
    
    /* Get memory for full buffer, including space for trailing EOB's. */
    n = _yybytes_len + 2;
    buf = (char *) ael_yyalloc(n ,yyscanner );
    if ( ! buf )
        YY_FATAL_ERROR( "out of dynamic memory in ael_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 = ael_yy_scan_buffer(buf,n ,yyscanner);
    if ( ! b )
        YY_FATAL_ERROR( "bad buffer in ael_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;
}

References ael_yy_scan_buffer(), ael_yyalloc(), b, buf, YY_END_OF_BUFFER_CHAR, and YY_FATAL_ERROR.

Referenced by ael_yy_scan_string().

◆ ael_yy_scan_string()

YY_BUFFER_STATE ael_yy_scan_string	(	yyconst char *	yystr,
		yyscan_t	yyscanner
	)

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

Parameters

yystr	a NUL-terminated string to scan
yyscanner	The scanner object.

Returns: the newly allocated buffer state object.

Note: If you want to scan bytes that may contain NUL values, then use ael_yy_scan_bytes() instead.

Definition at line 2807 of file ael_lex.c.

{
    
    return ael_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
}

References ael_yy_scan_bytes().

Referenced by ael2_parse(), and setup_filestack().

◆ ael_yy_switch_to_buffer()

void ael_yy_switch_to_buffer	(	YY_BUFFER_STATE	new_buffer,
		yyscan_t	yyscanner
	)

Switch to a different input buffer.

Parameters

new_buffer	The new input buffer.
yyscanner	The scanner object.

Definition at line 2511 of file ael_lex.c.

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

References ael_yy_load_buffer_state(), ael_yyensure_buffer_stack(), yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, and yyg.

Referenced by ael_yy_scan_buffer(), setup_filestack(), and while().

◆ ael_yyalloc()

void * ael_yyalloc	(	yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 3198 of file ael_lex.c.

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

References malloc().

Referenced by ael_yy_create_buffer(), ael_yy_scan_buffer(), ael_yy_scan_bytes(), ael_yyensure_buffer_stack(), ael_yylex_init(), and ael_yylex_init_extra().

◆ ael_yyensure_buffer_stack()

static void ael_yyensure_buffer_stack ( yyscan_t yyscanner )

static

Definition at line 2720 of file ael_lex.c.

{
    int num_to_alloc;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    if (!yyg->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;
        yyg->yy_buffer_stack = (struct yy_buffer_state**)ael_yyalloc
                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                , yyscanner);
        if ( ! yyg->yy_buffer_stack )
            YY_FATAL_ERROR( "out of dynamic memory in ael_yyensure_buffer_stack()" );
                                  
        memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                
        yyg->yy_buffer_stack_max = num_to_alloc;
        yyg->yy_buffer_stack_top = 0;
        return;
    }
 
    if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
 
        /* Increase the buffer to prepare for a possible push. */
        int grow_size = 8 /* arbitrary grow size */;
 
        num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
        yyg->yy_buffer_stack = (struct yy_buffer_state**)ael_yyrealloc
                                (yyg->yy_buffer_stack,
                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                , yyscanner);
        if ( ! yyg->yy_buffer_stack )
            YY_FATAL_ERROR( "out of dynamic memory in ael_yyensure_buffer_stack()" );
 
        /* zero only the new slots.*/
        memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
        yyg->yy_buffer_stack_max = num_to_alloc;
    }
}

References ael_yyalloc(), ael_yyrealloc(), yyguts_t::yy_buffer_stack, yyguts_t::yy_buffer_stack_max, yyguts_t::yy_buffer_stack_top, YY_FATAL_ERROR, and yyg.

Referenced by ael_yy_switch_to_buffer(), ael_yypush_buffer_state(), ael_yyrestart(), and if().

◆ ael_yyfree()

void ael_yyfree	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 3226 of file ael_lex.c.

{
    if (ptr)
        free( (char*) ptr );
}

References free().

Referenced by ael_yy_delete_buffer(), and ael_yylex_destroy().

◆ ael_yyget_column()

int ael_yyget_column ( yyscan_t yyscanner )

Get the current column number.

Parameters

yyscanner The scanner object.

Definition at line 2904 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    
        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

References YY_CURRENT_BUFFER, yycolumn, and yyg.

◆ ael_yyget_debug()

int ael_yyget_debug ( yyscan_t yyscanner )

Definition at line 3009 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yy_flex_debug;
}

References yy_flex_debug, and yyg.

◆ ael_yyget_extra()

YY_EXTRA_TYPE ael_yyget_extra ( yyscan_t yyscanner )

Get the user-defined data for this scanner.

Parameters

yyscanner The scanner object.

Definition at line 2882 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyextra;
}

References yyextra, and yyg.

◆ ael_yyget_in()

FILE * ael_yyget_in ( yyscan_t yyscanner )

Get the input stream.

Parameters

yyscanner The scanner object.

Definition at line 2917 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyin;
}

References yyg, and yyin.

◆ ael_yyget_leng()

int ael_yyget_leng ( yyscan_t yyscanner )

Get the length of the current token.

Parameters

yyscanner The scanner object.

Definition at line 2935 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyleng;
}

References yyg, and yyleng.

◆ ael_yyget_lineno()

int ael_yyget_lineno ( yyscan_t yyscanner )

Get the current line number.

Parameters

yyscanner The scanner object.

Definition at line 2891 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    
        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

References YY_CURRENT_BUFFER, yyg, and yylineno.

◆ ael_yyget_lloc()

YYLTYPE * ael_yyget_lloc ( yyscan_t yyscanner )

Definition at line 3035 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylloc;
}

References yyg, and yylloc.

◆ ael_yyget_lval()

YYSTYPE * ael_yyget_lval ( yyscan_t yyscanner )

Definition at line 3023 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yylval;
}

References yyg, and yylval.

◆ ael_yyget_out()

FILE * ael_yyget_out ( yyscan_t yyscanner )

Get the output stream.

Parameters

yyscanner The scanner object.

Definition at line 2926 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yyout;
}

References yyg, and yyout.

◆ ael_yyget_text()

char * ael_yyget_text ( yyscan_t yyscanner )

Get the current token.

Parameters

yyscanner The scanner object.

Definition at line 2945 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return yytext;
}

References yyg, and yytext.

◆ ael_yylex()

int ael_yylex	(	YYSTYPE *	yylval_param,
		YYLTYPE *	yylloc_param,
		yyscan_t	yyscanner
	)

◆ ael_yylex_destroy()

int ael_yylex_destroy ( yyscan_t yyscanner )

Definition at line 3145 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    /* Pop the buffer stack, destroying each element. */
    while(YY_CURRENT_BUFFER){
        ael_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
        YY_CURRENT_BUFFER_LVALUE = NULL;
        ael_yypop_buffer_state(yyscanner);
    }
 
    /* Destroy the stack itself. */
    ael_yyfree(yyg->yy_buffer_stack ,yyscanner);
    yyg->yy_buffer_stack = NULL;
 
    /* Destroy the start condition stack. */
        ael_yyfree(yyg->yy_start_stack ,yyscanner );
        yyg->yy_start_stack = NULL;
 
    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * ael_yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);
 
    /* Destroy the main struct (reentrant only). */
    ael_yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

References ael_yy_delete_buffer(), ael_yyfree(), ael_yypop_buffer_state(), NULL, yyguts_t::yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_globals(), yyguts_t::yy_start_stack, and yyg.

Referenced by ael2_parse().

◆ ael_yylex_init()

int ael_yylex_init ( yyscan_t * scanner )

Definition at line 3054 of file ael_lex.c.

{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }
 
    *ptr_yy_globals = (yyscan_t) ael_yyalloc ( sizeof( struct yyguts_t ), NULL );
 
    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }
 
    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
 
    return yy_init_globals ( *ptr_yy_globals );
}

References ael_yyalloc(), errno, NULL, and yy_init_globals().

Referenced by ael2_parse().

◆ ael_yylex_init_extra()

int ael_yylex_init_extra	(	YY_EXTRA_TYPE	user_defined,
		yyscan_t *	scanner
	)

Definition at line 3083 of file ael_lex.c.

{
    struct yyguts_t dummy_yyguts;
 
    ael_yyset_extra (yy_user_defined, &dummy_yyguts);
 
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }
    
    *ptr_yy_globals = (yyscan_t) ael_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
    
    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }
    
    /* By setting to 0xAA, we expose bugs in
    yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
    
    ael_yyset_extra (yy_user_defined, *ptr_yy_globals);
    
    return yy_init_globals ( *ptr_yy_globals );
}

References ael_yyalloc(), ael_yyset_extra(), errno, NULL, and yy_init_globals().

◆ ael_yyparse()

int ael_yyparse ( struct parse_io * )

Referenced by ael2_parse().

◆ ael_yypop_buffer_state()

void ael_yypop_buffer_state ( yyscan_t yyscanner )

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

Parameters

yyscanner The scanner object.

Definition at line 2700 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    if (!YY_CURRENT_BUFFER)
        return;
 
    ael_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
    YY_CURRENT_BUFFER_LVALUE = NULL;
    if (yyg->yy_buffer_stack_top > 0)
        --yyg->yy_buffer_stack_top;
 
    if (YY_CURRENT_BUFFER) {
        ael_yy_load_buffer_state(yyscanner );
        yyg->yy_did_buffer_switch_on_eof = 1;
    }
}

References ael_yy_delete_buffer(), ael_yy_load_buffer_state(), NULL, yyguts_t::yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, and yyg.

Referenced by ael_yylex_destroy().

◆ ael_yypush_buffer_state()

void ael_yypush_buffer_state	(	YY_BUFFER_STATE	new_buffer,
		yyscan_t	yyscanner
	)

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.
yyscanner	The scanner object.

Definition at line 2669 of file ael_lex.c.

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

References ael_yy_load_buffer_state(), ael_yyensure_buffer_stack(), NULL, yyguts_t::yy_buffer_stack_top, yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, and yyg.

◆ ael_yyrealloc()

void * ael_yyrealloc	(	void *	ptr,
		yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 3203 of file ael_lex.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 );
}

References realloc.

Referenced by ael_yyensure_buffer_stack(), and yy_get_next_buffer().

◆ ael_yyrestart()

void ael_yyrestart	(	FILE *	input_file,
		yyscan_t	yyscanner
	)

Immediately switch to a different input stream.

Parameters

input_file	A readable stream.
yyscanner	The scanner object.

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

Definition at line 2493 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    if ( ! YY_CURRENT_BUFFER ){
        ael_yyensure_buffer_stack (yyscanner);
        YY_CURRENT_BUFFER_LVALUE =
            ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
    }
 
    ael_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
    ael_yy_load_buffer_state(yyscanner );
}

References ael_yy_create_buffer(), ael_yy_init_buffer(), ael_yy_load_buffer_state(), ael_yyensure_buffer_stack(), YY_BUF_SIZE, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyg, and yyin.

Referenced by input(), and yy_get_next_buffer().

◆ ael_yyset_column()

void ael_yyset_column	(	int	column_no,
		yyscan_t	yyscanner
	)

Set the current column.

Parameters

line_number
yyscanner	The scanner object.

Definition at line 2980 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
        /* column is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           yy_fatal_error( "ael_yyset_column called with no buffer" , yyscanner); 
    
    yycolumn = column_no;
}

References YY_CURRENT_BUFFER, yy_fatal_error(), yycolumn, and yyg.

◆ ael_yyset_debug()

void ael_yyset_debug	(	int	debug_flag,
		yyscan_t	yyscanner
	)

Definition at line 3015 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yy_flex_debug = bdebug ;
}

References yy_flex_debug, and yyg.

◆ ael_yyset_extra()

void ael_yyset_extra	(	YY_EXTRA_TYPE	user_defined,
		yyscan_t	yyscanner
	)

Set the user-defined data. This data is never touched by the scanner.

Parameters

user_defined	The data to be associated with this scanner.
yyscanner	The scanner object.

Definition at line 2955 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyextra = user_defined ;
}

References yyextra, and yyg.

Referenced by ael_yylex_init_extra().

◆ ael_yyset_in()

void ael_yyset_in	(	FILE *	in_str,
		yyscan_t	yyscanner
	)

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

Parameters

in_str	A readable stream.
yyscanner	The scanner object.

See also: ael_yy_switch_to_buffer

Definition at line 2997 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyin = in_str ;
}

References yyg, and yyin.

◆ ael_yyset_lineno()

void ael_yyset_lineno	(	int	line_number,
		yyscan_t	yyscanner
	)

Set the current line number.

Parameters

line_number
yyscanner	The scanner object.

Definition at line 2965 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
        /* lineno is only valid if an input buffer exists. */
        if (! YY_CURRENT_BUFFER )
           yy_fatal_error( "ael_yyset_lineno called with no buffer" , yyscanner); 
    
    yylineno = line_number;
}

References YY_CURRENT_BUFFER, yy_fatal_error(), yyg, and yylineno.

Referenced by ael2_parse().

◆ ael_yyset_lloc()

void ael_yyset_lloc	(	YYLTYPE *	yylloc_param,
		yyscan_t	yyscanner
	)

Definition at line 3041 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylloc = yylloc_param;
}

References yyg, and yylloc.

◆ ael_yyset_lval()

void ael_yyset_lval	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 3029 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yylval = yylval_param;
}

References yyg, and yylval.

◆ ael_yyset_out()

void ael_yyset_out	(	FILE *	out_str,
		yyscan_t	yyscanner
	)

Definition at line 3003 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    yyout = out_str ;
}

References yyg, and yyout.

◆ c_prevword()

static int c_prevword ( void )

static

Definition at line 3275 of file ael_lex.c.

{
    char *c = prev_word;
    if (c == NULL)
        return 0;
    while ( *c ) {
        switch (*c) {
        case '{':
        case '[':
        case '(':
            pbcpush(*c);
            break;
        case '}':
        case ']':
        case ')':
            if (pbcpop(*c))
                return 1;
            break;
        }
        c++;
    }
    return 0;
}

References c, NULL, pbcpop(), pbcpush(), and prev_word.

Referenced by reset_argcount(), and reset_parencount().

◆ if()

if ( !yyg-> yy_init )

Definition at line 1216 of file ael_lex.c.

        {
        yyg->yy_init = 1;
 
#ifdef YY_USER_INIT
        YY_USER_INIT;
#endif
 
        if ( ! yyg->yy_start )
            yyg->yy_start = 1;  /* first start state */
 
        if ( ! yyin )
            yyin = stdin;
 
        if ( ! yyout )
            yyout = stdout;
 
        if ( ! YY_CURRENT_BUFFER ) {
            ael_yyensure_buffer_stack (yyscanner);
            YY_CURRENT_BUFFER_LVALUE =
                ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
        }
 
        ael_yy_load_buffer_state(yyscanner );
        }

References ael_yy_create_buffer(), ael_yy_load_buffer_state(), ael_yyensure_buffer_stack(), YY_BUF_SIZE, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_init, yyguts_t::yy_start, yyg, yyin, and yyout.

◆ input()

static int input ( yyscan_t yyscanner )

static

Definition at line 2417 of file ael_lex.c.

{
    int c;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    *yyg->yy_c_buf_p = yyg->yy_hold_char;
 
    if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
        {
        /* yy_c_buf_p now points to the character we want to return.
         * If this occurs *before* the EOB characters, then it's a
         * valid NUL; if not, then we've hit the end of the buffer.
         */
        if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
            /* This was really a NUL. */
            *yyg->yy_c_buf_p = '\0';
 
        else
            { /* need more input */
            int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
            ++yyg->yy_c_buf_p;
 
            switch ( yy_get_next_buffer( yyscanner ) )
                {
                case EOB_ACT_LAST_MATCH:
                    /* This happens because yy_g_n_b()
                     * sees that we've accumulated a
                     * token and flags that we need to
                     * try matching the token before
                     * proceeding.  But for input(),
                     * there's no matching to consider.
                     * So convert the EOB_ACT_LAST_MATCH
                     * to EOB_ACT_END_OF_FILE.
                     */
 
                    /* Reset buffer status. */
                    ael_yyrestart(yyin ,yyscanner);
 
                    /*FALLTHROUGH*/
 
                case EOB_ACT_END_OF_FILE:
                    {
                    if ( ael_yywrap(yyscanner ) )
                        return EOF;
 
                    if ( ! yyg->yy_did_buffer_switch_on_eof )
                        YY_NEW_FILE;
#ifdef __cplusplus
                    return yyinput(yyscanner);
#else
                    return input(yyscanner);
#endif
                    }
 
                case EOB_ACT_CONTINUE_SCAN:
                    yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
                    break;
                }
            }
        }
 
    c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
    *yyg->yy_c_buf_p = '\0';    /* preserve yytext */
    yyg->yy_hold_char = *++yyg->yy_c_buf_p;
 
    return c;
}

References ael_yyrestart(), ael_yywrap, c, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, input(), yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, yy_get_next_buffer(), yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, YY_NEW_FILE, yyg, and yyin.

Referenced by input().

◆ isatty()

int isatty ( int )

Referenced by ael_yy_init_buffer().

◆ pbcpop()

static int pbcpop ( char x )

static

Definition at line 3232 of file ael_lex.c.

{
    if (   ( x == ')' && pbcstack[pbcpos-1] == '(' )
        || ( x == ']' && pbcstack[pbcpos-1] == '[' )
        || ( x == '}' && pbcstack[pbcpos-1] == '{' )) {
        pbcpos--;
        return 0;
    }
    return 1; /* error */
}

References pbcpos, and pbcstack.

Referenced by c_prevword(), and while().

◆ pbcpop2()

static int pbcpop2 ( char x )

static

Definition at line 3248 of file ael_lex.c.

{
    if (   ( x == ')' && pbcstack2[pbcpos2-1] == '(' )
        || ( x == ']' && pbcstack2[pbcpos2-1] == '[' )
        || ( x == '}' && pbcstack2[pbcpos2-1] == '{' )) {
        pbcpos2--;
        return 0;
    }
    return 1; /* error */
}

References pbcpos2, and pbcstack2.

Referenced by while().

◆ pbcpop3()

static int pbcpop3 ( char x )

static

Definition at line 3264 of file ael_lex.c.

{
    if (   ( x == ')' && pbcstack3[pbcpos3-1] == '(' )
        || ( x == ']' && pbcstack3[pbcpos3-1] == '[' )
        || ( x == '}' && pbcstack3[pbcpos3-1] == '{' )) {
        pbcpos3--;
        return 0;
    }
    return 1; /* error */
}

References pbcpos3, and pbcstack3.

Referenced by while().

◆ pbcpush()

static void pbcpush ( char x )

static

Definition at line 3221 of file ael_lex.c.

{
    pbcstack[pbcpos++] = x;
}

References pbcpos, and pbcstack.

Referenced by c_prevword(), reset_argcount(), reset_parencount(), and while().

◆ pbcpush2()

static void pbcpush2 ( char x )

static

Definition at line 3243 of file ael_lex.c.

{
    pbcstack2[pbcpos2++] = x;
}

References pbcpos2, and pbcstack2.

Referenced by while().

◆ pbcpush3()

static void pbcpush3 ( char x )

static

Definition at line 3259 of file ael_lex.c.

{
    pbcstack3[pbcpos3++] = x;
}

References pbcpos3, and pbcstack3.

Referenced by while().

◆ pbcwhere()

static void pbcwhere	(	const char *	text,
		int *	line,
		int *	col
	)

static

Definition at line 923 of file ael_lex.c.

{
    int loc_line = *line;
    int loc_col = *col;
    char c;
    while ( (c = *text++) ) {
        if ( c == '\t' ) {
            loc_col += 8 - (loc_col % 8);
        } else if ( c == '\n' ) {
            loc_line++;
            loc_col = 1;
        } else
            loc_col++;
    }
    *line = loc_line;
    *col = loc_col;
}

References c, and text.

◆ reset_argcount()

void reset_argcount ( yyscan_t yyscanner )

Definition at line 3333 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    parencount = 0;
    pbcpos = 0;
    pbcpush('(');   /* push '(' so the last pcbpop (parencount= -1) will succeed */
    c_prevword();
    BEGIN(argg);
}

References argg, BEGIN, c_prevword(), parencount, pbcpos, pbcpush(), and yyg.

Referenced by yyparse().

◆ reset_parencount()

void reset_parencount ( yyscan_t yyscanner )

Definition at line 3314 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    parencount = 0;
    pbcpos = 0;
    pbcpush('(');   /* push '(' so the last pcbpop (parencount= -1) will succeed */
    c_prevword();
    BEGIN(paren);
}

References BEGIN, c_prevword(), paren, parencount, pbcpos, pbcpush(), and yyg.

Referenced by yyparse().

◆ reset_semicount()

void reset_semicount ( yyscan_t yyscanner )

Definition at line 3325 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    pbcpos = 0;
    BEGIN(semic);
}

References BEGIN, pbcpos, semic, and yyg.

Referenced by yyparse().

◆ setup_filestack()

static void setup_filestack	(	char *	fnamebuf,
		int	fnamebuf_siz,
		glob_t *	globbuf,
		int	globpos,
		yyscan_t	xscan,
		int	create
	)

static

Definition at line 3399 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    int error, i;
    FILE *in1;
    char fnamebuf[2048];
 
    if (globbuf && globbuf->gl_pathv && globbuf->gl_pathc > 0)
#if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
            strncpy(fnamebuf, globbuf->gl_pathv[globpos], fnamebuf_siz);
#else
            ast_copy_string(fnamebuf, globbuf->gl_pathv[globpos], fnamebuf_siz);
#endif
    else {
        ast_log(LOG_ERROR,"Include file name not present!\n");
        return;
    }
    for (i=0; i<include_stack_index; i++) {
        if ( !strcmp(fnamebuf,include_stack[i].fname )) {
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Nice Try!!! But %s has already been included (perhaps by another file), and would cause an infinite loop of file inclusions!!! Include directive ignored\n",
                my_file, my_lineno, my_col, fnamebuf);
            break;
        }
    }
    error = 1;
    if (i == include_stack_index)
        error = 0;  /* we can use this file */
    if ( !error ) { /* valid file name */
        /* relative vs. absolute */
        if (fnamebuf[0] != '/')
            snprintf(fnamebuf2, fnamebuf_siz, "%s/%s", ast_config_AST_CONFIG_DIR, fnamebuf);
        else
#if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
            strncpy(fnamebuf2, fnamebuf, fnamebuf_siz);
#else
            ast_copy_string(fnamebuf2, fnamebuf, fnamebuf_siz);
#endif
        in1 = fopen( fnamebuf2, "r" );
 
        if ( ! in1 ) {
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Couldn't find the include file: %s; ignoring the Include directive!\n", my_file, my_lineno, my_col, fnamebuf2);
        } else {
            char *buffer;
            struct stat stats;
            if (stat(fnamebuf2, &stats)) {
                ast_log(LOG_WARNING, "Failed to populate stats from file '%s'\n", fnamebuf2);
            }
            buffer = (char*)malloc(stats.st_size+1);
            if (fread(buffer, 1, stats.st_size, in1) != stats.st_size) {
                ast_log(LOG_ERROR, "fread() failed: %s\n", strerror(errno));
            }
            buffer[stats.st_size] = 0;
            ast_debug(1, "  --Read in included file %s, %d chars\n",fnamebuf2, (int)stats.st_size);
            fclose(in1);
            if (include_stack[include_stack_index].fname) {
                free(include_stack[include_stack_index].fname);
                include_stack[include_stack_index].fname = 0;
            }
            include_stack[include_stack_index].fname = strdup(S_OR(my_file, "<none>"));
            include_stack[include_stack_index].lineno = my_lineno;
            include_stack[include_stack_index].colno = my_col+yyleng;
            if (my_file)
                free(my_file);
            my_file = strdup(fnamebuf2);
            if (create)
                include_stack[include_stack_index].globbuf = *globbuf;
 
            include_stack[include_stack_index].globbuf_pos = 0;
 
            include_stack[include_stack_index].bufstate = YY_CURRENT_BUFFER;
            if (create)
                include_stack_index++;
            ael_yy_switch_to_buffer(ael_yy_scan_string (buffer ,yyscanner),yyscanner);
            free(buffer);
            my_lineno = 1;
            my_col = 1;
            BEGIN(INITIAL);
        }
    }
}

References ael_yy_scan_string(), ael_yy_switch_to_buffer(), ast_config_AST_CONFIG_DIR, ast_copy_string(), ast_debug, ast_log, BEGIN, stackelement::bufstate, stackelement::colno, errno, error(), stackelement::fname, free(), stackelement::globbuf, stackelement::globbuf_pos, include_stack, include_stack_index, INITIAL, stackelement::lineno, LOG_ERROR, LOG_WARNING, malloc(), my_col, my_file, my_lineno, S_OR, strdup, YY_CURRENT_BUFFER, yyg, and yyleng.

Referenced by while().

◆ while()

while ( 1 )

Definition at line 1242 of file ael_lex.c.

        {
        yyg->yy_more_len = 0;
        if ( yyg->yy_more_flag )
            {
            yyg->yy_more_len = yyg->yy_c_buf_p - yyg->yytext_ptr;
            yyg->yy_more_flag = 0;
            }
        yy_cp = yyg->yy_c_buf_p;
 
        /* Support of yytext. */
        *yy_cp = yyg->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 = yyg->yy_start;
yy_match:
        do
            {
            register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
            if ( yy_accept[yy_current_state] )
                {
                yyg->yy_last_accepting_state = yy_current_state;
                yyg->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 >= 285 )
                    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 != 284 );
        yy_cp = yyg->yy_last_accepting_cpos;
        yy_current_state = yyg->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 = yyg->yy_hold_char;
            yy_cp = yyg->yy_last_accepting_cpos;
            yy_current_state = yyg->yy_last_accepting_state;
            goto yy_find_action;
 
case 1:
YY_RULE_SETUP
#line 222 "ael.flex"
{ STORE_POS; return LC;}
    YY_BREAK
case 2:
YY_RULE_SETUP
#line 223 "ael.flex"
{ STORE_POS; return RC;}
    YY_BREAK
case 3:
YY_RULE_SETUP
#line 224 "ael.flex"
{ STORE_POS; return LP;}
    YY_BREAK
case 4:
YY_RULE_SETUP
#line 225 "ael.flex"
{ STORE_POS; return RP;}
    YY_BREAK
case 5:
YY_RULE_SETUP
#line 226 "ael.flex"
{ STORE_POS; return SEMI;}
    YY_BREAK
case 6:
YY_RULE_SETUP
#line 227 "ael.flex"
{ STORE_POS; return EQ;}
    YY_BREAK
case 7:
YY_RULE_SETUP
#line 228 "ael.flex"
{ STORE_POS; return COMMA;}
    YY_BREAK
case 8:
YY_RULE_SETUP
#line 229 "ael.flex"
{ STORE_POS; return COLON;}
    YY_BREAK
case 9:
YY_RULE_SETUP
#line 230 "ael.flex"
{ STORE_POS; return AMPER;}
    YY_BREAK
case 10:
YY_RULE_SETUP
#line 231 "ael.flex"
{ STORE_POS; return BAR;}
    YY_BREAK
case 11:
YY_RULE_SETUP
#line 232 "ael.flex"
{ STORE_POS; return EXTENMARK;}
    YY_BREAK
case 12:
YY_RULE_SETUP
#line 233 "ael.flex"
{ STORE_POS; return AT;}
    YY_BREAK
case 13:
YY_RULE_SETUP
#line 234 "ael.flex"
{/*comment*/}
    YY_BREAK
case 14:
YY_RULE_SETUP
#line 235 "ael.flex"
{ STORE_POS; return KW_CONTEXT;}
    YY_BREAK
case 15:
YY_RULE_SETUP
#line 236 "ael.flex"
{ STORE_POS; return KW_ABSTRACT;}
    YY_BREAK
case 16:
YY_RULE_SETUP
#line 237 "ael.flex"
{ STORE_POS; return KW_EXTEND;}
    YY_BREAK
case 17:
YY_RULE_SETUP
#line 238 "ael.flex"
{ STORE_POS; return KW_MACRO;};
    YY_BREAK
case 18:
YY_RULE_SETUP
#line 239 "ael.flex"
{ STORE_POS; return KW_GLOBALS;}
    YY_BREAK
case 19:
YY_RULE_SETUP
#line 240 "ael.flex"
{ STORE_POS; return KW_LOCAL;}
    YY_BREAK
case 20:
YY_RULE_SETUP
#line 241 "ael.flex"
{ STORE_POS; return KW_IGNOREPAT;}
    YY_BREAK
case 21:
YY_RULE_SETUP
#line 242 "ael.flex"
{ STORE_POS; return KW_SWITCH;}
    YY_BREAK
case 22:
YY_RULE_SETUP
#line 243 "ael.flex"
{ STORE_POS; return KW_IF;}
    YY_BREAK
case 23:
YY_RULE_SETUP
#line 244 "ael.flex"
{ STORE_POS; return KW_IFTIME;}
    YY_BREAK
case 24:
YY_RULE_SETUP
#line 245 "ael.flex"
{ STORE_POS; return KW_RANDOM;}
    YY_BREAK
case 25:
YY_RULE_SETUP
#line 246 "ael.flex"
{ STORE_POS; return KW_REGEXTEN;}
    YY_BREAK
case 26:
YY_RULE_SETUP
#line 247 "ael.flex"
{ STORE_POS; return KW_HINT;}
    YY_BREAK
case 27:
YY_RULE_SETUP
#line 248 "ael.flex"
{ STORE_POS; return KW_ELSE;}
    YY_BREAK
case 28:
YY_RULE_SETUP
#line 249 "ael.flex"
{ STORE_POS; return KW_GOTO;}
    YY_BREAK
case 29:
YY_RULE_SETUP
#line 250 "ael.flex"
{ STORE_POS; return KW_JUMP;}
    YY_BREAK
case 30:
YY_RULE_SETUP
#line 251 "ael.flex"
{ STORE_POS; return KW_RETURN;}
    YY_BREAK
case 31:
YY_RULE_SETUP
#line 252 "ael.flex"
{ STORE_POS; return KW_BREAK;}
    YY_BREAK
case 32:
YY_RULE_SETUP
#line 253 "ael.flex"
{ STORE_POS; return KW_CONTINUE;}
    YY_BREAK
case 33:
YY_RULE_SETUP
#line 254 "ael.flex"
{ STORE_POS; return KW_FOR;}
    YY_BREAK
case 34:
YY_RULE_SETUP
#line 255 "ael.flex"
{ STORE_POS; return KW_WHILE;}
    YY_BREAK
case 35:
YY_RULE_SETUP
#line 256 "ael.flex"
{ STORE_POS; return KW_CASE;}
    YY_BREAK
case 36:
YY_RULE_SETUP
#line 257 "ael.flex"
{ STORE_POS; return KW_DEFAULT;}
    YY_BREAK
case 37:
YY_RULE_SETUP
#line 258 "ael.flex"
{ STORE_POS; return KW_PATTERN;}
    YY_BREAK
case 38:
YY_RULE_SETUP
#line 259 "ael.flex"
{ STORE_POS; return KW_CATCH;}
    YY_BREAK
case 39:
YY_RULE_SETUP
#line 260 "ael.flex"
{ STORE_POS; return KW_SWITCHES;}
    YY_BREAK
case 40:
YY_RULE_SETUP
#line 261 "ael.flex"
{ STORE_POS; return KW_ESWITCHES;}
    YY_BREAK
case 41:
YY_RULE_SETUP
#line 262 "ael.flex"
{ STORE_POS; return KW_INCLUDES;}
    YY_BREAK
case 42:
YY_RULE_SETUP
#line 263 "ael.flex"
{ BEGIN(comment); my_col += 2; }
    YY_BREAK
case 43:
YY_RULE_SETUP
#line 265 "ael.flex"
{ my_col += yyleng; }
    YY_BREAK
case 44:
/* rule 44 can match eol */
YY_RULE_SETUP
#line 266 "ael.flex"
{ ++my_lineno; my_col=1;}
    YY_BREAK
case 45:
YY_RULE_SETUP
#line 267 "ael.flex"
{ my_col += yyleng; }
    YY_BREAK
case 46:
/* rule 46 can match eol */
YY_RULE_SETUP
#line 268 "ael.flex"
{ ++my_lineno; my_col=1;}
    YY_BREAK
case 47:
YY_RULE_SETUP
#line 269 "ael.flex"
{ my_col += 2; BEGIN(INITIAL); } /* the nice thing about comments is that you know exactly what ends them */
    YY_BREAK
case 48:
/* rule 48 can match eol */
YY_RULE_SETUP
#line 271 "ael.flex"
{ my_lineno++; my_col = 1; }
    YY_BREAK
case 49:
YY_RULE_SETUP
#line 272 "ael.flex"
{ my_col += yyleng; }
    YY_BREAK
case 50:
YY_RULE_SETUP
#line 273 "ael.flex"
{ my_col += (yyleng*8)-(my_col%8); }
    YY_BREAK
case 51:
YY_RULE_SETUP
#line 275 "ael.flex"
{
      /* boy did I open a can of worms when I changed the lexical token "word".
         all the above keywords can be used as a beginning to a "word".-
         before, a "word" would match a longer sequence than the above
         keywords, and all would be well. But now "word" is a single char
         and feeds into a statemachine sort of sequence from there on. So...
         I added the {KEYWORD}? to the beginning of the word match sequence */
 
        if (!strcmp(yytext,"${")) {
            parencount2 = 0;
            pbcpos2 = 0;
            pbcpush2('{');  /* push '{' so the last pcbpop (parencount2 = -1) will succeed */
            BEGIN(curlystate);
            yymore();
        } else if (!strcmp(yytext,"$[")) {
            parencount3 = 0;
            pbcpos3 = 0;
            pbcpush3('[');  /* push '[' so the last pcbpop (parencount3 = -1) will succeed */
            BEGIN(brackstate);
            yymore();
        } else {
            BEGIN(wordstate);
            yymore();
        }
    }
    YY_BREAK
case 52:
YY_RULE_SETUP
#line 301 "ael.flex"
{ yymore(); /* Keep going */ }
    YY_BREAK
case 53:
YY_RULE_SETUP
#line 302 "ael.flex"
{ yymore(); /* Keep going */ }
    YY_BREAK
case 54:
YY_RULE_SETUP
#line 303 "ael.flex"
{ yymore(); /* Keep Going */ }
    YY_BREAK
case 55:
YY_RULE_SETUP
#line 304 "ael.flex"
{ /* the beginning of a ${} construct. prepare and pop into curlystate */
        parencount2 = 0;
        pbcpos2 = 0;
        pbcpush2('{');  /* push '{' so the last pcbpop (parencount2 = -1) will succeed */
        BEGIN(curlystate);
        yymore();
    }
    YY_BREAK
case 56:
YY_RULE_SETUP
#line 311 "ael.flex"
{ /* the beginning of a $[] construct. prepare and pop into brackstate */
        parencount3 = 0;
        pbcpos3 = 0;
        pbcpush3('[');  /* push '[' so the last pcbpop (parencount3 = -1) will succeed */
        BEGIN(brackstate);
        yymore();
    }
    YY_BREAK
case 57:
/* rule 57 can match eol */
YY_RULE_SETUP
#line 318 "ael.flex"
{
        /* a non-word constituent char, like a space, tab, curly, paren, etc */
        char c = yytext[yyleng-1];
        STORE_POS;
        yylval->str = malloc(yyleng);
        strncpy(yylval->str, yytext, yyleng);
        yylval->str[yyleng-1] = 0;
        unput(c);  /* put this ending char back in the stream */
        BEGIN(0);
        return word;
    }
    YY_BREAK
case 58:
/* rule 58 can match eol */
YY_RULE_SETUP
#line 331 "ael.flex"
{
        if ( pbcpop2('}') ) {   /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            return word;
        }
        parencount2--;
        if ( parencount2 >= 0) {
            yymore();
        } else {
            BEGIN(wordstate); /* Finished with the current ${} construct. Return to word gathering state */
            yymore();
        }
    }
    YY_BREAK
case 59:
/* rule 59 can match eol */
YY_RULE_SETUP
#line 350 "ael.flex"
{
        char c = yytext[yyleng-1];
        if (c == '{')
            parencount2++;
        pbcpush2(c);
        yymore();
    }
    YY_BREAK
case 60:
/* rule 60 can match eol */
YY_RULE_SETUP
#line 358 "ael.flex"
{
        char c = yytext[yyleng-1];
        if ( pbcpop2(c))  { /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
                my_file, my_lineno, my_col, c);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            return word;
        }
        yymore();
    }
    YY_BREAK
case 61:
/* rule 61 can match eol */
YY_RULE_SETUP
#line 374 "ael.flex"
{
        if ( pbcpop3(']') ) {   /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            return word;
        }
        parencount3--;
        if ( parencount3 >= 0) {
            yymore();
        } else {
            BEGIN(wordstate); /* Finished with the current ${} construct. Return to word gathering state */
            yymore();
        }
    }
    YY_BREAK
case 62:
/* rule 62 can match eol */
YY_RULE_SETUP
#line 393 "ael.flex"
{
        char c = yytext[yyleng-1];
        if (c == '[')
            parencount3++;
        pbcpush3(c);
        yymore();
    }
    YY_BREAK
case 63:
/* rule 63 can match eol */
YY_RULE_SETUP
#line 401 "ael.flex"
{
        char c = yytext[yyleng-1];
        if ( pbcpop3(c))  { /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
                my_file, my_lineno, my_col, c);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            return word;
        }
        yymore();
    }
    YY_BREAK
/*
     * context used for arguments of if_head, random_head, switch_head,
     * for (last statement), while (XXX why not iftime_head ?).
     * End with the matching parentheses.
     * A comma at the top level is valid here, unlike in argg where it
     * is an argument separator so it must be returned as a token.
     */
case 64:
/* rule 64 can match eol */
YY_RULE_SETUP
#line 424 "ael.flex"
{
        if ( pbcpop(')') ) {    /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            prev_word = 0;
            return word;
        }
        parencount--;
        if ( parencount >= 0) {
            yymore();
        } else {
            STORE_LOC;
            yylval->str = malloc(yyleng);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng-1] = 0;
            unput(')');
            BEGIN(0);
            return word;
        }
    }
    YY_BREAK
case 65:
/* rule 65 can match eol */
YY_RULE_SETUP
#line 449 "ael.flex"
{
        char c = yytext[yyleng-1];
        if (c == '(')
            parencount++;
        pbcpush(c);
        yymore();
    }
    YY_BREAK
case 66:
/* rule 66 can match eol */
YY_RULE_SETUP
#line 457 "ael.flex"
{
        char c = yytext[yyleng-1];
        if ( pbcpop(c))  { /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
                my_file, my_lineno, my_col, c);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            return word;
        }
        yymore();
    }
    YY_BREAK
/*
     * handlers for arguments to a macro or application calls.
     * We enter this context when we find the initial '(' and
     * stay here until we close all matching parentheses,
     * and find the comma (argument separator) or the closing ')'
     * of the (external) call, which happens when parencount == 0
     * before the decrement.
     */
case 67:
/* rule 67 can match eol */
YY_RULE_SETUP
#line 481 "ael.flex"
{
        char c = yytext[yyleng-1];
        if (c == '(')
            parencount++;
        pbcpush(c);
        yymore();
    }
    YY_BREAK
case 68:
/* rule 68 can match eol */
YY_RULE_SETUP
#line 489 "ael.flex"
{
        if ( pbcpop(')') ) { /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression!\n", my_file, my_lineno, my_col);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = 0;
            return word;
        }
 
        parencount--;
        if( parencount >= 0){
            yymore();
        } else {
            STORE_LOC;
            BEGIN(0);
            if ( !strcmp(yytext, ")") )
                return RP;
            yylval->str = malloc(yyleng);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng-1] = '\0'; /* trim trailing ')' */
            unput(')');
            return word;
        }
    }
    YY_BREAK
case 69:
/* rule 69 can match eol */
YY_RULE_SETUP
#line 516 "ael.flex"
{
        if( parencount != 0) { /* ast_log(LOG_NOTICE,"Folding in a comma!\n"); */
            yymore();
        } else  {
            STORE_LOC;
            if( !strcmp(yytext,"," ) )
                return COMMA;
            yylval->str = malloc(yyleng);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng-1] = '\0'; /* trim trailing ',' */
            unput(',');
            return word;
        }
    }
    YY_BREAK
case 70:
/* rule 70 can match eol */
YY_RULE_SETUP
#line 531 "ael.flex"
{
        char c = yytext[yyleng-1];
        if ( pbcpop(c) ) { /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n", my_file, my_lineno, my_col, c);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = '\0';
            return word;
        }
        yymore();
    }
    YY_BREAK
/*
     * context used to find tokens in the right hand side of assignments,
     * or in the first and second operand of a 'for'. As above, match
     * commas and use ';' as a separator (hence return it as a separate token).
     */
case 71:
/* rule 71 can match eol */
YY_RULE_SETUP
#line 550 "ael.flex"
{
        char c = yytext[yyleng-1];
        yymore();
        pbcpush(c);
    }
    YY_BREAK
case 72:
/* rule 72 can match eol */
YY_RULE_SETUP
#line 556 "ael.flex"
{
        char c = yytext[yyleng-1];
        if ( pbcpop(c) ) { /* error */
            STORE_LOC;
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n", my_file, my_lineno, my_col, c);
            BEGIN(0);
            yylval->str = malloc(yyleng+1);
            strncpy(yylval->str, yytext, yyleng);
            yylval->str[yyleng] = '\0';
            return word;
        }
        yymore();
    }
    YY_BREAK
case 73:
/* rule 73 can match eol */
YY_RULE_SETUP
#line 570 "ael.flex"
{
        STORE_LOC;
        yylval->str = malloc(yyleng);
        strncpy(yylval->str, yytext, yyleng);
        yylval->str[yyleng-1] = '\0'; /* trim trailing ';' */
        unput(';');
        BEGIN(0);
        return word;
    }
    YY_BREAK
case 74:
/* rule 74 can match eol */
YY_RULE_SETUP
#line 580 "ael.flex"
{
        char fnamebuf[1024],*p1,*p2;
        int glob_ret;
        glob_t globbuf;        /* the current globbuf */
        int globbuf_pos = -1;   /* where we are in the current globbuf */
        globbuf.gl_offs = 0;    /* initialize it to silence gcc */
 
        p1 = strchr(yytext,'"');
        p2 = strrchr(yytext,'"');
        if ( include_stack_index >= MAX_INCLUDE_DEPTH ) {
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Includes nested too deeply! Wow!!! How did you do that?\n", my_file, my_lineno, my_col);
        } else if ( (int)(p2-p1) > sizeof(fnamebuf) - 1 ) {
            ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Filename is incredibly way too long (%d chars!). Inclusion ignored!\n", my_file, my_lineno, my_col, yyleng - 10);
        } else {
            strncpy(fnamebuf, p1+1, p2-p1-1);
            fnamebuf[p2-p1-1] = 0;
        if (fnamebuf[0] != '/') {
           char fnamebuf2[1024];
           snprintf(fnamebuf2,sizeof(fnamebuf2), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, fnamebuf);
           ast_copy_string(fnamebuf,fnamebuf2,sizeof(fnamebuf));
        }
#ifdef SOLARIS
            glob_ret = glob(fnamebuf, GLOB_NOCHECK, NULL, &globbuf);
#else
            glob_ret = glob(fnamebuf, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf);
#endif
            if (glob_ret == GLOB_NOSPACE) {
                ast_log(LOG_WARNING,
                    "Glob Expansion of pattern '%s' failed: Not enough memory\n", fnamebuf);
            } else if (glob_ret  == GLOB_ABORTED) {
                ast_log(LOG_WARNING,
                    "Glob Expansion of pattern '%s' failed: Read error\n", fnamebuf);
            } else if (glob_ret  == GLOB_NOMATCH) {
                ast_log(LOG_WARNING,
                    "Glob Expansion of pattern '%s' failed: No matches!\n", fnamebuf);
            } else {
              globbuf_pos = 0;
            }
        }
        if (globbuf_pos > -1) {
            setup_filestack(fnamebuf, sizeof(fnamebuf), &globbuf, 0, yyscanner, 1);
        }
    }
    YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(paren):
case YY_STATE_EOF(semic):
case YY_STATE_EOF(argg):
case YY_STATE_EOF(comment):
case YY_STATE_EOF(curlystate):
case YY_STATE_EOF(wordstate):
case YY_STATE_EOF(brackstate):
#line 625 "ael.flex"
{
        char fnamebuf[2048];
        if (include_stack_index > 0 && include_stack[include_stack_index-1].globbuf_pos < include_stack[include_stack_index-1].globbuf.gl_pathc-1) {
            ael_yy_delete_buffer(YY_CURRENT_BUFFER,yyscanner );
            include_stack[include_stack_index-1].globbuf_pos++;
            setup_filestack(fnamebuf, sizeof(fnamebuf), &include_stack[include_stack_index-1].globbuf, include_stack[include_stack_index-1].globbuf_pos, yyscanner, 0);
            /* finish this */
 
        } else {
            if (include_stack[include_stack_index].fname) {
                free(include_stack[include_stack_index].fname);
                include_stack[include_stack_index].fname = 0;
            }
            if (my_file) {
                free(my_file);
                my_file = 0;
            }
            if ( --include_stack_index < 0 ) {
                yyterminate();
            } else {
                globfree(&include_stack[include_stack_index].globbuf);
                include_stack[include_stack_index].globbuf_pos = -1;
 
                ael_yy_delete_buffer(YY_CURRENT_BUFFER,yyscanner );
                ael_yy_switch_to_buffer(include_stack[include_stack_index].bufstate,yyscanner );
                my_lineno = include_stack[include_stack_index].lineno;
                my_col    = include_stack[include_stack_index].colno;
                my_file   = strdup(include_stack[include_stack_index].fname);
            }
        }
    }
    YY_BREAK
case 75:
/* rule 75 can match eol */
YY_RULE_SETUP
#line 657 "ael.flex"
{ /* default rule */ ast_log(LOG_ERROR,"Unhandled char(s): %s\n", yytext); }
    YY_BREAK
case 76:
YY_RULE_SETUP
#line 659 "ael.flex"
YY_FATAL_ERROR( "flex scanner jammed" );
    YY_BREAK
#line 2042 "ael_lex.c"
 
    case YY_END_OF_BUFFER:
        {
        /* Amount of text matched not including the EOB char. */
        int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
 
        /* Undo the effects of YY_DO_BEFORE_ACTION. */
        *yy_cp = yyg->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
             * ael_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.
             */
            yyg->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 ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
            { /* This was really a NUL. */
            yy_state_type yy_next_state;
 
            yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
 
            yy_current_state = yy_get_previous_state( yyscanner );
 
            /* 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 , yyscanner);
 
            yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 
            if ( yy_next_state )
                {
                /* Consume the NUL. */
                yy_cp = ++yyg->yy_c_buf_p;
                yy_current_state = yy_next_state;
                goto yy_match;
                }
 
            else
                {
                yy_cp = yyg->yy_last_accepting_cpos;
                yy_current_state = yyg->yy_last_accepting_state;
                goto yy_find_action;
                }
            }
 
        else switch ( yy_get_next_buffer( yyscanner ) )
            {
            case EOB_ACT_END_OF_FILE:
                {
                yyg->yy_did_buffer_switch_on_eof = 0;
 
                if ( ael_yywrap(yyscanner ) )
                    {
                    /* 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.
                     */
                    yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
 
                    yy_act = YY_STATE_EOF(YY_START);
                    goto do_action;
                    }
 
                else
                    {
                    if ( ! yyg->yy_did_buffer_switch_on_eof )
                        YY_NEW_FILE;
                    }
                break;
                }
 
            case EOB_ACT_CONTINUE_SCAN:
                yyg->yy_c_buf_p =
                    yyg->yytext_ptr + yy_amount_of_matched_text;
 
                yy_current_state = yy_get_previous_state( yyscanner );
 
                yy_cp = yyg->yy_c_buf_p;
                yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
                goto yy_match;
 
            case EOB_ACT_LAST_MATCH:
                yyg->yy_c_buf_p =
                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
 
                yy_current_state = yy_get_previous_state( yyscanner );
 
                yy_cp = yyg->yy_c_buf_p;
                yy_bp = yyg->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 */

References ael_yy_delete_buffer(), ael_yy_switch_to_buffer(), ael_yywrap, AMPER, argg, ast_config_AST_CONFIG_DIR, ast_copy_string(), ast_log, AT, BAR, BEGIN, brackstate, c, stackelement::colno, COLON, COMMA, comment, curlystate, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, EQ, EXTENMARK, stackelement::fname, free(), GLOB_ABORTED, GLOB_BRACE, GLOB_NOMAGIC, stackelement::globbuf_pos, include_stack, include_stack_index, INITIAL, KW_ABSTRACT, KW_BREAK, KW_CASE, KW_CATCH, KW_CONTEXT, KW_CONTINUE, KW_DEFAULT, KW_ELSE, KW_ESWITCHES, KW_EXTEND, KW_FOR, KW_GLOBALS, KW_GOTO, KW_HINT, KW_IF, KW_IFTIME, KW_IGNOREPAT, KW_INCLUDES, KW_JUMP, KW_LOCAL, KW_MACRO, KW_PATTERN, KW_RANDOM, KW_REGEXTEN, KW_RETURN, KW_SWITCH, KW_SWITCHES, KW_WHILE, LC, stackelement::lineno, LOG_ERROR, LOG_WARNING, LP, malloc(), MAX_INCLUDE_DEPTH, my_col, my_file, my_lineno, NULL, paren, parencount, parencount2, parencount3, pbcpop(), pbcpop2(), pbcpop3(), pbcpos2, pbcpos3, pbcpush(), pbcpush2(), pbcpush3(), prev_word, RC, RP, SEMI, semic, setup_filestack(), STORE_LOC, STORE_POS, strdup, unput, wordstate, yy_accept, yy_act, yy_base, yy_bp, YY_BREAK, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yyguts_t::yy_c_buf_p, yy_chk, yy_cp, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_def, yyguts_t::yy_did_buffer_switch_on_eof, YY_DO_BEFORE_ACTION, yy_ec, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yyguts_t::yy_hold_char, yyguts_t::yy_last_accepting_cpos, yyguts_t::yy_last_accepting_state, yy_meta, YY_MORE_ADJ, yyguts_t::yy_more_flag, yyguts_t::yy_more_len, yyguts_t::yy_n_chars, YY_NEW_FILE, yy_nxt, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, yyguts_t::yy_start, YY_START, YY_STATE_EOF, yy_try_NUL_trans(), yyg, yyin, yyleng, yylval, yymore, yyterminate, and yytext.

◆ yy_fatal_error() [1/2]

static void yy_fatal_error	(	yyconst char *	msg,
		yyscan_t	yyscanner
	)

static

Definition at line 2854 of file ael_lex.c.

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

References YY_EXIT_FAILURE.

◆ yy_fatal_error() [2/2]

static void yy_fatal_error	(	yyconst char	msg[],
		yyscan_t	yyscanner
	)

static

Referenced by ael_yyset_column(), and ael_yyset_lineno().

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( yyscan_t yyscanner )

static

Definition at line 2183 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    register char *source = yyg->yytext_ptr;
    register int number_to_move, i;
    int ret_val;
 
    if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;
 
    else
        {
            int 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;
 
            int yy_c_buf_p_offset =
                (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 
            if ( b->yy_is_our_buffer )
                {
                int 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. */
                    ael_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
                }
            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" );
 
            yyg->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]),
            yyg->yy_n_chars, (size_t) num_to_read );
 
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
        }
 
    if ( yyg->yy_n_chars == 0 )
        {
        if ( number_to_move == YY_MORE_ADJ )
            {
            ret_val = EOB_ACT_END_OF_FILE;
            ael_yyrestart(yyin  ,yyscanner);
            }
 
        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) (yyg->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 = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ael_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
        if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    }
 
    yyg->yy_n_chars += number_to_move;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 
    yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
    return ret_val;
}

References ael_yyrealloc(), ael_yyrestart(), b, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, YY_BUFFER_EOF_PENDING, yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, YY_INPUT, YY_MORE_ADJ, yyguts_t::yy_n_chars, YY_READ_BUF_SIZE, yyg, and yyin.

Referenced by input(), and while().

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner )

static

Definition at line 2318 of file ael_lex.c.

{
    register yy_state_type yy_current_state;
    register char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    yy_current_state = yyg->yy_start;
 
    for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->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] )
            {
            yyg->yy_last_accepting_state = yy_current_state;
            yyg->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 >= 285 )
                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;
}

References yy_accept, yy_base, yyguts_t::yy_c_buf_p, yy_chk, yy_cp, yy_def, yy_ec, yyguts_t::yy_last_accepting_cpos, yyguts_t::yy_last_accepting_state, yy_meta, YY_MORE_ADJ, yy_nxt, YY_SC_TO_UI, yyguts_t::yy_start, and yyg.

Referenced by while().

◆ yy_init_globals()

static int yy_init_globals ( yyscan_t yyscanner )

static

Definition at line 3111 of file ael_lex.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from ael_yylex_destroy(), so don't allocate here.
     */
 
    yyg->yy_buffer_stack = 0;
    yyg->yy_buffer_stack_top = 0;
    yyg->yy_buffer_stack_max = 0;
    yyg->yy_c_buf_p = (char *) 0;
    yyg->yy_init = 0;
    yyg->yy_start = 0;
 
    yyg->yy_start_stack_ptr = 0;
    yyg->yy_start_stack_depth = 0;
    yyg->yy_start_stack =  NULL;
 
/* 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
     * ael_yylex_init()
     */
    return 0;
}

References NULL, yyguts_t::yy_buffer_stack, yyguts_t::yy_buffer_stack_max, yyguts_t::yy_buffer_stack_top, yyguts_t::yy_c_buf_p, yyguts_t::yy_init, yyguts_t::yy_start, yyguts_t::yy_start_stack, yyguts_t::yy_start_stack_depth, yyguts_t::yy_start_stack_ptr, yyg, yyin, and yyout.

Referenced by ael_yylex_destroy(), ael_yylex_init(), and ael_yylex_init_extra().

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans	(	yy_state_type	current_state,
		yyscan_t	yyscanner
	)

static

Definition at line 2351 of file ael_lex.c.

{
    register int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
    register char *yy_cp = yyg->yy_c_buf_p;
 
    register YY_CHAR yy_c = 1;
    if ( yy_accept[yy_current_state] )
        {
        yyg->yy_last_accepting_state = yy_current_state;
        yyg->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 >= 285 )
            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 == 284);
 
    return yy_is_jam ? 0 : yy_current_state;
}

References yy_accept, yy_base, yyguts_t::yy_c_buf_p, yy_chk, yy_cp, yy_def, yyguts_t::yy_last_accepting_cpos, yyguts_t::yy_last_accepting_state, yy_meta, yy_nxt, and yyg.

Referenced by while().

◆ yyunput() [1/2]

static void yyunput	(	int	c,
		char *	buf_ptr,
		yyscan_t	yyscanner
	)

static

◆ yyunput() [2/2]

static void yyunput	(	int	c,
		register char *	yy_bp,
		yyscan_t	yyscanner
	)

static

Definition at line 2375 of file ael_lex.c.

{
    register char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    yy_cp = yyg->yy_c_buf_p;
 
    /* undo effects of setting up yytext */
    *yy_cp = yyg->yy_hold_char;
 
    if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
        { /* need to shift things up to make room */
        /* +2 for EOB chars. */
        register int number_to_move = yyg->yy_n_chars + 2;
        register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
                    YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
        register char *source =
                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
        while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            *--dest = *--source;
 
        yy_cp += (int) (dest - source);
        yy_bp += (int) (dest - source);
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
            yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
            YY_FATAL_ERROR( "flex scanner push-back overflow" );
        }
 
    *--yy_cp = (char) c;
 
    yyg->yytext_ptr = yy_bp;
    yyg->yy_hold_char = *yy_cp;
    yyg->yy_c_buf_p = yy_cp;
}

References c, yy_bp, yyguts_t::yy_c_buf_p, yy_cp, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, and yyg.

Variable Documentation

◆ include_stack

struct stackelement include_stack[MAX_INCLUDE_DEPTH]

static

Definition at line 907 of file ael_lex.c.

Referenced by setup_filestack(), and while().

◆ include_stack_index

int include_stack_index = 0

static

Definition at line 908 of file ael_lex.c.

Referenced by ael2_parse(), setup_filestack(), and while().

◆ my_col

int my_col = 1

static

Definition at line 876 of file ael_lex.c.

Referenced by ael2_parse(), setup_filestack(), and while().

◆ my_file

char* my_file = 0

Definition at line 877 of file ael_lex.c.

Referenced by ael2_parse(), npval(), setup_filestack(), while(), yyerror(), and yyparse().

◆ my_lineno

int my_lineno = 1

static

Definition at line 875 of file ael_lex.c.

Referenced by ael2_parse(), setup_filestack(), and while().

◆ parencount

int parencount = 0

static

Definition at line 851 of file ael_lex.c.

Referenced by reset_argcount(), reset_parencount(), and while().

◆ parencount2

int parencount2 = 0

static

Definition at line 860 of file ael_lex.c.

Referenced by while().

◆ parencount3

int parencount3 = 0

static

Definition at line 869 of file ael_lex.c.

Referenced by while().

◆ pbcpos

int pbcpos = 0

static

Definition at line 848 of file ael_lex.c.

Referenced by pbcpop(), pbcpush(), reset_argcount(), reset_parencount(), and reset_semicount().

◆ pbcpos2

int pbcpos2 = 0

static

Definition at line 857 of file ael_lex.c.

Referenced by pbcpop2(), pbcpush2(), and while().

◆ pbcpos3

int pbcpos3 = 0

static

Definition at line 866 of file ael_lex.c.

Referenced by pbcpop3(), pbcpush3(), and while().

◆ pbcstack

char pbcstack[400]

static

Definition at line 847 of file ael_lex.c.

Referenced by pbcpop(), and pbcpush().

◆ pbcstack2

char pbcstack2[400]

static

Definition at line 856 of file ael_lex.c.

Referenced by pbcpop2(), and pbcpush2().

◆ pbcstack3

char pbcstack3[400]

static

Definition at line 865 of file ael_lex.c.

Referenced by pbcpop3(), and pbcpush3().

◆ prev_word

char* prev_word

Definition at line 878 of file ael_lex.c.

Referenced by ael2_parse(), c_prevword(), while(), yydestruct(), and yyparse().

◆ yy_accept

yyconst flex_int16_t yy_accept[285]

static

Definition at line 365 of file ael_lex.c.

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

◆ yy_act

register int yy_act

Definition at line 1204 of file ael_lex.c.

Referenced by while().

◆ yy_base

yyconst flex_int16_t yy_base[304]

static

Definition at line 441 of file ael_lex.c.

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

◆ yy_bp

register char * yy_bp

Definition at line 1203 of file ael_lex.c.

Referenced by while(), and yyunput().

◆ yy_chk

yyconst flex_int16_t yy_chk[1073]

static

Definition at line 639 of file ael_lex.c.

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

◆ yy_cp

register char* yy_cp

Definition at line 1203 of file ael_lex.c.

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

◆ YY_DECL

YY_DECL

Initial value:

{

register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 1200 of file ael_lex.c.

◆ yy_def

yyconst flex_int16_t yy_def[304]

static

Definition at line 479 of file ael_lex.c.

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

◆ yy_ec

yyconst flex_int32_t yy_ec[256]

static

Definition at line 400 of file ael_lex.c.

Referenced by while(), and yy_get_previous_state().

◆ yy_meta

yyconst flex_int32_t yy_meta[50]

static

Definition at line 432 of file ael_lex.c.

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

◆ yy_nxt

yyconst flex_int16_t yy_nxt[1073]

static

Definition at line 517 of file ael_lex.c.

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

◆ yyg

struct yyguts_t* yyg = (struct yyguts_t*)yyscanner

◆ yylloc

yylloc = yylloc_param

Definition at line 1214 of file ael_lex.c.

◆ yylval

yylval = yylval_param

Definition at line 1212 of file ael_lex.c.

Data Structures

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ael_yywrap

◆ argg

◆ ASTMM_LIBC

◆ BEGIN

◆ brackstate

◆ comment

◆ curlystate

◆ ECHO

◆ EOB_ACT_CONTINUE_SCAN

◆ EOB_ACT_END_OF_FILE

◆ EOB_ACT_LAST_MATCH

◆ FLEX_BETA

◆ FLEX_SCANNER

◆ FLEXINT_H

◆ GLOB_ABORTED

◆ GLOB_BRACE

◆ GLOB_NOMAGIC

◆ INITIAL

◆ INT16_MAX

◆ INT16_MIN

◆ INT32_MAX

◆ INT32_MIN

◆ INT8_MAX

◆ INT8_MIN

◆ MAX_INCLUDE_DEPTH

◆ paren

◆ REJECT

◆ semic

◆ STORE_LOC

◆ STORE_POS

◆ UINT16_MAX

◆ UINT32_MAX

◆ UINT8_MAX

◆ unput

◆ wordstate

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

◆ 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_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_SKIP_YYWRAP

◆ YY_START

◆ YY_START_STACK_INCR