ast_expr2f.c File Reference

Dialplan Expression Lexical Scanner. More...

#include "asterisk.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <locale.h>
#include <ctype.h>
#include <regex.h>
#include <limits.h>
#include "asterisk/ast_expr.h"
#include "asterisk/logger.h"
#include "asterisk/strings.h"
#include "asterisk/channel.h"
#include "ast_expr2.h"
#include <unistd.h>

Include dependency graph for ast_expr2f.c:

Go to the source code of this file.

Data Structures
struct	parse_io
struct	val
struct	yy_buffer_state
struct	yy_trans_info
struct	yyguts_t

Macros
#define	ast_yywrap(n)   1
#define	ASTMM_LIBC   ASTMM_REDIRECT
#define	BEGIN   yyg->yy_start = 1 + 2 *
#define	ECHO   do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	FLEX_SCANNER
#define	FLEXINT_H
#define	FP___FMOD   fmod
#define	FP___PRINTF   "%.16g"
#define	FP___STRTOD   strtod
#define	FP___TYPE   double
#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	REJECT   reject_used_but_not_detected
#define	SET_COLUMNS
#define	SET_NUMERIC_STRING
#define	SET_STRING
#define	trail   2
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	UINT8_MAX   (255U)
#define	unput(c)   yyunput( c, yyg->yytext_ptr , yyscanner )
#define	var   1
#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   39
#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   ast_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   ast_yy_create_buffer
#define	YY_NEW_FILE   ast_yyrestart(yyin ,yyscanner )
#define	YY_NULL   0
#define	YY_NUM_RULES   38
#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

Enumerations
enum	valtype { AST_EXPR_number , AST_EXPR_numeric_string , AST_EXPR_string }

Functions
int	ast_expr (char *expr, char *buf, int length, struct ast_channel *chan)
	Evaluate the given expression.
void	ast_expr_clear_extra_error_info (void)
void	ast_expr_register_extra_error_info (char *message)
int	ast_str_expr (struct ast_str **str, ssize_t maxlen, struct ast_channel *chan, char *expr)
	Evaluate the given expression.
YY_BUFFER_STATE	ast_yy_create_buffer (FILE *file, int size, yyscan_t yyscanner)
void	ast_yy_delete_buffer (YY_BUFFER_STATE b, yyscan_t yyscanner)
void	ast_yy_flush_buffer (YY_BUFFER_STATE b, yyscan_t yyscanner)
static void	ast_yy_init_buffer (YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner)
static void	ast_yy_load_buffer_state (yyscan_t yyscanner)
YY_BUFFER_STATE	ast_yy_scan_buffer (char *base, yy_size_t size, yyscan_t yyscanner)
YY_BUFFER_STATE	ast_yy_scan_bytes (yyconst char *bytes, int len, yyscan_t yyscanner)
YY_BUFFER_STATE	ast_yy_scan_string (yyconst char *yy_str, yyscan_t yyscanner)
void	ast_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer, yyscan_t yyscanner)
void *	ast_yyalloc (yy_size_t, yyscan_t yyscanner)
static void	ast_yyensure_buffer_stack (yyscan_t yyscanner)
int	ast_yyerror (const char *, YYLTYPE *, struct parse_io *)
int	ast_yyerror (const char *s, yyltype *loc, struct parse_io *parseio)
void	ast_yyfree (void *, yyscan_t yyscanner)
int	ast_yyget_column (yyscan_t yyscanner)
int	ast_yyget_debug (yyscan_t yyscanner)
YY_EXTRA_TYPE	ast_yyget_extra (yyscan_t yyscanner)
FILE *	ast_yyget_in (yyscan_t yyscanner)
int	ast_yyget_leng (yyscan_t yyscanner)
int	ast_yyget_lineno (yyscan_t yyscanner)
YYLTYPE *	ast_yyget_lloc (yyscan_t yyscanner)
YYSTYPE *	ast_yyget_lval (yyscan_t yyscanner)
FILE *	ast_yyget_out (yyscan_t yyscanner)
char *	ast_yyget_text (yyscan_t yyscanner)
int	ast_yylex (YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner)
int	ast_yylex_destroy (yyscan_t yyscanner)
int	ast_yylex_init (yyscan_t *scanner)
int	ast_yylex_init_extra (YY_EXTRA_TYPE user_defined, yyscan_t *scanner)
int	ast_yyparse (void *)
void	ast_yypop_buffer_state (yyscan_t yyscanner)
void	ast_yypush_buffer_state (YY_BUFFER_STATE new_buffer, yyscan_t yyscanner)
void *	ast_yyrealloc (void *, yy_size_t, yyscan_t yyscanner)
void	ast_yyrestart (FILE *input_file, yyscan_t yyscanner)
void	ast_yyset_column (int column_no, yyscan_t yyscanner)
void	ast_yyset_debug (int debug_flag, yyscan_t yyscanner)
void	ast_yyset_extra (YY_EXTRA_TYPE user_defined, yyscan_t yyscanner)
void	ast_yyset_in (FILE *in_str, yyscan_t yyscanner)
void	ast_yyset_lineno (int line_number, yyscan_t yyscanner)
void	ast_yyset_lloc (YYLTYPE *yylloc_param, yyscan_t yyscanner)
void	ast_yyset_lval (YYSTYPE *yylval_param, yyscan_t yyscanner)
void	ast_yyset_out (FILE *out_str, yyscan_t yyscanner)
static char *	expr2_token_subst (const char *mess)
	if (!yyg->yy_init)
static int	input (yyscan_t yyscanner)
int	isatty (int)
	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 int	curlycount = 0
static const char *const	expr2_token_equivs1 []
static const char *const	expr2_token_equivs2 []
char	extra_error_message [4095]
int	extra_error_message_supplied = 0
static yyconst flex_int16_t	yy_accept [63]
register int	yy_act
static yyconst flex_int16_t	yy_base [70]
register char *	yy_bp
static yyconst flex_int16_t	yy_chk [159]
register char *	yy_cp
	YY_DECL
static yyconst flex_int16_t	yy_def [70]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [29]
static yyconst flex_int16_t	yy_nxt [159]
struct yyguts_t *	yyg = (struct yyguts_t*)yyscanner
	yylloc = yylloc_param
	yylval = yylval_param

Detailed Description

Dialplan Expression Lexical Scanner.

Definition in file ast_expr2f.c.

Macro Definition Documentation

ast_yywrap

#define ast_yywrap

(

n

)

1

Definition at line 331 of file ast_expr2f.c.

ASTMM_LIBC

#define ASTMM_LIBC   ASTMM_REDIRECT

Definition at line 1 of file ast_expr2f.c.

BEGIN

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

Definition at line 145 of file ast_expr2f.c.

ECHO

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

Definition at line 554 of file ast_expr2f.c.

EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 176 of file ast_expr2f.c.

EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 177 of file ast_expr2f.c.

EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 178 of file ast_expr2f.c.

FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 12 of file ast_expr2f.c.

FLEXINT_H

#define FLEXINT_H

Definition at line 33 of file ast_expr2f.c.

FP___FMOD

#define FP___FMOD   fmod

Definition at line 527 of file ast_expr2f.c.

FP___PRINTF

