Asterisk - The Open Source Telephony Project GIT-master-f36a736
Data Structures | Typedefs | Enumerations | Functions
pval.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  argapp
 
struct  pval
 

Typedefs

typedef struct pval pval
 

Enumerations

enum  pvaltype {
  PV_WORD , PV_MACRO , PV_CONTEXT , PV_MACRO_CALL ,
  PV_APPLICATION_CALL , PV_CASE , PV_PATTERN , PV_DEFAULT ,
  PV_CATCH , PV_SWITCHES , PV_ESWITCHES , PV_INCLUDES ,
  PV_STATEMENTBLOCK , PV_VARDEC , PV_GOTO , PV_LABEL ,
  PV_FOR , PV_WHILE , PV_BREAK , PV_RETURN ,
  PV_CONTINUE , PV_IF , PV_IFTIME , PV_RANDOM ,
  PV_SWITCH , PV_EXTENSION , PV_IGNOREPAT , PV_GLOBALS ,
  PV_LOCALVARDEC
}
 

Functions

void add_extensions (struct ael_extension *exten)
 
int ast_compile_ael2 (struct ast_context **local_contexts, struct ast_hashtab *local_table, struct pval *root)
 
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 *errmsg)
 
int check_app_args (pval *appcall, pval *arglist, struct argapp *app)
 
void check_pval (pval *item, struct argapp *apps, int in_globals)
 
void check_pval_item (pval *item, struct argapp *apps, int in_globals)
 
void check_switch_expr (pval *item, struct argapp *apps)
 
int count_labels_in_current_context (char *label)
 
void destroy_extensions (struct ael_extension *exten)
 
void destroy_pval (pval *item)
 
void destroy_pval_item (pval *item)
 
int do_pbx_load_module (void)
 
struct pvalfind_context (char *name)
 
struct pvalfind_macro (char *name)
 
int is_empty (char *arg)
 
int is_float (char *arg)
 
int is_int (char *arg)
 
void linkprio (struct ael_extension *exten, struct ael_priority *prio, struct ael_extension *mother_exten)
 
struct ael_extensionnew_exten (void)
 
struct ael_prioritynew_prio (void)
 
void pvalAppCallAddArg (pval *p, pval *arg)
 
char * pvalAppCallGetAppName (pval *p)
 
void pvalAppCallSetAppName (pval *p, char *name)
 
void pvalAppCallSetArglist (pval *p, pval *arglist)
 
pvalpvalAppCallWalkArgs (pval *p, pval **args)
 
void pvalCasePatDefAddStatement (pval *p, pval *statement)
 
pvalpvalCasePatDefWalkStatements (pval *p, pval **statement)
 
char * pvalCasePatGetVal (pval *p)
 
void pvalCasePatSetVal (pval *p, char *val)
 
char * pvalCatchGetExtName (pval *p)
 
pvalpvalCatchGetStatement (pval *p)
 
void pvalCatchSetExtName (pval *p, char *name)
 
void pvalCatchSetStatement (pval *p, pval *statement)
 
int pvalCheckType (pval *p, char *funcname, pvaltype type)
 
pvalpvalConditionalGetElseStatement (pval *p)
 
pvalpvalConditionalGetThenStatement (pval *p)
 
void pvalConditionalSetElseStatement (pval *p, pval *statement)
 
void pvalConditionalSetThenStatement (pval *p, pval *statement)
 
void pvalContextAddStatement (pval *p, pval *statement)
 
int pvalContextGetAbstract (pval *p)
 
char * pvalContextGetName (pval *p)
 
void pvalContextSetAbstract (pval *p)
 
void pvalContextSetName (pval *p, char *name)
 
void pvalContextUnsetAbstract (pval *p)
 
pvalpvalContextWalkStatements (pval *p, pval **statements)
 
pvalpvalCreateNode (pvaltype type)
 
void pvalESwitchesAddSwitch (pval *p, char *name)
 
char * pvalESwitchesWalkNames (pval *p, pval **next_item)
 
char * pvalExtenGetHints (pval *p)
 
char * pvalExtenGetName (pval *p)
 
int pvalExtenGetRegexten (pval *p)
 
pvalpvalExtenGetStatement (pval *p)
 
void pvalExtenSetHints (pval *p, char *hints)
 
void pvalExtenSetName (pval *p, char *name)
 
void pvalExtenSetRegexten (pval *p)
 
void pvalExtenSetStatement (pval *p, pval *statement)
 
void pvalExtenUnSetRegexten (pval *p)
 
char * pvalForGetInc (pval *p)
 
char * pvalForGetInit (pval *p)
 
pvalpvalForGetStatement (pval *p)
 
char * pvalForGetTest (pval *p)
 
void pvalForSetInc (pval *p, char *inc)
 
void pvalForSetInit (pval *p, char *init)
 
void pvalForSetStatement (pval *p, pval *statement)
 
void pvalForSetTest (pval *p, char *test)
 
void pvalGlobalsAddStatement (pval *p, pval *statement)
 
pvalpvalGlobalsWalkStatements (pval *p, pval **next_statement)
 
void pvalGotoGetTarget (pval *p, char **context, char **exten, char **label)
 
void pvalGotoSetTarget (pval *p, char *context, char *exten, char *label)
 
char * pvalIfGetCondition (pval *p)
 
void pvalIfSetCondition (pval *p, char *expr)
 
void pvalIfTimeGetCondition (pval *p, char **hour_range, char **dow_range, char **dom_range, char **month_range)
 
void pvalIfTimeSetCondition (pval *p, char *hour_range, char *dow_range, char *dom_range, char *mon_range)
 
char * pvalIgnorePatGetPattern (pval *p)
 
void pvalIgnorePatSetPattern (pval *p, char *pat)
 
void pvalIncludeGetTimeConstraints (pval *p, char **hour_range, char **dom_range, char **dow_range, char **month_range)
 
void pvalIncludesAddInclude (pval *p, const char *include)
 
void pvalIncludesAddIncludeWithTimeConstraints (pval *p, const char *include, char *hour_range, char *dom_range, char *dow_range, char *month_range)
 
char * pvalIncludesWalk (pval *p, pval **next_item)
 
char * pvalLabelGetName (pval *p)
 
void pvalLabelSetName (pval *p, char *name)
 
void pvalMacroAddArg (pval *p, pval *arg)
 
void pvalMacroAddStatement (pval *p, pval *statement)
 
void pvalMacroCallAddArg (pval *p, pval *arg)
 
char * pvalMacroCallGetMacroName (pval *p)
 
void pvalMacroCallSetArglist (pval *p, pval *arglist)
 
void pvalMacroCallSetMacroName (pval *p, char *name)
 
pvalpvalMacroCallWalkArgs (pval *p, pval **args)
 
char * pvalMacroGetName (pval *p)
 
void pvalMacroSetArglist (pval *p, pval *arglist)
 
void pvalMacroSetName (pval *p, char *name)
 
pvalpvalMacroWalkArgs (pval *p, pval **arg)
 
pvalpvalMacroWalkStatements (pval *p, pval **next_statement)
 
pvaltype pvalObjectGetType (pval *p)
 
char * pvalRandomGetCondition (pval *p)
 
void pvalRandomSetCondition (pval *p, char *percent)
 
void pvalStatementBlockAddStatement (pval *p, pval *statement)
 
pvalpvalStatementBlockWalkStatements (pval *p, pval **next_statement)
 
void pvalSwitchAddCase (pval *p, pval *Case)
 
void pvalSwitchesAddSwitch (pval *p, char *name)
 
char * pvalSwitchesWalkNames (pval *p, pval **next_item)
 
char * pvalSwitchGetTestexpr (pval *p)
 
void pvalSwitchSetTestexpr (pval *p, char *expr)
 
pvalpvalSwitchWalkCases (pval *p, pval **next_case)
 
void pvalTopLevAddObject (pval *p, pval *contextOrObj)
 
pvalpvalTopLevWalkObjects (pval *p, pval **next_obj)
 
char * pvalVarDecGetValue (pval *p)
 
char * pvalVarDecGetVarname (pval *p)
 
void pvalVarDecSetValue (pval *p, char *value)
 
void pvalVarDecSetVarname (pval *p, char *name)
 
char * pvalWordGetString (pval *p)
 
void pvalWordSetString (pval *p, char *str)
 
void set_priorities (struct ael_extension *exten)
 

Typedef Documentation

◆ pval

typedef struct pval pval

Definition at line 101 of file pval.h.

Enumeration Type Documentation

◆ pvaltype

enum pvaltype
Enumerator
PV_WORD 
PV_MACRO 
PV_CONTEXT 
PV_MACRO_CALL 
PV_APPLICATION_CALL 
PV_CASE 
PV_PATTERN 
PV_DEFAULT 
PV_CATCH 
PV_SWITCHES 
PV_ESWITCHES 
PV_INCLUDES 
PV_STATEMENTBLOCK 
PV_VARDEC 
PV_GOTO 
PV_LABEL 
PV_FOR 
PV_WHILE 
PV_BREAK 
PV_RETURN 
PV_CONTINUE 
PV_IF 
PV_IFTIME 
PV_RANDOM 
PV_SWITCH 
PV_EXTENSION 
PV_IGNOREPAT 
PV_GLOBALS 
PV_LOCALVARDEC 

Definition at line 6 of file pval.h.

7{
8 PV_WORD, /* an ident, string, name, label, etc. A user-supplied string. */ /* 0 */
9 PV_MACRO, /* 1 */
10 PV_CONTEXT, /* 2 */
11 PV_MACRO_CALL, /* 3 */
12 PV_APPLICATION_CALL, /* 4 */
13 PV_CASE, /* 5 */
14 PV_PATTERN, /* 6 */
15 PV_DEFAULT, /* 7 */
16 PV_CATCH, /* 8 */
17 PV_SWITCHES, /* 9 */
18 PV_ESWITCHES, /* 10 */
19 PV_INCLUDES, /* 11 */
20 PV_STATEMENTBLOCK, /* 12 */
21 PV_VARDEC, /* you know, var=val; */ /* 13 */
22 PV_GOTO, /* 14 */
23 PV_LABEL, /* 15 */
24 PV_FOR, /* 16 */
25 PV_WHILE, /* 17 */
26 PV_BREAK, /* 18 */
27 PV_RETURN, /* 19 */
28 PV_CONTINUE, /* 20 */
29 PV_IF, /* 21 */
30 PV_IFTIME, /* 22 */
31 PV_RANDOM, /* 23 */
32 PV_SWITCH, /* 24 */
33 PV_EXTENSION, /* 25 */
34 PV_IGNOREPAT, /* 26 */
35 PV_GLOBALS, /* 27 */
36 PV_LOCALVARDEC, /* 28 */
37} pvaltype;
pvaltype
Definition: pval.h:7
@ PV_CATCH
Definition: pval.h:16
@ PV_WORD
Definition: pval.h:8
@ PV_GLOBALS
Definition: pval.h:35
@ PV_LOCALVARDEC
Definition: pval.h:36
@ PV_CONTEXT
Definition: pval.h:10
@ PV_DEFAULT
Definition: pval.h:15
@ PV_INCLUDES
Definition: pval.h:19
@ PV_MACRO
Definition: pval.h:9
@ PV_SWITCHES
Definition: pval.h:17
@ PV_IGNOREPAT
Definition: pval.h:34
@ PV_CASE
Definition: pval.h:13
@ PV_CONTINUE
Definition: pval.h:28
@ PV_SWITCH
Definition: pval.h:32
@ PV_BREAK
Definition: pval.h:26
@ PV_APPLICATION_CALL
Definition: pval.h:12
@ PV_IFTIME
Definition: pval.h:30
@ PV_PATTERN
Definition: pval.h:14
@ PV_RETURN
Definition: pval.h:27
@ PV_IF
Definition: pval.h:29
@ PV_VARDEC
Definition: pval.h:21
@ PV_MACRO_CALL
Definition: pval.h:11
@ PV_GOTO
Definition: pval.h:22
@ PV_LABEL
Definition: pval.h:23
@ PV_ESWITCHES
Definition: pval.h:18
@ PV_FOR
Definition: pval.h:24
@ PV_RANDOM
Definition: pval.h:31
@ PV_STATEMENTBLOCK
Definition: pval.h:20
@ PV_EXTENSION
Definition: pval.h:33
@ PV_WHILE
Definition: pval.h:25

Function Documentation

◆ add_extensions()

void add_extensions ( struct ael_extension exten)

Definition at line 4213 of file pval.c.

4214{
4215 struct ael_priority *pr;
4216 char *label=0;
4217 char realext[AST_MAX_EXTENSION];
4218 if (!exten) {
4219 ast_log(LOG_WARNING, "This file is Empty!\n" );
4220 return;
4221 }
4222 do {
4223 struct ael_priority *last = 0;
4224
4225 pbx_substitute_variables_helper(NULL, exten->name, realext, sizeof(realext) - 1);
4226 if (exten->hints) {
4227 if (ast_add_extension2(exten->context, 0 /*no replace*/, realext, PRIORITY_HINT, NULL, exten->cidmatch,
4229 ast_log(LOG_WARNING, "Unable to add step at priority 'hint' of extension '%s'\n",
4230 exten->name);
4231 }
4232 }
4233
4234 for (pr=exten->plist; pr; pr=pr->next) {
4235 char app[2000];
4236 char appargs[2000];
4237
4238 /* before we can add the extension, we need to prep the app/appargs;
4239 the CONTROL types need to be done after the priority numbers are calculated.
4240 */
4241 if (pr->type == AEL_LABEL) /* don't try to put labels in the dialplan! */ {
4242 last = pr;
4243 continue;
4244 }
4245
4246 if (pr->app)
4247 strcpy(app, pr->app);
4248 else
4249 app[0] = 0;
4250 if (pr->appargs )
4251 strcpy(appargs, pr->appargs);
4252 else
4253 appargs[0] = 0;
4254 switch( pr->type ) {
4255 case AEL_APPCALL:
4256 /* easy case. Everything is all set up */
4257 break;
4258
4259 case AEL_CONTROL1: /* FOR loop, WHILE loop, BREAK, CONTINUE, IF, IFTIME */
4260 /* simple, unconditional goto. */
4261 strcpy(app,"Goto");
4262 if (pr->goto_true->origin && pr->goto_true->origin->type == PV_SWITCH ) {
4263 snprintf(appargs,sizeof(appargs),"%s,%d", pr->goto_true->exten->name, pr->goto_true->priority_num);
4264 } else if (pr->goto_true->origin && pr->goto_true->origin->type == PV_IFTIME && pr->goto_true->origin->u3.else_statements ) {
4265 snprintf(appargs,sizeof(appargs),"%d", pr->goto_true->priority_num+1);
4266 } else
4267 snprintf(appargs,sizeof(appargs),"%d", pr->goto_true->priority_num);
4268 break;
4269
4270 case AEL_FOR_CONTROL: /* WHILE loop test, FOR loop test */
4271 strcpy(app,"GotoIf");
4272 snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num);
4273 break;
4274
4275 case AEL_IF_CONTROL:
4276 strcpy(app,"GotoIf");
4277 if (pr->origin->u3.else_statements )
4278 snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num+1);
4279 else
4280 snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num);
4281 break;
4282
4283 case AEL_RAND_CONTROL:
4284 strcpy(app,"Random");
4285 snprintf(appargs,sizeof(appargs),"%s:%d", pr->appargs, pr->goto_true->priority_num+1);
4286 break;
4287
4288 case AEL_IFTIME_CONTROL:
4289 strcpy(app,"GotoIfTime");
4290 snprintf(appargs,sizeof(appargs),"%s?%d", pr->appargs, pr->priority_num+2);
4291 break;
4292
4293 case AEL_RETURN:
4294 strcpy(app,"Return");
4295 appargs[0] = 0;
4296 break;
4297
4298 default:
4299 break;
4300 }
4301 if (last && last->type == AEL_LABEL ) {
4302 label = last->origin->u1.str;
4303 }
4304 else
4305 label = 0;
4306
4307 if (ast_add_extension2(exten->context, 0 /*no replace*/, realext, pr->priority_num, (label?label:NULL), exten->cidmatch,
4309 ast_log(LOG_WARNING, "Unable to add step at priority '%d' of extension '%s'\n", pr->priority_num,
4310 exten->name);
4311 }
4312 last = pr;
4313 }
4315 } while ( exten );
4316}
@ AEL_FOR_CONTROL
Definition: ael_structs.h:84
@ AEL_RAND_CONTROL
Definition: ael_structs.h:84
@ AEL_RETURN
Definition: ael_structs.h:84
@ AEL_IF_CONTROL
Definition: ael_structs.h:84
@ AEL_IFTIME_CONTROL
Definition: ael_structs.h:84
@ AEL_CONTROL1
Definition: ael_structs.h:84
@ AEL_LABEL
Definition: ael_structs.h:84
@ AEL_APPCALL
Definition: ael_structs.h:84
static const char app[]
Definition: app_adsiprog.c:56
struct sla_ringing_trunk * last
Definition: app_sla.c:332
#define strdup(a)
Definition: astmm.h:163
void ast_free_ptr(void *ptr)
free() wrapper
Definition: astmm.c:1739
#define ast_log
Definition: astobj2.c:42
#define AST_MAX_EXTENSION
Definition: channel.h:134
#define LOG_WARNING
int ast_add_extension2(struct ast_context *con, int replace, const char *extension, int priority, const char *label, const char *callerid, const char *application, void *data, void(*datad)(void *), const char *registrar, const char *registrar_file, int registrar_line)
Add an extension to an extension context, this time with an ast_context *.
Definition: pbx.c:7257
#define PRIORITY_HINT
Definition: pbx.h:54
void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count)
Definition: ael_main.c:211
static char * registrar
Definition: pval.c:70
#define NULL
Definition: resample.c:96
struct ael_priority * plist
Definition: ael_structs.h:115
struct ast_context * context
Definition: ael_structs.h:113
char * cidmatch
Definition: ael_structs.h:106
struct ael_extension * next_exten
Definition: ael_structs.h:117
struct ael_priority * goto_false
Definition: ael_structs.h:99
struct ael_priority * goto_true
Definition: ael_structs.h:98
struct pval * origin
Definition: ael_structs.h:95
char * appargs
Definition: ael_structs.h:93
char * app
Definition: ael_structs.h:92
ael_priority_type type
Definition: ael_structs.h:90
struct ael_priority * next
Definition: ael_structs.h:100
int priority_num
Definition: ael_structs.h:89
struct ael_extension * exten
Definition: ael_structs.h:96
struct pval * else_statements
Definition: pval.h:78
union pval::@248 u3
pvaltype type
Definition: pval.h:50

