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_BETA
#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, 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. More...
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. More...
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 340 of file ast_expr2f.c.

Referenced by input(), and while().

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

Referenced by while().

ECHO

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

Definition at line 563 of file ast_expr2f.c.

Referenced by ast_hide_password(), ast_restore_tty(), and while().

EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 185 of file ast_expr2f.c.

Referenced by input(), while(), and yy_get_next_buffer().

EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 186 of file ast_expr2f.c.

Referenced by input(), while(), and yy_get_next_buffer().

EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 187 of file ast_expr2f.c.

Referenced by input(), while(), and yy_get_next_buffer().

FLEX_BETA

#define FLEX_BETA

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

FP___PRINTF

#define FP___PRINTF   "%.16g"

Definition at line 535 of file ast_expr2f.c.

Referenced by ast_expr(), and ast_str_expr().

FP___STRTOD

#define FP___STRTOD   strtod

Definition at line 537 of file ast_expr2f.c.

FP___TYPE

#define FP___TYPE   double

Definition at line 538 of file ast_expr2f.c.

INITIAL

#define INITIAL   0

Definition at line 613 of file ast_expr2f.c.

Referenced by while().

INT16_MAX

#define INT16_MAX   (32767)

Definition at line 75 of file ast_expr2f.c.

INT16_MIN

#define INT16_MIN   (-32767-1)

Definition at line 66 of file ast_expr2f.c.

INT32_MAX

#define INT32_MAX   (2147483647)

Definition at line 78 of file ast_expr2f.c.

Referenced by ast_parse_arg().

INT32_MIN

#define INT32_MIN   (-2147483647-1)

Definition at line 69 of file ast_expr2f.c.

Referenced by ast_parse_arg().

INT8_MAX

#define INT8_MAX   (127)

Definition at line 72 of file ast_expr2f.c.

INT8_MIN

#define INT8_MIN   (-128)

Definition at line 63 of file ast_expr2f.c.

REJECT

#define REJECT   reject_used_but_not_detected

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

Referenced by while().

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

Referenced by while().

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

Referenced by while().

trail

#define trail   2

Definition at line 615 of file ast_expr2f.c.

Referenced by while().

UINT16_MAX

#define UINT16_MAX   (65535U)

Definition at line 84 of file ast_expr2f.c.

UINT32_MAX

#define UINT32_MAX   (4294967295U)

Definition at line 87 of file ast_expr2f.c.

Referenced by ast_parse_arg().

UINT8_MAX

#define UINT8_MAX   (255U)

Definition at line 81 of file ast_expr2f.c.

unput

#define unput

(

c

)

yyunput( c, yyg->yytext_ptr , yyscanner )

Definition at line 205 of file ast_expr2f.c.

Referenced by while().

var

#define var   1

Definition at line 614 of file ast_expr2f.c.