#define FP___PRINTF   "%.16g"

Definition at line 526 of file ast_expr2f.c.

FP___STRTOD

#define FP___STRTOD   strtod

Definition at line 528 of file ast_expr2f.c.

FP___TYPE

#define FP___TYPE   double

Definition at line 529 of file ast_expr2f.c.

INITIAL

#define INITIAL   0

Definition at line 604 of file ast_expr2f.c.

INT16_MAX

#define INT16_MAX   (32767)

Definition at line 76 of file ast_expr2f.c.

INT16_MIN

#define INT16_MIN   (-32767-1)

Definition at line 67 of file ast_expr2f.c.

INT32_MAX

#define INT32_MAX   (2147483647)

Definition at line 79 of file ast_expr2f.c.

INT32_MIN

#define INT32_MIN   (-2147483647-1)

Definition at line 70 of file ast_expr2f.c.

INT8_MAX

#define INT8_MAX   (127)

Definition at line 73 of file ast_expr2f.c.

INT8_MIN

#define INT8_MIN   (-128)

Definition at line 64 of file ast_expr2f.c.

REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 482 of file ast_expr2f.c.

SET_COLUMNS

#define SET_COLUMNS

Value:

    do {        \
    yylloc_param->first_column = (int)(yyg->yytext_r - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf); \
    yylloc_param->last_column += yyleng - 1; \
    yylloc_param->first_line = yylloc_param->last_line = 1; \
    } while (0)

Definition at line 571 of file ast_expr2f.c.

                       {        \
    yylloc_param->first_column = (int)(yyg->yytext_r - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf); \
    yylloc_param->last_column += yyleng - 1; \
    yylloc_param->first_line = yylloc_param->last_line = 1; \
    } while (0)

SET_NUMERIC_STRING

#define SET_NUMERIC_STRING

Value:

    do {    \
    yylval_param->val = calloc(1, sizeof(struct val));  \
    yylval_param->val->type = AST_EXPR_numeric_string;  \
    yylval_param->val->u.s = strdup(yytext);    \
    } while (0)

Definition at line 583 of file ast_expr2f.c.

                               {    \
    yylval_param->val = calloc(1, sizeof(struct val));  \
    yylval_param->val->type = AST_EXPR_numeric_string;  \
    yylval_param->val->u.s = strdup(yytext);    \
    } while (0)

SET_STRING

#define SET_STRING

Value:

    do {        \
    yylval_param->val = calloc(1, sizeof(struct val));  \
    yylval_param->val->type = AST_EXPR_string;      \
    yylval_param->val->u.s = strdup(yytext);        \
    } while (0)

Definition at line 577 of file ast_expr2f.c.

                       {        \
    yylval_param->val = calloc(1, sizeof(struct val));  \
    yylval_param->val->type = AST_EXPR_string;      \
    yylval_param->val->u.s = strdup(yytext);        \
    } while (0)

trail

#define trail   2

Definition at line 606 of file ast_expr2f.c.

UINT16_MAX

#define UINT16_MAX   (65535U)

Definition at line 85 of file ast_expr2f.c.

UINT32_MAX

#define UINT32_MAX   (4294967295U)

Definition at line 88 of file ast_expr2f.c.

UINT8_MAX

#define UINT8_MAX   (255U)

Definition at line 82 of file ast_expr2f.c.

unput

#define unput

(

c

)

yyunput( c, yyg->yytext_ptr , yyscanner )

Definition at line 196 of file ast_expr2f.c.

var

#define var   1

Examples

app_skel.c.

Definition at line 605 of file ast_expr2f.c.

YY_AT_BOL

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 327 of file ast_expr2f.c.

YY_BREAK

#define YY_BREAK   break;

Definition at line 830 of file ast_expr2f.c.

YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 164 of file ast_expr2f.c.

YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 263 of file ast_expr2f.c.

YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 251 of file ast_expr2f.c.

YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 252 of file ast_expr2f.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 ast_expr2f.c.

                          : NULL)

YY_CURRENT_BUFFER_LVALUE

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

Definition at line 281 of file ast_expr2f.c.

YY_DECL

#define YY_DECL

Value:

               int ast_yylex \
               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)

Definition at line 817 of file ast_expr2f.c.

YY_DECL_IS_OURS

#define YY_DECL_IS_OURS   1

Definition at line 812 of file ast_expr2f.c.

YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Definition at line 348 of file ast_expr2f.c.

YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   39

Definition at line 357 of file ast_expr2f.c.

YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 160 of file ast_expr2f.c.

YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 2004 of file ast_expr2f.c.

YY_EXTRA_TYPE

#define YY_EXTRA_TYPE   void *

Definition at line 617 of file ast_expr2f.c.

YY_FATAL_ERROR

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg , yyscanner)

Definition at line 803 of file ast_expr2f.c.

yy_flex_debug

#define yy_flex_debug   yyg->yy_flex_debug_r

Definition at line 139 of file ast_expr2f.c.

YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 13 of file ast_expr2f.c.

YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 14 of file ast_expr2f.c.

YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 15 of file ast_expr2f.c.

YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER   ast_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)

Definition at line 295 of file ast_expr2f.c.

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size
	)