References AEL_APPCALL, AEL_CONTROL1, AEL_FOR_CONTROL, AEL_IF_CONTROL, AEL_IFTIME_CONTROL, AEL_LABEL, AEL_RAND_CONTROL, AEL_RETURN, app, ael_priority::app, ael_priority::appargs, ast_add_extension2(), ast_free_ptr(), ast_log, AST_MAX_EXTENSION, ael_extension::cidmatch, ael_extension::context, pval::else_statements, ael_priority::exten, ael_priority::goto_false, ael_priority::goto_true, ael_extension::hints, last, LOG_WARNING, ael_extension::name, ael_priority::next, ael_extension::next_exten, NULL, ael_priority::origin, pbx_substitute_variables_helper(), ael_extension::plist, PRIORITY_HINT, ael_priority::priority_num, PV_IFTIME, PV_SWITCH, registrar, strdup, ael_priority::type, pval::type, and pval::u3.

◆ ast_compile_ael2()

int ast_compile_ael2 ( struct ast_context **  local_contexts,
struct ast_hashtab local_table,
struct pval root 
)

Definition at line 4413 of file pval.c.

4414{
4415 pval *p,*p2;
4416 struct ast_context *context;
4417 char buf[2000];
4418 struct ael_extension *exten;
4419 struct ael_extension *exten_list = 0;
4420
4421 /* Reset the counter so that we get consistent labels between reloads */
4423
4424 for (p=root; p; p=p->next ) { /* do the globals first, so they'll be there
4425 when we try to eval them */
4426 switch (p->type) {
4427 case PV_GLOBALS:
4428 /* just VARDEC elements */
4429 for (p2=p->u1.list; p2; p2=p2->next) {
4430 char buf2[2000];
4431 snprintf(buf2,sizeof(buf2),"%s=%s", p2->u1.str, p2->u2.val);
4433 }
4434 break;
4435 default:
4436 break;
4437 }
4438 }
4439
4440 for (p=root; p; p=p->next ) {
4441 pval *lp;
4442 int argc;
4443
4444 switch (p->type) {
4445 case PV_MACRO:
4446
4448
4449 exten = new_exten();
4450 exten->context = context;
4451 exten->name = strdup("~~s~~");
4452 argc = 1;
4453 for (lp=p->u2.arglist; lp; lp=lp->next) {
4454 /* for each arg, set up a "Set" command */
4455 struct ael_priority *np2 = new_prio();
4456 np2->type = AEL_APPCALL;
4457 np2->app = strdup("MSet");
4458 snprintf(buf,sizeof(buf),"LOCAL(%s)=${ARG%d}", lp->u1.str, argc++);
4460 np2->appargs = strdup(buf);
4461 linkprio(exten, np2, NULL);
4462 }
4463
4464 /* CONTAINS APPCALLS, CATCH, just like extensions... */
4465 if (gen_prios(exten, p->u1.str, p->u3.macro_statements, 0, context)) {
4466 return -1;
4467 }
4468 if (exten->return_needed) { /* most likely, this will go away */
4469 struct ael_priority *np2 = new_prio();
4470 np2->type = AEL_APPCALL;
4471 np2->app = strdup("NoOp");
4472 snprintf(buf,sizeof(buf),"End of Macro %s-%s",p->u1.str, exten->name);
4473 np2->appargs = strdup(buf);
4474 linkprio(exten, np2, NULL);
4475 exten-> return_target = np2;
4476 }
4477
4479 attach_exten(&exten_list, exten);
4480 break;
4481
4482 case PV_GLOBALS:
4483 /* already done */
4484 break;
4485
4486 case PV_CONTEXT:
4488
4489 /* contexts contain: ignorepat, includes, switches, eswitches, extensions, */
4490 for (p2=p->u2.statements; p2; p2=p2->next) {
4491 pval *p3;
4492 char *s3;
4493
4494 switch (p2->type) {
4495 case PV_EXTENSION:
4496 exten = new_exten();
4497 exten->name = strdup(p2->u1.str);
4499
4500 if( (s3=strchr(exten->name, '/') ) != 0 )
4501 {
4502 *s3 = 0;
4503 exten->cidmatch = s3+1;
4504 }
4505
4506 if ( p2->u3.hints )
4507 exten->hints = strdup(p2->u3.hints);
4508 exten->regexten = p2->u4.regexten;
4509 if (gen_prios(exten, p->u1.str, p2->u2.statements, 0, context)) {
4510 return -1;
4511 }
4512 if (exten->return_needed) { /* returns don't generate a goto eoe (end of extension) any more, just a Return() app call) */
4513 struct ael_priority *np2 = new_prio();
4514 np2->type = AEL_APPCALL;
4515 np2->app = strdup("NoOp");
4516 snprintf(buf,sizeof(buf),"End of Extension %s", exten->name);
4517 np2->appargs = strdup(buf);
4518 linkprio(exten, np2, NULL);
4519 exten-> return_target = np2;
4520 }
4521 /* is the last priority in the extension a label? Then add a trailing no-op */
4522 if ( exten->plist_last && exten->plist_last->type == AEL_LABEL ) {
4523 struct ael_priority *np2 = new_prio();
4524 np2->type = AEL_APPCALL;
4525 np2->app = strdup("NoOp");
4526 snprintf(buf,sizeof(buf),"A NoOp to follow a trailing label %s", exten->plist_last->origin->u1.str);
4527 np2->appargs = strdup(buf);
4528 linkprio(exten, np2, NULL);
4529 }
4530
4532 attach_exten(&exten_list, exten);
4533 break;
4534
4535 case PV_IGNOREPAT:
4537 break;
4538
4539 case PV_INCLUDES:
4540 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
4541 if ( p3->u2.arglist ) {
4542 snprintf(buf,sizeof(buf), "%s,%s,%s,%s,%s",
4543 p3->u1.str,
4544 p3->u2.arglist->u1.str,
4545 p3->u2.arglist->next->u1.str,
4546 p3->u2.arglist->next->next->u1.str,
4547 p3->u2.arglist->next->next->next->u1.str);
4549 } else
4551 }
4552 break;
4553
4554 case PV_SWITCHES:
4555 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
4556 char *c = strchr(p3->u1.str, '/');
4557 if (c) {
4558 *c = '\0';
4559 c++;
4560 } else
4561 c = "";
4562
4564 }
4565 break;
4566
4567 case PV_ESWITCHES:
4568 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
4569 char *c = strchr(p3->u1.str, '/');
4570 if (c) {
4571 *c = '\0';
4572 c++;
4573 } else
4574 c = "";
4575
4577 }
4578 break;
4579 default:
4580 break;
4581 }
4582 }
4583
4584 break;
4585
4586 default:
4587 /* huh? what? */
4588 break;
4589
4590 }
4591 }
4592
4593 /* Create default "h" bubble context */
4594 if (ast_custom_function_find("DIALPLAN_EXISTS") && ast_custom_function_find("STACK_PEEK")) {
4595 int i;
4596 const char *h_context = "ael-builtin-h-bubble";
4597 struct ael_priority *np;
4598 struct {
4599 int priority;
4600 const char *app;
4601 const char *arg;
4602 } steps[] = {
4603 /* Start high, to avoid conflict with existing h extensions */
4604 { 1, "Goto", "9991" },
4605 /* Save the context, because after the StackPop, it disappears */
4606 { 9991, "Set", "~~parentcxt~~=${STACK_PEEK(1,c,1)}" },
4607 /* If we're not in a Gosub frame, exit */
4608 { 9992, "GotoIf", "$[\"${~~parentcxt~~}\"=\"\"]?9996" },
4609 /* Check for an "h" extension in that context */
4610 { 9993, "GotoIf", "${DIALPLAN_EXISTS(${~~parentcxt~~},h,1)}?9994:9996" },
4611 /* Pop off the stack frame to prevent an infinite loop */
4612 { 9994, "StackPop", "" },
4613 /* Finally, go there. */
4614 { 9995, "Goto", "${~~parentcxt~~},h,1" },
4615 /* Just an empty priority for jumping out early */
4616 { 9996, "NoOp", "" }
4617 };
4619 if (context_used(exten_list, context)) {
4620 int found = 0;
4621 while (!found) {
4622 /* Pick a new context name that is not used. */
4623 char h_context_template[] = "/tmp/ael-builtin-h-bubble-XXXXXX";
4624 int fd = mkstemp(h_context_template);
4625 unlink(h_context_template);
4626 close(fd);
4628 found = !context_used(exten_list, context);
4629 }
4630 h_context = ast_get_context_name(context);
4631 }
4632 exten = new_exten();
4633 exten->context = context;
4634 exten->name = strdup("h");
4635
4636 for (i = 0; i < ARRAY_LEN(steps); i++) {
4637 np = new_prio();
4638 np->type = AEL_APPCALL;
4639 np->priority_num = steps[i].priority;
4640 np->app = strdup(steps[i].app);
4641 np->appargs = strdup(steps[i].arg);
4642 linkprio(exten, np, NULL);
4643 }
4644 attach_exten(&exten_list, exten);
4645
4646 /* Include the default "h" bubble context in each macro context */
4647 for (exten = exten_list; exten; exten = exten->next_exten) {
4648 /* All macros contain a "~~s~~" extension, and it's the first created. If
4649 * we perchance get a non-macro context, it's no big deal; the logic is
4650 * designed to exit out smoothly if not called from within a Gosub. */
4651 if (!strcmp(exten->name, "~~s~~")) {
4652 ast_context_add_include2(exten->context, h_context, registrar);
4653 }
4654 }
4655 }
4656
4657 /* moved these from being done after a macro or extension were processed,
4658 to after all processing is done, for the sake of fixing gotos to labels inside cases... */
4659 /* I guess this would be considered 2nd pass of compiler now... */
4660 fix_gotos_in_extensions(exten_list); /* find and fix extension ref in gotos to labels that are in case statements */
4661 add_extensions(exten_list); /* actually makes calls to create priorities in ast_contexts -- feeds dialplan to asterisk */
4662 destroy_extensions(exten_list); /* all that remains is an empty husk, discard of it as is proper */
4663
4664 return 0;
4665}
static int priority
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
static struct ast_threadstorage buf2
int pbx_builtin_setvar(struct ast_channel *chan, const char *data)
Parse and set a single channel variable, where the name and value are separated with an '=' character...
int ast_context_add_include2(struct ast_context *con, const char *value, const char *registrar)
Add a context include.
Definition: ael_main.c:359
int ast_context_add_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar)
Definition: ael_main.c:348
struct ast_custom_function * ast_custom_function_find(const char *name)
Definition: ael_main.c:173
struct ast_context * ast_context_find_or_create(struct ast_context **extcontexts, struct ast_hashtab *exttable, const char *name, const char *registrar)
Register a new context or find an existing one.
Definition: pbx.c:6149
const char * ast_get_context_name(struct ast_context *con)
Definition: ael_main.c:421
int ast_context_add_switch2(struct ast_context *con, const char *sw, const char *data, int eval, const char *registrar)
Adds a switch (first param is a ast_context)
Definition: ael_main.c:370
static struct ast_context * local_contexts
Definition: pbx_config.c:113
static struct ast_hashtab * local_table
Definition: pbx_config.c:114
static void attach_exten(struct ael_extension **list, struct ael_extension *newmem)
Definition: pval.c:4318
struct ael_priority * new_prio(void)
Definition: pval.c:2924
static int context_used(struct ael_extension *exten_list, struct ast_context *context)
Definition: pval.c:4398
static void remove_spaces_before_equals(char *str)
Definition: pval.c:3038
void set_priorities(struct ael_extension *exten)
Definition: pval.c:4187
struct ael_extension * new_exten(void)
Definition: pval.c:2930
static int gen_prios(struct ael_extension *exten, char *label, pval *statement, struct ael_extension *mother_exten, struct ast_context *this_context)
Definition: pval.c:3341
void destroy_extensions(struct ael_extension *exten)
Definition: pval.c:2978
void linkprio(struct ael_extension *exten, struct ael_priority *prio, struct ael_extension *mother_exten)
Definition: pval.c:2936
void add_extensions(struct ael_extension *exten)
Definition: pval.c:4213
static int control_statement_count
Definition: pval.c:2922
static void fix_gotos_in_extensions(struct ael_extension *exten)
Definition: pval.c:4355
struct ael_priority * plist_last
Definition: ael_structs.h:116
ast_context: An extension context
Definition: pbx.c:284
Definition: pval.h:49
struct pval * arglist
Definition: pval.h:68
char * val
Definition: pval.h:70
struct pval * next
Definition: pval.h:93
char * hints
Definition: pval.h:81
struct pval * statements
Definition: pval.h:61
struct pval * macro_statements
Definition: pval.h:79
union pval::@246 u1
char * str
Definition: pval.h:59
union pval::@247 u2
union pval::@249 u4
int regexten
Definition: pval.h:90
struct pval * list
Definition: pval.h:60
static struct test_val c
#define ARRAY_LEN(a)
Definition: utils.h:666

References add_extensions(), AEL_APPCALL, AEL_LABEL, app, ael_priority::app, ael_priority::appargs, pval::arglist, ARRAY_LEN, ast_context_add_ignorepat2(), ast_context_add_include2(), ast_context_add_switch2(), ast_context_find_or_create(), ast_custom_function_find(), ast_get_context_name(), attach_exten(), buf, buf2, c, ael_extension::cidmatch, voicemailpwcheck::context, ael_extension::context, context_used(), control_statement_count, destroy_extensions(), ael_priority::exten, fix_gotos_in_extensions(), gen_prios(), ael_extension::hints, pval::hints, linkprio(), pval::list, local_contexts, local_table, pval::macro_statements, ael_extension::name, new_exten(), new_prio(), pval::next, ael_extension::next_exten, NULL, ael_priority::origin, pbx_builtin_setvar(), ael_extension::plist_last, priority, ael_priority::priority_num, PV_CONTEXT, PV_ESWITCHES, PV_EXTENSION, PV_GLOBALS, PV_IGNOREPAT, PV_INCLUDES, PV_MACRO, PV_SWITCHES, ael_extension::regexten, pval::regexten, registrar, remove_spaces_before_equals(), ael_extension::return_needed, set_priorities(), pval::statements, pval::str, strdup, ael_priority::type, pval::type, pval::u1, pval::u2, pval::u3, pval::u4, and pval::val.