Referenced by __init_manager(), _ast_var_assign(), acf_iaxvar_read(), acf_iaxvar_write(), acf_sprintf(), aco_process_category_options(), add_cfg_entry(), add_message_id(), add_rt_cfg_entry(), add_rt_multi_cfg_entry(), agent_login_channel_config(), aMYSQL_set(), app_control_set_channel_var(), append_channel_vars(), append_row_to_cfg(), append_variable(), apply_options(), apply_options_full(), array(), assign_and_insert(), ast_ari_callback(), ast_bridge_timelimit(), ast_category_inherit(), ast_cdr_serialize_variables(), ast_channel_get_vars(), ast_channeltype_list(), ast_config_text_file_save2(), ast_http_get_post_vars(), ast_iax2_new(), ast_json_channel_vars(), ast_manager_build_channel_state_string_prefix(), ast_phoneprov_provider_register(), AST_TEST_DEFINE(), ast_var_assign(), ast_var_find(), ast_var_list_clone(), ast_var_list_destroy(), ast_variables_reverse(), ast_xmldoc_load_documentation(), authenticate_reply(), build_calendar(), build_cfg(), chan_pjsip_new(), channel_get_external_vars(), channel_set_external_vars(), check_expiration_thread(), clearvar_prefix(), cli_realtime_load(), conf_exec(), conf_run(), config_function_read(), config_option_destroy(), console_cmd(), contact_to_var_list(), copy_plain_file(), copy_variables(), create_mwi_subscriptions(), crement_function_read(), fields_handler(), find_conf(), find_conf_realtime(), find_realtime(), find_user_realtime(), free_chanvar(), free_external_channelvars(), function_realtime_read(), function_realtime_readdestroy(), get_chan_by_ast_name(), get_defaults(), get_insecure_variable_from_config(), get_insecure_variable_from_sippeers(), global_read(), handle_aor(), handle_show_chanvar(), handle_showchan(), handle_updates(), handle_uri(), http_post_callback(), iax2_call(), iax_parse_ies(), inherit_category(), init_logger_chain(), ldap_loadentry(), ldap_table_config_add_attribute(), leave_queue(), load_aliases(), load_config(), load_moh_classes(), load_realtime_musiconhold(), load_users(), load_zonemessages(), local_ast_moh_start(), localized_config_text_file_save(), man_do_variable_value(), manager_sipnotify(), meetme_menu_admin_extended(), minivm_account_func_read(), misdn_hangup(), moh_parse_options(), move_variables(), my_connect_db(), my_load_module(), new_realtime_sqlite3_db(), odbc_load_module(), originate_exec(), osp_create_provider(), oss_request(), parse_config(), parse_cookies(), parse_variable_name(), pbx_builtin_serialize_variables(), pbx_substitute_variables_helper_full(), prep_email_sub_vars(), process_my_load_module(), process_text_line(), profile_destructor(), queue_function_queuegetchannel(), queue_function_queuewaitingcount(), realtime_curl(), realtime_directory(), realtime_ldap(), realtime_ldap_entry_to_var(), realtime_ldap_result_to_vars(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_mysql(), realtime_odbc(), realtime_peer(), realtime_peer_get_sippeer_helper(), realtime_pgsql(), realtime_user(), realtimefield_read(), register_realtime_peers_with_callbackextens(), reload_followme(), reload_module(), reload_single_queue(), rt_extend_conf(), rtp_reload(), set_var_to_str(), shared_read(), shared_variable_free(), shared_write(), shift_pop(), show_users_realtime(), sip_cli_notify(), sip_msg_send(), sipinfo_send(), sla_build_station(), sla_build_trunk(), socket_process_helper(), stasis_app_control_set_channel_var(), static_realtime_cb(), test_chan_variable(), test_config_validity(), tls_method_to_str(), transmit_invite(), unshift_push(), variable_named(), variables_count(), varshead_dtor(), vm_allocate_dh(), vm_change_password(), while(), write_password_to_file(), and xml_translate().

YY_AT_BOL

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 336 of file ast_expr2f.c.

YY_BREAK

#define YY_BREAK   break;

Definition at line 844 of file ast_expr2f.c.

Referenced by while().

YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 172 of file ast_expr2f.c.

Referenced by ast_yyrestart(), and if().

YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 272 of file ast_expr2f.c.

Referenced by yy_get_next_buffer().

YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 260 of file ast_expr2f.c.

Referenced by ast_yy_flush_buffer(), ast_yy_scan_buffer(), and while().

YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 261 of file ast_expr2f.c.

Referenced by while().

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

Referenced by ast_yy_delete_buffer(), ast_yy_flush_buffer(), ast_yy_init_buffer(), ast_yy_switch_to_buffer(), ast_yyget_column(), ast_yyget_lineno(), ast_yylex_destroy(), ast_yypop_buffer_state(), ast_yypush_buffer_state(), ast_yyrestart(), ast_yyset_column(), ast_yyset_lineno(), if(), and yy_get_next_buffer().

YY_CURRENT_BUFFER_LVALUE

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

Definition at line 290 of file ast_expr2f.c.

Referenced by ast_yy_delete_buffer(), ast_yy_load_buffer_state(), ast_yy_switch_to_buffer(), ast_yyerror(), ast_yylex_destroy(), ast_yypop_buffer_state(), ast_yypush_buffer_state(), ast_yyrestart(), if(), input(), while(), yy_get_next_buffer(), and yyunput().

YY_DECL

#define YY_DECL

Value:

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

Definition at line 831 of file ast_expr2f.c.

YY_DECL_IS_OURS

#define YY_DECL_IS_OURS   1

Definition at line 826 of file ast_expr2f.c.

YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Definition at line 357 of file ast_expr2f.c.

Referenced by while().

YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   39

Definition at line 366 of file ast_expr2f.c.

Referenced by while().

YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 161 of file ast_expr2f.c.

Referenced by ast_yy_flush_buffer(), ast_yy_scan_buffer(), ast_yy_scan_bytes(), input(), and yy_get_next_buffer().

YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 2018 of file ast_expr2f.c.

Referenced by yy_fatal_error().

YY_EXTRA_TYPE

#define YY_EXTRA_TYPE   void *

Definition at line 626 of file ast_expr2f.c.

YY_FATAL_ERROR

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg , yyscanner)

