Asterisk - The Open Source Telephony Project  GIT-master-44aef04
Data Structures | Typedefs | Enumerations | Functions
pval.h File Reference

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;
Definition: pval.h:32
Definition: pval.h:29
Definition: pval.h:22
Definition: pval.h:8
Definition: pval.h:13
Definition: pval.h:21
Definition: pval.h:24
pvaltype
Definition: pval.h:6
Definition: pval.h:9
Definition: pval.h:31
Definition: pval.h:25
Definition: pval.h:30
Definition: pval.h:23
Definition: pval.h:27
Definition: pval.h:26
Definition: pval.h:16

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,
4228  exten->hints, NULL, ast_free_ptr, registrar, NULL, 0)) {
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,
4308  app, strdup(appargs), ast_free_ptr, registrar, NULL, 0)) {
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  }
4314  exten = exten->next_exten;
4315  } while ( exten );
4316 }
struct pval * origin
Definition: ael_structs.h:95
Definition: pval.h:32
struct ael_priority * goto_true
Definition: ael_structs.h:98
#define LOG_WARNING
Definition: logger.h:274
union pval::@281 u3
struct ael_priority * plist
Definition: ael_structs.h:115
#define NULL
Definition: resample.c:96
struct ael_priority * goto_false
Definition: ael_structs.h:99
char * appargs
Definition: ael_structs.h:93
void ast_free_ptr(void *ptr)
free() wrapper
Definition: astmm.c:1771
struct ael_extension * next_exten
Definition: ael_structs.h:117
struct ast_context * context
Definition: ael_structs.h:113
char * cidmatch
Definition: ael_structs.h:106
#define ast_log
Definition: astobj2.c:42
struct sla_ringing_trunk * last
Definition: app_meetme.c:1092
#define AST_MAX_EXTENSION
Definition: channel.h:135
struct ael_extension * exten
Definition: ael_structs.h:96
char * str
Definition: pval.h:59
#define PRIORITY_HINT
Definition: pbx.h:54
char * app
Definition: ael_structs.h:92
static char * registrar
Definition: pval.c:70
struct pval * else_statements
Definition: pval.h:78
struct ael_priority * next
Definition: ael_structs.h:100
pvaltype type
Definition: pval.h:50
union pval::@279 u1
int priority_num
Definition: ael_structs.h:89
Definition: pval.h:30
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:7299
void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count)
Definition: ael_main.c:211
ael_priority_type type
Definition: ael_structs.h:90
#define strdup(a)
Definition: astmm.h:165
static const char app[]
Definition: app_mysql.c:62

◆ 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);
4432  pbx_builtin_setvar(NULL, buf2);
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 
4447  context = ast_context_find_or_create(local_contexts, local_table, p->u1.str, registrar);
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 
4478  set_priorities(exten);
4479  attach_exten(&exten_list, exten);
4480  break;
4481 
4482  case PV_GLOBALS:
4483  /* already done */
4484  break;
4485 
4486  case PV_CONTEXT:
4487  context = ast_context_find_or_create(local_contexts, local_table, p->u1.str, registrar);
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);
4498  exten->context = context;
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 
4531  set_priorities(exten);
4532  attach_exten(&exten_list, exten);
4533  break;
4534 
4535  case PV_IGNOREPAT:
4536  ast_context_add_ignorepat2(context, p2->u1.str, registrar);
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);
4548  ast_context_add_include2(context, buf, registrar);
4549  } else
4550  ast_context_add_include2(context, p3->u1.str, registrar);
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 
4563  ast_context_add_switch2(context, p3->u1.str, c, 0, registrar);
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 
4576  ast_context_add_switch2(context, p3->u1.str, c, 1, registrar);
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  };
4618  context = ast_context_find_or_create(local_contexts, local_table, h_context, registrar);
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);
4627  context = ast_context_find_or_create(local_contexts, local_table, h_context_template + 5, registrar);
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 context_used(struct ael_extension *exten_list, struct ast_context *context)
Definition: pval.c:4398
static char exten[AST_MAX_EXTENSION]
Definition: chan_alsa.c:118
int regexten
Definition: pval.h:90
static int control_statement_count
Definition: pval.c:2922
#define ARRAY_LEN(a)
Definition: isdn_lib.c:42
struct pval * origin
Definition: ael_structs.h:95
const char * ast_get_context_name(struct ast_context *con)
Definition: ael_main.c:421
struct pval * list
Definition: pval.h:60
void set_priorities(struct ael_extension *exten)
Definition: pval.c:4187
static void fix_gotos_in_extensions(struct ael_extension *exten)
Definition: pval.c:4355
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
struct ael_extension * new_exten(void)
Definition: pval.c:2930
struct ael_priority * plist_last
Definition: ael_structs.h:116
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
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
static struct ast_threadstorage buf2
union pval::@281 u3
static struct test_val c
#define NULL
Definition: resample.c:96
char * appargs
Definition: ael_structs.h:93
static int priority
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
struct ael_extension * next_exten
Definition: ael_structs.h:117
void linkprio(struct ael_extension *exten, struct ael_priority *prio, struct ael_extension *mother_exten)
Definition: pval.c:2936
struct ast_context * context
Definition: ael_structs.h:113
int ast_context_add_include2(struct ast_context *con, const char *include, const char *registrar)
Add a context include.
Definition: ael_main.c:359
char * cidmatch
Definition: ael_structs.h:106
char * val
Definition: pval.h:70
struct ael_extension * exten
Definition: ael_structs.h:96
union pval::@282 u4
char * str
Definition: pval.h:59
Definition: pval.h:48
struct ael_priority * new_prio(void)
Definition: pval.c:2924
void destroy_extensions(struct ael_extension *exten)
Definition: pval.c:2978
char * hints
Definition: pval.h:81
struct ast_custom_function * ast_custom_function_find(const char *name)
Definition: ael_main.c:173
char * app
Definition: ael_structs.h:92
static char * registrar
Definition: pval.c:70
struct pval * arglist
Definition: pval.h:68
Definition: pval.h:9
pvaltype type
Definition: pval.h:50
static void attach_exten(struct ael_extension **list, struct ael_extension *newmem)
Definition: pval.c:4318
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 &#39;=&#39; character...
union pval::@279 u1
int priority_num
Definition: ael_structs.h:89
static void remove_spaces_before_equals(char *str)
Definition: pval.c:3038
struct pval * next
Definition: pval.h:93
int ast_context_add_ignorepat2(struct ast_context *con, const char *ignorepat, const char *registrar)
Definition: ael_main.c:348
ael_priority_type type
Definition: ael_structs.h:90
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:116
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:6198
#define strdup(a)
Definition: astmm.h:165
ast_context: An extension context - must remain in sync with fake_context
Definition: pbx.c:284
void add_extensions(struct ael_extension *exten)
Definition: pval.c:4213
struct pval * macro_statements
Definition: pval.h:79

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

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