◆ ast_expr()

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

Evaluate the given expression.

Parameters
exprAn expression
bufResult buffer
lengthSize of the result buffer, in bytes
chanChannel 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.

2392{
2393 struct parse_io io = { .string = expr, .chan = chan };
2394 int return_value = 0;
2395
2396 ast_yylex_init(&io.scanner);
2397
2398 ast_yy_scan_string(expr, io.scanner);
2399
2400 ast_yyparse ((void *) &io);
2401
2402 ast_yylex_destroy(io.scanner);
2403
2404 if (!io.val) {
2405 if (length > 1) {
2406 strcpy(buf, "0");
2407 return_value = 1;
2408 }
2409 } else {
2410 if (io.val->type == AST_EXPR_number) {
2411 int res_length;
2412
2413 res_length = snprintf(buf, length, FP___PRINTF, io.val->u.i);
2414 return_value = (res_length <= length) ? res_length : length;
2415 } else {
2416 if (io.val->u.s)
2417#if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE)
2418 strncpy(buf, io.val->u.s, length - 1);
2419#else /* !STANDALONE && !LOW_MEMORY */
2420 ast_copy_string(buf, io.val->u.s, length);
2421#endif /* STANDALONE || LOW_MEMORY */
2422 else
2423 buf[0] = 0;
2424 return_value = strlen(buf);
2425 free(io.val->u.s);
2426 }
2427 free(io.val);
2428 }
2429 return return_value;
2430}
int ast_yylex_destroy(yyscan_t yyscanner)
Definition: ast_expr2f.c:2298
int ast_yyparse(void *)
@ AST_EXPR_number
Definition: ast_expr2f.c:558
YY_BUFFER_STATE ast_yy_scan_string(yyconst char *yy_str, yyscan_t yyscanner)
Definition: ast_expr2f.c:1960
#define FP___PRINTF
Definition: ast_expr2f.c:526
int ast_yylex_init(yyscan_t *scanner)
Definition: ast_expr2f.c:2207
static struct io_context * io
Definition: chan_ooh323.c:401
void free()
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
struct ast_channel * chan
Definition: ast_expr2.c:353

◆ ast_expr_clear_extra_error_info()

void ast_expr_clear_extra_error_info ( void  )

Definition at line 2469 of file ast_expr2f.c.

2470{
2472 extra_error_message[0] = 0;
2473}
char extra_error_message[4095]
Definition: ast_expr2f.c:2458
int extra_error_message_supplied
Definition: ast_expr2f.c:2459

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 *  errmsg)

Definition at line 2463 of file ast_expr2f.c.

2464{
2467}

References extra_error_message, and extra_error_message_supplied.

Referenced by check_pval_item().

◆ check_app_args()

int check_app_args ( pval appcall,
pval arglist,
struct argapp app 
)

Definition at line 2130 of file pval.c.

2131{
2132#ifdef AAL_ARGCHECK
2133 struct argdesc *ad = app->args;
2134 pval *pa;
2135 int z;
2136
2137 for (pa = arglist; pa; pa=pa->next) {
2138 if (!ad) {
2139 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Extra argument %s not in application call to %s !\n",
2140 arglist->filename, arglist->startline, arglist->endline, pa->u1.str, app->name);
2141 warns++;
2142 return 1;
2143 } else {
2144 /* find the first entry in the ad list that will match */
2145 do {
2146 if ( ad->dtype == ARGD_VARARG ) /* once we hit the VARARG, all bets are off. Discontinue the comparisons */
2147 break;
2148
2149 z= option_matches( ad, pa, app);
2150 if (!z) {
2151 if ( !arglist )
2152 arglist=appcall;
2153
2154 if (ad->type == ARGD_REQUIRED) {
2155 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
2156 arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
2157 warns++;
2158 return 1;
2159 }
2160 } else if (z && ad->dtype == ARGD_OPTIONSET) {
2161 option_matches_j( ad, pa, app);
2162 }
2163 ad = ad->next;
2164 } while (ad && !z);
2165 }
2166 }
2167 /* any app nodes left, that are not optional? */
2168 for ( ; ad; ad=ad->next) {
2169 if (ad->type == ARGD_REQUIRED && ad->dtype != ARGD_VARARG) {
2170 if ( !arglist )
2171 arglist=appcall;
2172 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
2173 arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
2174 warns++;
2175 return 1;
2176 }
2177 }
2178 return 0;
2179#else
2180 return 0;
2181#endif
2182}
static int warns
Definition: pval.c:65
int endline
Definition: pval.h:52
char * filename
Definition: pval.h:55
int startline
Definition: pval.h:51

References app, ast_log, pval::endline, pval::filename, LOG_WARNING, pval::next, pval::startline, pval::str, pval::u1, and warns.

◆ check_pval()

void check_pval ( pval item,
struct argapp apps,
int  in_globals 
)

Definition at line 2865 of file pval.c.

2866{
2867 pval *i;
2868
2869 /* checks to do:
2870 1. Do goto's point to actual labels?
2871 2. Do macro calls reference a macro?
2872 3. Does the number of macro args match the definition?
2873 4. Is a macro call missing its & at the front?
2874 5. Application calls-- we could check syntax for existing applications,
2875 but I need some sort of universal description bnf for a general
2876 sort of method for checking arguments, in number, maybe even type, at least.
2877 Don't want to hand code checks for hundreds of applications.
2878 */
2879
2880 for (i=item; i; i=i->next) {
2881 check_pval_item(i,apps,in_globals);
2882 }
2883}
void check_pval_item(pval *item, struct argapp *apps, int in_globals)
Definition: pval.c:2357
Registered applications container.
Definition: pbx_app.c:67
static struct aco_type item
Definition: test_config.c:1463

References check_pval_item(), item, and pval::next.

◆ check_pval_item()

void check_pval_item ( pval item,
struct argapp apps,
int  in_globals 
)

Definition at line 2357 of file pval.c.