Definition at line 817 of file ast_expr2f.c.

Referenced by ast_yy_create_buffer(), ast_yy_scan_buffer(), ast_yy_scan_bytes(), ast_yyensure_buffer_stack(), while(), yy_get_next_buffer(), and yyunput().

yy_flex_debug

#define yy_flex_debug   yyg->yy_flex_debug_r

Definition at line 140 of file ast_expr2f.c.

Referenced by ast_yyget_debug(), and ast_yyset_debug().

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

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size
	)

Definition at line 770 of file ast_expr2f.c.

Referenced by yy_get_next_buffer().

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

YY_MORE_ADJ

#define YY_MORE_ADJ   yyg->yy_more_len

Definition at line 493 of file ast_expr2f.c.

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

yy_new_buffer

#define yy_new_buffer   ast_yy_create_buffer

Definition at line 314 of file ast_expr2f.c.

YY_NEW_FILE

#define YY_NEW_FILE   ast_yyrestart(yyin ,yyscanner )

Definition at line 159 of file ast_expr2f.c.

Referenced by input(), and while().

YY_NULL

#define YY_NULL   0

Definition at line 116 of file ast_expr2f.c.

YY_NUM_RULES

#define YY_NUM_RULES   38

Definition at line 365 of file ast_expr2f.c.

YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 754 of file ast_expr2f.c.

Referenced by yy_get_next_buffer().

YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 494 of file ast_expr2f.c.

Referenced by while().

YY_RULE_SETUP

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 847 of file ast_expr2f.c.

Referenced by while().

YY_SC_TO_UI

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 123 of file ast_expr2f.c.

Referenced by while(), and yy_get_previous_state().

yy_set_bol

#define yy_set_bol

(

at_bol

)

Definition at line 326 of file ast_expr2f.c.

yy_set_interactive

#define yy_set_interactive

(

is_interactive

)

Definition at line 316 of file ast_expr2f.c.

YY_SKIP_YYWRAP

#define YY_SKIP_YYWRAP

Definition at line 341 of file ast_expr2f.c.

YY_START

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

Definition at line 152 of file ast_expr2f.c.

Referenced by while().

YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

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

YY_STATE_EOF

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 156 of file ast_expr2f.c.

Referenced by while().

YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 213 of file ast_expr2f.c.

YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 181 of file ast_expr2f.c.

YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 127 of file ast_expr2f.c.

YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 208 of file ast_expr2f.c.

YY_USER_ACTION

#define YY_USER_ACTION

Definition at line 839 of file ast_expr2f.c.

yycolumn

#define yycolumn   (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)

Definition at line 139 of file ast_expr2f.c.

Referenced by ast_yyget_column(), and ast_yyset_column().

yyconst

#define yyconst

Definition at line 112 of file ast_expr2f.c.

Referenced by ast_yylex_destroy().

yyextra

#define yyextra   yyg->yyextra_r

Definition at line 135 of file ast_expr2f.c.

Referenced by ast_yyget_extra(), and ast_yyset_extra().

yyin

#define yyin   yyg->yyin_r

Definition at line 133 of file ast_expr2f.c.

Referenced by ast_yy_load_buffer_state(), ast_yyget_in(), ast_yyrestart(), ast_yyset_in(), if(), input(), while(), yy_get_next_buffer(), and yy_init_globals().

yyleng

#define yyleng   yyg->yyleng_r

Definition at line 136 of file ast_expr2f.c.

Referenced by ast_yyget_leng(), and while().

yyless [1/2]

#define yyless

(

n

)

Definition at line 2030 of file ast_expr2f.c.