Definition at line 756 of file ast_expr2f.c.

        { \
        int c = '*'; \
        int n; \
        for ( n = 0; n < max_size && \
                 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
            buf[n] = (char) c; \
        if ( c == '\n' ) \
            buf[n++] = (char) c; \
        if ( c == EOF && ferror( yyin ) ) \
            YY_FATAL_ERROR( "input in flex scanner failed" ); \
        result = n; \
        } \
    else \
        { \
        errno=0; \
        while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
            { \
            if( errno != EINTR) \
                { \
                YY_FATAL_ERROR( "input in flex scanner failed" ); \
                break; \
                } \
            errno=0; \
            clearerr(yyin); \
            } \
        }\
\
 

YY_INT_ALIGNED

#define YY_INT_ALIGNED   short int

Definition at line 8 of file ast_expr2f.c.

YY_LESS_LINENO

#define YY_LESS_LINENO

(

n

)

Definition at line 180 of file ast_expr2f.c.

YY_MORE_ADJ

#define YY_MORE_ADJ   yyg->yy_more_len

Definition at line 484 of file ast_expr2f.c.

yy_new_buffer

#define yy_new_buffer   ast_yy_create_buffer

Definition at line 305 of file ast_expr2f.c.

YY_NEW_FILE

#define YY_NEW_FILE   ast_yyrestart(yyin ,yyscanner )

Definition at line 158 of file ast_expr2f.c.

YY_NULL

#define YY_NULL   0

Definition at line 115 of file ast_expr2f.c.

YY_NUM_RULES

#define YY_NUM_RULES   38

Definition at line 356 of file ast_expr2f.c.

YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 741 of file ast_expr2f.c.

YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 485 of file ast_expr2f.c.

YY_RULE_SETUP

#define YY_RULE_SETUP    YY_USER_ACTION

Definition at line 833 of file ast_expr2f.c.

YY_SC_TO_UI

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 122 of file ast_expr2f.c.

yy_set_bol

#define yy_set_bol

(

at_bol

)

Definition at line 317 of file ast_expr2f.c.

    { \
    if ( ! YY_CURRENT_BUFFER ){\
        ast_yyensure_buffer_stack (yyscanner); \
        YY_CURRENT_BUFFER_LVALUE =    \
            ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
    } \
    YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    }

yy_set_interactive

#define yy_set_interactive

(

is_interactive

)

Definition at line 307 of file ast_expr2f.c.

    { \
    if ( ! YY_CURRENT_BUFFER ){ \
        ast_yyensure_buffer_stack (yyscanner); \
        YY_CURRENT_BUFFER_LVALUE =    \
            ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
    } \
    YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    }

YY_SKIP_YYWRAP

#define YY_SKIP_YYWRAP

Definition at line 332 of file ast_expr2f.c.

YY_START

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

Definition at line 151 of file ast_expr2f.c.

YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 798 of file ast_expr2f.c.

YY_STATE_BUF_SIZE

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

Definition at line 169 of file ast_expr2f.c.

YY_STATE_EOF

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 155 of file ast_expr2f.c.

YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 204 of file ast_expr2f.c.

YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 172 of file ast_expr2f.c.

YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 126 of file ast_expr2f.c.

YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 199 of file ast_expr2f.c.

YY_USER_ACTION

#define YY_USER_ACTION

Definition at line 825 of file ast_expr2f.c.

yycolumn

#define yycolumn   (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)

Definition at line 138 of file ast_expr2f.c.

yyconst

#define yyconst

Definition at line 111 of file ast_expr2f.c.

yyextra

#define yyextra   yyg->yyextra_r

Definition at line 134 of file ast_expr2f.c.

yyin

#define yyin   yyg->yyin_r

Definition at line 132 of file ast_expr2f.c.

yyleng

#define yyleng   yyg->yyleng_r

Definition at line 135 of file ast_expr2f.c.

yyless [1/2]

#define yyless

(

n

)

Definition at line 183 of file ast_expr2f.c.

        { \
        /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        *yy_cp = yyg->yy_hold_char; \
        YY_RESTORE_YY_MORE_OFFSET \
        yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
        YY_DO_BEFORE_ACTION; /* set up yytext again */ \
        } \
    while ( 0 )

yyless [2/2]

#define yyless

(

n

)

Definition at line 183 of file ast_expr2f.c.

        { \
        /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        *yy_cp = yyg->yy_hold_char; \
        YY_RESTORE_YY_MORE_OFFSET \
        yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
        YY_DO_BEFORE_ACTION; /* set up yytext again */ \
        } \
    while ( 0 )

yylineno

#define yylineno   (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)

Definition at line 137 of file ast_expr2f.c.

yylloc

#define yylloc   yyg->yylloc_r

Definition at line 664 of file ast_expr2f.c.

yylval

#define yylval   yyg->yylval_r

Definition at line 662 of file ast_expr2f.c.

yymore

#define yymore

(

)

(yyg->yy_more_flag = 1)

Definition at line 483 of file ast_expr2f.c.

yyout

#define yyout   yyg->yyout_r

Definition at line 133 of file ast_expr2f.c.

YYSTATE

#define YYSTATE   YY_START

Definition at line 152 of file ast_expr2f.c.

YYTABLES_NAME

#define YYTABLES_NAME   "yytables"

Definition at line 2368 of file ast_expr2f.c.

yyterminate

#define yyterminate

(

)

return YY_NULL

Definition at line 793 of file ast_expr2f.c.

yytext

#define yytext   yyg->yytext_r

Definition at line 136 of file ast_expr2f.c.

yytext_ptr

#define yytext_ptr   yytext_r

Definition at line 338 of file ast_expr2f.c.

Typedef Documentation

flex_int16_t

typedef short int flex_int16_t

Definition at line 55 of file ast_expr2f.c.

flex_int32_t

typedef int flex_int32_t

Definition at line 56 of file ast_expr2f.c.

flex_int8_t

typedef signed char flex_int8_t

Definition at line 54 of file ast_expr2f.c.

flex_uint16_t

typedef unsigned short int flex_uint16_t

Definition at line 58 of file ast_expr2f.c.

flex_uint32_t

typedef unsigned int flex_uint32_t

Definition at line 59 of file ast_expr2f.c.

flex_uint8_t

typedef unsigned char flex_uint8_t

Definition at line 57 of file ast_expr2f.c.

YY_BUFFER_STATE

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 173 of file ast_expr2f.c.

YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 334 of file ast_expr2f.c.

yy_size_t

typedef size_t yy_size_t

Definition at line 200 of file ast_expr2f.c.

yy_state_type

typedef int yy_state_type

Definition at line 336 of file ast_expr2f.c.

yyscan_t

typedef void* yyscan_t

Definition at line 127 of file ast_expr2f.c.

Enumeration Type Documentation

valtype

enum valtype

Enumerator
AST_EXPR_number
AST_EXPR_numeric_string
AST_EXPR_string

Definition at line 557 of file ast_expr2f.c.

             {
    AST_EXPR_number, AST_EXPR_numeric_string, AST_EXPR_string
} ;

Function Documentation

ast_expr()

int ast_expr	(	char *	expr,
		char *	buf,
		int	length,
		struct ast_channel *	chan
	)

Evaluate the given expression.

Parameters

expr	An expression
buf	Result buffer
length	Size of the result buffer, in bytes
chan	Channel to use for evaluating included dialplan functions, if any

Returns

Length of the result string, in bytes

Definition at line 2391 of file ast_expr2f.c.

{
    struct parse_io io = { .string = expr, .chan = chan };
    int return_value = 0;
 
    ast_yylex_init(&io.scanner);
 
    ast_yy_scan_string(expr, io.scanner);
 
    ast_yyparse ((void *) &io);
 
    ast_yylex_destroy(io.scanner);
 
    if (!io.val) {
        if (length > 1) {
            strcpy(buf, "0");
            return_value = 1;
        }
    } else {
        if (io.val->type == AST_EXPR_number) {
            int res_length;
 
            res_length = snprintf(buf, length, FP___PRINTF, io.val->u.i);
            return_value = (res_length <= length) ? res_length : length;
        } else {
            if (io.val->u.s)
#if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE)
                strncpy(buf, io.val->u.s, length - 1);
#else /* !STANDALONE && !LOW_MEMORY */
                ast_copy_string(buf, io.val->u.s, length);
#endif /* STANDALONE || LOW_MEMORY */
            else
                buf[0] = 0;
            return_value = strlen(buf);
            free(io.val->u.s);
        }
        free(io.val);
    }
    return return_value;
}

References ast_copy_string(), AST_EXPR_number, ast_yy_scan_string(), ast_yylex_destroy(), ast_yylex_init(), ast_yyparse(), buf, parse_io::chan, FP___PRINTF, free(), and io.

Referenced by AST_TEST_DEFINE(), check_eval(), check_pval_item(), pbx_substitute_variables_helper_full(), and pbx_substitute_variables_helper_full_location().

ast_expr_clear_extra_error_info()

void ast_expr_clear_extra_error_info

(

void

)

Definition at line 2469 of file ast_expr2f.c.

{
       extra_error_message_supplied=0;
       extra_error_message[0] = 0;
}

References extra_error_message, and extra_error_message_supplied.

Referenced by check_pval_item().

ast_expr_register_extra_error_info()

void ast_expr_register_extra_error_info

(

char *

message

)

Definition at line 2463 of file ast_expr2f.c.

{
       extra_error_message_supplied=1;
       strcpy(extra_error_message, message);
}

References extra_error_message, and extra_error_message_supplied.

Referenced by check_pval_item().

ast_str_expr()

int ast_str_expr	(	struct ast_str **	str,
		ssize_t	maxlen,
		struct ast_channel *	chan,
		char *	expr
	)

Evaluate the given expression.

Parameters

str	Dynamic result buffer
maxlen	<0 if the size of the buffer should remain constant, >0 if the size of the buffer should expand to that many bytes, maximum, or 0 for unlimited expansion of the result buffer
chan	Channel to use for evaluating included dialplan functions, if any
expr	An expression

Returns

Length of the result string, in bytes

Definition at line 2433 of file ast_expr2f.c.

{
    struct parse_io io = { .string = expr, .chan = chan };
 
    ast_yylex_init(&io.scanner);
    ast_yy_scan_string(expr, io.scanner);
    ast_yyparse ((void *) &io);
    ast_yylex_destroy(io.scanner);
 
    if (!io.val) {
        ast_str_set(str, maxlen, "0");
    } else {
        if (io.val->type == AST_EXPR_number) {
            ast_str_set(str, maxlen, FP___PRINTF, io.val->u.i);
        } else if (io.val->u.s) {
            ast_str_set(str, maxlen, "%s", io.val->u.s);
            free(io.val->u.s);
        }
        free(io.val);
    }
    return ast_str_strlen(*str);
}

References AST_EXPR_number, ast_str_set(), ast_str_strlen(), ast_yy_scan_string(), ast_yylex_destroy(), ast_yylex_init(), ast_yyparse(), parse_io::chan, FP___PRINTF, free(), io, and str.

Referenced by ast_str_substitute_variables_full2().

ast_yy_create_buffer()

YY_BUFFER_STATE ast_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 1711 of file ast_expr2f.c.

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

References ast_yy_init_buffer(), ast_yyalloc(), b, and YY_FATAL_ERROR.

Referenced by ast_yyrestart(), and if().

ast_yy_delete_buffer()

void ast_yy_delete_buffer	(	YY_BUFFER_STATE	b,
		yyscan_t	yyscanner
	)

Destroy the buffer.

Parameters

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

Definition at line 1739 of file ast_expr2f.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 )
        ast_yyfree((void *) b->yy_ch_buf ,yyscanner );
 
    ast_yyfree((void *) b ,yyscanner );
}

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