2358{
2359 pval *lp;
2360#ifdef AAL_ARGCHECK
2361 struct argapp *app, *found;
2362#endif
2363 struct pval *macro_def;
2364 struct pval *app_def;
2365
2366 char errmsg[4096];
2367 char *strp;
2368
2369 switch (item->type) {
2370 case PV_WORD:
2371 /* fields: item->u1.str == string associated with this (word).
2372 item->u2.arglist == pval list of 4 PV_WORD elements for time values (only in PV_INCLUDES) */
2373 break;
2374
2375 case PV_MACRO:
2376 /* fields: item->u1.str == name of macro
2377 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
2378 item->u2.arglist->u1.str == argument
2379 item->u2.arglist->next == next arg
2380
2381 item->u3.macro_statements == pval list of statements in macro body.
2382 */
2386
2388
2389 for (lp=item->u2.arglist; lp; lp=lp->next) {
2390
2391 }
2392 check_pval(item->u3.macro_statements, apps,in_globals);
2393 break;
2394
2395 case PV_CONTEXT:
2396 /* fields: item->u1.str == name of context
2397 item->u2.statements == pval list of statements in context body
2398 item->u3.abstract == int 1 if an abstract keyword were present
2399 */
2402 if ( item->u3.abstract ) {
2405 } else
2407 check_pval(item->u2.statements, apps,in_globals);
2408 break;
2409
2410 case PV_MACRO_CALL:
2411 /* fields: item->u1.str == name of macro to call
2412 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
2413 item->u2.arglist->u1.str == argument
2414 item->u2.arglist->next == next arg
2415 */
2416#ifdef STANDALONE
2417 /* if this is a standalone, we will need to make sure the
2418 localized load of extensions.conf is done */
2419 if (!extensions_dot_conf_loaded) {
2421 extensions_dot_conf_loaded++;
2422 }
2423#endif
2424 macro_def = find_macro(item->u1.str);
2425 if (!macro_def) {
2426#ifdef STANDALONE
2427 struct pbx_find_info pfiq = {.stacklen = 0 };
2428 struct pbx_find_info pfiq2 = {.stacklen = 0 };
2429
2430 /* look for the macro in the extensions.conf world */
2431 pbx_find_extension(NULL, NULL, &pfiq, item->u1.str, "s", 1, NULL, NULL, E_MATCH);
2432
2433 if (pfiq.status != STATUS_SUCCESS) {
2434 char namebuf2[256];
2435 snprintf(namebuf2, 256, "macro-%s", item->u1.str);
2436
2437 /* look for the macro in the extensions.conf world */
2438 pbx_find_extension(NULL, NULL, &pfiq2, namebuf2, "s", 1, NULL, NULL, E_MATCH);
2439
2440 if (pfiq2.status == STATUS_SUCCESS) {
2441 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to non-existent %s! (macro-%s was found in the extensions.conf stuff, but we are using gosubs!)\n",
2442 item->filename, item->startline, item->endline, item->u1.str, item->u1.str);
2443 warns++;
2444 } else {
2445 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to non-existent %s! (Not even in the extensions.conf stuff!)\n",
2446 item->filename, item->startline, item->endline, item->u1.str);
2447 warns++;
2448 }
2449 }
2450#else
2451 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to %s cannot be found in the AEL code!\n",
2452 item->filename, item->startline, item->endline, item->u1.str);
2453 warns++;
2454
2455#endif
2456#ifdef THIS_IS_1DOT4
2457 char namebuf2[256];
2458 snprintf(namebuf2, 256, "macro-%s", item->u1.str);
2459
2460 /* look for the macro in the extensions.conf world */
2461 pbx_find_extension(NULL, NULL, &pfiq, namebuf2, "s", 1, NULL, NULL, E_MATCH);
2462
2463 if (pfiq.status != STATUS_SUCCESS) {
2464 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to %s was not found in the AEL, nor the extensions.conf !\n",
2465 item->filename, item->startline, item->endline, item->u1.str);
2466 warns++;
2467 }
2468
2469#endif
2470
2471 } else if (macro_def->type != PV_MACRO) {
2472 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: macro call to %s references a context, not a macro!\n",
2473 item->filename, item->startline, item->endline, item->u1.str);
2474 errs++;
2475 } else {
2476 /* macro_def is a MACRO, so do the args match in number? */
2477 int hereargs = 0;
2478 int thereargs = 0;
2479
2480 for (lp=item->u2.arglist; lp; lp=lp->next) {
2481 hereargs++;
2482 }
2483 for (lp=macro_def->u2.arglist; lp; lp=lp->next) {
2484 thereargs++;
2485 }
2486 if (hereargs != thereargs ) {
2487 ast_log(LOG_ERROR, "Error: file %s, line %d-%d: The macro call to %s has %d arguments, but the macro definition has %d arguments\n",
2488 item->filename, item->startline, item->endline, item->u1.str, hereargs, thereargs);
2489 errs++;
2490 }
2491 }
2492 break;
2493
2495 /* fields: item->u1.str == name of application to call
2496 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
2497 item->u2.arglist->u1.str == argument
2498 item->u2.arglist->next == next arg
2499 */
2500 /* Need to check to see if the application is available! */
2501 app_def = find_context(item->u1.str);
2502 if (app_def && app_def->type == PV_MACRO) {
2503 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: application call to %s references an existing macro, but had no & preceding it!\n",
2504 item->filename, item->startline, item->endline, item->u1.str);
2505 errs++;
2506 }
2507 if (strcasecmp(item->u1.str,"GotoIf") == 0
2508 || strcasecmp(item->u1.str,"GotoIfTime") == 0
2509 || strcasecmp(item->u1.str,"while") == 0
2510 || strcasecmp(item->u1.str,"endwhile") == 0
2511 || strcasecmp(item->u1.str,"random") == 0
2512 || strcasecmp(item->u1.str,"gosub") == 0
2513 || strcasecmp(item->u1.str,"gosubif") == 0
2514 || strcasecmp(item->u1.str,"continuewhile") == 0
2515 || strcasecmp(item->u1.str,"endwhile") == 0
2516 || strcasecmp(item->u1.str,"execif") == 0
2517 || strcasecmp(item->u1.str,"execiftime") == 0
2518 || strcasecmp(item->u1.str,"exitwhile") == 0
2519 || strcasecmp(item->u1.str,"goto") == 0
2520 || strcasecmp(item->u1.str,"macro") == 0
2521 || strcasecmp(item->u1.str,"macroexclusive") == 0
2522 || strcasecmp(item->u1.str,"macroif") == 0
2523 || strcasecmp(item->u1.str,"stackpop") == 0
2524 || strcasecmp(item->u1.str,"execIf") == 0 ) {
2525 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: application call to %s affects flow of control, and needs to be re-written using AEL if, while, goto, etc. keywords instead!\n",
2526 item->filename, item->startline, item->endline, item->u1.str);
2527 warns++;
2528 }
2529 if (strcasecmp(item->u1.str,"macroexit") == 0) {
2530 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: I am converting the MacroExit call here to a return statement.\n",
2531 item->filename, item->startline, item->endline);
2532 item->type = PV_RETURN;
2533 free(item->u1.str);
2534 item->u1.str = 0;
2535 }
2536
2537#ifdef AAL_ARGCHECK
2538 found = 0;
2539 for (app=apps; app; app=app->next) {
2540 if (strcasecmp(app->name, item->u1.str) == 0) {
2541 found =app;
2542 break;
2543 }
2544 }
2545 if (!found) {
2546 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: application call to %s not listed in applist database!\n",
2547 item->filename, item->startline, item->endline, item->u1.str);
2548 warns++;
2549 } else
2550 check_app_args(item, item->u2.arglist, app);
2551#endif
2552 break;
2553
2554 case PV_CASE:
2555 /* fields: item->u1.str == value of case
2556 item->u2.statements == pval list of statements under the case
2557 */
2558 /* Make sure sequence of statements under case is terminated with goto, return, or break */
2559 /* find the last statement */
2560 check_pval(item->u2.statements, apps,in_globals);
2561 break;
2562
2563 case PV_PATTERN:
2564 /* fields: item->u1.str == value of case
2565 item->u2.statements == pval list of statements under the case
2566 */
2567 /* Make sure sequence of statements under case is terminated with goto, return, or break */
2568 /* find the last statement */
2569
2570 check_pval(item->u2.statements, apps,in_globals);
2571 break;
2572
2573 case PV_DEFAULT:
2574 /* fields:
2575 item->u2.statements == pval list of statements under the case
2576 */
2577
2578 check_pval(item->u2.statements, apps,in_globals);
2579 break;
2580
2581 case PV_CATCH:
2582 /* fields: item->u1.str == name of extension to catch
2583 item->u2.statements == pval list of statements in context body
2584 */
2585 check_pval(item->u2.statements, apps,in_globals);
2586 break;
2587
2588 case PV_SWITCHES:
2589 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
2590 */
2591 check_pval(item->u1.list, apps,in_globals);
2592 break;
2593
2594 case PV_ESWITCHES:
2595 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
2596 */
2597 check_pval(item->u1.list, apps,in_globals);
2598 break;
2599
2600 case PV_INCLUDES:
2601 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
2602 */
2603 check_pval(item->u1.list, apps,in_globals);
2605 for (lp=item->u1.list; lp; lp=lp->next){
2606 char *incl_context = lp->u1.str;
2607 struct pval *that_context = find_context(incl_context);
2608
2609 if ( lp->u2.arglist ) {
2611 check_dow(lp->u2.arglist->next);
2612 check_day(lp->u2.arglist->next->next);
2614 }
2615
2616 if (that_context) {
2617 find_pval_gotos(that_context->u2.statements,0);
2618
2619 }
2620 }
2621 break;
2622
2623 case PV_STATEMENTBLOCK:
2624 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
2625 */
2626 check_pval(item->u1.list, apps,in_globals);
2627 break;
2628
2629 case PV_VARDEC:
2630 /* fields: item->u1.str == variable name
2631 item->u2.val == variable value to assign
2632 */
2633 /* the RHS of a vardec is encapsulated in a $[] expr. Is it legal? */
2634 if( !in_globals ) { /* don't check stuff inside the globals context; no wrapping in $[ ] there... */
2635 snprintf(errmsg,sizeof(errmsg), "file %s, line %d, columns %d-%d, variable declaration expr '%s':", item->filename, item->startline, item->startcol, item->endcol, item->u2.val);
2637 ast_expr(item->u2.val, expr_output, sizeof(expr_output),NULL);
2639 if ( strpbrk(item->u2.val,"~!-+<>=*/&^") && !strstr(item->u2.val,"${") ) {
2640 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2641 item->filename, item->startline, item->endline, item->u2.val);
2642 warns++;
2643 }
2644 check_expr2_input(item,item->u2.val);
2645 }
2646 break;
2647
2648 case PV_LOCALVARDEC:
2649 /* fields: item->u1.str == variable name
2650 item->u2.val == variable value to assign
2651 */
2652 /* the RHS of a vardec is encapsulated in a $[] expr. Is it legal? */
2653 snprintf(errmsg,sizeof(errmsg), "file %s, line %d, columns %d-%d, variable declaration expr '%s':", item->filename, item->startline, item->startcol, item->endcol, item->u2.val);
2655 ast_expr(item->u2.val, expr_output, sizeof(expr_output),NULL);
2657 if ( strpbrk(item->u2.val,"~!-+<>=*/&^") && !strstr(item->u2.val,"${") ) {
2658 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2659 item->filename, item->startline, item->endline, item->u2.val);
2660 warns++;
2661 }
2662 check_expr2_input(item,item->u2.val);
2663 break;
2664
2665 case PV_GOTO:
2666 /* fields: item->u1.list == pval list of PV_WORD target names, up to 3, in order as given by user.
2667 item->u1.list->u1.str == where the data on a PV_WORD will always be.
2668 */
2669 /* don't check goto's in abstract contexts */
2670 if ( in_abstract_context )
2671 break;
2672
2674 break;
2675
2676 case PV_LABEL:
2677 /* fields: item->u1.str == label name
2678 */
2679 if ( strspn(item->u1.str, "0123456789") == strlen(item->u1.str) ) {
2680 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: label '%s' is numeric, this is bad practice!\n",
2681 item->filename, item->startline, item->endline, item->u1.str);
2682 warns++;
2683 }
2684
2686 break;
2687
2688 case PV_FOR:
2689 /* fields: item->u1.for_init == a string containing the initializer
2690 item->u2.for_test == a string containing the loop test
2691 item->u3.for_inc == a string containing the loop increment
2692
2693 item->u4.for_statements == a pval list of statements in the for ()
2694 */
2695 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, for test expr '%s':", item->filename, item->startline, item->startcol, item->endcol, item->u2.for_test);
2697
2698 strp = strchr(item->u1.for_init, '=');
2699 if (strp) {
2700 ast_expr(strp+1, expr_output, sizeof(expr_output),NULL);
2701 }
2702 ast_expr(item->u2.for_test, expr_output, sizeof(expr_output),NULL);
2703 strp = strchr(item->u3.for_inc, '=');
2704 if (strp) {
2705 ast_expr(strp+1, expr_output, sizeof(expr_output),NULL);
2706 }
2707 if ( strpbrk(item->u2.for_test,"~!-+<>=*/&^") && !strstr(item->u2.for_test,"${") ) {
2708 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2709 item->filename, item->startline, item->endline, item->u2.for_test);
2710 warns++;
2711 }
2712 if ( strpbrk(item->u3.for_inc,"~!-+<>=*/&^") && !strstr(item->u3.for_inc,"${") ) {
2713 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2714 item->filename, item->startline, item->endline, item->u3.for_inc);
2715 warns++;
2716 }
2717 check_expr2_input(item,item->u2.for_test);
2718 check_expr2_input(item,item->u3.for_inc);
2719
2721 check_pval(item->u4.for_statements, apps,in_globals);
2722 break;
2723
2724 case PV_WHILE:
2725 /* fields: item->u1.str == the while conditional, as supplied by user
2726
2727 item->u2.statements == a pval list of statements in the while ()
2728 */
2729 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, while expr '%s':", item->filename, item->startline, item->startcol, item->endcol, item->u1.str);
2731 ast_expr(item->u1.str, expr_output, sizeof(expr_output),NULL);
2733 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2734 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2735 item->filename, item->startline, item->endline, item->u1.str);
2736 warns++;
2737 }
2738 check_expr2_input(item,item->u1.str);
2739 check_pval(item->u2.statements, apps,in_globals);
2740 break;
2741
2742 case PV_BREAK:
2743 /* fields: none
2744 */
2746 break;
2747
2748 case PV_RETURN:
2749 /* fields: none
2750 */
2751 break;
2752
2753 case PV_CONTINUE:
2754 /* fields: none
2755 */
2757 break;
2758
2759 case PV_RANDOM:
2760 /* fields: item->u1.str == the random number expression, as supplied by user
2761
2762 item->u2.statements == a pval list of statements in the if ()
2763 item->u3.else_statements == a pval list of statements in the else
2764 (could be zero)
2765 */
2766 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, random expr '%s':", item->filename, item->startline, item->startcol, item->endcol, item->u1.str);
2768 ast_expr(item->u1.str, expr_output, sizeof(expr_output),NULL);
2770 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2771 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: random expression '%s' has operators, but no variables. Interesting...\n",
2772 item->filename, item->startline, item->endline, item->u1.str);
2773 warns++;
2774 }
2775 check_expr2_input(item,item->u1.str);
2776 check_pval(item->u2.statements, apps,in_globals);
2777 if (item->u3.else_statements) {
2778 check_pval(item->u3.else_statements, apps,in_globals);
2779 }
2780 break;
2781
2782 case PV_IFTIME:
2783 /* fields: item->u1.list == the if time values, 4 of them, each in PV_WORD, linked list
2784
2785 item->u2.statements == a pval list of statements in the if ()
2786 item->u3.else_statements == a pval list of statements in the else
2787 (could be zero)
2788 */
2789 if ( item->u2.arglist ) {
2790 check_timerange(item->u1.list);
2791 check_dow(item->u1.list->next);
2792 check_day(item->u1.list->next->next);
2793 check_month(item->u1.list->next->next->next);
2794 }
2795
2796 check_pval(item->u2.statements, apps,in_globals);
2797 if (item->u3.else_statements) {
2798 check_pval(item->u3.else_statements, apps,in_globals);
2799 }
2800 break;
2801
2802 case PV_IF:
2803 /* fields: item->u1.str == the if conditional, as supplied by user
2804
2805 item->u2.statements == a pval list of statements in the if ()
2806 item->u3.else_statements == a pval list of statements in the else
2807 (could be zero)
2808 */
2809 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, if expr '%s':", item->filename, item->startline, item->startcol, item->endcol, item->u1.str);
2811 ast_expr(item->u1.str, expr_output, sizeof(expr_output),NULL);
2813 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2814 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression '%s' has operators, but no variables. Interesting...\n",
2815 item->filename, item->startline, item->endline, item->u1.str);
2816 warns++;
2817 }
2818 check_expr2_input(item,item->u1.str);
2819 check_pval(item->u2.statements, apps,in_globals);
2820 if (item->u3.else_statements) {
2821 check_pval(item->u3.else_statements, apps,in_globals);
2822 }
2823 break;
2824
2825 case PV_SWITCH:
2826 /* fields: item->u1.str == the switch expression
2827
2828 item->u2.statements == a pval list of statements in the switch,
2829 (will be case statements, most likely!)
2830 */
2831 /* we can check the switch expression, see if it matches any of the app variables...
2832 if it does, then, are all the possible cases accounted for? */
2834 check_pval(item->u2.statements, apps,in_globals);
2835 break;
2836
2837 case PV_EXTENSION:
2838 /* fields: item->u1.str == the extension name, label, whatever it's called
2839
2840 item->u2.statements == a pval list of statements in the extension
2841 item->u3.hints == a char * hint argument
2842 item->u4.regexten == an int boolean. non-zero says that regexten was specified
2843 */
2845
2846 check_pval(item->u2.statements, apps,in_globals);
2847 break;
2848
2849 case PV_IGNOREPAT:
2850 /* fields: item->u1.str == the ignorepat data
2851 */
2852 break;
2853
2854 case PV_GLOBALS:
2855 /* fields: item->u1.statements == pval list of statements, usually vardecs
2856 */
2858 check_pval(item->u1.statements, apps, 1);
2859 break;
2860 default:
2861 break;
2862 }
2863}
int ast_expr(char *expr, char *buf, int length, struct ast_channel *chan)
Evaluate the given expression.
Definition: ast_expr2f.c:2391
@ E_MATCH
Definition: extconf.h:217
#define STATUS_SUCCESS
Definition: extconf.h:248
#define LOG_ERROR
struct ast_exten * pbx_find_extension(struct ast_channel *chan, struct ast_context *bypass, struct pbx_find_info *q, const char *context, const char *exten, int priority, const char *label, const char *callerid, enum ext_match_t action)
Definition: ael_main.c:152
static int check_continue(pval *item)
Definition: pval.c:1058
void check_switch_expr(pval *item, struct argapp *apps)
Definition: pval.c:2184
static void check_macro_returns(pval *macro)
Definition: pval.c:650
static void check_day(pval *DAY)
Definition: pval.c:937
struct pval * find_macro(char *name)
Definition: pval.c:1943
static void check_label(pval *item)
Definition: pval.c:1106
static void find_pval_gotos(pval *item, int lev)
Definition: pval.c:1550
int check_app_args(pval *appcall, pval *arglist, struct argapp *app)
Definition: pval.c:2130
static void check_dow(pval *DOW)
get_dow: Get day of week
Definition: pval.c:898
static void check_goto(pval *item)
Definition: pval.c:1225
static void check_abstract_reference(pval *abstract_context)
Definition: pval.c:2329
static void check_timerange(pval *p)
Definition: pval.c:830
static void check_includes(pval *includes)
Definition: pval.c:811
static void check_month(pval *MON)
Definition: pval.c:1000
static int errs
Definition: pval.c:65
void check_pval(pval *item, struct argapp *apps, int in_globals)
Definition: pval.c:2865
static int in_abstract_context
Definition: pval.c:79
static pval * current_context
Definition: pval.c:73
struct pval * find_context(char *name)
Definition: pval.c:1953
int localized_pbx_load_module(void)
Definition: extconf.c:5644
static pval * current_extension
Definition: pval.c:74
static void check_expr2_input(pval *expr, char *str)
Definition: pval.c:801
static int check_break(pval *item)
Definition: pval.c:1038
static char expr_output[2096]
Definition: pval.c:60
void ast_expr_clear_extra_error_info(void)
Definition: ast_expr2f.c:2469
void ast_expr_register_extra_error_info(char *errmsg)
Definition: ast_expr2f.c:2463
enum aco_type_t type
Definition: pval.h:111
int stacklen
Definition: extconf.h:237

References app, pval::arglist, ast_expr(), ast_expr_clear_extra_error_info(), ast_expr_register_extra_error_info(), ast_log, check_abstract_reference(), check_app_args(), check_break(), check_continue(), check_day(), check_dow(), check_expr2_input(), check_goto(), check_includes(), check_label(), check_macro_returns(), check_month(), check_pval(), check_switch_expr(), check_timerange(), current_context, current_extension, E_MATCH, errs, expr_output, find_context(), find_macro(), find_pval_gotos(), free(), in_abstract_context, item, localized_pbx_load_module(), LOG_ERROR, LOG_WARNING, pval::next, NULL, pbx_find_extension(), PV_APPLICATION_CALL, PV_BREAK, PV_CASE, PV_CATCH, PV_CONTEXT, PV_CONTINUE, PV_DEFAULT, PV_ESWITCHES, PV_EXTENSION, PV_FOR, PV_GLOBALS, PV_GOTO, PV_IF, PV_IFTIME, PV_IGNOREPAT, PV_INCLUDES, PV_LABEL, PV_LOCALVARDEC, PV_MACRO, PV_MACRO_CALL, PV_PATTERN, PV_RANDOM, PV_RETURN, PV_STATEMENTBLOCK, PV_SWITCH, PV_SWITCHES, PV_VARDEC, PV_WHILE, PV_WORD, pbx_find_info::stacklen, pval::statements, pbx_find_info::status, STATUS_SUCCESS, pval::str, aco_type::type, pval::type, pval::u1, pval::u2, and warns.

◆ check_switch_expr()

void check_switch_expr ( pval item,
struct argapp apps 
)

Definition at line 2184 of file pval.c.

2185{
2186#ifdef AAL_ARGCHECK
2187 /* get and clean the variable name */
2188 char *buff1, *p;
2189 struct argapp *a,*a2;
2190 struct appsetvar *v,*v2;
2191 struct argchoice *c;
2192 pval *t;
2193
2194 p = item->u1.str;
2195 while (p && *p && (*p == ' ' || *p == '\t' || *p == '$' || *p == '{' ) )
2196 p++;
2197
2198 buff1 = ast_strdupa(p);
2199
2200 while (strlen(buff1) > 0 && ( buff1[strlen(buff1)-1] == '}' || buff1[strlen(buff1)-1] == ' ' || buff1[strlen(buff1)-1] == '\t'))
2201 buff1[strlen(buff1)-1] = 0;
2202 /* buff1 now contains the variable name */
2203 v = 0;
2204 for (a=apps; a; a=a->next) {
2205 for (v=a->setvars;v;v=v->next) {
2206 if (strcmp(v->name,buff1) == 0) {
2207 break;
2208 }
2209 }
2210 if ( v )
2211 break;
2212 }
2213 if (v && v->vals) {
2214 /* we have a match, to a variable that has a set of determined values */
2215 int def= 0;
2216 int pat = 0;
2217 int f1 = 0;
2218
2219 /* first of all, does this switch have a default case ? */
2220 for (t=item->u2.statements; t; t=t->next) {
2221 if (t->type == PV_DEFAULT) {
2222 def =1;
2223 break;
2224 }
2225 if (t->type == PV_PATTERN) {
2226 pat++;
2227 }
2228 }
2229 if (def || pat) /* nothing to check. All cases accounted for! */
2230 return;
2231 for (c=v->vals; c; c=c->next) {
2232 f1 = 0;
2233 for (t=item->u2.statements; t; t=t->next) {
2234 if (t->type == PV_CASE || t->type == PV_PATTERN) {
2235 if (!strcmp(t->u1.str,c->name)) {
2236 f1 = 1;
2237 break;
2238 }
2239 }
2240 }
2241 if (!f1) {
2242 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: switch with expression(%s) does not handle the case of %s !\n",
2243 item->filename, item->startline, item->endline, item->u1.str, c->name);
2244 warns++;
2245 }
2246 }
2247 /* next, is there an app call in the current exten, that would set this var? */
2248 f1 = 0;
2250 if ( t && t->type == PV_STATEMENTBLOCK )
2251 t = t->u1.statements;
2252 for (; t && t != item; t=t->next) {
2253 if (t->type == PV_APPLICATION_CALL) {
2254 /* find the application that matches the u1.str */
2255 for (a2=apps; a2; a2=a2->next) {
2256 if (strcasecmp(a2->name, t->u1.str)==0) {
2257 for (v2=a2->setvars; v2; v2=v2->next) {
2258 if (strcmp(v2->name, buff1) == 0) {
2259 /* found an app that sets the var */
2260 f1 = 1;
2261 break;
2262 }
2263 }
2264 }
2265 if (f1)
2266 break;
2267 }
2268 }
2269 if (f1)
2270 break;
2271 }
2272
2273 /* see if it sets the var */
2274 if (!f1) {
2275 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: Couldn't find an application call in this extension that sets the expression (%s) value!\n",
2276 item->filename, item->startline, item->endline, item->u1.str);
2277 warns++;
2278 }
2279 }
2280#else
2281 pval *t,*tl=0,*p2;
2282 int def= 0;
2283
2284 /* first of all, does this switch have a default case ? */
2285 for (t=item->u2.statements; t; t=t->next) {
2286 if (t->type == PV_DEFAULT) {
2287 def =1;
2288 break;
2289 }
2290 tl = t;
2291 }
2292 if (def) /* nothing to check. All cases accounted for! */
2293 return;
2294 /* if no default, warn and insert a default case at the end */
2295 p2 = tl->next = calloc(1, sizeof(struct pval));
2296
2297 p2->type = PV_DEFAULT;
2298 p2->startline = tl->startline;
2299 p2->endline = tl->endline;
2300 p2->startcol = tl->startcol;
2301 p2->endcol = tl->endcol;
2302 p2->filename = strdup(tl->filename);
2303 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: A default case was automatically added to the switch.\n",
2304 p2->filename, p2->startline, p2->endline);
2305 warns++;
2306
2307#endif
2308}
#define calloc(a, b)
Definition: astmm.h:155
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
struct argapp * next
Definition: pval.h:112
int startcol
Definition: pval.h:53
int endcol
Definition: pval.h:54
struct test_val * next
const char * name
static struct test_val a