yyless [2/2]

#define yyless

(

n

)

Definition at line 2030 of file ast_expr2f.c.

yylineno

#define yylineno   (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)

Definition at line 138 of file ast_expr2f.c.

Referenced by ast_yyget_lineno(), and ast_yyset_lineno().

yylloc

#define yylloc   yyg->yylloc_r

Definition at line 673 of file ast_expr2f.c.

Referenced by ast_yyget_lloc(), and ast_yyset_lloc().

yylval

#define yylval   yyg->yylval_r

Definition at line 671 of file ast_expr2f.c.

Referenced by ast_yyget_lval(), and ast_yyset_lval().

yymore

#define yymore

(

)

(yyg->yy_more_flag = 1)

Definition at line 492 of file ast_expr2f.c.

Referenced by while().

yyout

#define yyout   yyg->yyout_r

Definition at line 134 of file ast_expr2f.c.

Referenced by ast_yyget_out(), ast_yyset_out(), if(), and yy_init_globals().

YYSTATE

#define YYSTATE   YY_START

Definition at line 153 of file ast_expr2f.c.

YYTABLES_NAME

#define YYTABLES_NAME   "yytables"

Definition at line 2382 of file ast_expr2f.c.

yyterminate

#define yyterminate

(

)

return YY_NULL

Definition at line 807 of file ast_expr2f.c.

Referenced by while().

yytext

#define yytext   yyg->yytext_r

Definition at line 137 of file ast_expr2f.c.

Referenced by ast_yyerror(), ast_yyget_text(), and while().

yytext_ptr

#define yytext_ptr   yytext_r

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

YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 343 of file ast_expr2f.c.

yy_size_t

typedef size_t yy_size_t

Definition at line 209 of file ast_expr2f.c.

yy_state_type

typedef int yy_state_type

Definition at line 345 of file ast_expr2f.c.

yyscan_t

typedef void* yyscan_t

Definition at line 128 of file ast_expr2f.c.

Enumeration Type Documentation

valtype

enum valtype

Enumerator
AST_EXPR_number
AST_EXPR_numeric_string
AST_EXPR_string
AST_EXPR_number
AST_EXPR_numeric_string
AST_EXPR_string

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

References ast_copy_string(), AST_EXPR_number, ast_yy_scan_string(), ast_yylex_destroy(), ast_yylex_init(), ast_yyparse(), FP___PRINTF, free(), parse_io::scanner, and parse_io::string.

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

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

ast_expr_clear_extra_error_info()

void ast_expr_clear_extra_error_info

(

void

)

Definition at line 2483 of file ast_expr2f.c.

Referenced by check_pval_item().

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

ast_expr_register_extra_error_info()

void ast_expr_register_extra_error_info

(

char *

message

)

Definition at line 2477 of file ast_expr2f.c.

Referenced by check_pval_item().

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

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

References AST_EXPR_number, ast_str_set(), ast_str_strlen(), ast_yy_scan_string(), ast_yylex_destroy(), ast_yylex_init(), ast_yyparse(), FP___PRINTF, free(), parse_io::scanner, and parse_io::string.

Referenced by ast_str_substitute_variables_full().

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

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

References ast_yy_init_buffer(), ast_yyalloc(), b, yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, and yy_buffer_state::yy_is_our_buffer.

Referenced by ast_yyrestart(), and if().

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

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

References ast_yyfree(), isatty(), yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_buffer_state::yy_is_our_buffer.

Referenced by ast_yylex_destroy(), and ast_yypop_buffer_state().

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

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

References ast_yy_load_buffer_state(), yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, and yy_buffer_state::yy_n_chars.

Referenced by ast_yy_init_buffer().

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

ast_yy_init_buffer()

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

static

Definition at line 1777 of file ast_expr2f.c.

References ast_yy_flush_buffer(), errno, make_ari_stubs::file, isatty(), yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.

Referenced by ast_yy_create_buffer(), and ast_yyrestart().

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

ast_yy_load_buffer_state()

static void ast_yy_load_buffer_state ( yyscan_t  yyscanner )

static

Definition at line 1710 of file ast_expr2f.c.

References yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, 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().

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

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