Referenced by ast_yylex_destroy(), and ast_yypop_buffer_state().

ast_yy_flush_buffer()

void ast_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 1792 of file ast_expr2f.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 )
        ast_yy_load_buffer_state(yyscanner );
}

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

Referenced by ast_yy_init_buffer().

ast_yy_init_buffer()

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

static

Definition at line 1763 of file ast_expr2f.c.

{
    int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    ast_yy_flush_buffer(b ,yyscanner);
 
    b->yy_input_file = file;
    b->yy_fill_buffer = 1;
 
    /* If b is the current buffer, then ast_yy_init_buffer was _probably_
     * called from ast_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 ast_yy_flush_buffer(), b, errno, isatty(), YY_CURRENT_BUFFER, and yyg.

Referenced by ast_yy_create_buffer(), and ast_yyrestart().

ast_yy_load_buffer_state()

static void ast_yy_load_buffer_state ( yyscan_t  yyscanner )

static

Definition at line 1696 of file ast_expr2f.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 ast_yy_flush_buffer(), ast_yy_switch_to_buffer(), ast_yypop_buffer_state(), ast_yypush_buffer_state(), ast_yyrestart(), and if().

ast_yy_scan_buffer()

YY_BUFFER_STATE ast_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 1923 of file ast_expr2f.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) ast_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in ast_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;
 
    ast_yy_switch_to_buffer(b ,yyscanner );
 
    return b;
}

References ast_yy_switch_to_buffer(), ast_yyalloc(), b, YY_BUFFER_NEW, YY_END_OF_BUFFER_CHAR, and YY_FATAL_ERROR.

Referenced by ast_yy_scan_bytes().

ast_yy_scan_bytes()

YY_BUFFER_STATE ast_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 ast_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 1973 of file ast_expr2f.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 *) ast_yyalloc(n ,yyscanner );
    if ( ! buf )
        YY_FATAL_ERROR( "out of dynamic memory in ast_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 = ast_yy_scan_buffer(buf,n ,yyscanner);
    if ( ! b )
        YY_FATAL_ERROR( "bad buffer in ast_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 ast_yy_scan_buffer(), ast_yyalloc(), b, buf, YY_END_OF_BUFFER_CHAR, and YY_FATAL_ERROR.

Referenced by ast_yy_scan_string().

ast_yy_scan_string()

YY_BUFFER_STATE ast_yy_scan_string	(	yyconst char *	yystr,
		yyscan_t	yyscanner
	)

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

Definition at line 1960 of file ast_expr2f.c.

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

References ast_yy_scan_bytes().

Referenced by ast_expr(), and ast_str_expr().

ast_yy_switch_to_buffer()

void ast_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 1664 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    /* TODO. We should be able to replace this entire function body
     * with
     *      ast_yypop_buffer_state();
     *      ast_yypush_buffer_state(new_buffer);
     */
    ast_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;
    ast_yy_load_buffer_state(yyscanner );
 
    /* We don't actually know whether we did this switch during
     * EOF (ast_yywrap()) processing, but the only time this flag
     * is looked at is after ast_yywrap() is called, so it's safe
     * to go ahead and always set it.
     */
    yyg->yy_did_buffer_switch_on_eof = 1;
}

References ast_yy_load_buffer_state(), ast_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 ast_yy_scan_buffer().

ast_yyalloc()

void * ast_yyalloc	(	yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 2351 of file ast_expr2f.c.

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

References malloc().

Referenced by ast_yy_create_buffer(), ast_yy_scan_buffer(), ast_yy_scan_bytes(), ast_yyensure_buffer_stack(), ast_yylex_init(), and ast_yylex_init_extra().

ast_yyensure_buffer_stack()

static void ast_yyensure_buffer_stack ( yyscan_t  yyscanner )

static

Definition at line 1873 of file ast_expr2f.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**)ast_yyalloc
                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                , yyscanner);
        if ( ! yyg->yy_buffer_stack )
            YY_FATAL_ERROR( "out of dynamic memory in ast_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**)ast_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 ast_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 ast_yyalloc(), ast_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 ast_yy_switch_to_buffer(), ast_yypush_buffer_state(), ast_yyrestart(), and if().

ast_yyerror() [1/2]

int ast_yyerror	(	const char *	,
		YYLTYPE *	,
		struct parse_io *
	)

ast_yyerror() [2/2]

int ast_yyerror	(	const char *	s,
		yyltype *	loc,
		struct parse_io *	parseio
	)

Definition at line 2572 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)(parseio->scanner);
    char spacebuf[8000]; /* best safe than sorry */
    int i=0;
    char *s2 = expr2_token_subst(s);
    spacebuf[0] = 0;
 
    for (i = 0; i < (int)(yytext - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf); i++) {
        spacebuf[i] = ' ';
    }
    /* uh... assuming yyg is defined, then I can use the yycolumn macro,
    which is the same thing as... get this:
    yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]->yy_bs_column
    I was tempted to just use yy_buf_pos in the STATE, but..., well:
    a. the yy_buf_pos is the current position in the buffer, which
        may not relate to the entire string/buffer because of the
        buffering.
    b. but, analysis of the situation is that when you use the
        ast_yy_scan_string func, it creates a single buffer the size of
        string, so the two would be the same...
        so, in the end, the yycolumn macro is available, shorter, therefore easier. */
 
    spacebuf[i++] = '^';
    spacebuf[i] = 0;
 