References a, ast_log, ast_strdupa, c, calloc, current_extension, pval::endcol, pval::endline, pval::filename, item, LOG_WARNING, test_val::name, pval::next, argapp::next, test_val::next, PV_APPLICATION_CALL, PV_CASE, PV_DEFAULT, PV_PATTERN, PV_STATEMENTBLOCK, pval::startcol, pval::startline, pval::statements, pval::str, strdup, pval::type, pval::u1, pval::u2, and warns.

◆ count_labels_in_current_context()

int count_labels_in_current_context ( char *  label)

◆ destroy_extensions()

void destroy_extensions ( struct ael_extension exten)

Definition at line 2978 of file pval.c.

2979{
2980 struct ael_extension *ne, *nen;
2981 for (ne=exten; ne; ne=nen) {
2982 struct ael_priority *pe, *pen;
2983
2984 if (ne->name)
2985 free(ne->name);
2986
2987 /* cidmatch fields are allocated with name, and freed when
2988 the name field is freed. Don't do a free for this field,
2989 unless you LIKE to see a crash! */
2990
2991 if (ne->hints)
2992 free(ne->hints);
2993
2994 for (pe=ne->plist; pe; pe=pen) {
2995 pen = pe->next;
2996 if (pe->app)
2997 free(pe->app);
2998 pe->app = 0;
2999 if (pe->appargs)
3000 free(pe->appargs);
3001 pe->appargs = 0;
3002 pe->origin = 0;
3003 pe->goto_true = 0;
3004 pe->goto_false = 0;
3005 free(pe);
3006 }
3007 nen = ne->next_exten;
3008 ne->next_exten = 0;
3009 ne->plist =0;
3010 ne->plist_last = 0;
3011 ne->next_exten = 0;
3012 ne->loop_break = 0;
3013 ne->loop_continue = 0;
3014 free(ne);
3015 }
3016}
struct ael_priority * loop_break
Definition: ael_structs.h:119
struct ael_priority * loop_continue
Definition: ael_structs.h:120

References ael_priority::app, ael_priority::appargs, free(), ael_priority::goto_false, ael_priority::goto_true, ael_extension::hints, ael_extension::loop_break, ael_extension::loop_continue, ael_extension::name, ael_priority::next, ael_extension::next_exten, ael_priority::origin, ael_extension::plist, and ael_extension::plist_last.

◆ destroy_pval()

void destroy_pval ( pval item)

Definition at line 4940 of file pval.c.

4941{
4942 pval *i,*nxt;
4943
4944 for (i=item; i; i=nxt) {
4945 nxt = i->next;
4946
4948 }
4949}
void destroy_pval_item(pval *item)
Definition: pval.c:4672

◆ destroy_pval_item()

void destroy_pval_item ( pval item)

Definition at line 4672 of file pval.c.

4673{
4674 if (item == NULL) {
4675 ast_log(LOG_WARNING, "null item\n");
4676 return;
4677 }
4678
4679 if (item->filename)
4680 free(item->filename);
4681
4682 switch (item->type) {
4683 case PV_WORD:
4684 /* fields: item->u1.str == string associated with this (word). */
4685 if (item->u1.str )
4686 free(item->u1.str);
4687 if ( item->u2.arglist )
4688 destroy_pval(item->u2.arglist);
4689 break;
4690
4691 case PV_MACRO:
4692 /* fields: item->u1.str == name of macro
4693 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
4694 item->u2.arglist->u1.str == argument
4695 item->u2.arglist->next == next arg
4696
4697 item->u3.macro_statements == pval list of statements in macro body.
4698 */
4699 destroy_pval(item->u2.arglist);
4700 if (item->u1.str )
4701 free(item->u1.str);
4702 destroy_pval(item->u3.macro_statements);
4703 break;
4704
4705 case PV_CONTEXT:
4706 /* fields: item->u1.str == name of context
4707 item->u2.statements == pval list of statements in context body
4708 item->u3.abstract == int 1 if an abstract keyword were present
4709 */
4710 if (item->u1.str)
4711 free(item->u1.str);
4712 destroy_pval(item->u2.statements);
4713 break;
4714
4715 case PV_MACRO_CALL:
4716 /* fields: item->u1.str == name of macro to call
4717 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
4718 item->u2.arglist->u1.str == argument
4719 item->u2.arglist->next == next arg
4720 */
4721 if (item->u1.str)
4722 free(item->u1.str);
4723 destroy_pval(item->u2.arglist);
4724 break;
4725
4727 /* fields: item->u1.str == name of application to call
4728 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
4729 item->u2.arglist->u1.str == argument
4730 item->u2.arglist->next == next arg
4731 */
4732 if (item->u1.str)
4733 free(item->u1.str);
4734 destroy_pval(item->u2.arglist);
4735 break;
4736
4737 case PV_CASE:
4738 /* fields: item->u1.str == value of case
4739 item->u2.statements == pval list of statements under the case
4740 */
4741 if (item->u1.str)
4742 free(item->u1.str);
4743 destroy_pval(item->u2.statements);
4744 break;
4745
4746 case PV_PATTERN:
4747 /* fields: item->u1.str == value of case
4748 item->u2.statements == pval list of statements under the case
4749 */
4750 if (item->u1.str)
4751 free(item->u1.str);
4752 destroy_pval(item->u2.statements);
4753 break;
4754
4755 case PV_DEFAULT:
4756 /* fields:
4757 item->u2.statements == pval list of statements under the case
4758 */
4759 destroy_pval(item->u2.statements);
4760 break;
4761
4762 case PV_CATCH:
4763 /* fields: item->u1.str == name of extension to catch
4764 item->u2.statements == pval list of statements in context body
4765 */
4766 if (item->u1.str)
4767 free(item->u1.str);
4768 destroy_pval(item->u2.statements);
4769 break;
4770
4771 case PV_SWITCHES:
4772 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
4773 */
4774 destroy_pval(item->u1.list);
4775 break;
4776
4777 case PV_ESWITCHES:
4778 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
4779 */
4780 destroy_pval(item->u1.list);
4781 break;
4782
4783 case PV_INCLUDES:
4784 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
4785 item->u2.arglist == pval list of 4 PV_WORD elements for time values
4786 */
4787 destroy_pval(item->u1.list);
4788 break;
4789
4790 case PV_STATEMENTBLOCK:
4791 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
4792 */
4793 destroy_pval(item->u1.list);
4794 break;
4795
4796 case PV_LOCALVARDEC:
4797 case PV_VARDEC:
4798 /* fields: item->u1.str == variable name
4799 item->u2.val == variable value to assign
4800 */
4801 if (item->u1.str)
4802 free(item->u1.str);
4803 if (item->u2.val)
4804 free(item->u2.val);
4805 break;
4806
4807 case PV_GOTO:
4808 /* fields: item->u1.list == pval list of PV_WORD target names, up to 3, in order as given by user.
4809 item->u1.list->u1.str == where the data on a PV_WORD will always be.
4810 */
4811
4812 destroy_pval(item->u1.list);
4813 break;
4814
4815 case PV_LABEL:
4816 /* fields: item->u1.str == label name
4817 */
4818 if (item->u1.str)
4819 free(item->u1.str);
4820 break;
4821
4822 case PV_FOR:
4823 /* fields: item->u1.for_init == a string containing the initializer
4824 item->u2.for_test == a string containing the loop test
4825 item->u3.for_inc == a string containing the loop increment
4826
4827 item->u4.for_statements == a pval list of statements in the for ()
4828 */
4829 if (item->u1.for_init)
4830 free(item->u1.for_init);
4831 if (item->u2.for_test)
4832 free(item->u2.for_test);
4833 if (item->u3.for_inc)
4834 free(item->u3.for_inc);
4835 destroy_pval(item->u4.for_statements);
4836 break;
4837
4838 case PV_WHILE:
4839 /* fields: item->u1.str == the while conditional, as supplied by user
4840
4841 item->u2.statements == a pval list of statements in the while ()
4842 */
4843 if (item->u1.str)
4844 free(item->u1.str);
4845 destroy_pval(item->u2.statements);
4846 break;
4847
4848 case PV_BREAK:
4849 /* fields: none
4850 */
4851 break;
4852
4853 case PV_RETURN:
4854 /* fields: none
4855 */
4856 break;
4857
4858 case PV_CONTINUE:
4859 /* fields: none
4860 */
4861 break;
4862
4863 case PV_IFTIME:
4864 /* fields: item->u1.list == the 4 time values, in PV_WORD structs, linked list
4865
4866 item->u2.statements == a pval list of statements in the if ()
4867 item->u3.else_statements == a pval list of statements in the else
4868 (could be zero)
4869 */
4870 destroy_pval(item->u1.list);
4871 destroy_pval(item->u2.statements);
4872 if (item->u3.else_statements) {
4873 destroy_pval(item->u3.else_statements);
4874 }
4875 break;
4876
4877 case PV_RANDOM:
4878 /* fields: item->u1.str == the random percentage, as supplied by user
4879
4880 item->u2.statements == a pval list of statements in the true part ()
4881 item->u3.else_statements == a pval list of statements in the else
4882 (could be zero)
4883 fall thru to If */
4884 case PV_IF:
4885 /* fields: item->u1.str == the if conditional, as supplied by user
4886
4887 item->u2.statements == a pval list of statements in the if ()
4888 item->u3.else_statements == a pval list of statements in the else
4889 (could be zero)
4890 */
4891 if (item->u1.str)
4892 free(item->u1.str);
4893 destroy_pval(item->u2.statements);
4894 if (item->u3.else_statements) {
4895 destroy_pval(item->u3.else_statements);
4896 }
4897 break;
4898
4899 case PV_SWITCH:
4900 /* fields: item->u1.str == the switch expression
4901
4902 item->u2.statements == a pval list of statements in the switch,
4903 (will be case statements, most likely!)
4904 */
4905 if (item->u1.str)
4906 free(item->u1.str);
4907 destroy_pval(item->u2.statements);
4908 break;
4909
4910 case PV_EXTENSION:
4911 /* fields: item->u1.str == the extension name, label, whatever it's called
4912
4913 item->u2.statements == a pval list of statements in the extension
4914 item->u3.hints == a char * hint argument
4915 item->u4.regexten == an int boolean. non-zero says that regexten was specified
4916 */
4917 if (item->u1.str)
4918 free(item->u1.str);
4919 if (item->u3.hints)
4920 free(item->u3.hints);
4921 destroy_pval(item->u2.statements);
4922 break;
4923
4924 case PV_IGNOREPAT:
4925 /* fields: item->u1.str == the ignorepat data
4926 */
4927 if (item->u1.str)
4928 free(item->u1.str);
4929 break;
4930
4931 case PV_GLOBALS:
4932 /* fields: item->u1.statements == pval list of statements, usually vardecs
4933 */
4934 destroy_pval(item->u1.statements);
4935 break;
4936 }
4937 free(item);
4938}
void destroy_pval(pval *item)
Definition: pval.c:4940

References ast_log, destroy_pval(), free(), item, LOG_WARNING, NULL, PV_APPLICATION_CALL, PV_BREAK, PV_CASE, PV_CATCH, PV_CONTEXT, PV_CONTINUE, PV_DEFAULT, PV_ESWITCHES, PV_EXTENSION, PV_FOR, PV_GLOBALS, PV_GOTO, PV_IF, PV_IFTIME, PV_IGNOREPAT, PV_INCLUDES, PV_LABEL, PV_LOCALVARDEC, PV_MACRO, PV_MACRO_CALL, PV_PATTERN, PV_RANDOM, PV_RETURN, PV_STATEMENTBLOCK, PV_SWITCH, PV_SWITCHES, PV_VARDEC, PV_WHILE, PV_WORD, and aco_type::type.

◆ do_pbx_load_module()

int do_pbx_load_module ( void  )

◆ find_context()

struct pval * find_context ( char *  name)

Definition at line 1953 of file pval.c.

1954{
1956 count_labels = 0;
1958 match_exten = "*"; /* don't really need to set these, shouldn't be reached */
1959 match_label = "*";
1960 return match_pval(current_db);
1961}
static const char name[]
Definition: format_mp3.c:68
static const char * match_context
Definition: pval.c:76
struct pval * match_pval(pval *item)
Definition: pval.c:1811
static pval * current_db
Definition: pval.c:72
static int count_labels
Definition: pval.c:80
static int return_on_context_match
Definition: pval.c:82
static const char * match_label
Definition: pval.c:78
static const char * match_exten
Definition: pval.c:77

References count_labels, current_db, match_context, match_exten, match_label, match_pval(), name, and return_on_context_match.

◆ find_macro()

struct pval * find_macro ( char *  name)

Definition at line 1943 of file pval.c.

1944{
1946 count_labels = 0;
1948 match_exten = "*"; /* don't really need to set these, shouldn't be reached */
1949 match_label = "*";
1950 return match_pval(current_db);
1951}

References count_labels, current_db, match_context, match_exten, match_label, match_pval(), name, and return_on_context_match.

Referenced by check_pval_item().

◆ is_empty()

int is_empty ( char *  arg)

Definition at line 1981 of file pval.c.

1982{
1983 if (!arg)
1984 return 1;
1985 if (*arg == 0)
1986 return 1;
1987 while (*arg) {
1988 if (*arg != ' ' && *arg != '\t')
1989 return 0;
1990 arg++;
1991 }
1992 return 1;
1993}

◆ is_float()

int is_float ( char *  arg)

Definition at line 1963 of file pval.c.

1964{
1965 char *s;
1966 for (s=arg; *s; s++) {
1967 if (*s != '.' && (*s < '0' || *s > '9'))
1968 return 0;
1969 }
1970 return 1;
1971}

◆ is_int()

int is_int ( char *  arg)

Definition at line 1972 of file pval.c.

1973{
1974 char *s;
1975 for (s=arg; *s; s++) {
1976 if (*s < '0' || *s > '9')
1977 return 0;
1978 }
1979 return 1;
1980}

◆ linkprio()

void linkprio ( struct ael_extension exten,
struct ael_priority prio,
struct ael_extension mother_exten 
)

Definition at line 2936 of file pval.c.

2937{
2938 char *p1, *p2;
2939
2940 if (!exten->plist) {
2941 exten->plist = prio;
2942 exten->plist_last = prio;
2943 } else {
2944 exten->plist_last->next = prio;
2945 exten->plist_last = prio;
2946 }
2947 if( !prio->exten )
2948 prio->exten = exten; /* don't override the switch value */
2949 /* The following code will cause all priorities within an extension
2950 to have ${EXTEN} or ${EXTEN: replaced with ~~EXTEN~~, which is
2951 set just before the first switch in an exten. The switches
2952 will muck up the original ${EXTEN} value, so we save it away
2953 and the user accesses this copy instead. */
2954 if (prio->appargs && ((mother_exten && mother_exten->has_switch) || exten->has_switch) ) {
2955 while ((p1 = strstr(prio->appargs, "${EXTEN}"))) {
2956 p2 = malloc(strlen(prio->appargs)+5);
2957 *p1 = 0;
2958 strcpy(p2, prio->appargs);
2959 strcat(p2, "${~~EXTEN~~}");
2960 if (*(p1+8))
2961 strcat(p2, p1+8);
2962 free(prio->appargs);
2963 prio->appargs = p2;
2964 }
2965 while ((p1 = strstr(prio->appargs, "${EXTEN:"))) {
2966 p2 = malloc(strlen(prio->appargs)+5);
2967 *p1 = 0;
2968 strcpy(p2, prio->appargs);
2969 strcat(p2, "${~~EXTEN~~:");
2970 if (*(p1+8))
2971 strcat(p2, p1+8);
2972 free(prio->appargs);
2973 prio->appargs = p2;
2974 }
2975 }
2976}
char * malloc()