2406 {
2407  struct parse_io io = { .string = expr, .chan = chan };
2408  int return_value = 0;
2409 
2410  ast_yylex_init(&io.scanner);
2411 
2412  ast_yy_scan_string(expr, io.scanner);
2413 
2414  ast_yyparse ((void *) &io);
2415 
2417 
2418  if (!io.val) {
2419  if (length > 1) {
2420  strcpy(buf, "0");
2421  return_value = 1;
2422  }
2423  } else {
2424  if (io.val->type == AST_EXPR_number) {
2425  int res_length;
2426 
2427  res_length = snprintf(buf, length, FP___PRINTF, io.val->u.i);
2428  return_value = (res_length <= length) ? res_length : length;
2429  } else {
2430  if (io.val->u.s)
2431 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE)
2432  strncpy(buf, io.val->u.s, length - 1);
2433 #else /* !STANDALONE && !LOW_MEMORY */
2434  ast_copy_string(buf, io.val->u.s, length);
2435 #endif /* STANDALONE || LOW_MEMORY */
2436  else
2437  buf[0] = 0;
2438  return_value = strlen(buf);
2439  free(io.val->u.s);
2440  }
2441  free(io.val);
2442  }
2443  return return_value;
2444 }
int ast_yyparse(void *)
#define FP___PRINTF
Definition: ast_expr2f.c:535
FP___TYPE i
Definition: ast_expr2.c:329
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
YY_BUFFER_STATE ast_yy_scan_string(yyconst char *yy_str, yyscan_t yyscanner)
Definition: ast_expr2f.c:1974
struct val * val
Definition: ast_expr2.c:351
yyscan_t scanner
Definition: ael_structs.h:78
enum valtype type
Definition: ast_expr2.c:326
char * s
Definition: ast_expr2.c:328
void free()
static struct io_context * io
Definition: chan_ooh323.c:401
int ast_yylex_init(yyscan_t *scanner)
Definition: ast_expr2f.c:2221
int ast_yylex_destroy(yyscan_t yyscanner)
Definition: ast_expr2f.c:2312
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:401
union val::@329 u

◆ ast_expr_clear_extra_error_info()

void ast_expr_clear_extra_error_info ( void  )

Definition at line 2483 of file ast_expr2f.c.

Referenced by check_pval_item().

2484 {
2486  extra_error_message[0] = 0;
2487 }
char extra_error_message[4095]
Definition: ast_expr2f.c:2472
int extra_error_message_supplied
Definition: ast_expr2f.c:2473

◆ ast_expr_register_extra_error_info()

void ast_expr_register_extra_error_info ( char *  errmsg)

Definition at line 2477 of file ast_expr2f.c.

Referenced by check_pval_item().

2478 {
2480  strcpy(extra_error_message, message);
2481 }
char extra_error_message[4095]
Definition: ast_expr2f.c:2472
int extra_error_message_supplied
Definition: ast_expr2f.c:2473

◆ 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 }
#define LOG_WARNING
Definition: logger.h:274
int startline
Definition: pval.h:51
#define ast_log
Definition: astobj2.c:42
char * filename
Definition: pval.h:55
char * str
Definition: pval.h:59
Definition: pval.h:48
union pval::@279 u1
static int warns
Definition: pval.c:65
struct pval * next
Definition: pval.h:93
int endline
Definition: pval.h:52

◆ 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
Definition: pval.h:48
struct pval * next
Definition: pval.h:93