#ifdef STANDALONE3
    /* easier to read in the standalone version */
    printf("ast_yyerror(): %s syntax error: %s; Input:\n%s\n%s\n",
            (extra_error_message_supplied ? extra_error_message : ""), s2, parseio->string, spacebuf);
#else
    ast_log(LOG_WARNING,"ast_yyerror(): %s syntax error: %s; Input:\n%s\n%s\n",
            (extra_error_message_supplied ? extra_error_message : ""), s2, parseio->string, spacebuf);
#endif
#ifndef STANDALONE
    ast_log(LOG_WARNING,"If you have questions, please refer to https://docs.asterisk.org/Configuration/Dialplan/Variables/Channel-Variables/\n");
#endif
    free(s2);
    return(0);
}

References ast_log, expr2_token_subst(), extra_error_message, extra_error_message_supplied, free(), LOG_WARNING, parse_io::scanner, parse_io::string, YY_CURRENT_BUFFER_LVALUE, yyg, and yytext.

ast_yyfree()

void ast_yyfree	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 2383 of file ast_expr2f.c.

{
    /* the normal generated ast_yyfree func just frees its first arg;
     this get complaints on some systems, as sometimes this
     arg is a nil ptr! It's usually not fatal, but is irritating! */
    free( (char *) ptr );
}

References free().

Referenced by ast_yy_delete_buffer(), and ast_yylex_destroy().

ast_yyget_column()

int ast_yyget_column

(

yyscan_t

yyscanner

)

Get the current column number.

Parameters

yyscanner

The scanner object.

Definition at line 2057 of file ast_expr2f.c.

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

References YY_CURRENT_BUFFER, yycolumn, and yyg.

ast_yyget_debug()

int ast_yyget_debug

(

yyscan_t

yyscanner

)

Definition at line 2162 of file ast_expr2f.c.

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

References yy_flex_debug, and yyg.

ast_yyget_extra()

YY_EXTRA_TYPE ast_yyget_extra

(

yyscan_t

yyscanner

)

Get the user-defined data for this scanner.

Parameters

yyscanner

The scanner object.

Definition at line 2035 of file ast_expr2f.c.

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

References yyextra, and yyg.

ast_yyget_in()

FILE * ast_yyget_in

(

yyscan_t

yyscanner

)

Get the input stream.

Parameters

yyscanner

The scanner object.

Definition at line 2070 of file ast_expr2f.c.

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

References yyg, and yyin.

ast_yyget_leng()

int ast_yyget_leng

(

yyscan_t

yyscanner

)

Get the length of the current token.

Parameters

yyscanner

The scanner object.

Definition at line 2088 of file ast_expr2f.c.

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

References yyg, and yyleng.

ast_yyget_lineno()

int ast_yyget_lineno

(

yyscan_t

yyscanner

)

Get the current line number.

Parameters

yyscanner

The scanner object.

Definition at line 2044 of file ast_expr2f.c.

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

References YY_CURRENT_BUFFER, yyg, and yylineno.

ast_yyget_lloc()

YYLTYPE * ast_yyget_lloc

(

yyscan_t

yyscanner

)

Definition at line 2188 of file ast_expr2f.c.

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

References yyg, and yylloc.

ast_yyget_lval()

YYSTYPE * ast_yyget_lval

(

yyscan_t

yyscanner

)

Definition at line 2176 of file ast_expr2f.c.

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

References yyg, and yylval.

ast_yyget_out()

FILE * ast_yyget_out

(

yyscan_t

yyscanner

)

Get the output stream.

Parameters

yyscanner

The scanner object.

Definition at line 2079 of file ast_expr2f.c.

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

References yyg, and yyout.

ast_yyget_text()

char * ast_yyget_text

(

yyscan_t

yyscanner

)

Get the current token.

Parameters

yyscanner

The scanner object.

Definition at line 2098 of file ast_expr2f.c.

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

References yyg, and yytext.

ast_yylex()

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

extern

ast_yylex_destroy()

int ast_yylex_destroy

(

yyscan_t

yyscanner

)

Definition at line 2298 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    /* Pop the buffer stack, destroying each element. */
    while(YY_CURRENT_BUFFER){
        ast_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
        YY_CURRENT_BUFFER_LVALUE = NULL;
        ast_yypop_buffer_state(yyscanner);
    }
 
    /* Destroy the stack itself. */
    ast_yyfree(yyg->yy_buffer_stack ,yyscanner);
    yyg->yy_buffer_stack = NULL;
 
    /* Destroy the start condition stack. */
        ast_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
     * ast_yylex() is called, initialization will occur. */
    yy_init_globals( yyscanner);
 
    /* Destroy the main struct (reentrant only). */
    ast_yyfree ( yyscanner , yyscanner );
    yyscanner = NULL;
    return 0;
}

References ast_yy_delete_buffer(), ast_yyfree(), ast_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 ast_expr(), and ast_str_expr().

ast_yylex_init()

int ast_yylex_init

(

yyscan_t *

scanner

)

Definition at line 2207 of file ast_expr2f.c.

{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }
 
    *ptr_yy_globals = (yyscan_t) ast_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 ast_yyalloc(), errno, NULL, and yy_init_globals().

Referenced by ast_expr(), and ast_str_expr().

ast_yylex_init_extra()

int ast_yylex_init_extra	(	YY_EXTRA_TYPE	user_defined,
		yyscan_t *	scanner
	)

Definition at line 2236 of file ast_expr2f.c.

{
    struct yyguts_t dummy_yyguts;
 
    ast_yyset_extra (yy_user_defined, &dummy_yyguts);
 
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }
    
    *ptr_yy_globals = (yyscan_t) ast_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));
    
    ast_yyset_extra (yy_user_defined, *ptr_yy_globals);
    
    return yy_init_globals ( *ptr_yy_globals );
}

References ast_yyalloc(), ast_yyset_extra(), errno, NULL, and yy_init_globals().

ast_yyparse()

int ast_yyparse

(

void *

)

Referenced by ast_expr(), and ast_str_expr().

ast_yypop_buffer_state()

void ast_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 1853 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    if (!YY_CURRENT_BUFFER)
        return;
 
    ast_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) {
        ast_yy_load_buffer_state(yyscanner );
        yyg->yy_did_buffer_switch_on_eof = 1;
    }
}

References ast_yy_delete_buffer(), ast_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 ast_yylex_destroy().

ast_yypush_buffer_state()