References ael_priority::appargs, ael_priority::exten, free(), ael_extension::has_switch, malloc(), ael_priority::next, ael_extension::plist, and ael_extension::plist_last.

Referenced by ast_compile_ael2(), and gen_prios().

◆ new_exten()

struct ael_extension * new_exten ( void  )

Definition at line 2930 of file pval.c.

2931{
2932 struct ael_extension *x = (struct ael_extension *)calloc(sizeof(struct ael_extension),1);
2933 return x;
2934}

References calloc.

◆ new_prio()

struct ael_priority * new_prio ( void  )

Definition at line 2924 of file pval.c.

2925{
2926 struct ael_priority *x = (struct ael_priority *)calloc(sizeof(struct ael_priority),1);
2927 return x;
2928}

References calloc.

◆ pvalAppCallAddArg()

void pvalAppCallAddArg ( pval p,
pval arg 
)

Definition at line 5268 of file pval.c.

5269{
5270 if (!pvalCheckType(p, "pvalAppCallAddArg", PV_APPLICATION_CALL))
5271 return;
5272 if (!p->u2.arglist)
5273 p->u2.arglist = arg;
5274 else
5275 linku1(p->u2.arglist, arg);
5276}
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922

References pval::arglist, linku1(), PV_APPLICATION_CALL, pvalCheckType(), and pval::u2.

◆ pvalAppCallGetAppName()

char * pvalAppCallGetAppName ( pval p)

Definition at line 5254 of file pval.c.

5255{
5256 if (!pvalCheckType(p, "pvalAppCallGetAppName", PV_APPLICATION_CALL))
5257 return 0;
5258 return p->u1.str;
5259}

References PV_APPLICATION_CALL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalAppCallSetAppName()

void pvalAppCallSetAppName ( pval p,
char *  name 
)

Definition at line 5247 of file pval.c.

5248{
5249 if (!pvalCheckType(p, "pvalAppCallSetAppName", PV_APPLICATION_CALL))
5250 return;
5251 p->u1.str = name;
5252}

References name, PV_APPLICATION_CALL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalAppCallSetArglist()

void pvalAppCallSetArglist ( pval p,
pval arglist 
)

Definition at line 5261 of file pval.c.

5262{
5263 if (!pvalCheckType(p, "pvalAppCallSetArglist", PV_APPLICATION_CALL))
5264 return;
5265 p->u2.arglist = arglist;
5266}

References pval::arglist, PV_APPLICATION_CALL, pvalCheckType(), and pval::u2.

◆ pvalAppCallWalkArgs()

pval * pvalAppCallWalkArgs ( pval p,
pval **  args 
)

Definition at line 5278 of file pval.c.

5279{
5280 if (!pvalCheckType(p, "pvalAppCallWalkArgs", PV_APPLICATION_CALL))
5281 return 0;
5282 if (!(*args))
5283 *args = p->u2.arglist;
5284 else {
5285 *args = (*args)->next;
5286 }
5287 return *args;
5288}
const char * args

References pval::arglist, args, PV_APPLICATION_CALL, pvalCheckType(), and pval::u2.

◆ pvalCasePatDefAddStatement()

void pvalCasePatDefAddStatement ( pval p,
pval statement 
)

Definition at line 5303 of file pval.c.

5304{
5305 if (!p->u2.arglist)
5306 p->u2.statements = statement;
5307 else
5308 linku1(p->u2.statements, statement);
5309}

References pval::arglist, linku1(), pval::statements, and pval::u2.

◆ pvalCasePatDefWalkStatements()

pval * pvalCasePatDefWalkStatements ( pval p,
pval **  statement 
)

Definition at line 5311 of file pval.c.

5312{
5313 if (!(*statement))
5314 *statement = p->u2.statements;
5315 else {
5316 *statement = (*statement)->next;
5317 }
5318 return *statement;
5319}

References pval::next, pval::statements, and pval::u2.

◆ pvalCasePatGetVal()

char * pvalCasePatGetVal ( pval p)

Definition at line 5298 of file pval.c.

5299{
5300 return p->u1.str;
5301}

References pval::str, and pval::u1.

◆ pvalCasePatSetVal()

void pvalCasePatSetVal ( pval p,
char *  val 
)

Definition at line 5291 of file pval.c.

5292{
5293 if (!pvalCheckType(p, "pvalAppCallWalkArgs", PV_APPLICATION_CALL))
5294 return;
5295 p->u1.str = val;
5296}
Definition: ast_expr2.c:325

References PV_APPLICATION_CALL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalCatchGetExtName()

char * pvalCatchGetExtName ( pval p)

Definition at line 5329 of file pval.c.

5330{
5331 if (!pvalCheckType(p, "pvalCatchGetExtName", PV_CATCH))
5332 return 0;
5333 return p->u1.str;
5334}

References PV_CATCH, pvalCheckType(), pval::str, and pval::u1.

◆ pvalCatchGetStatement()

pval * pvalCatchGetStatement ( pval p)

Definition at line 5343 of file pval.c.

5344{
5345 if (!pvalCheckType(p, "pvalCatchGetStatement", PV_CATCH))
5346 return 0;
5347 return p->u2.statements;
5348}

References PV_CATCH, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalCatchSetExtName()

void pvalCatchSetExtName ( pval p,
char *  name 
)

Definition at line 5322 of file pval.c.

5323{
5324 if (!pvalCheckType(p, "pvalCatchSetExtName", PV_CATCH))
5325 return;
5326 p->u1.str = name;
5327}

References name, PV_CATCH, pvalCheckType(), pval::str, and pval::u1.

◆ pvalCatchSetStatement()

void pvalCatchSetStatement ( pval p,
pval statement 
)

Definition at line 5336 of file pval.c.

5337{
5338 if (!pvalCheckType(p, "pvalCatchSetStatement", PV_CATCH))
5339 return;
5340 p->u2.statements = statement;
5341}

References PV_CATCH, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalCheckType()

int pvalCheckType ( pval p,
char *  funcname,
pvaltype  type 
)

Definition at line 5031 of file pval.c.

5032{
5033 if (p->type != type)
5034 {
5035 ast_log(LOG_ERROR, "Func: %s the pval passed is not appropriate for this function!\n", funcname);
5036 return 0;
5037 }
5038 return 1;
5039}
static const char type[]
Definition: chan_ooh323.c:109

References ast_log, LOG_ERROR, type, and pval::type.

Referenced by pvalAppCallAddArg(), pvalAppCallGetAppName(), pvalAppCallSetAppName(), pvalAppCallSetArglist(), pvalAppCallWalkArgs(), pvalCasePatSetVal(), pvalCatchGetExtName(), pvalCatchGetStatement(), pvalCatchSetExtName(), pvalCatchSetStatement(), pvalContextAddStatement(), pvalContextGetAbstract(), pvalContextGetName(), pvalContextSetAbstract(), pvalContextSetName(), pvalContextUnsetAbstract(), pvalContextWalkStatements(), pvalESwitchesAddSwitch(), pvalESwitchesWalkNames(), pvalExtenGetHints(), pvalExtenGetName(), pvalExtenGetRegexten(), pvalExtenGetStatement(), pvalExtenSetHints(), pvalExtenSetName(), pvalExtenSetRegexten(), pvalExtenSetStatement(), pvalExtenUnSetRegexten(), pvalForGetInc(), pvalForGetInit(), pvalForGetStatement(), pvalForGetTest(), pvalForSetInc(), pvalForSetInit(), pvalForSetStatement(), pvalForSetTest(), pvalGlobalsWalkStatements(), pvalGotoGetTarget(), pvalGotoSetTarget(), pvalIfGetCondition(), pvalIfSetCondition(), pvalIfTimeGetCondition(), pvalIfTimeSetCondition(), pvalIgnorePatGetPattern(), pvalIgnorePatSetPattern(), pvalIncludeGetTimeConstraints(), pvalIncludesAddInclude(), pvalIncludesAddIncludeWithTimeConstraints(), pvalIncludesWalk(), pvalLabelGetName(), pvalLabelSetName(), pvalMacroAddArg(), pvalMacroAddStatement(), pvalMacroCallAddArg(), pvalMacroCallGetMacroName(), pvalMacroCallSetArglist(), pvalMacroCallSetMacroName(), pvalMacroCallWalkArgs(), pvalMacroGetName(), pvalMacroSetArglist(), pvalMacroSetName(), pvalMacroWalkArgs(), pvalMacroWalkStatements(), pvalRandomGetCondition(), pvalRandomSetCondition(), pvalStatementBlockAddStatement(), pvalStatementBlockWalkStatements(), pvalSwitchAddCase(), pvalSwitchesAddSwitch(), pvalSwitchesWalkNames(), pvalSwitchGetTestexpr(), pvalSwitchSetTestexpr(), pvalSwitchWalkCases(), pvalVarDecGetValue(), pvalVarDecGetVarname(), pvalVarDecSetValue(), pvalVarDecSetVarname(), pvalWordGetString(), and pvalWordSetString().

◆ pvalConditionalGetElseStatement()

pval * pvalConditionalGetElseStatement ( pval p)

Definition at line 5751 of file pval.c.

5752{
5753 return p->u3.else_statements;
5754}

References pval::else_statements, and pval::u3.

◆ pvalConditionalGetThenStatement()

pval * pvalConditionalGetThenStatement ( pval p)

Definition at line 5746 of file pval.c.

5747{
5748 return p->u2.statements;
5749}

References pval::statements, and pval::u2.

◆ pvalConditionalSetElseStatement()

void pvalConditionalSetElseStatement ( pval p,
pval statement 
)

Definition at line 5741 of file pval.c.

5742{
5743 p->u3.else_statements = statement;
5744}

References pval::else_statements, and pval::u3.

◆ pvalConditionalSetThenStatement()

void pvalConditionalSetThenStatement ( pval p,
pval statement 
)

Definition at line 5736 of file pval.c.

5737{
5738 p->u2.statements = statement;
5739}

References pval::statements, and pval::u2.

◆ pvalContextAddStatement()

void pvalContextAddStatement ( pval p,
pval statement 
)

Definition at line 5180 of file pval.c.

5181{
5182 if (!pvalCheckType(p, "pvalContextAddStatement", PV_CONTEXT))
5183 return;
5184 if (!p->u2.statements)
5185 p->u2.statements = statement;
5186 else
5187 linku1(p->u2.statements, statement);
5188}

References linku1(), PV_CONTEXT, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalContextGetAbstract()

int pvalContextGetAbstract ( pval p)

Definition at line 5171 of file pval.c.

5172{
5173 if (!pvalCheckType(p, "pvalContextGetAbstract", PV_CONTEXT))
5174 return 0;
5175 return p->u3.abstract;
5176}
int abstract
Definition: pval.h:80

References pval::abstract, PV_CONTEXT, pvalCheckType(), and pval::u3.

◆ pvalContextGetName()

char * pvalContextGetName ( pval p)

Definition at line 5150 of file pval.c.

5151{
5152 if (!pvalCheckType(p, "pvalContextGetName", PV_CONTEXT))
5153 return 0;
5154 return p->u1.str;
5155}

References PV_CONTEXT, pvalCheckType(), pval::str, and pval::u1.

◆ pvalContextSetAbstract()

void pvalContextSetAbstract ( pval p)

Definition at line 5157 of file pval.c.

5158{
5159 if (!pvalCheckType(p, "pvalContextSetAbstract", PV_CONTEXT))
5160 return;
5161 p->u3.abstract = 1;
5162}

References pval::abstract, PV_CONTEXT, pvalCheckType(), and pval::u3.

◆ pvalContextSetName()

void pvalContextSetName ( pval p,
char *  name 
)

Definition at line 5143 of file pval.c.

5144{
5145 if (!pvalCheckType(p, "pvalContextSetName", PV_CONTEXT))
5146 return;
5147 p->u1.str = name;
5148}

References name, PV_CONTEXT, pvalCheckType(), pval::str, and pval::u1.

◆ pvalContextUnsetAbstract()

void pvalContextUnsetAbstract ( pval p)

Definition at line 5164 of file pval.c.

5165{
5166 if (!pvalCheckType(p, "pvalContextUnsetAbstract", PV_CONTEXT))
5167 return;
5168 p->u3.abstract = 0;
5169}

References pval::abstract, PV_CONTEXT, pvalCheckType(), and pval::u3.

◆ pvalContextWalkStatements()

pval * pvalContextWalkStatements ( pval p,
pval **  statements 
)

Definition at line 5190 of file pval.c.

5191{
5192 if (!pvalCheckType(p, "pvalContextWalkStatements", PV_CONTEXT))
5193 return 0;
5194 if (!(*statements))
5195 *statements = p->u2.statements;
5196 else {
5197 *statements = (*statements)->next;
5198 }
5199 return *statements;
5200}

References pval::next, PV_CONTEXT, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalCreateNode()

pval * pvalCreateNode ( pvaltype  type)

Definition at line 5042 of file pval.c.

5043{
5044 pval *p = calloc(1,sizeof(pval)); /* why, oh why, don't I use ast_calloc? Way, way, way too messy if I do! */
5045 /* remember, this can be used externally or internally to asterisk */
5046 if (p) {
5047 p->type = type;
5048 }
5049 return p;
5050}

References calloc, type, and pval::type.

Referenced by pvalESwitchesAddSwitch(), pvalGotoSetTarget(), pvalIfTimeSetCondition(), pvalIncludesAddInclude(), pvalIncludesAddIncludeWithTimeConstraints(), and pvalSwitchesAddSwitch().

◆ pvalESwitchesAddSwitch()

void pvalESwitchesAddSwitch ( pval p,
char *  name 
)

Definition at line 5373 of file pval.c.

5374{
5375 pval *s;
5376 if (!pvalCheckType(p, "pvalESwitchesAddSwitch", PV_ESWITCHES))
5377 return;
5379 s->u1.str = name;
5380 p->u1.list = linku1(p->u1.list, s);
5381}
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

References linku1(), pval::list, name, PV_ESWITCHES, PV_WORD, pvalCheckType(), pvalCreateNode(), pval::str, and pval::u1.

◆ pvalESwitchesWalkNames()

char * pvalESwitchesWalkNames ( pval p,
pval **  next_item 
)

Definition at line 5383 of file pval.c.

5384{
5385 if (!pvalCheckType(p, "pvalESwitchesWalkNames", PV_ESWITCHES))
5386 return 0;
5387 if (!(*next_item))
5388 *next_item = p->u1.list;
5389 else {
5390 *next_item = (*next_item)->next;
5391 }
5392 return (*next_item)->u1.str;
5393}
static char next_item(const char *format)
Definition: say.c:4667

References pval::list, next_item(), PV_ESWITCHES, pvalCheckType(), and pval::u1.

◆ pvalExtenGetHints()

char * pvalExtenGetHints ( pval p)

Definition at line 5837 of file pval.c.

5838{
5839 if (!pvalCheckType(p, "pvalExtenGetHints", PV_EXTENSION))
5840 return 0;
5841 return p->u3.hints;
5842}

References pval::hints, PV_EXTENSION, pvalCheckType(), and pval::u3.

◆ pvalExtenGetName()

char * pvalExtenGetName ( pval p)

Definition at line 5802 of file pval.c.

5803{
5804 if (!pvalCheckType(p, "pvalExtenGetName", PV_EXTENSION))
5805 return 0;
5806 return p->u1.str;
5807}

References PV_EXTENSION, pvalCheckType(), pval::str, and pval::u1.

◆ pvalExtenGetRegexten()

int pvalExtenGetRegexten ( pval p)

Definition at line 5823 of file pval.c.

5824{
5825 if (!pvalCheckType(p, "pvalExtenGetRegexten", PV_EXTENSION))
5826 return 0;
5827 return p->u4.regexten;
5828}