◆ 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  */
2383  in_abstract_context = 0;
2385  current_extension = 0;
2386 
2387  check_macro_returns(item);
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  */
2401  current_extension = 0;
2402  if ( item->u3.abstract ) {
2403  in_abstract_context = 1;
2405  } else
2406  in_abstract_context = 0;
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 
2494  case PV_APPLICATION_CALL:
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);
2604  check_includes(item);
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 ) {
2610  check_timerange(lp->u2.arglist);
2611  check_dow(lp->u2.arglist->next);
2612  check_day(lp->u2.arglist->next->next);
2613  check_month(lp->u2.arglist->next->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 
2673  check_goto(item);
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 
2685  check_label(item);
2686  break;
2687 
2688  case PV_FOR:
2689  /* fields: item->u1.for_init == a string containing the initalizer
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  */
2745  check_break(item);
2746  break;
2747 
2748  case PV_RETURN:
2749  /* fields: none
2750  */
2751  break;
2752 
2753  case PV_CONTINUE:
2754  /* fields: none
2755  */
2756  check_continue(item);
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? */
2833  check_switch_expr(item, apps);
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  */
2857  in_abstract_context = 0;
2858  check_pval(item->u1.statements, apps, 1);
2859  break;
2860  default:
2861  break;
2862  }
2863 }
char * for_inc
Definition: pval.h:77
static void find_pval_gotos(pval *item, int lev)
Definition: pval.c:1550
static int check_break(pval *item)
Definition: pval.c:1038
static int errs
Definition: pval.c:65
struct pval * list
Definition: pval.h:60
Definition: pval.h:32
Definition: pval.h:29
#define LOG_WARNING
Definition: logger.h:274
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
struct pval * find_macro(char *name)
Definition: pval.c:1943
struct pval * find_context(char *name)
Definition: pval.c:1953
static struct aco_type item
Definition: test_config.c:1463
union pval::@281 u3
static void check_day(pval *DAY)
Definition: pval.c:937
Definition: pval.h:22
int startline
Definition: pval.h:51
#define NULL
Definition: resample.c:96
int abstract
Definition: pval.h:80
Definition: pval.h:8
Definition: pval.h:110
static void check_abstract_reference(pval *abstract_context)
Definition: pval.c:2329
char * val
Definition: pval.h:70
#define ast_log
Definition: astobj2.c:42
void free()
static int check_continue(pval *item)
Definition: pval.c:1058
static pval * current_extension
Definition: pval.c:74
Definition: pval.h:13
static int in_abstract_context
Definition: pval.c:79
static void check_timerange(pval *p)
Definition: pval.c:830
char * filename
Definition: pval.h:55
static void check_macro_returns(pval *macro)
Definition: pval.c:650
Definition: pval.h:21
union pval::@282 u4
int localized_pbx_load_module(void)
Definition: extconf.c:5647
char * str
Definition: pval.h:59
Definition: pval.h:48
char * for_test
Definition: pval.h:71
static char expr_output[2096]
Definition: pval.c:60
void ast_expr_clear_extra_error_info(void)
Definition: ast_expr2f.c:2483
#define LOG_ERROR
Definition: logger.h:285
struct pval * else_statements
Definition: pval.h:78
static void check_goto(pval *item)
Definition: pval.c:1225
Definition: pval.h:24
struct pval * arglist
Definition: pval.h:68
int endcol
Definition: pval.h:54
static void check_label(pval *item)
Definition: pval.c:1106
#define STATUS_SUCCESS
Definition: extconf.h:249
Definition: pval.h:9
Definition: pval.h:31
static void check_includes(pval *includes)
Definition: pval.c:811
Definition: pval.h:25
int stacklen
Definition: extconf.h:238
pvaltype type
Definition: pval.h:50
union pval::@279 u1
void ast_expr_register_extra_error_info(char *errmsg)
Definition: ast_expr2f.c:2477
static void check_month(pval *MON)
Definition: pval.c:1000
Definition: pval.h:30
Definition: pval.h:23
static pval * current_context
Definition: pval.c:73
static int warns
Definition: pval.c:65
struct argapp * next
Definition: pval.h:112
struct pval * next
Definition: pval.h:93
static void check_expr2_input(pval *expr, char *str)
Definition: pval.c:801
Definition: pval.h:27
struct pval * for_statements
Definition: pval.h:89
void check_switch_expr(pval *item, struct argapp *apps)
Definition: pval.c:2184
static const char app[]
Definition: app_mysql.c:62
int endline
Definition: pval.h:52
int startcol
Definition: pval.h:53
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
int ast_expr(char *expr, char *buf, int length, struct ast_channel *chan)
Evaluate the given expression.
Definition: ast_expr2f.c:2405
Definition: pval.h:26
char * for_init
Definition: pval.h:62
int check_app_args(pval *appcall, pval *arglist, struct argapp *app)
Definition: pval.c:2130
Definition: pval.h:16
static void check_dow(pval *DOW)
get_dow: Get day of week
Definition: pval.c:898
struct pval * macro_statements
Definition: pval.h:79
void check_pval(pval *item, struct argapp *apps, int in_globals)
Definition: pval.c:2865

◆ 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 LOG_WARNING
Definition: logger.h:274
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
static struct aco_type item
Definition: test_config.c:1463
int startline
Definition: pval.h:51
static struct test_val c
Definition: pval.h:110
#define calloc(a, b)
Definition: astmm.h:157
#define ast_log
Definition: astobj2.c:42
static pval * current_extension
Definition: pval.c:74
Definition: pval.h:13
char * filename
Definition: pval.h:55
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:300
char * str
Definition: pval.h:59
Definition: pval.h:48
int endcol
Definition: pval.h:54
pvaltype type
Definition: pval.h:50
union pval::@279 u1
static int warns
Definition: pval.c:65
struct argapp * next
Definition: pval.h:112
struct pval * next
Definition: pval.h:93
#define strdup(a)
Definition: astmm.h:165
int endline
Definition: pval.h:52
int startcol
Definition: pval.h:53
static struct test_val a

◆ count_labels_in_current_context()

int count_labels_in_current_context ( char *  label)

Referenced by match_pval().

◆ 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 pval * origin
Definition: ael_structs.h:95
struct ael_priority * goto_true
Definition: ael_structs.h:98
struct ael_priority * plist_last
Definition: ael_structs.h:116
struct ael_priority * plist
Definition: ael_structs.h:115
struct ael_priority * goto_false
Definition: ael_structs.h:99
char * appargs
Definition: ael_structs.h:93
struct ael_extension * next_exten
Definition: ael_structs.h:117
void free()
struct ael_priority * loop_break
Definition: ael_structs.h:119
char * app
Definition: ael_structs.h:92
struct ael_priority * loop_continue
Definition: ael_structs.h:120
struct ael_priority * next
Definition: ael_structs.h:100

◆ 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 
4947  destroy_pval_item(i);
4948  }
4949 }
void destroy_pval_item(pval *item)
Definition: pval.c:4672
Definition: pval.h:48
struct pval * next
Definition: pval.h:93

◆ 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);
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 
4726  case PV_APPLICATION_CALL:
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 initalizer
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);
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) {
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) {
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 }
char * for_inc
Definition: pval.h:77
struct pval * list
Definition: pval.h:60
Definition: pval.h:32
Definition: pval.h:29
#define LOG_WARNING
Definition: logger.h:274
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
union pval::@281 u3
Definition: pval.h:22
#define NULL
Definition: resample.c:96
Definition: pval.h:8
char * val
Definition: pval.h:70
#define ast_log
Definition: astobj2.c:42
void free()
Definition: pval.h:13
char * filename
Definition: pval.h:55
Definition: pval.h:21
union pval::@282 u4
void destroy_pval(pval *item)
Definition: pval.c:4940
char * str
Definition: pval.h:59
char * for_test
Definition: pval.h:71
char * hints
Definition: pval.h:81
struct pval * else_statements
Definition: pval.h:78
Definition: pval.h:24
struct pval * arglist
Definition: pval.h:68
Definition: pval.h:9
Definition: pval.h:31
Definition: pval.h:25
pvaltype type
Definition: pval.h:50
union pval::@279 u1
Definition: pval.h:30
Definition: pval.h:23
Definition: pval.h:27
struct pval * for_statements
Definition: pval.h:89
Definition: pval.h:26
char * for_init
Definition: pval.h:62
Definition: pval.h:16
struct pval * macro_statements
Definition: pval.h:79

◆ 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;
1957  match_context = name;
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 int count_labels
Definition: pval.c:80
static const char name[]
Definition: cdr_mysql.c:74
static const char * match_exten
Definition: pval.c:77
static int return_on_context_match
Definition: pval.c:82
static pval * current_db
Definition: pval.c:72
struct pval * match_pval(pval *item)
Definition: pval.c:1811
static const char * match_context
Definition: pval.c:76
static const char * match_label
Definition: pval.c:78