void ast_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 1822 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    if (new_buffer == NULL)
        return;
 
    ast_yyensure_buffer_stack(yyscanner);
 
    /* This block is copied from ast_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 ast_yy_switch_to_buffer. */
    ast_yy_load_buffer_state(yyscanner );
    yyg->yy_did_buffer_switch_on_eof = 1;
}

References ast_yy_load_buffer_state(), ast_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.

ast_yyrealloc()

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

Definition at line 2356 of file ast_expr2f.c.

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

Referenced by ast_yyensure_buffer_stack(), and yy_get_next_buffer().

ast_yyrestart()

void ast_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 1646 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
    if ( ! YY_CURRENT_BUFFER ){
        ast_yyensure_buffer_stack (yyscanner);
        YY_CURRENT_BUFFER_LVALUE =
            ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
    }
 
    ast_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
    ast_yy_load_buffer_state(yyscanner );
}

References ast_yy_create_buffer(), ast_yy_init_buffer(), ast_yy_load_buffer_state(), ast_yyensure_buffer_stack(), YY_BUF_SIZE, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyg, and yyin.

Referenced by input(), and yy_get_next_buffer().

ast_yyset_column()

void ast_yyset_column	(	int	column_no,
		yyscan_t	yyscanner
	)

Set the current column.

Parameters

line_number
yyscanner	The scanner object.

Definition at line 2133 of file ast_expr2f.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( "ast_yyset_column called with no buffer" , yyscanner); 
    
    yycolumn = column_no;
}

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

ast_yyset_debug()

void ast_yyset_debug	(	int	debug_flag,
		yyscan_t	yyscanner
	)

Definition at line 2168 of file ast_expr2f.c.

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

References yy_flex_debug, and yyg.

ast_yyset_extra()

void ast_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 2108 of file ast_expr2f.c.

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

References yyextra, and yyg.

Referenced by ast_yylex_init_extra().

ast_yyset_in()

void ast_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

ast_yy_switch_to_buffer

Definition at line 2150 of file ast_expr2f.c.

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

References yyg, and yyin.

ast_yyset_lineno()

void ast_yyset_lineno	(	int	line_number,
		yyscan_t	yyscanner
	)

Set the current line number.

Parameters

line_number
yyscanner	The scanner object.

Definition at line 2118 of file ast_expr2f.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( "ast_yyset_lineno called with no buffer" , yyscanner); 
    
    yylineno = line_number;
}

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

ast_yyset_lloc()

void ast_yyset_lloc	(	YYLTYPE *	yylloc_param,
		yyscan_t	yyscanner
	)

Definition at line 2194 of file ast_expr2f.c.

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

References yyg, and yylloc.

ast_yyset_lval()

void ast_yyset_lval	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 2182 of file ast_expr2f.c.

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

References yyg, and yylval.

ast_yyset_out()

void ast_yyset_out	(	FILE *	out_str,
		yyscan_t	yyscanner
	)

Definition at line 2156 of file ast_expr2f.c.

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

References yyg, and yyout.

expr2_token_subst()

static char * expr2_token_subst ( const char *  mess )

static

Definition at line 2528 of file ast_expr2f.c.

{
    /* calc a length, malloc, fill, and return; yyerror had better free it! */
    int len=0,i;
    const char *p;
    char *res, *s;
    const char *t;
    int expr2_token_equivs_entries = sizeof(expr2_token_equivs1)/sizeof(char*);
 
    for (p=mess; *p; p++) {
        for (i=0; i<expr2_token_equivs_entries; i++) {
            if ( strncmp(p,expr2_token_equivs1[i],strlen(expr2_token_equivs1[i])) == 0 )
            {
                len+=strlen(expr2_token_equivs2[i])+2;
                p += strlen(expr2_token_equivs1[i])-1;
                break;
            }
        }
        len++;
    }
    res = (char*)malloc(len+1);
    res[0] = 0;
    s = res;
    for (p=mess; *p;) {
        int found = 0;
        for (i=0; i<expr2_token_equivs_entries; i++) {
            if ( strncmp(p,expr2_token_equivs1[i],strlen(expr2_token_equivs1[i])) == 0 ) {
                *s++ = '\'';
                for (t=expr2_token_equivs2[i]; *t;) {
                    *s++ = *t++;
                }
                *s++ = '\'';
                p += strlen(expr2_token_equivs1[i]);
                found = 1;
                break;
            }
        }
        if( !found )
            *s++ = *p++;
    }
    *s++ = 0;
    return res;
}

References expr2_token_equivs1, expr2_token_equivs2, len(), and malloc().

Referenced by ast_yyerror().

if()

if

(

!yyg->

yy_init

)

Definition at line 854 of file ast_expr2f.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 ) {
            ast_yyensure_buffer_stack (yyscanner);
            YY_CURRENT_BUFFER_LVALUE =
                ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
        }
 
        ast_yy_load_buffer_state(yyscanner );
        }

References ast_yy_create_buffer(), ast_yy_load_buffer_state(), ast_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.

Referenced by ast_format_cmp(), ast_sorcery_wizard_unregister(), and dundi_send().

input()

static int input ( yyscan_t  yyscanner )

static

Definition at line 1570 of file ast_expr2f.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. */
                    ast_yyrestart(yyin ,yyscanner);
 
                    /*FALLTHROUGH*/
 
                case EOB_ACT_END_OF_FILE:
                    {
                    if ( ast_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 ast_yyrestart(), ast_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(), and yyunput().

isatty()

int isatty ( int  )

extern

Referenced by ast_get_termcols(), ast_hide_password(), and ast_yy_init_buffer().

while()

while

(

1

)

Definition at line 880 of file ast_expr2f.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 >= 63 )
                    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 != 62 );
        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 130 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_OR;}
    YY_BREAK
case 2:
YY_RULE_SETUP
#line 131 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_AND;}
    YY_BREAK
case 3:
YY_RULE_SETUP
#line 132 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_EQ;}
    YY_BREAK
case 4:
YY_RULE_SETUP
#line 133 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_OR;}
    YY_BREAK
case 5:
YY_RULE_SETUP
#line 134 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_AND;}
    YY_BREAK
case 6:
YY_RULE_SETUP
#line 135 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_EQ;}
    YY_BREAK
case 7:
YY_RULE_SETUP
#line 136 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_EQTILDE;}
    YY_BREAK
case 8:
YY_RULE_SETUP
#line 137 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_TILDETILDE;}
    YY_BREAK
case 9:
YY_RULE_SETUP
#line 138 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_GT;}
    YY_BREAK
case 10:
YY_RULE_SETUP
#line 139 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_LT;}
    YY_BREAK
case 11:
YY_RULE_SETUP
#line 140 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_GE;}
    YY_BREAK
case 12:
YY_RULE_SETUP
#line 141 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_LE;}
    YY_BREAK
case 13:
YY_RULE_SETUP
#line 142 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_NE;}
    YY_BREAK
case 14:
YY_RULE_SETUP
#line 143 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_PLUS;}
    YY_BREAK
case 15:
YY_RULE_SETUP
#line 144 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COMMA;}
    YY_BREAK
case 16:
YY_RULE_SETUP
#line 145 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_MINUS;}
    YY_BREAK