References PV_EXTENSION, pvalCheckType(), pval::regexten, and pval::u4.

◆ pvalExtenGetStatement()

pval * pvalExtenGetStatement ( pval p)

Definition at line 5851 of file pval.c.

5852{
5853 if (!pvalCheckType(p, "pvalExtenGetStatement", PV_EXTENSION))
5854 return 0;
5855 return p->u2.statements;
5856}

References PV_EXTENSION, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalExtenSetHints()

void pvalExtenSetHints ( pval p,
char *  hints 
)

Definition at line 5830 of file pval.c.

5831{
5832 if (!pvalCheckType(p, "pvalExtenSetHints", PV_EXTENSION))
5833 return;
5834 p->u3.hints = hints;
5835}
static struct ao2_container * hints
Definition: pbx.c:806

References pval::hints, hints, PV_EXTENSION, pvalCheckType(), and pval::u3.

◆ pvalExtenSetName()

void pvalExtenSetName ( pval p,
char *  name 
)

Definition at line 5795 of file pval.c.

5796{
5797 if (!pvalCheckType(p, "pvalExtenSetName", PV_EXTENSION))
5798 return;
5799 p->u1.str = name;
5800}

References name, PV_EXTENSION, pvalCheckType(), pval::str, and pval::u1.

◆ pvalExtenSetRegexten()

void pvalExtenSetRegexten ( pval p)

Definition at line 5809 of file pval.c.

5810{
5811 if (!pvalCheckType(p, "pvalExtenSetRegexten", PV_EXTENSION))
5812 return;
5813 p->u4.regexten = 1;
5814}

References PV_EXTENSION, pvalCheckType(), pval::regexten, and pval::u4.

◆ pvalExtenSetStatement()

void pvalExtenSetStatement ( pval p,
pval statement 
)

Definition at line 5844 of file pval.c.

5845{
5846 if (!pvalCheckType(p, "pvalExtenSetStatement", PV_EXTENSION))
5847 return;
5848 p->u2.statements = statement;
5849}

References PV_EXTENSION, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalExtenUnSetRegexten()

void pvalExtenUnSetRegexten ( pval p)

Definition at line 5816 of file pval.c.

5817{
5818 if (!pvalCheckType(p, "pvalExtenUnSetRegexten", PV_EXTENSION))
5819 return;
5820 p->u4.regexten = 0;
5821}

References PV_EXTENSION, pvalCheckType(), pval::regexten, and pval::u4.

◆ pvalForGetInc()

char * pvalForGetInc ( pval p)

Definition at line 5647 of file pval.c.

5648{
5649 if (!pvalCheckType(p, "pvalForGetInc", PV_FOR))
5650 return 0;
5651 return p->u3.for_inc;
5652}
char * for_inc
Definition: pval.h:77

References pval::for_inc, PV_FOR, pvalCheckType(), and pval::u3.

◆ pvalForGetInit()

char * pvalForGetInit ( pval p)

Definition at line 5633 of file pval.c.

5634{
5635 if (!pvalCheckType(p, "pvalForGetInit", PV_FOR))
5636 return 0;
5637 return p->u1.for_init;
5638}
char * for_init
Definition: pval.h:62

References pval::for_init, PV_FOR, pvalCheckType(), and pval::u1.

◆ pvalForGetStatement()

pval * pvalForGetStatement ( pval p)

Definition at line 5654 of file pval.c.

5655{
5656 if (!pvalCheckType(p, "pvalForGetStatement", PV_FOR))
5657 return 0;
5658 return p->u4.for_statements;
5659}
struct pval * for_statements
Definition: pval.h:89

References pval::for_statements, PV_FOR, pvalCheckType(), and pval::u4.

◆ pvalForGetTest()

char * pvalForGetTest ( pval p)

Definition at line 5640 of file pval.c.

5641{
5642 if (!pvalCheckType(p, "pvalForGetTest", PV_FOR))
5643 return 0;
5644 return p->u2.for_test;
5645}
char * for_test
Definition: pval.h:71

References pval::for_test, PV_FOR, pvalCheckType(), and pval::u2.

◆ pvalForSetInc()

void pvalForSetInc ( pval p,
char *  inc 
)

Definition at line 5619 of file pval.c.

5620{
5621 if (!pvalCheckType(p, "pvalForSetInc", PV_FOR))
5622 return;
5623 p->u3.for_inc = inc;
5624}

References pval::for_inc, PV_FOR, pvalCheckType(), and pval::u3.

◆ pvalForSetInit()

void pvalForSetInit ( pval p,
char *  init 
)

Definition at line 5605 of file pval.c.

5606{
5607 if (!pvalCheckType(p, "pvalForSetInit", PV_FOR))
5608 return;
5609 p->u1.for_init = init;
5610}

References pval::for_init, PV_FOR, pvalCheckType(), and pval::u1.

◆ pvalForSetStatement()

void pvalForSetStatement ( pval p,
pval statement 
)

Definition at line 5626 of file pval.c.

5627{
5628 if (!pvalCheckType(p, "pvalForSetStatement", PV_FOR))
5629 return;
5630 p->u4.for_statements = statement;
5631}

References pval::for_statements, PV_FOR, pvalCheckType(), and pval::u4.

◆ pvalForSetTest()

void pvalForSetTest ( pval p,
char *  test 
)

Definition at line 5612 of file pval.c.

5613{
5614 if (!pvalCheckType(p, "pvalForSetTest", PV_FOR))
5615 return;
5616 p->u2.for_test = test;
5617}

References pval::for_test, PV_FOR, pvalCheckType(), and pval::u2.

◆ pvalGlobalsAddStatement()

void pvalGlobalsAddStatement ( pval p,
pval statement 
)

Definition at line 5874 of file pval.c.

5875{
5876 if (p->type != PV_GLOBALS) {
5877 ast_log(LOG_ERROR, "pvalGlobalsAddStatement called where first arg is not a Globals!\n");
5878 } else {
5879 if (!p->u1.statements) {
5880 p->u1.statements = statement;
5881 } else {
5882 p->u1.statements = linku1(p->u1.statements,statement);
5883 }
5884 }
5885}

References ast_log, linku1(), LOG_ERROR, PV_GLOBALS, pval::statements, pval::type, and pval::u1.

◆ pvalGlobalsWalkStatements()

pval * pvalGlobalsWalkStatements ( pval p,
pval **  next_statement 
)

Definition at line 5887 of file pval.c.

5888{
5889 if (!pvalCheckType(p, "pvalGlobalsWalkStatements", PV_GLOBALS))
5890 return 0;
5891 if (!*next_statement) {
5892 *next_statement = p;
5893 return p;
5894 } else {
5895 *next_statement = (*next_statement)->next;
5896 return (*next_statement)->next;
5897 }
5898}

References pval::next, PV_GLOBALS, and pvalCheckType().

◆ pvalGotoGetTarget()

void pvalGotoGetTarget ( pval p,
char **  context,
char **  exten,
char **  label 
)

Definition at line 5563 of file pval.c.

5564{
5565 if (!pvalCheckType(p, "pvalGotoGetTarget", PV_GOTO))
5566 return;
5567 if (p->u1.list && p->u1.list->next && p->u1.list->next->next) {
5568 *context = p->u1.list->u1.str;
5569 *exten = p->u1.list->next->u1.str;
5570 *label = p->u1.list->next->next->u1.str;
5571
5572 } else if (p->u1.list && p->u1.list->next ) {
5573 *exten = p->u1.list->u1.str;
5574 *label = p->u1.list->next->u1.str;
5575 *context = 0;
5576
5577 } else if (p->u1.list) {
5578 *label = p->u1.list->u1.str;
5579 *context = 0;
5580 *exten = 0;
5581
5582 } else {
5583 *context = 0;
5584 *exten = 0;
5585 *label = 0;
5586 }
5587}

References voicemailpwcheck::context, pval::list, pval::next, PV_GOTO, pvalCheckType(), pval::str, and pval::u1.

◆ pvalGotoSetTarget()

void pvalGotoSetTarget ( pval p,
char *  context,
char *  exten,
char *  label 
)

Definition at line 5527 of file pval.c.

5528{
5529 pval *con, *ext, *pri;
5530
5531 if (!pvalCheckType(p, "pvalGotoSetTarget", PV_GOTO))
5532 return;
5533 if (context && strlen(context)) {
5534 con = pvalCreateNode(PV_WORD);
5536 pri = pvalCreateNode(PV_WORD);
5537
5538 con->u1.str = context;
5539 ext->u1.str = exten;
5540 pri->u1.str = label;
5541
5542 con->next = ext;
5543 ext->next = pri;
5544 p->u1.list = con;
5545 } else if (exten && strlen(exten)) {
5547 pri = pvalCreateNode(PV_WORD);
5548
5549 ext->u1.str = exten;
5550 pri->u1.str = label;
5551
5552 ext->next = pri;
5553 p->u1.list = ext;
5554 } else {
5555 pri = pvalCreateNode(PV_WORD);
5556
5557 pri->u1.str = label;
5558
5559 p->u1.list = pri;
5560 }
5561}
const char * ext
Definition: http.c:150

References voicemailpwcheck::context, ext, pval::list, pval::next, PV_GOTO, PV_WORD, pvalCheckType(), pvalCreateNode(), pval::str, and pval::u1.

◆ pvalIfGetCondition()

char * pvalIfGetCondition ( pval p)

Definition at line 5670 of file pval.c.

5671{
5672 if (!pvalCheckType(p, "pvalIfGetCondition", PV_IFTIME))
5673 return 0;
5674 return p->u1.str;
5675}

References PV_IFTIME, pvalCheckType(), pval::str, and pval::u1.

◆ pvalIfSetCondition()

void pvalIfSetCondition ( pval p,
char *  expr 
)

Definition at line 5663 of file pval.c.

5664{
5665 if (!pvalCheckType(p, "pvalIfSetCondition", PV_IF))
5666 return;
5667 p->u1.str = expr;
5668}

References PV_IF, pvalCheckType(), pval::str, and pval::u1.

◆ pvalIfTimeGetCondition()

void pvalIfTimeGetCondition ( pval p,
char **  hour_range,
char **  dow_range,
char **  dom_range,
char **  month_range 
)

Definition at line 5712 of file pval.c.

5713{
5714 if (!pvalCheckType(p, "pvalIfTimeGetCondition", PV_IFTIME))
5715 return;
5716 *hour_range = p->u1.list->u1.str;
5717 *dow_range = p->u1.list->next->u1.str;
5718 *dom_range = p->u1.list->next->next->u1.str;
5719 *month_range = p->u1.list->next->next->next->u1.str;
5720}

References pval::list, pval::next, PV_IFTIME, pvalCheckType(), pval::str, and pval::u1.

◆ pvalIfTimeSetCondition()

void pvalIfTimeSetCondition ( pval p,
char *  hour_range,
char *  dow_range,
char *  dom_range,
char *  mon_range 
)

Definition at line 5677 of file pval.c.

5678{
5679 pval *hr;
5680 pval *dow;
5681 pval *dom;
5682 pval *mon;
5683
5684 if (!pvalCheckType(p, "pvalIfTimeSetCondition", PV_IFTIME)) {
5685 return;
5686 }
5687
5688 hr = pvalCreateNode(PV_WORD);
5689 dow = pvalCreateNode(PV_WORD);
5690 dom = pvalCreateNode(PV_WORD);
5691 mon = pvalCreateNode(PV_WORD);
5692
5693 if (!hr || !dom || !dow || !mon) {
5694 destroy_pval(hr);
5695 destroy_pval(dom);
5696 destroy_pval(dow);
5697 destroy_pval(mon);
5698 return;
5699 }
5700
5701 pvalWordSetString(hr, hour_range);
5702 pvalWordSetString(dow, dow_range);
5703 pvalWordSetString(dom, dom_range);
5704 pvalWordSetString(mon, mon_range);
5705 dom->next = mon;
5706 dow->next = dom;
5707 hr->next = dow;
5708 p->u1.list = hr;
5709}
void pvalWordSetString(pval *p, char *str)
Definition: pval.c:5058

References destroy_pval(), pval::list, pval::next, PV_IFTIME, PV_WORD, pvalCheckType(), pvalCreateNode(), pvalWordSetString(), and pval::u1.

◆ pvalIgnorePatGetPattern()

char * pvalIgnorePatGetPattern ( pval p)

Definition at line 5866 of file pval.c.

5867{
5868 if (!pvalCheckType(p, "pvalIgnorePatGetPattern", PV_IGNOREPAT))
5869 return 0;
5870 return p->u1.str;
5871}

References PV_IGNOREPAT, pvalCheckType(), pval::str, and pval::u1.

◆ pvalIgnorePatSetPattern()

void pvalIgnorePatSetPattern ( pval p,
char *  pat 
)

Definition at line 5859 of file pval.c.

5860{
5861 if (!pvalCheckType(p, "pvalIgnorePatSetPattern", PV_IGNOREPAT))
5862 return;
5863 p->u1.str = pat;
5864}

References PV_IGNOREPAT, pvalCheckType(), pval::str, and pval::u1.

◆ pvalIncludeGetTimeConstraints()

void pvalIncludeGetTimeConstraints ( pval p,
char **  hour_range,
char **  dom_range,
char **  dow_range,
char **  month_range 
)

Definition at line 5450 of file pval.c.

5451{
5452 if (!pvalCheckType(p, "pvalIncludeGetTimeConstraints", PV_WORD))
5453 return;
5454 if (p->u2.arglist) {
5455 *hour_range = p->u2.arglist->u1.str;
5456 *dom_range = p->u2.arglist->next->u1.str;
5457 *dow_range = p->u2.arglist->next->next->u1.str;
5458 *month_range = p->u2.arglist->next->next->next->u1.str;
5459 } else {
5460 *hour_range = 0;
5461 *dom_range = 0;
5462 *dow_range = 0;
5463 *month_range = 0;
5464 }
5465}

References pval::arglist, pval::next, PV_WORD, pvalCheckType(), pval::str, pval::u1, and pval::u2.

◆ pvalIncludesAddInclude()

void pvalIncludesAddInclude ( pval p,
const char *  include 
)

Definition at line 5396 of file pval.c.

5397{
5398 pval *s;
5399 if (!pvalCheckType(p, "pvalIncludesAddSwitch", PV_INCLUDES))
5400 return;
5402 s->u1.str = (char *)include;
5403 p->u1.list = linku1(p->u1.list, s);
5404}

References linku1(), pval::list, PV_INCLUDES, PV_WORD, pvalCheckType(), pvalCreateNode(), pval::str, and pval::u1.

◆ pvalIncludesAddIncludeWithTimeConstraints()

void pvalIncludesAddIncludeWithTimeConstraints ( pval p,
const char *  include,
char *  hour_range,
char *  dom_range,
char *  dow_range,
char *  month_range 
)

Definition at line 5407 of file pval.c.

5408{
5409 pval *hr;
5410 pval *dom;
5411 pval *dow;
5412 pval *mon;
5413 pval *s;
5414
5415 if (!pvalCheckType(p, "pvalIncludeAddIncludeWithTimeConstraints", PV_INCLUDES)) {
5416 return;
5417 }
5418
5419 hr = pvalCreateNode(PV_WORD);
5420 dom = pvalCreateNode(PV_WORD);
5421 dow = pvalCreateNode(PV_WORD);
5422 mon = pvalCreateNode(PV_WORD);
5424
5425 if (!hr || !dom || !dow || !mon || !s) {
5426 destroy_pval(hr);
5427 destroy_pval(dom);
5428 destroy_pval(dow);
5429 destroy_pval(mon);
5430 destroy_pval(s);
5431 return;
5432 }
5433
5434 s->u1.str = (char *)include;
5435 p->u1.list = linku1(p->u1.list, s);
5436
5437 hr->u1.str = hour_range;
5438 dom->u1.str = dom_range;
5439 dow->u1.str = dow_range;
5440 mon->u1.str = month_range;
5441
5442 s->u2.arglist = hr;
5443
5444 hr->next = dom;
5445 dom->next = dow;
5446 dow->next = mon;
5447 mon->next = 0;
5448}