◆ find_macro()

struct pval * find_macro ( char *  name)

Definition at line 1943 of file pval.c.

1944 {
1946  count_labels = 0;
1947  match_context = name;
1948  match_exten = "*"; /* don't really need to set these, shouldn't be reached */
1949  match_label = "*";
1950  return match_pval(current_db);
1951 }
static int count_labels
Definition: pval.c:80
static const char name[]
Definition: cdr_mysql.c:74
static const char * match_exten
Definition: pval.c:77
static int return_on_context_match
Definition: pval.c:82
static pval * current_db
Definition: pval.c:72
struct pval * match_pval(pval *item)
Definition: pval.c:1811
static const char * match_context
Definition: pval.c:76
static const char * match_label
Definition: pval.c:78

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

References ael_priority::appargs, ael_priority::exten, 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().

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 }
static char exten[AST_MAX_EXTENSION]
Definition: chan_alsa.c:118
struct ael_priority * plist_last
Definition: ael_structs.h:116
struct ael_priority * plist
Definition: ael_structs.h:115
char * appargs
Definition: ael_structs.h:93
char * malloc()
void free()
struct ael_extension * exten
Definition: ael_structs.h:96
struct ael_priority * next
Definition: ael_structs.h:100

◆ 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 }
#define calloc(a, b)
Definition: astmm.h:157

◆ 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 }
#define calloc(a, b)
Definition: astmm.h:157

◆ pvalAppCallAddArg()

void pvalAppCallAddArg ( pval p,
pval arg 
)

Definition at line 5268 of file pval.c.

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

Referenced by main().

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
union pval::@280 u2
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
struct pval * arglist
Definition: pval.h:68

◆ pvalAppCallGetAppName()

char* pvalAppCallGetAppName ( pval p)

Definition at line 5254 of file pval.c.

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