case 17:
YY_RULE_SETUP
#line 146 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_MULT;}
    YY_BREAK
case 18:
YY_RULE_SETUP
#line 147 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_DIV;}
    YY_BREAK
case 19:
YY_RULE_SETUP
#line 148 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_MOD;}
    YY_BREAK
case 20:
YY_RULE_SETUP
#line 149 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COND;}
    YY_BREAK
case 21:
YY_RULE_SETUP
#line 150 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COMPL;}
    YY_BREAK
case 22:
YY_RULE_SETUP
#line 151 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COLON;}
    YY_BREAK
case 23:
YY_RULE_SETUP
#line 152 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COLONCOLON;}
    YY_BREAK
case 24:
YY_RULE_SETUP
#line 153 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_LP;}
    YY_BREAK
case 25:
YY_RULE_SETUP
#line 154 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_RP;}
    YY_BREAK
case 26:
YY_RULE_SETUP
#line 155 "ast_expr2.fl"
{
        /* gather the contents of ${} expressions, with trailing stuff,
         * into a single TOKEN.
         * They are much more complex now than they used to be
         */
        curlycount = 0;
        BEGIN(var);
        yymore();
    }
    YY_BREAK
case 27:
YY_RULE_SETUP
#line 165 "ast_expr2.fl"
{}
    YY_BREAK
case 28:
/* rule 28 can match eol */
YY_RULE_SETUP
#line 166 "ast_expr2.fl"
{SET_COLUMNS; SET_STRING; return TOKEN;}
    YY_BREAK
case 29:
/* rule 29 can match eol */
YY_RULE_SETUP
#line 168 "ast_expr2.fl"
{/* what to do with eol */}
    YY_BREAK
case 30:
YY_RULE_SETUP
#line 169 "ast_expr2.fl"
{
        SET_COLUMNS;
        /* the original behavior of the expression parser was
         * to bring in numbers as a numeric string
         */
        SET_NUMERIC_STRING;
        return TOKEN;
    }
    YY_BREAK
case 31:
/* rule 31 can match eol */
YY_RULE_SETUP
#line 178 "ast_expr2.fl"
{
        SET_COLUMNS;
        SET_STRING;
        return TOKEN;
    }
    YY_BREAK
case 32:
/* rule 32 can match eol */
YY_RULE_SETUP
#line 184 "ast_expr2.fl"
{
        curlycount = 0;
        BEGIN(var);
        yymore();
    }
    YY_BREAK
case 33:
/* rule 33 can match eol */
YY_RULE_SETUP
#line 190 "ast_expr2.fl"
{
        curlycount--;
        if (curlycount < 0) {
            BEGIN(trail);
            yymore();
        } else {
            yymore();
        }
    }
    YY_BREAK
case 34:
/* rule 34 can match eol */
YY_RULE_SETUP
#line 200 "ast_expr2.fl"
{
        curlycount++;
        yymore();
    }
    YY_BREAK
case 35:
YY_RULE_SETUP
#line 206 "ast_expr2.fl"
{
        BEGIN(0);
        SET_COLUMNS;
        SET_STRING;
        return TOKEN;
    }
    YY_BREAK
case 36:
YY_RULE_SETUP
#line 213 "ast_expr2.fl"
{
        curlycount = 0;
        BEGIN(var);
        yymore();
    }
    YY_BREAK
case 37:
/* rule 37 can match eol */
YY_RULE_SETUP
#line 219 "ast_expr2.fl"
{
        char c = yytext[yyleng-1];
        BEGIN(0);
        unput(c);
        SET_COLUMNS;
        SET_STRING;
        return TOKEN;
    }
    YY_BREAK
case YY_STATE_EOF(trail):
#line 228 "ast_expr2.fl"
{
        BEGIN(0);
        SET_COLUMNS;
        SET_STRING;
        return TOKEN;
        /*actually, if an expr is only a variable ref, this could happen a LOT */
    }
    YY_BREAK
case 38:
YY_RULE_SETUP
#line 236 "ast_expr2.fl"
ECHO;
    YY_BREAK
#line 1192 "ast_expr2f.c"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(var):
    yyterminate();
 
    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
             * ast_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 ( ast_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 ast_yywrap, BEGIN, c, curlycount, ECHO, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, INITIAL, SET_COLUMNS, SET_NUMERIC_STRING, SET_STRING, TOK_AND, TOK_COLON, TOK_COLONCOLON, TOK_COMMA, TOK_COMPL, TOK_COND, TOK_DIV, TOK_EQ, TOK_EQTILDE, TOK_GE, TOK_GT, TOK_LE, TOK_LP, TOK_LT, TOK_MINUS, TOK_MOD, TOK_MULT, TOK_NE, TOK_OR, TOK_PLUS, TOK_RP, TOK_TILDETILDE, TOKEN, trail, unput, var, 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_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, YY_START, yyguts_t::yy_start, YY_STATE_EOF, yy_try_NUL_trans(), yyg, yyin, yyleng, yymore, yyterminate, and yytext.

yy_fatal_error() [1/2]

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

static

Definition at line 2007 of file ast_expr2f.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 ast_yyset_column(), and ast_yyset_lineno().

yy_get_next_buffer()

static int yy_get_next_buffer ( yyscan_t  yyscanner )

static

Definition at line 1336 of file ast_expr2f.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. */
                    ast_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;
            ast_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 *) ast_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 ast_yyrealloc(), ast_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 1471 of file ast_expr2f.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 >= 63 )
                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 2264 of file ast_expr2f.c.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from ast_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
     * ast_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 ast_yylex_destroy(), ast_yylex_init(), and ast_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 1504 of file ast_expr2f.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 >= 63 )
            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 == 62);
 
    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

References input().

yyunput() [2/2]

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

static

Definition at line 1528 of file ast_expr2f.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

curlycount

int curlycount = 0

static

Definition at line 599 of file ast_expr2f.c.

Referenced by while().

expr2_token_equivs1

const char* const expr2_token_equivs1[]

static

Definition at line 2475 of file ast_expr2f.c.

{
    "TOKEN",
    "TOK_COND",
    "TOK_COLONCOLON",
    "TOK_OR",
    "TOK_AND",
    "TOK_EQ",
    "TOK_GT",
    "TOK_LT",
    "TOK_GE",
    "TOK_LE",
    "TOK_NE",
    "TOK_PLUS",
    "TOK_MINUS",
    "TOK_MULT",
    "TOK_DIV",
    "TOK_MOD",
    "TOK_COMPL",
    "TOK_COLON",
    "TOK_EQTILDE",
    "TOK_COMMA",
    "TOK_RP",
    "TOK_LP"
};

Referenced by expr2_token_subst().

expr2_token_equivs2

const char* const expr2_token_equivs2[]

static

Definition at line 2501 of file ast_expr2f.c.

{
    "<token>",
    "?",
    "::",
    "|",
    "&",
    "=",
    ">",
    "<",
    ">=",
    "<=",
    "!=",
    "+",
    "-",
    "*",
    "/",
    "%",
    "!",
    ":",
    "=~",
    ",",
    ")",
    "("
};

Referenced by expr2_token_subst().

extra_error_message

char extra_error_message[4095]

Definition at line 2458 of file ast_expr2f.c.