References pval::arglist, destroy_pval(), linku1(), pval::list, pval::next, PV_INCLUDES, PV_WORD, pvalCheckType(), pvalCreateNode(), pval::str, pval::u1, and pval::u2.

◆ pvalIncludesWalk()

char * pvalIncludesWalk ( pval p,
pval **  next_item 
)

Definition at line 5467 of file pval.c.

5468{
5469 if (!pvalCheckType(p, "pvalIncludesWalk", PV_INCLUDES))
5470 return 0;
5471 if (!(*next_item))
5472 *next_item = p->u1.list;
5473 else {
5474 *next_item = (*next_item)->next;
5475 }
5476 return (*next_item)->u1.str;
5477}

References pval::list, next_item(), PV_INCLUDES, pvalCheckType(), and pval::u1.

◆ pvalLabelGetName()

char * pvalLabelGetName ( pval p)

Definition at line 5597 of file pval.c.

5598{
5599 if (!pvalCheckType(p, "pvalLabelGetName", PV_LABEL))
5600 return 0;
5601 return p->u1.str;
5602}

References PV_LABEL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalLabelSetName()

void pvalLabelSetName ( pval p,
char *  name 
)

Definition at line 5590 of file pval.c.

5591{
5592 if (!pvalCheckType(p, "pvalLabelSetName", PV_LABEL))
5593 return;
5594 p->u1.str = name;
5595}

References name, PV_LABEL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalMacroAddArg()

void pvalMacroAddArg ( pval p,
pval arg 
)

Definition at line 5094 of file pval.c.

5095{
5096 if (!pvalCheckType(p, "pvalMacroAddArg", PV_MACRO))
5097 return;
5098 if (!p->u2.arglist)
5099 p->u2.arglist = arg;
5100 else
5101 linku1(p->u2.arglist, arg);
5102
5103}

References pval::arglist, linku1(), PV_MACRO, pvalCheckType(), and pval::u2.

◆ pvalMacroAddStatement()

void pvalMacroAddStatement ( pval p,
pval statement 
)

Definition at line 5117 of file pval.c.

5118{
5119 if (!pvalCheckType(p, "pvalMacroAddStatement", PV_MACRO))
5120 return;
5121 if (!p->u3.macro_statements)
5122 p->u3.macro_statements = statement;
5123 else
5124 linku1(p->u3.macro_statements, statement);
5125
5126
5127}

References linku1(), pval::macro_statements, PV_MACRO, pvalCheckType(), and pval::u3.

◆ pvalMacroCallAddArg()

void pvalMacroCallAddArg ( pval p,
pval arg 
)

Definition at line 5224 of file pval.c.

5225{
5226 if (!pvalCheckType(p, "pvalMacroCallGetAddArg", PV_MACRO_CALL))
5227 return;
5228 if (!p->u2.arglist)
5229 p->u2.arglist = arg;
5230 else
5231 linku1(p->u2.arglist, arg);
5232}

References pval::arglist, linku1(), PV_MACRO_CALL, pvalCheckType(), and pval::u2.

◆ pvalMacroCallGetMacroName()

char * pvalMacroCallGetMacroName ( pval p)

Definition at line 5210 of file pval.c.

5211{
5212 if (!pvalCheckType(p, "pvalMacroCallGetMacroName", PV_MACRO_CALL))
5213 return 0;
5214 return p->u1.str;
5215}

References PV_MACRO_CALL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalMacroCallSetArglist()

void pvalMacroCallSetArglist ( pval p,
pval arglist 
)

Definition at line 5217 of file pval.c.

5218{
5219 if (!pvalCheckType(p, "pvalMacroCallSetArglist", PV_MACRO_CALL))
5220 return;
5221 p->u2.arglist = arglist;
5222}

References pval::arglist, PV_MACRO_CALL, pvalCheckType(), and pval::u2.

◆ pvalMacroCallSetMacroName()

void pvalMacroCallSetMacroName ( pval p,
char *  name 
)

Definition at line 5203 of file pval.c.

5204{
5205 if (!pvalCheckType(p, "pvalMacroCallSetMacroName", PV_MACRO_CALL))
5206 return;
5207 p->u1.str = name;
5208}

References name, PV_MACRO_CALL, pvalCheckType(), pval::str, and pval::u1.

◆ pvalMacroCallWalkArgs()

pval * pvalMacroCallWalkArgs ( pval p,
pval **  args 
)

Definition at line 5234 of file pval.c.

5235{
5236 if (!pvalCheckType(p, "pvalMacroCallWalkArgs", PV_MACRO_CALL))
5237 return 0;
5238 if (!(*args))
5239 *args = p->u2.arglist;
5240 else {
5241 *args = (*args)->next;
5242 }
5243 return *args;
5244}

References pval::arglist, args, PV_MACRO_CALL, pvalCheckType(), and pval::u2.

◆ pvalMacroGetName()

char * pvalMacroGetName ( pval p)

Definition at line 5080 of file pval.c.

5081{
5082 if (!pvalCheckType(p, "pvalMacroGetName", PV_MACRO))
5083 return 0;
5084 return p->u1.str;
5085}

References PV_MACRO, pvalCheckType(), pval::str, and pval::u1.

◆ pvalMacroSetArglist()

void pvalMacroSetArglist ( pval p,
pval arglist 
)

Definition at line 5087 of file pval.c.

5088{
5089 if (!pvalCheckType(p, "pvalMacroSetArglist", PV_MACRO))
5090 return;
5091 p->u2.arglist = arglist;
5092}

References pval::arglist, PV_MACRO, pvalCheckType(), and pval::u2.

◆ pvalMacroSetName()

void pvalMacroSetName ( pval p,
char *  name 
)

Definition at line 5073 of file pval.c.

5074{
5075 if (!pvalCheckType(p, "pvalMacroSetName", PV_MACRO))
5076 return;
5077 p->u1.str = name;
5078}

References name, PV_MACRO, pvalCheckType(), pval::str, and pval::u1.

◆ pvalMacroWalkArgs()

pval * pvalMacroWalkArgs ( pval p,
pval **  arg 
)

Definition at line 5105 of file pval.c.

5106{
5107 if (!pvalCheckType(p, "pvalMacroWalkArgs", PV_MACRO))
5108 return 0;
5109 if (!(*arg))
5110 *arg = p->u2.arglist;
5111 else {
5112 *arg = (*arg)->next;
5113 }
5114 return *arg;
5115}

References pval::arglist, pval::next, PV_MACRO, pvalCheckType(), and pval::u2.

◆ pvalMacroWalkStatements()

pval * pvalMacroWalkStatements ( pval p,
pval **  next_statement 
)

Definition at line 5129 of file pval.c.

5130{
5131 if (!pvalCheckType(p, "pvalMacroWalkStatements", PV_MACRO))
5132 return 0;
5133 if (!(*next_statement))
5134 *next_statement = p->u3.macro_statements;
5135 else {
5136 *next_statement = (*next_statement)->next;
5137 }
5138 return *next_statement;
5139}

References pval::macro_statements, pval::next, PV_MACRO, pvalCheckType(), and pval::u3.

◆ pvalObjectGetType()

pvaltype pvalObjectGetType ( pval p)

Definition at line 5052 of file pval.c.

5053{
5054 return p->type;
5055}

References pval::type.

◆ pvalRandomGetCondition()

char * pvalRandomGetCondition ( pval p)

Definition at line 5729 of file pval.c.

5730{
5731 if (!pvalCheckType(p, "pvalRandomGetCondition", PV_RANDOM))
5732 return 0;
5733 return p->u1.str;
5734}

References PV_RANDOM, pvalCheckType(), pval::str, and pval::u1.

◆ pvalRandomSetCondition()

void pvalRandomSetCondition ( pval p,
char *  percent 
)

Definition at line 5722 of file pval.c.

5723{
5724 if (!pvalCheckType(p, "pvalRandomSetCondition", PV_RANDOM))
5725 return;
5726 p->u1.str = percent;
5727}

References PV_RANDOM, pvalCheckType(), pval::str, and pval::u1.

◆ pvalStatementBlockAddStatement()

void pvalStatementBlockAddStatement ( pval p,
pval statement 
)

Definition at line 5480 of file pval.c.

5481{
5482 if (!pvalCheckType(p, "pvalStatementBlockAddStatement", PV_STATEMENTBLOCK))
5483 return;
5484 p->u1.list = linku1(p->u1.list, statement);
5485}

References linku1(), pval::list, PV_STATEMENTBLOCK, pvalCheckType(), and pval::u1.

◆ pvalStatementBlockWalkStatements()

pval * pvalStatementBlockWalkStatements ( pval p,
pval **  next_statement 
)

Definition at line 5487 of file pval.c.

5488{
5489 if (!pvalCheckType(p, "pvalStatementBlockWalkStatements", PV_STATEMENTBLOCK))
5490 return 0;
5491 if (!(*next_statement))
5492 *next_statement = p->u1.list;
5493 else {
5494 *next_statement = (*next_statement)->next;
5495 }
5496 return *next_statement;
5497}

References pval::list, pval::next, PV_STATEMENTBLOCK, pvalCheckType(), and pval::u1.

◆ pvalSwitchAddCase()

void pvalSwitchAddCase ( pval p,
pval Case 
)

Definition at line 5770 of file pval.c.

5771{
5772 if (!pvalCheckType(p, "pvalSwitchAddCase", PV_SWITCH))
5773 return;
5774 if (!pvalCheckType(Case, "pvalSwitchAddCase", PV_CASE))
5775 return;
5776 if (!p->u2.statements)
5777 p->u2.statements = Case;
5778 else
5779 linku1(p->u2.statements, Case);
5780}

References linku1(), PV_CASE, PV_SWITCH, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalSwitchesAddSwitch()

void pvalSwitchesAddSwitch ( pval p,
char *  name 
)

Definition at line 5351 of file pval.c.

5352{
5353 pval *s;
5354 if (!pvalCheckType(p, "pvalSwitchesAddSwitch", PV_SWITCHES))
5355 return;
5357 s->u1.str = name;
5358 p->u1.list = linku1(p->u1.list, s);
5359}

References linku1(), pval::list, name, PV_SWITCHES, PV_WORD, pvalCheckType(), pvalCreateNode(), pval::str, and pval::u1.

◆ pvalSwitchesWalkNames()

char * pvalSwitchesWalkNames ( pval p,
pval **  next_item 
)

Definition at line 5361 of file pval.c.

5362{
5363 if (!pvalCheckType(p, "pvalSwitchesWalkNames", PV_SWITCHES))
5364 return 0;
5365 if (!(*next_item))
5366 *next_item = p->u1.list;
5367 else {
5368 *next_item = (*next_item)->next;
5369 }
5370 return (*next_item)->u1.str;
5371}

References pval::list, next_item(), PV_SWITCHES, pvalCheckType(), and pval::u1.

◆ pvalSwitchGetTestexpr()

char * pvalSwitchGetTestexpr ( pval p)

Definition at line 5763 of file pval.c.

5764{
5765 if (!pvalCheckType(p, "pvalSwitchGetTestexpr", PV_SWITCH))
5766 return 0;
5767 return p->u1.str;
5768}

References PV_SWITCH, pvalCheckType(), pval::str, and pval::u1.

◆ pvalSwitchSetTestexpr()

void pvalSwitchSetTestexpr ( pval p,
char *  expr 
)

Definition at line 5756 of file pval.c.

5757{
5758 if (!pvalCheckType(p, "pvalSwitchSetTestexpr", PV_SWITCH))
5759 return;
5760 p->u1.str = expr;
5761}

References PV_SWITCH, pvalCheckType(), pval::str, and pval::u1.

◆ pvalSwitchWalkCases()

pval * pvalSwitchWalkCases ( pval p,
pval **  next_case 
)

Definition at line 5782 of file pval.c.

5783{
5784 if (!pvalCheckType(p, "pvalSwitchWalkCases", PV_SWITCH))
5785 return 0;
5786 if (!(*next_case))
5787 *next_case = p->u2.statements;
5788 else {
5789 *next_case = (*next_case)->next;
5790 }
5791 return *next_case;
5792}

References pval::next, PV_SWITCH, pvalCheckType(), pval::statements, and pval::u2.

◆ pvalTopLevAddObject()

void pvalTopLevAddObject ( pval p,
pval contextOrObj 
)

Definition at line 5901 of file pval.c.

5902{
5903 if (p) {
5904 linku1(p,contextOrObj);
5905 } else {
5906 ast_log(LOG_ERROR, "First arg to pvalTopLevel is NULL!\n");
5907 }
5908}

References ast_log, linku1(), and LOG_ERROR.

◆ pvalTopLevWalkObjects()

pval * pvalTopLevWalkObjects ( pval p,
pval **  next_obj 
)

Definition at line 5910 of file pval.c.

5911{
5912 if (!*next_obj) {
5913 *next_obj = p;
5914 return p;
5915 } else {
5916 *next_obj = (*next_obj)->next;
5917 return (*next_obj)->next;
5918 }
5919}

References pval::next.

◆ pvalVarDecGetValue()

char * pvalVarDecGetValue ( pval p)

Definition at line 5520 of file pval.c.

5521{
5522 if (!pvalCheckType(p, "pvalVarDecGetValue", PV_VARDEC))
5523 return 0;
5524 return p->u2.val;
5525}

References PV_VARDEC, pvalCheckType(), pval::u2, and pval::val.

◆ pvalVarDecGetVarname()

char * pvalVarDecGetVarname ( pval p)

Definition at line 5513 of file pval.c.

5514{
5515 if (!pvalCheckType(p, "pvalVarDecGetVarname", PV_VARDEC))
5516 return 0;
5517 return p->u1.str;
5518}

References PV_VARDEC, pvalCheckType(), pval::str, and pval::u1.

◆ pvalVarDecSetValue()

void pvalVarDecSetValue ( pval p,
char *  value 
)

Definition at line 5506 of file pval.c.

5507{
5508 if (!pvalCheckType(p, "pvalVarDecSetValue", PV_VARDEC))
5509 return;
5510 p->u2.val = value;
5511}
int value
Definition: syslog.c:37

References PV_VARDEC, pvalCheckType(), pval::u2, pval::val, and value.

◆ pvalVarDecSetVarname()

void pvalVarDecSetVarname ( pval p,
char *  name 
)

Definition at line 5499 of file pval.c.

5500{
5501 if (!pvalCheckType(p, "pvalVarDecSetVarname", PV_VARDEC))
5502 return;
5503 p->u1.str = name;
5504}

References name, PV_VARDEC, pvalCheckType(), pval::str, and pval::u1.

◆ pvalWordGetString()

char * pvalWordGetString ( pval p)

Definition at line 5065 of file pval.c.

5066{
5067 if (!pvalCheckType(p, "pvalWordGetString", PV_WORD))
5068 return 0;
5069 return p->u1.str;
5070}

References PV_WORD, pvalCheckType(), pval::str, and pval::u1.

◆ pvalWordSetString()

void pvalWordSetString ( pval p,
char *  str 
)

Definition at line 5058 of file pval.c.

5059{
5060 if (!pvalCheckType(p, "pvalWordSetString", PV_WORD))
5061 return;
5062 p->u1.str = str;
5063}
const char * str
Definition: app_jack.c:147

References PV_WORD, pvalCheckType(), str, pval::str, and pval::u1.

Referenced by pvalIfTimeSetCondition().

◆ set_priorities()

void set_priorities ( struct ael_extension exten)

Definition at line 4187 of file pval.c.

4188{
4189 int i;
4190 struct ael_priority *pr;
4191 do {
4192 if (exten->is_switch)
4193 i = 10;
4194 else if (exten->regexten)
4195 i=2;
4196 else
4197 i=1;
4198
4199 for (pr=exten->plist; pr; pr=pr->next) {
4200 pr->priority_num = i;
4201
4202 if (!pr->origin || (pr->origin && pr->origin->type != PV_LABEL) ) /* Labels don't show up in the dialplan,
4203 but we want them to point to the right
4204 priority, which would be the next line
4205 after the label; */
4206 i++;
4207 }
4208
4210 } while ( exten );
4211}

References ael_priority::exten, ael_extension::is_switch, ael_priority::next, ael_extension::next_exten, ael_priority::origin, ael_extension::plist, ael_priority::priority_num, PV_LABEL, ael_extension::regexten, and pval::type.