5255 {
5256  if (!pvalCheckType(p, "pvalAppCallGetAppName", PV_APPLICATION_CALL))
5257  return 0;
5258  return p->u1.str;
5259 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalAppCallSetAppName()

void pvalAppCallSetAppName ( pval p,
char *  name 
)

Definition at line 5247 of file pval.c.

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

Referenced by main().

5248 {
5249  if (!pvalCheckType(p, "pvalAppCallSetAppName", PV_APPLICATION_CALL))
5250  return;
5251  p->u1.str = name;
5252 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1

◆ pvalAppCallSetArglist()

void pvalAppCallSetArglist ( pval p,
pval arglist 
)

Definition at line 5261 of file pval.c.

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

5262 {
5263  if (!pvalCheckType(p, "pvalAppCallSetArglist", PV_APPLICATION_CALL))
5264  return;
5265  p->u2.arglist = arglist;
5266 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * arglist
Definition: pval.h:68

◆ pvalAppCallWalkArgs()

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

Definition at line 5278 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
const char * args
struct pval * arglist
Definition: pval.h:68
struct pval * next
Definition: pval.h:93

◆ pvalCasePatDefAddStatement()

void pvalCasePatDefAddStatement ( pval p,
pval statement 
)

Definition at line 5303 of file pval.c.

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

5304 {
5305  if (!p->u2.arglist)
5306  p->u2.statements = statement;
5307  else
5308  linku1(p->u2.statements, statement);
5309 }
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
struct pval * arglist
Definition: pval.h:68

◆ pvalCasePatDefWalkStatements()

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

Definition at line 5311 of file pval.c.

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

5312 {
5313  if (!(*statement))
5314  *statement = p->u2.statements;
5315  else {
5316  *statement = (*statement)->next;
5317  }
5318  return *statement;
5319 }
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
struct pval * next
Definition: pval.h:93

◆ pvalCasePatGetVal()

char* pvalCasePatGetVal ( pval p)

Definition at line 5298 of file pval.c.

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

5299 {
5300  return p->u1.str;
5301 }
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalCasePatSetVal()

void pvalCasePatSetVal ( pval p,
char *  val 
)

Definition at line 5291 of file pval.c.

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

5292 {
5293  if (!pvalCheckType(p, "pvalAppCallWalkArgs", PV_APPLICATION_CALL))
5294  return;
5295  p->u1.str = val;
5296 }
Definition: ast_expr2.c:325
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalCatchGetExtName()

char* pvalCatchGetExtName ( pval p)

Definition at line 5329 of file pval.c.

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

5330 {
5331  if (!pvalCheckType(p, "pvalCatchGetExtName", PV_CATCH))
5332  return 0;
5333  return p->u1.str;
5334 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
Definition: pval.h:16

◆ pvalCatchGetStatement()

pval* pvalCatchGetStatement ( pval p)

Definition at line 5343 of file pval.c.

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

5344 {
5345  if (!pvalCheckType(p, "pvalCatchGetStatement", PV_CATCH))
5346  return 0;
5347  return p->u2.statements;
5348 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
Definition: pval.h:16

◆ pvalCatchSetExtName()

void pvalCatchSetExtName ( pval p,
char *  name 
)

Definition at line 5322 of file pval.c.

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

5323 {
5324  if (!pvalCheckType(p, "pvalCatchSetExtName", PV_CATCH))
5325  return;
5326  p->u1.str = name;
5327 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1
Definition: pval.h:16

◆ pvalCatchSetStatement()

void pvalCatchSetStatement ( pval p,
pval statement 
)

Definition at line 5336 of file pval.c.

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

5337 {
5338  if (!pvalCheckType(p, "pvalCatchSetStatement", PV_CATCH))
5339  return;
5340  p->u2.statements = statement;
5341 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
Definition: pval.h:16

◆ pvalCheckType()

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

Definition at line 5031 of file pval.c.

References ast_log, LOG_ERROR, 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().

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
#define ast_log
Definition: astobj2.c:42
#define LOG_ERROR
Definition: logger.h:285
pvaltype type
Definition: pval.h:50

◆ pvalConditionalGetElseStatement()

pval* pvalConditionalGetElseStatement ( pval p)

Definition at line 5751 of file pval.c.

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

5752 {
5753  return p->u3.else_statements;
5754 }
union pval::@281 u3
struct pval * else_statements
Definition: pval.h:78

◆ pvalConditionalGetThenStatement()

pval* pvalConditionalGetThenStatement ( pval p)

Definition at line 5746 of file pval.c.

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

5747 {
5748  return p->u2.statements;
5749 }
union pval::@280 u2
struct pval * statements
Definition: pval.h:61

◆ pvalConditionalSetElseStatement()

void pvalConditionalSetElseStatement ( pval p,
pval statement 
)

Definition at line 5741 of file pval.c.

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

5742 {
5743  p->u3.else_statements = statement;
5744 }
union pval::@281 u3
struct pval * else_statements
Definition: pval.h:78

◆ pvalConditionalSetThenStatement()

void pvalConditionalSetThenStatement ( pval p,
pval statement 
)

Definition at line 5736 of file pval.c.

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

5737 {
5738  p->u2.statements = statement;
5739 }
union pval::@280 u2
struct pval * statements
Definition: pval.h:61

◆ pvalContextAddStatement()

void pvalContextAddStatement ( pval p,
pval statement 
)

Definition at line 5180 of file pval.c.

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

Referenced by main().

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922

◆ pvalContextGetAbstract()

int pvalContextGetAbstract ( pval p)

Definition at line 5171 of file pval.c.

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

5172 {
5173  if (!pvalCheckType(p, "pvalContextGetAbstract", PV_CONTEXT))
5174  return 0;
5175  return p->u3.abstract;
5176 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
int abstract
Definition: pval.h:80

◆ pvalContextGetName()

char* pvalContextGetName ( pval p)

Definition at line 5150 of file pval.c.

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

5151 {
5152  if (!pvalCheckType(p, "pvalContextGetName", PV_CONTEXT))
5153  return 0;
5154  return p->u1.str;
5155 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalContextSetAbstract()

void pvalContextSetAbstract ( pval p)

Definition at line 5157 of file pval.c.

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

5158 {
5159  if (!pvalCheckType(p, "pvalContextSetAbstract", PV_CONTEXT))
5160  return;
5161  p->u3.abstract = 1;
5162 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
int abstract
Definition: pval.h:80

◆ pvalContextSetName()

void pvalContextSetName ( pval p,
char *  name 
)

Definition at line 5143 of file pval.c.

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

Referenced by main().

5144 {
5145  if (!pvalCheckType(p, "pvalContextSetName", PV_CONTEXT))
5146  return;
5147  p->u1.str = name;
5148 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1

◆ pvalContextUnsetAbstract()

void pvalContextUnsetAbstract ( pval p)

Definition at line 5164 of file pval.c.

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

5165 {
5166  if (!pvalCheckType(p, "pvalContextUnsetAbstract", PV_CONTEXT))
5167  return;
5168  p->u3.abstract = 0;
5169 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
int abstract
Definition: pval.h:80

◆ pvalContextWalkStatements()

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

Definition at line 5190 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
struct pval * next
Definition: pval.h:93

◆ pvalCreateNode()

pval* pvalCreateNode ( pvaltype  type)

Definition at line 5042 of file pval.c.

References calloc, pval::type, and ael_priority::type.

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

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 }
static const char type[]
Definition: chan_ooh323.c:109
#define calloc(a, b)
Definition: astmm.h:157
Definition: pval.h:48
pvaltype type
Definition: pval.h:50

◆ pvalESwitchesAddSwitch()

void pvalESwitchesAddSwitch ( pval p,
char *  name 
)

Definition at line 5373 of file pval.c.

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

5374 {
5375  pval *s;
5376  if (!pvalCheckType(p, "pvalESwitchesAddSwitch", PV_ESWITCHES))
5377  return;
5378  s = pvalCreateNode(PV_WORD);
5379  s->u1.str = name;
5380  p->u1.list = linku1(p->u1.list, s);
5381 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:8
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
char * str
Definition: pval.h:59
Definition: pval.h:48
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

◆ pvalESwitchesWalkNames()

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

Definition at line 5383 of file pval.c.

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

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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
struct pval * next
Definition: pval.h:93

◆ pvalExtenGetHints()

char* pvalExtenGetHints ( pval p)

Definition at line 5837 of file pval.c.

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

5838 {
5839  if (!pvalCheckType(p, "pvalExtenGetHints", PV_EXTENSION))
5840  return 0;
5841  return p->u3.hints;
5842 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
char * hints
Definition: pval.h:81

◆ pvalExtenGetName()

char* pvalExtenGetName ( pval p)

Definition at line 5802 of file pval.c.

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

5803 {
5804  if (!pvalCheckType(p, "pvalExtenGetName", PV_EXTENSION))
5805  return 0;
5806  return p->u1.str;
5807 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalExtenGetRegexten()

int pvalExtenGetRegexten ( pval p)

Definition at line 5823 of file pval.c.

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

5824 {
5825  if (!pvalCheckType(p, "pvalExtenGetRegexten", PV_EXTENSION))
5826  return 0;
5827  return p->u4.regexten;
5828 }
int regexten
Definition: pval.h:90
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@282 u4

◆ pvalExtenGetStatement()

pval* pvalExtenGetStatement ( pval p)

Definition at line 5851 of file pval.c.

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

5852 {
5853  if (!pvalCheckType(p, "pvalExtenGetStatement", PV_EXTENSION))
5854  return 0;
5855  return p->u2.statements;
5856 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61

◆ pvalExtenSetHints()

void pvalExtenSetHints ( pval p,
char *  hints 
)

Definition at line 5830 of file pval.c.

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

Referenced by main().

5831 {
5832  if (!pvalCheckType(p, "pvalExtenSetHints", PV_EXTENSION))
5833  return;
5834  p->u3.hints = hints;
5835 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
static struct ao2_container * hints
Definition: pbx.c:801
char * hints
Definition: pval.h:81

◆ pvalExtenSetName()

void pvalExtenSetName ( pval p,
char *  name 
)

Definition at line 5795 of file pval.c.

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

Referenced by main().

5796 {
5797  if (!pvalCheckType(p, "pvalExtenSetName", PV_EXTENSION))
5798  return;
5799  p->u1.str = name;
5800 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1

◆ pvalExtenSetRegexten()

void pvalExtenSetRegexten ( pval p)

Definition at line 5809 of file pval.c.

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

5810 {
5811  if (!pvalCheckType(p, "pvalExtenSetRegexten", PV_EXTENSION))
5812  return;
5813  p->u4.regexten = 1;
5814 }
int regexten
Definition: pval.h:90
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@282 u4

◆ pvalExtenSetStatement()

void pvalExtenSetStatement ( pval p,
pval statement 
)

Definition at line 5844 of file pval.c.

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

Referenced by main().

5845 {
5846  if (!pvalCheckType(p, "pvalExtenSetStatement", PV_EXTENSION))
5847  return;
5848  p->u2.statements = statement;
5849 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61

◆ pvalExtenUnSetRegexten()

void pvalExtenUnSetRegexten ( pval p)

Definition at line 5816 of file pval.c.

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

5817 {
5818  if (!pvalCheckType(p, "pvalExtenUnSetRegexten", PV_EXTENSION))
5819  return;
5820  p->u4.regexten = 0;
5821 }
int regexten
Definition: pval.h:90
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@282 u4

◆ pvalForGetInc()

char* pvalForGetInc ( pval p)

Definition at line 5647 of file pval.c.

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

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
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
Definition: pval.h:24

◆ pvalForGetInit()

char* pvalForGetInit ( pval p)

Definition at line 5633 of file pval.c.

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

5634 {
5635  if (!pvalCheckType(p, "pvalForGetInit", PV_FOR))
5636  return 0;
5637  return p->u1.for_init;
5638 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:24
union pval::@279 u1
char * for_init
Definition: pval.h:62

◆ pvalForGetStatement()

pval* pvalForGetStatement ( pval p)

Definition at line 5654 of file pval.c.

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

5655 {
5656  if (!pvalCheckType(p, "pvalForGetStatement", PV_FOR))
5657  return 0;
5658  return p->u4.for_statements;
5659 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@282 u4
Definition: pval.h:24
struct pval * for_statements
Definition: pval.h:89

◆ pvalForGetTest()

char* pvalForGetTest ( pval p)

Definition at line 5640 of file pval.c.

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

5641 {
5642  if (!pvalCheckType(p, "pvalForGetTest", PV_FOR))
5643  return 0;
5644  return p->u2.for_test;
5645 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
char * for_test
Definition: pval.h:71
Definition: pval.h:24

◆ pvalForSetInc()

void pvalForSetInc ( pval p,
char *  inc 
)

Definition at line 5619 of file pval.c.

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

5620 {
5621  if (!pvalCheckType(p, "pvalForSetInc", PV_FOR))
5622  return;
5623  p->u3.for_inc = inc;
5624 }
char * for_inc
Definition: pval.h:77
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
Definition: pval.h:24

◆ pvalForSetInit()

void pvalForSetInit ( pval p,
char *  init 
)

Definition at line 5605 of file pval.c.

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

5606 {
5607  if (!pvalCheckType(p, "pvalForSetInit", PV_FOR))
5608  return;
5609  p->u1.for_init = init;
5610 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:24
union pval::@279 u1
char * for_init
Definition: pval.h:62

◆ pvalForSetStatement()

void pvalForSetStatement ( pval p,
pval statement 
)

Definition at line 5626 of file pval.c.

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

5627 {
5628  if (!pvalCheckType(p, "pvalForSetStatement", PV_FOR))
5629  return;
5630  p->u4.for_statements = statement;
5631 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@282 u4
Definition: pval.h:24
struct pval * for_statements
Definition: pval.h:89

◆ pvalForSetTest()

void pvalForSetTest ( pval p,
char *  test 
)

Definition at line 5612 of file pval.c.

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

5613 {
5614  if (!pvalCheckType(p, "pvalForSetTest", PV_FOR))
5615  return;
5616  p->u2.for_test = test;
5617 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
char * for_test
Definition: pval.h:71
Definition: pval.h:24

◆ pvalGlobalsAddStatement()

void pvalGlobalsAddStatement ( pval p,
pval statement 
)

Definition at line 5874 of file pval.c.

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

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 }
struct pval * statements
Definition: pval.h:61
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
#define ast_log
Definition: astobj2.c:42
#define LOG_ERROR
Definition: logger.h:285
pvaltype type
Definition: pval.h:50
union pval::@279 u1

◆ pvalGlobalsWalkStatements()

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

Definition at line 5887 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
struct pval * next
Definition: pval.h:93

◆ pvalGotoGetTarget()

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

Definition at line 5563 of file pval.c.

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

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 }
static char exten[AST_MAX_EXTENSION]
Definition: chan_alsa.c:118
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:22
char * str
Definition: pval.h:59
union pval::@279 u1
struct pval * next
Definition: pval.h:93
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:116

◆ pvalGotoSetTarget()

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

Definition at line 5527 of file pval.c.

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

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);
5535  ext = 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)) {
5546  ext = pvalCreateNode(PV_WORD);
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 }
static char exten[AST_MAX_EXTENSION]
Definition: chan_alsa.c:118
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:22
const char * ext
Definition: http.c:147
Definition: pval.h:8
char * str
Definition: pval.h:59
Definition: pval.h:48
union pval::@279 u1
struct pval * next
Definition: pval.h:93
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:116
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

◆ pvalIfGetCondition()

char* pvalIfGetCondition ( pval p)

Definition at line 5670 of file pval.c.

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

5671 {
5672  if (!pvalCheckType(p, "pvalIfGetCondition", PV_IFTIME))
5673  return 0;
5674  return p->u1.str;
5675 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
Definition: pval.h:30

◆ pvalIfSetCondition()

void pvalIfSetCondition ( pval p,
char *  expr 
)

Definition at line 5663 of file pval.c.

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

5664 {
5665  if (!pvalCheckType(p, "pvalIfSetCondition", PV_IF))
5666  return;
5667  p->u1.str = expr;
5668 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:29
char * str
Definition: pval.h:59
union pval::@279 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.

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

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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
Definition: pval.h:30
struct pval * next
Definition: pval.h:93

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

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

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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:8
void destroy_pval(pval *item)
Definition: pval.c:4940
Definition: pval.h:48
union pval::@279 u1
Definition: pval.h:30
void pvalWordSetString(pval *p, char *str)
Definition: pval.c:5058
struct pval * next
Definition: pval.h:93
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

◆ pvalIgnorePatGetPattern()

char* pvalIgnorePatGetPattern ( pval p)

Definition at line 5866 of file pval.c.

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

5867 {
5868  if (!pvalCheckType(p, "pvalIgnorePatGetPattern", PV_IGNOREPAT))
5869  return 0;
5870  return p->u1.str;
5871 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalIgnorePatSetPattern()

void pvalIgnorePatSetPattern ( pval p,
char *  pat 
)

Definition at line 5859 of file pval.c.

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

Referenced by main().

5860 {
5861  if (!pvalCheckType(p, "pvalIgnorePatSetPattern", PV_IGNOREPAT))
5862  return;
5863  p->u1.str = pat;
5864 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 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.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
Definition: pval.h:8
char * str
Definition: pval.h:59
struct pval * arglist
Definition: pval.h:68
union pval::@279 u1
struct pval * next
Definition: pval.h:93

◆ pvalIncludesAddInclude()

void pvalIncludesAddInclude ( pval p,
const char *  include 
)

Definition at line 5396 of file pval.c.

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

Referenced by main().

5397 {
5398  pval *s;
5399  if (!pvalCheckType(p, "pvalIncludesAddSwitch", PV_INCLUDES))
5400  return;
5401  s = pvalCreateNode(PV_WORD);
5402  s->u1.str = (char *)include;
5403  p->u1.list = linku1(p->u1.list, s);
5404 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:8
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
char * str
Definition: pval.h:59
Definition: pval.h:48
union pval::@279 u1
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

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

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

Referenced by main().

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);
5423  s = 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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
Definition: pval.h:8
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
void destroy_pval(pval *item)
Definition: pval.c:4940
char * str
Definition: pval.h:59
Definition: pval.h:48
struct pval * arglist
Definition: pval.h:68
union pval::@279 u1
struct pval * next
Definition: pval.h:93
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

◆ pvalIncludesWalk()

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

Definition at line 5467 of file pval.c.

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

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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
struct pval * next
Definition: pval.h:93

◆ pvalLabelGetName()

char* pvalLabelGetName ( pval p)

Definition at line 5597 of file pval.c.

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

5598 {
5599  if (!pvalCheckType(p, "pvalLabelGetName", PV_LABEL))
5600  return 0;
5601  return p->u1.str;
5602 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
Definition: pval.h:23

◆ pvalLabelSetName()

void pvalLabelSetName ( pval p,
char *  name 
)

Definition at line 5590 of file pval.c.

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

5591 {
5592  if (!pvalCheckType(p, "pvalLabelSetName", PV_LABEL))
5593  return;
5594  p->u1.str = name;
5595 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1
Definition: pval.h:23

◆ pvalMacroAddArg()

void pvalMacroAddArg ( pval p,
pval arg 
)

Definition at line 5094 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
struct pval * arglist
Definition: pval.h:68
Definition: pval.h:9

◆ pvalMacroAddStatement()

void pvalMacroAddStatement ( pval p,
pval statement 
)

Definition at line 5117 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
Definition: pval.h:9
struct pval * macro_statements
Definition: pval.h:79

◆ pvalMacroCallAddArg()

void pvalMacroCallAddArg ( pval p,
pval arg 
)

Definition at line 5224 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
struct pval * arglist
Definition: pval.h:68

◆ pvalMacroCallGetMacroName()

char* pvalMacroCallGetMacroName ( pval p)

Definition at line 5210 of file pval.c.

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

5211 {
5212  if (!pvalCheckType(p, "pvalMacroCallGetMacroName", PV_MACRO_CALL))
5213  return 0;
5214  return p->u1.str;
5215 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalMacroCallSetArglist()

void pvalMacroCallSetArglist ( pval p,
pval arglist 
)

Definition at line 5217 of file pval.c.

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

5218 {
5219  if (!pvalCheckType(p, "pvalMacroCallSetArglist", PV_MACRO_CALL))
5220  return;
5221  p->u2.arglist = arglist;
5222 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * arglist
Definition: pval.h:68

◆ pvalMacroCallSetMacroName()

void pvalMacroCallSetMacroName ( pval p,
char *  name 
)

Definition at line 5203 of file pval.c.

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

5204 {
5205  if (!pvalCheckType(p, "pvalMacroCallSetMacroName", PV_MACRO_CALL))
5206  return;
5207  p->u1.str = name;
5208 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1

◆ pvalMacroCallWalkArgs()

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

Definition at line 5234 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
const char * args
struct pval * arglist
Definition: pval.h:68
struct pval * next
Definition: pval.h:93

◆ pvalMacroGetName()

char* pvalMacroGetName ( pval p)

Definition at line 5080 of file pval.c.

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

5081 {
5082  if (!pvalCheckType(p, "pvalMacroGetName", PV_MACRO))
5083  return 0;
5084  return p->u1.str;
5085 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
Definition: pval.h:9
union pval::@279 u1

◆ pvalMacroSetArglist()

void pvalMacroSetArglist ( pval p,
pval arglist 
)

Definition at line 5087 of file pval.c.

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

5088 {
5089  if (!pvalCheckType(p, "pvalMacroSetArglist", PV_MACRO))
5090  return;
5091  p->u2.arglist = arglist;
5092 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * arglist
Definition: pval.h:68
Definition: pval.h:9

◆ pvalMacroSetName()

void pvalMacroSetName ( pval p,
char *  name 
)

Definition at line 5073 of file pval.c.

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

5074 {
5075  if (!pvalCheckType(p, "pvalMacroSetName", PV_MACRO))
5076  return;
5077  p->u1.str = name;
5078 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
Definition: pval.h:9
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1

◆ pvalMacroWalkArgs()

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

Definition at line 5105 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * arglist
Definition: pval.h:68
Definition: pval.h:9
struct pval * next
Definition: pval.h:93

◆ pvalMacroWalkStatements()

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

Definition at line 5129 of file pval.c.

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

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 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@281 u3
Definition: pval.h:9
struct pval * next
Definition: pval.h:93
struct pval * macro_statements
Definition: pval.h:79

◆ pvalObjectGetType()

pvaltype pvalObjectGetType ( pval p)

Definition at line 5052 of file pval.c.

References pval::type.

5053 {
5054  return p->type;
5055 }
pvaltype type
Definition: pval.h:50

◆ pvalRandomGetCondition()

char* pvalRandomGetCondition ( pval p)

Definition at line 5729 of file pval.c.

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

5730 {
5731  if (!pvalCheckType(p, "pvalRandomGetCondition", PV_RANDOM))
5732  return 0;
5733  return p->u1.str;
5734 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
Definition: pval.h:31
union pval::@279 u1

◆ pvalRandomSetCondition()

void pvalRandomSetCondition ( pval p,
char *  percent 
)

Definition at line 5722 of file pval.c.

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

5723 {
5724  if (!pvalCheckType(p, "pvalRandomSetCondition", PV_RANDOM))
5725  return;
5726  p->u1.str = percent;
5727 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
Definition: pval.h:31
union pval::@279 u1

◆ pvalStatementBlockAddStatement()

void pvalStatementBlockAddStatement ( pval p,
pval statement 
)

Definition at line 5480 of file pval.c.

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

Referenced by main().

5481 {
5482  if (!pvalCheckType(p, "pvalStatementBlockAddStatement", PV_STATEMENTBLOCK))
5483  return;
5484  p->u1.list = linku1(p->u1.list, statement);
5485 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
union pval::@279 u1

◆ pvalStatementBlockWalkStatements()

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

Definition at line 5487 of file pval.c.

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

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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@279 u1
struct pval * next
Definition: pval.h:93

◆ pvalSwitchAddCase()

void pvalSwitchAddCase ( pval p,
pval Case 
)

Definition at line 5770 of file pval.c.

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

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 }
Definition: pval.h:32
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
Definition: pval.h:13

◆ pvalSwitchesAddSwitch()

void pvalSwitchesAddSwitch ( pval p,
char *  name 
)

Definition at line 5351 of file pval.c.

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

Referenced by main().

5352 {
5353  pval *s;
5354  if (!pvalCheckType(p, "pvalSwitchesAddSwitch", PV_SWITCHES))
5355  return;
5356  s = pvalCreateNode(PV_WORD);
5357  s->u1.str = name;
5358  p->u1.list = linku1(p->u1.list, s);
5359 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:8
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
char * str
Definition: pval.h:59
Definition: pval.h:48
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1
pval * pvalCreateNode(pvaltype type)
Definition: pval.c:5042

◆ pvalSwitchesWalkNames()

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

Definition at line 5361 of file pval.c.

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

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 }
struct pval * list
Definition: pval.h:60
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1
struct pval * next
Definition: pval.h:93

◆ pvalSwitchGetTestexpr()

char* pvalSwitchGetTestexpr ( pval p)

Definition at line 5763 of file pval.c.

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

5764 {
5765  if (!pvalCheckType(p, "pvalSwitchGetTestexpr", PV_SWITCH))
5766  return 0;
5767  return p->u1.str;
5768 }
Definition: pval.h:32
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalSwitchSetTestexpr()

void pvalSwitchSetTestexpr ( pval p,
char *  expr 
)

Definition at line 5756 of file pval.c.

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

5757 {
5758  if (!pvalCheckType(p, "pvalSwitchSetTestexpr", PV_SWITCH))
5759  return;
5760  p->u1.str = expr;
5761 }
Definition: pval.h:32
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalSwitchWalkCases()

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

Definition at line 5782 of file pval.c.

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

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 }
Definition: pval.h:32
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
struct pval * statements
Definition: pval.h:61
struct pval * next
Definition: pval.h:93

◆ pvalTopLevAddObject()

void pvalTopLevAddObject ( pval p,
pval contextOrObj 
)

Definition at line 5901 of file pval.c.

References ast_log, linku1(), and LOG_ERROR.

Referenced by main().

5902 {
5903  if (p) {
5904  linku1(p,contextOrObj);
5905  } else {
5906  ast_log(LOG_ERROR, "First arg to pvalTopLevel is NULL!\n");
5907  }
5908 }
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5922
#define ast_log
Definition: astobj2.c:42
#define LOG_ERROR
Definition: logger.h:285

◆ pvalTopLevWalkObjects()

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

Definition at line 5910 of file pval.c.

References pval::next.

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 }
struct pval * next
Definition: pval.h:93

◆ pvalVarDecGetValue()

char* pvalVarDecGetValue ( pval p)

Definition at line 5520 of file pval.c.

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

5521 {
5522  if (!pvalCheckType(p, "pvalVarDecGetValue", PV_VARDEC))
5523  return 0;
5524  return p->u2.val;
5525 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
char * val
Definition: pval.h:70
Definition: pval.h:21

◆ pvalVarDecGetVarname()

char* pvalVarDecGetVarname ( pval p)

Definition at line 5513 of file pval.c.

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

5514 {
5515  if (!pvalCheckType(p, "pvalVarDecGetVarname", PV_VARDEC))
5516  return 0;
5517  return p->u1.str;
5518 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:21
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalVarDecSetValue()

void pvalVarDecSetValue ( pval p,
char *  value 
)

Definition at line 5506 of file pval.c.

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

5507 {
5508  if (!pvalCheckType(p, "pvalVarDecSetValue", PV_VARDEC))
5509  return;
5510  p->u2.val = value;
5511 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
union pval::@280 u2
int value
Definition: syslog.c:37
char * val
Definition: pval.h:70
Definition: pval.h:21

◆ pvalVarDecSetVarname()

void pvalVarDecSetVarname ( pval p,
char *  name 
)

Definition at line 5499 of file pval.c.

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

5500 {
5501  if (!pvalCheckType(p, "pvalVarDecSetVarname", PV_VARDEC))
5502  return;
5503  p->u1.str = name;
5504 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:21
char * str
Definition: pval.h:59
static const char name[]
Definition: cdr_mysql.c:74
union pval::@279 u1

◆ pvalWordGetString()

char* pvalWordGetString ( pval p)

Definition at line 5065 of file pval.c.

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

5066 {
5067  if (!pvalCheckType(p, "pvalWordGetString", PV_WORD))
5068  return 0;
5069  return p->u1.str;
5070 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
Definition: pval.h:8
char * str
Definition: pval.h:59
union pval::@279 u1

◆ pvalWordSetString()

void pvalWordSetString ( pval p,
char *  str 
)

Definition at line 5058 of file pval.c.

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

Referenced by main(), and pvalIfTimeSetCondition().

5059 {
5060  if (!pvalCheckType(p, "pvalWordSetString", PV_WORD))
5061  return;
5062  p->u1.str = str;
5063 }
int pvalCheckType(pval *p, char *funcname, pvaltype type)
Definition: pval.c:5031
const char * str
Definition: app_jack.c:147
Definition: pval.h:8
char * str
Definition: pval.h:59
union pval::@279 u1

◆ 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 
4209  exten = exten->next_exten;
4210  } while ( exten );
4211 }
struct pval * origin
Definition: ael_structs.h:95
struct ael_priority * plist
Definition: ael_structs.h:115
struct ael_extension * next_exten
Definition: ael_structs.h:117
struct ael_priority * next
Definition: ael_structs.h:100
pvaltype type
Definition: pval.h:50
int priority_num
Definition: ael_structs.h:89
Definition: pval.h:23