Referenced by ast_expr_clear_extra_error_info(), ast_expr_register_extra_error_info(), and ast_yyerror().

extra_error_message_supplied

int extra_error_message_supplied = 0

Definition at line 2459 of file ast_expr2f.c.

Referenced by ast_expr_clear_extra_error_info(), ast_expr_register_extra_error_info(), ast_yyerror(), op_div(), op_minus(), op_negate(), op_plus(), op_rem(), and op_times().

yy_accept

yyconst flex_int16_t yy_accept[63]

static

Definition at line 365 of file ast_expr2f.c.

    {   0,
        0,    0,    0,    0,   35,   35,   39,   38,   27,   29,
       21,   38,   31,   38,   19,    2,   24,   25,   17,   14,
       15,   16,   18,   30,   22,   10,    3,    9,   20,    1,
       38,   38,   34,   33,   35,   37,   37,   13,    0,   28,
       31,    0,   26,    5,   31,   30,   23,   12,    6,    7,
       11,    4,    8,    0,   34,   33,   35,    0,   36,   32,
       30,    0
    } ;

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

yy_act

register int yy_act

Definition at line 842 of file ast_expr2f.c.

Referenced by while().

yy_base

yyconst flex_int16_t yy_base[70]

static

Definition at line 415 of file ast_expr2f.c.

    {   0,
        0,    0,    5,    6,   32,   60,   73,  130,  130,  130,
       51,   66,   63,   45,  130,   59,  130,  130,  130,  130,
      130,  130,  130,   83,   45,   42,   13,   41,  130,   32,
       28,   17,  130,  130,   47,  130,   29,  130,   47,  130,
       44,   25,  130,  130,   29,    0,  130,  130,  130,  130,
      130,  130,  130,   18,  130,  130,   38,   12,  130,  130,
        0,  130,  111,  114,  117,   32,  120,  123,  126
    } ;

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

yy_bp

register char * yy_bp

Definition at line 841 of file ast_expr2f.c.

Referenced by while(), and yyunput().

yy_chk

yyconst flex_int16_t yy_chk[159]

static

Definition at line 458 of file ast_expr2f.c.

    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    3,    4,
        3,    4,    5,   27,   66,   58,    5,    5,    5,   27,
       32,   54,   32,   54,   57,    5,   45,    5,   42,    5,
       41,   39,   37,   35,   31,    5,   30,    5,    5,    5,
        6,   28,   26,   25,    6,    6,    6,   16,   14,   13,
       12,   11,    7,    6,    0,    6,    0,    6,    0,    0,
        0,    0,    0,    6,    0,    6,    6,    6,   24,   24,
        0,    0,    0,    0,    0,    0,    0,    0,   24,    0,
 
       24,    0,    0,    0,    0,    0,    0,    0,    0,    0,
       24,   63,   63,   63,   64,   64,   64,   65,   65,   65,
       67,   67,   67,   68,   68,   68,   69,    0,   69,   62,
       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
       62,   62,   62,   62,   62,   62,   62,   62
    } ;

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

yy_cp

register char* yy_cp

Definition at line 841 of file ast_expr2f.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 838 of file ast_expr2f.c.

yy_def

yyconst flex_int16_t yy_def[70]

static

Definition at line 426 of file ast_expr2f.c.

    {   0,
       62,    1,   63,   63,   64,   64,   62,   62,   62,   62,
       62,   65,   66,   67,   62,   62,   62,   62,   62,   62,
       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
       62,   68,   62,   62,   69,   62,   62,   62,   65,   62,
       66,   67,   62,   62,   41,   24,   62,   62,   62,   62,
       62,   62,   62,   68,   62,   62,   69,   62,   62,   62,
       45,    0,   62,   62,   62,   62,   62,   62,   62
    } ;

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 376 of file ast_expr2f.c.

    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    4,    5,    6,    7,    8,    9,    6,   10,
       11,   12,   13,   14,   15,   16,   17,   18,   18,   18,
       18,   18,   18,   18,   18,   18,   18,   19,    6,   20,
       21,   22,   23,    6,    6,    6,    6,    6,    6,    6,
        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
        1,    6,    1,    6,    6,    1,    6,    6,    6,    6,
 
        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
        6,    6,   24,   25,   26,   27,    1,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
 
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       28,   28,   28,   28,   28
    } ;

Referenced by while(), and yy_get_previous_state().

yy_meta

yyconst flex_int32_t yy_meta[29]

static

Definition at line 408 of file ast_expr2f.c.

    {   0,
        1,    2,    2,    2,    1,    3,    3,    2,    2,    2,
        2,    2,    2,    1,    2,    3,    2,    3,    2,    2,
        2,    2,    2,    1,    2,    1,    1,    3
    } ;

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

yy_nxt

yyconst flex_int16_t yy_nxt[159]

static

Definition at line 437 of file ast_expr2f.c.

    {   0,
        8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
       18,   19,   20,   21,   22,   13,   23,   24,   25,   26,
       27,   28,   29,    8,   30,    8,   31,   13,   33,   33,
       34,   34,   35,   49,   41,   59,   35,   35,   37,   50,
       55,   55,   56,   56,   58,   35,   61,   35,   60,   35,
       42,   40,   59,   58,   53,   35,   52,   35,   35,   35,
       35,   51,   48,   47,   35,   35,   37,   44,   43,   42,
       40,   38,   62,   35,   62,   35,   62,   35,   62,   62,
       62,   62,   62,   35,   62,   35,   35,   35,   41,   42,
       62,   62,   62,   62,   62,   62,   62,   62,   45,   62,
 
       46,   62,   62,   62,   62,   62,   62,   62,   62,   62,
       41,   32,   32,   32,   36,   36,   36,   39,   39,   39,
       41,   41,   41,   54,   54,   54,   57,   62,   57,    7,
       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
       62,   62,   62,   62,   62,   62,   62,   62
    } ;

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

yyg

struct yyguts_t* yyg = (struct yyguts_t*)yyscanner

Definition at line 843 of file ast_expr2f.c.

Referenced by ast_yy_delete_buffer(), ast_yy_flush_buffer(), ast_yy_init_buffer(), ast_yy_load_buffer_state(), ast_yy_switch_to_buffer(), ast_yyensure_buffer_stack(), ast_yyerror(), ast_yyget_column(), ast_yyget_debug(), ast_yyget_extra(), ast_yyget_in(), ast_yyget_leng(), ast_yyget_lineno(), ast_yyget_lloc(), ast_yyget_lval(), ast_yyget_out(), ast_yyget_text(), ast_yylex_destroy(), ast_yypop_buffer_state(), ast_yypush_buffer_state(), ast_yyrestart(), ast_yyset_column(), ast_yyset_debug(), ast_yyset_extra(), ast_yyset_in(), ast_yyset_lineno(), ast_yyset_lloc(), ast_yyset_lval(), ast_yyset_out(), if(), input(), while(), yy_get_next_buffer(), yy_get_previous_state(), yy_init_globals(), yy_try_NUL_trans(), and yyunput().

yylloc

yylloc = yylloc_param

Definition at line 852 of file ast_expr2f.c.

yylval

yylval = yylval_param

Definition at line 850 of file ast_expr2f.c.