References ast_yy_switch_to_buffer(), ast_yyalloc(), b, yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, yy_buffer_state::yy_buf_size, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, yy_buffer_state::yy_is_interactive, yy_buffer_state::yy_is_our_buffer, and yy_buffer_state::yy_n_chars.

Referenced by ast_yy_scan_bytes().

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

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

yybytes	the byte buffer to scan
_yybytes_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 1987 of file ast_expr2f.c.

References ast_yy_scan_buffer(), ast_yyalloc(), b, buf, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, and yy_buffer_state::yy_is_our_buffer.

Referenced by ast_yy_scan_string().

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

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

References ast_yy_scan_bytes().

Referenced by ast_expr(), and ast_str_expr().

{

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

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

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, and yyguts_t::yy_n_chars.

Referenced by ast_yy_scan_buffer().

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

ast_yyalloc()

void * ast_yyalloc	(	yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 2365 of file ast_expr2f.c.

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

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

ast_yyensure_buffer_stack()

static void ast_yyensure_buffer_stack ( yyscan_t  yyscanner )

static

Definition at line 1887 of file ast_expr2f.c.

References ast_yyalloc(), ast_yyrealloc(), yyguts_t::yy_buffer_stack, yyguts_t::yy_buffer_stack_max, yyguts_t::yy_buffer_stack_top, and YY_FATAL_ERROR.

Referenced by ast_yy_switch_to_buffer(), ast_yypush_buffer_state(), ast_yyrestart(), and if().

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

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

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

{
   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://wiki.asterisk.org/wiki/display/AST/Channel+Variables\n");
#endif
   free(s2);
   return(0);
}

ast_yyfree()

void ast_yyfree	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 2397 of file ast_expr2f.c.

References free().

Referenced by ast_yy_delete_buffer(), and ast_yylex_destroy().

{
    /* 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 );
}

ast_yyget_column()

int ast_yyget_column

(

yyscan_t

yyscanner

)

Get the current column number.

Parameters

yyscanner

The scanner object.

Definition at line 2071 of file ast_expr2f.c.

References YY_CURRENT_BUFFER, and yycolumn.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;

    return yycolumn;
}

ast_yyget_debug()

int ast_yyget_debug

(

yyscan_t

yyscanner

)

Definition at line 2176 of file ast_expr2f.c.

References yy_flex_debug.

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

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

References yyextra.

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

ast_yyget_in()

FILE * ast_yyget_in

(

yyscan_t

yyscanner

)

Get the input stream.

Parameters

yyscanner

The scanner object.

Definition at line 2084 of file ast_expr2f.c.

References yyin.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    return 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 2102 of file ast_expr2f.c.

References yyleng.

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

ast_yyget_lineno()

int ast_yyget_lineno

(

yyscan_t

yyscanner

)

Get the current line number.

Parameters

yyscanner

The scanner object.

Definition at line 2058 of file ast_expr2f.c.

References YY_CURRENT_BUFFER, and yylineno.

{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;

    return yylineno;
}

ast_yyget_lloc()

YYLTYPE * ast_yyget_lloc

(

yyscan_t

yyscanner

)

Definition at line 2202 of file ast_expr2f.c.

References yylloc.

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

ast_yyget_lval()

YYSTYPE * ast_yyget_lval

(

yyscan_t

yyscanner

)

Definition at line 2190 of file ast_expr2f.c.

References yylval.

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

ast_yyget_out()

FILE * ast_yyget_out

(

yyscan_t

yyscanner

)

Get the output stream.

Parameters

yyscanner

The scanner object.

Definition at line 2093 of file ast_expr2f.c.

References yyout.

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

ast_yyget_text()

char * ast_yyget_text

(

yyscan_t

yyscanner

)

Get the current token.

Parameters

yyscanner

The scanner object.

Definition at line 2112 of file ast_expr2f.c.

References yytext.

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

ast_yylex()

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

ast_yylex_destroy()

int ast_yylex_destroy

(

yyscan_t

yyscanner

)

Definition at line 2312 of file ast_expr2f.c.

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

Referenced by ast_expr(), and ast_str_expr().

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

ast_yylex_init()

int ast_yylex_init

(

yyscan_t *

scanner

)

Definition at line 2221 of file ast_expr2f.c.

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

Referenced by ast_expr(), and ast_str_expr().

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

ast_yylex_init_extra()

int ast_yylex_init_extra	(	YY_EXTRA_TYPE	user_defined,
		yyscan_t *	scanner
	)

Definition at line 2250 of file ast_expr2f.c.

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

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

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

References ast_yy_delete_buffer(), ast_yy_load_buffer_state(), NULL, yyguts_t::yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yyguts_t::yy_did_buffer_switch_on_eof.

Referenced by ast_yylex_destroy().

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

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

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, and yyguts_t::yy_n_chars.

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

ast_yyrealloc()

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

Definition at line 2370 of file ast_expr2f.c.

References realloc.

Referenced by ast_yyensure_buffer_stack(), and yy_get_next_buffer().

{
   /* 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 );
}

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

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, and yyin.

Referenced by input(), and yy_get_next_buffer().

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

ast_yyset_column()

void ast_yyset_column	(	int	column_no,
		yyscan_t	yyscanner
	)

Set the current column.

Parameters

column_no	line_number
yyscanner	The scanner object.

Definition at line 2147 of file ast_expr2f.c.

References YY_CURRENT_BUFFER, yy_fatal_error(), and yycolumn.

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

ast_yyset_debug()

void ast_yyset_debug	(	int	debug_flag,
		yyscan_t	yyscanner
	)

Definition at line 2182 of file ast_expr2f.c.

References yy_flex_debug.

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

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

References yyextra.

Referenced by ast_yylex_init_extra().

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

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

References yyin.

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

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

References YY_CURRENT_BUFFER, yy_fatal_error(), and yylineno.

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

ast_yyset_lloc()

void ast_yyset_lloc	(	YYLTYPE *	yylloc_param,
		yyscan_t	yyscanner
	)

Definition at line 2208 of file ast_expr2f.c.

References yylloc.

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

ast_yyset_lval()

void ast_yyset_lval	(	YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 2196 of file ast_expr2f.c.

References yylval.

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

ast_yyset_out()

void ast_yyset_out	(	FILE *	out_str,
		yyscan_t	yyscanner
	)

Definition at line 2170 of file ast_expr2f.c.

References yyout.

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

expr2_token_subst()

static char * expr2_token_subst ( const char *  mess )

static

Definition at line 2542 of file ast_expr2f.c.

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

Referenced by ast_yyerror().

{
   /* 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;
}

if()

if

(

!yyg->

yy_init

)

Examples:

/usr/src/asterisk-18.5.0/include/asterisk/strings.h.

Definition at line 868 of file ast_expr2f.c.

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, yyin, and yyout.

Referenced by __add_ovflpage(), __addel(), __ast_str_helper(), __ast_str_helper2(), __big_delete(), __big_split(), __bt_put(), __bt_split(), __delpair(), __hash_open(), __rec_vmap(), __rec_vpipe(), apply_contact_acl(), apply_endpoint_contact_acl(), ast_cel_fabricate_channel_from_event(), ast_format_cmp(), ast_set_default_eid(), ast_sorcery_wizard_unregister(), ast_stun_request(), ast_unreal_setoption(), ast_variable_lists_match(), cli_complete(), cli_show_subscription_common(), defer_full_frame(), dundi_send(), fax_gateway_detect_v21(), g726_write(), generate_parked_user(), get_filestream(), h263_read(), h264_read(), handle_bchan(), handle_err(), handle_mgmt(), handle_request_subscribe(), hash_access(), hash_delete(), hash_fd(), hash_get(), hash_put(), hash_seq(), hash_sync(), history_get(), keypad_cfg_read(), lintospeex_feedback(), MD5Update(), misdn_lib_get_free_bc(), misdn_lib_get_port_info(), misdn_lib_isdn_event_catcher(), newbuf(), ogg_speex_read(), ogg_vorbis_close(), ogg_vorbis_read(), ogg_vorbis_seek(), ogg_vorbis_tell(), ogg_vorbis_write(), oss_write(), parse_release_complete(), phone_write_buf(), pitch_shift(), read_dirs_cb(), rtp_add_candidates_to_ice(), sdp_search(), send_trunk(), socket_read(), speex_callback(), tzload(), ugly_split(), update(), update_filter(), update_jitter_stats(), update_lost_stats(), wav_close(), wav_open(), wav_seek(), wav_write(), and xmpp_connect_hook().

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

input()

static int input ( yyscan_t  yyscanner )

static

Definition at line 1584 of file ast_expr2f.c.

References ast_yyrestart(), ast_yywrap, c, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, 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, and yyin.

Referenced by AST_TEST_DEFINE(), eivr_comm(), escape_and_substitute(), get_calleridname(), get_user_input(), and strip_control_and_high().

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

isatty()

int isatty

(

int

)

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

while()

while

(

1

)

Definition at line 894 of file ast_expr2f.c.

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_base, 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(), yyin, yyleng, yymore, yyterminate, and yytext.

Referenced by __addel(), __big_delete(), __big_return(), ast_sip_pubsub_has_eventlist_support(), fetch_bitmap(), find_challenge(), read_packet(), sms_exec(), subscription_get_generator_from_rdata(), timesub(), and tzload().

      {
      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 132 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_OR;}
   YY_BREAK
case 2:
YY_RULE_SETUP
#line 133 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_AND;}
   YY_BREAK
case 3:
YY_RULE_SETUP
#line 134 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_EQ;}
   YY_BREAK
case 4:
YY_RULE_SETUP
#line 135 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_OR;}
   YY_BREAK
case 5:
YY_RULE_SETUP
#line 136 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_AND;}
   YY_BREAK
case 6:
YY_RULE_SETUP
#line 137 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_EQ;}
   YY_BREAK
case 7:
YY_RULE_SETUP
#line 138 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_EQTILDE;}
   YY_BREAK
case 8:
YY_RULE_SETUP
#line 139 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_TILDETILDE;}
   YY_BREAK
case 9:
YY_RULE_SETUP
#line 140 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_GT;}
   YY_BREAK
case 10:
YY_RULE_SETUP
#line 141 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_LT;}
   YY_BREAK
case 11:
YY_RULE_SETUP
#line 142 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_GE;}
   YY_BREAK
case 12:
YY_RULE_SETUP
#line 143 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_LE;}
   YY_BREAK
case 13:
YY_RULE_SETUP
#line 144 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_NE;}
   YY_BREAK
case 14:
YY_RULE_SETUP
#line 145 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_PLUS;}
   YY_BREAK
case 15:
YY_RULE_SETUP
#line 146 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COMMA;}
   YY_BREAK
case 16:
YY_RULE_SETUP
#line 147 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_MINUS;}
   YY_BREAK
case 17:
YY_RULE_SETUP
#line 148 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_MULT;}
   YY_BREAK
case 18:
YY_RULE_SETUP
#line 149 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_DIV;}
   YY_BREAK
case 19:
YY_RULE_SETUP
#line 150 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_MOD;}
   YY_BREAK
case 20:
YY_RULE_SETUP
#line 151 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COND;}
   YY_BREAK
case 21:
YY_RULE_SETUP
#line 152 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COMPL;}
   YY_BREAK
case 22:
YY_RULE_SETUP
#line 153 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COLON;}
   YY_BREAK
case 23:
YY_RULE_SETUP
#line 154 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_COLONCOLON;}
   YY_BREAK
case 24:
YY_RULE_SETUP
#line 155 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_LP;}
   YY_BREAK
case 25:
YY_RULE_SETUP
#line 156 "ast_expr2.fl"
{ SET_COLUMNS; SET_STRING; return TOK_RP;}
   YY_BREAK
case 26:
YY_RULE_SETUP
#line 157 "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 167 "ast_expr2.fl"
{}
   YY_BREAK
case 28:
/* rule 28 can match eol */
YY_RULE_SETUP
#line 168 "ast_expr2.fl"
{SET_COLUMNS; SET_STRING; return TOKEN;}
   YY_BREAK
case 29:
/* rule 29 can match eol */
YY_RULE_SETUP
#line 170 "ast_expr2.fl"
{/* what to do with eol */}
   YY_BREAK
case 30:
YY_RULE_SETUP
#line 171 "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 180 "ast_expr2.fl"
{
      SET_COLUMNS;
      SET_STRING;
      return TOKEN;
   }
   YY_BREAK
case 32:
/* rule 32 can match eol */
YY_RULE_SETUP
#line 186 "ast_expr2.fl"
{
      curlycount = 0;
      BEGIN(var);
      yymore();
   }
   YY_BREAK
case 33:
/* rule 33 can match eol */
YY_RULE_SETUP
#line 192 "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 202 "ast_expr2.fl"
{
      curlycount++;
      yymore();
   }
   YY_BREAK
case 35:
YY_RULE_SETUP
#line 208 "ast_expr2.fl"
{
      BEGIN(0);
      SET_COLUMNS;
      SET_STRING;
      return TOKEN;
   }
   YY_BREAK
case 36:
YY_RULE_SETUP
#line 215 "ast_expr2.fl"
{
      curlycount = 0;
      BEGIN(var);
      yymore();
   }
   YY_BREAK
case 37:
/* rule 37 can match eol */
YY_RULE_SETUP
#line 221 "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 230 "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 238 "ast_expr2.fl"
ECHO;
   YY_BREAK
#line 1208 "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 */

yy_fatal_error() [1/2]

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

static

Referenced by ast_yyset_column(), and ast_yyset_lineno().

yy_fatal_error() [2/2]

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

static

Definition at line 2021 of file ast_expr2f.c.

References YY_EXIT_FAILURE.

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

yy_get_next_buffer()

static int yy_get_next_buffer ( yyscan_t  yyscanner )

static

Definition at line 1350 of file ast_expr2f.c.

References ast_yyrealloc(), ast_yyrestart(), b, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yyguts_t::yy_c_buf_p, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, yyguts_t::yy_n_chars, YY_READ_BUF_SIZE, and yyin.

Referenced by input(), and while().

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

yy_get_previous_state()

static yy_state_type yy_get_previous_state ( yyscan_t  yyscanner )

static

Definition at line 1485 of file ast_expr2f.c.

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, and yyguts_t::yy_start.

Referenced by while().

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

yy_init_globals()

static int yy_init_globals ( yyscan_t  yyscanner )

static

Definition at line 2278 of file ast_expr2f.c.

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, yyin, and yyout.

Referenced by ast_yylex_destroy(), ast_yylex_init(), and ast_yylex_init_extra().

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

yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state, yyscan_t  yyscanner  )

static

Definition at line 1518 of file ast_expr2f.c.

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, and yy_nxt.

Referenced by while().

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

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

References yy_bp, yyguts_t::yy_c_buf_p, yy_buffer_state::yy_ch_buf, yy_cp, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yyguts_t::yy_hold_char, and yyguts_t::yy_n_chars.

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

Variable Documentation

curlycount

int curlycount = 0

static

Definition at line 608 of file ast_expr2f.c.

Referenced by while().

expr2_token_equivs1

const char* const expr2_token_equivs1[]

static

Definition at line 2489 of file ast_expr2f.c.

Referenced by expr2_token_subst().

expr2_token_equivs2

const char* const expr2_token_equivs2[]

static

Definition at line 2515 of file ast_expr2f.c.

extra_error_message

char extra_error_message[4095]

Definition at line 2472 of file ast_expr2f.c.

extra_error_message_supplied

int extra_error_message_supplied = 0

Definition at line 2473 of file ast_expr2f.c.

Referenced by 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 374 of file ast_expr2f.c.

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

yy_act

register int yy_act

Definition at line 856 of file ast_expr2f.c.

yy_base

yyconst flex_int16_t yy_base[70]

static

Definition at line 424 of file ast_expr2f.c.

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

yy_bp

register char * yy_bp

Definition at line 855 of file ast_expr2f.c.

Referenced by yyunput().

yy_chk

yyconst flex_int16_t yy_chk[159]

static

Definition at line 467 of file ast_expr2f.c.

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

yy_cp

register char* yy_cp

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

yy_def

yyconst flex_int16_t yy_def[70]

static

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

Referenced by while(), and yy_get_previous_state().

yy_meta

yyconst flex_int32_t yy_meta[29]

static

Definition at line 417 of file ast_expr2f.c.

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

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

yyg

struct yyguts_t* yyg = (struct yyguts_t*)yyscanner

Definition at line 857 of file ast_expr2f.c.

yylloc

yylloc = yylloc_param

Definition at line 866 of file ast_expr2f.c.

yylval

yylval = yylval_param

Definition at line 864 of file ast_expr2f.c.