pval.c File Reference

Compile symbolic Asterisk Extension Logic into Asterisk extensions, version 2. More...

#include "asterisk.h"
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <regex.h>
#include <sys/stat.h>
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/logger.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/channel.h"
#include "asterisk/callerid.h"
#include "asterisk/pval.h"
#include "asterisk/ael_structs.h"
#include "asterisk/utils.h"

Include dependency graph for pval.c:

Go to the source code of this file.

Macros
#define	ASTMM_LIBC   ASTMM_REDIRECT
#define	BUF_SIZE   2000

Functions
void	add_extensions (struct ael_extension *exten)
void	ael2_print (char *fname, pval *tree)
void	ael2_semantic_check (pval *item, int *arg_errs, int *arg_warns, int *arg_notes)
int	ast_compile_ael2 (struct ast_context **local_contexts, struct ast_hashtab *local_table, struct pval *root)
static void	attach_exten (struct ael_extension **list, struct ael_extension *newmem)
static void	check_abstract_reference (pval *abstract_context)
int	check_app_args (pval *appcall, pval *arglist, struct argapp *app)
static int	check_break (pval *item)
static void	check_context_names (void)
static int	check_continue (pval *item)
static void	check_day (pval *DAY)
static void	check_dow (pval *DOW)
	get_dow: Get day of week More...
static void	check_expr2_input (pval *expr, char *str)
static void	check_goto (pval *item)
static void	check_includes (pval *includes)
static void	check_label (pval *item)
static void	check_macro_returns (pval *macro)
static void	check_month (pval *MON)
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)
static void	check_timerange (pval *p)
int	contains_switch (pval *item)
static int	context_used (struct ael_extension *exten_list, struct ast_context *context)
void	destroy_extensions (struct ael_extension *exten)
void	destroy_pval (pval *item)
void	destroy_pval_item (pval *item)
static int	extension_matches (pval *here, const char *exten, const char *pattern)
struct pval *	find_context (char *name)
static struct pval *	find_first_label_in_current_context (char *label, pval *curr_cont)
static struct pval *	find_label_in_current_context (char *exten, char *label, pval *curr_cont)
static struct pval *	find_label_in_current_db (const char *context, const char *exten, const char *label)
static struct pval *	find_label_in_current_extension (const char *label, pval *curr_ext)
struct pval *	find_macro (char *name)
static void	find_pval_goto_item (pval *item, int lev)
static void	find_pval_gotos (pval *item, int lev)
int	find_switch_item (pval *item)
static void	fix_gotos_in_extensions (struct ael_extension *exten)
static void	gen_match_to_pattern (char *pattern, char *result)
static int	gen_prios (struct ael_extension *exten, char *label, pval *statement, struct ael_extension *mother_exten, struct ast_context *this_context)
static pval *	get_contxt (pval *p)
static pval *	get_extension_or_contxt (pval *p)
static pval *	get_goto_target (pval *item)
static struct pval *	in_context (pval *item)
static struct pval *	in_macro (pval *item)
int	is_empty (char *arg)
int	is_float (char *arg)
int	is_int (char *arg)
static int	label_inside_case (pval *label)
static void	linkexten (struct ael_extension *exten, struct ael_extension *add)
void	linkprio (struct ael_extension *exten, struct ael_priority *prio, struct ael_extension *mother_exten)
pval *	linku1 (pval *head, pval *tail)
int	localized_pbx_load_module (void)
struct pval *	match_pval (pval *item)
static struct pval *	match_pval_item (pval *item)
struct ael_extension *	new_exten (void)
struct ael_priority *	new_prio (void)
static void	print_pval (FILE *fin, pval *item, int depth)
static void	print_pval_list (FILE *fin, pval *item, int depth)
void	pvalAppCallAddArg (pval *p, pval *arg)
char *	pvalAppCallGetAppName (pval *p)
void	pvalAppCallSetAppName (pval *p, char *name)
void	pvalAppCallSetArglist (pval *p, pval *arglist)
pval *	pvalAppCallWalkArgs (pval *p, pval **args)
void	pvalCasePatDefAddStatement (pval *p, pval *statement)
pval *	pvalCasePatDefWalkStatements (pval *p, pval **statement)
char *	pvalCasePatGetVal (pval *p)
void	pvalCasePatSetVal (pval *p, char *val)
char *	pvalCatchGetExtName (pval *p)
pval *	pvalCatchGetStatement (pval *p)
void	pvalCatchSetExtName (pval *p, char *name)
void	pvalCatchSetStatement (pval *p, pval *statement)
int	pvalCheckType (pval *p, char *funcname, pvaltype type)
pval *	pvalConditionalGetElseStatement (pval *p)
pval *	pvalConditionalGetThenStatement (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)
pval *	pvalContextWalkStatements (pval *p, pval **statements)
pval *	pvalCreateNode (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)
pval *	pvalExtenGetStatement (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)
pval *	pvalForGetStatement (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)
pval *	pvalGlobalsWalkStatements (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)
pval *	pvalMacroCallWalkArgs (pval *p, pval **args)
char *	pvalMacroGetName (pval *p)
void	pvalMacroSetArglist (pval *p, pval *arglist)
void	pvalMacroSetName (pval *p, char *name)
pval *	pvalMacroWalkArgs (pval *p, pval **arg)
pval *	pvalMacroWalkStatements (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)
pval *	pvalStatementBlockWalkStatements (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)
pval *	pvalSwitchWalkCases (pval *p, pval **next_case)
void	pvalTopLevAddObject (pval *p, pval *contextOrObj)
pval *	pvalTopLevWalkObjects (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)
static void	remove_spaces_before_equals (char *str)
void	set_priorities (struct ael_extension *exten)
void	traverse_pval_item_template (pval *item, int depth)
void	traverse_pval_template (pval *item, int depth)

Variables
static int	control_statement_count
static int	count_labels
static pval *	current_context
static pval *	current_db
static pval *	current_extension
static char *	days []
static int	errs
static char	expr_output [2096]
static int	in_abstract_context
static int	label_count
static pval *	last_matched_label
static const char *	match_context
static const char *	match_exten
static const char *	match_label
static char *	months []
static int	notes
static char *	registrar = "pbx_ael"
static int	return_on_context_match
static int	warns

Detailed Description

Compile symbolic Asterisk Extension Logic into Asterisk extensions, version 2.

Definition in file pval.c.

Macro Definition Documentation

ASTMM_LIBC

#define ASTMM_LIBC   ASTMM_REDIRECT

Definition at line 30 of file pval.c.

BUF_SIZE

#define BUF_SIZE   2000

Definition at line 61 of file pval.c.

Function Documentation

add_extensions()

void add_extensions

(

struct ael_extension *

exten

)

Definition at line 4213 of file pval.c.

{
    struct ael_priority *pr;
    char *label=0;
    char realext[AST_MAX_EXTENSION];
    if (!exten) {
        ast_log(LOG_WARNING, "This file is Empty!\n" );
        return;
    }
    do {
        struct ael_priority *last = 0;
 
        pbx_substitute_variables_helper(NULL, exten->name, realext, sizeof(realext) - 1);
        if (exten->hints) {
            if (ast_add_extension2(exten->context, 0 /*no replace*/, realext, PRIORITY_HINT, NULL, exten->cidmatch,
                                  exten->hints, NULL, ast_free_ptr, registrar, NULL, 0)) {
                ast_log(LOG_WARNING, "Unable to add step at priority 'hint' of extension '%s'\n",
                        exten->name);
            }
        }
 
        for (pr=exten->plist; pr; pr=pr->next) {
            char app[2000];
            char appargs[2000];
 
            /* before we can add the extension, we need to prep the app/appargs;
               the CONTROL types need to be done after the priority numbers are calculated.
            */
            if (pr->type == AEL_LABEL) /* don't try to put labels in the dialplan! */ {
                last = pr;
                continue;
            }
 
            if (pr->app)
                strcpy(app, pr->app);
            else
                app[0] = 0;
            if (pr->appargs )
                strcpy(appargs, pr->appargs);
            else
                appargs[0] = 0;
            switch( pr->type ) {
            case AEL_APPCALL:
                /* easy case. Everything is all set up */
                break;
 
            case AEL_CONTROL1: /* FOR loop, WHILE loop, BREAK, CONTINUE, IF, IFTIME */
                /* simple, unconditional goto. */
                strcpy(app,"Goto");
                if (pr->goto_true->origin && pr->goto_true->origin->type == PV_SWITCH ) {
                    snprintf(appargs,sizeof(appargs),"%s,%d", pr->goto_true->exten->name, pr->goto_true->priority_num);
                } else if (pr->goto_true->origin && pr->goto_true->origin->type == PV_IFTIME && pr->goto_true->origin->u3.else_statements ) {
                    snprintf(appargs,sizeof(appargs),"%d", pr->goto_true->priority_num+1);
                } else
                    snprintf(appargs,sizeof(appargs),"%d", pr->goto_true->priority_num);
                break;
 
            case AEL_FOR_CONTROL:  /* WHILE loop test, FOR loop test */
                strcpy(app,"GotoIf");
                snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num);
                break;
 
            case AEL_IF_CONTROL:
                strcpy(app,"GotoIf");
                if (pr->origin->u3.else_statements )
                    snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num+1);
                else
                    snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num);
                break;
 
            case AEL_RAND_CONTROL:
                strcpy(app,"Random");
                snprintf(appargs,sizeof(appargs),"%s:%d", pr->appargs, pr->goto_true->priority_num+1);
                break;
 
            case AEL_IFTIME_CONTROL:
                strcpy(app,"GotoIfTime");
                snprintf(appargs,sizeof(appargs),"%s?%d", pr->appargs, pr->priority_num+2);
                break;
 
            case AEL_RETURN:
                strcpy(app,"Return");
                appargs[0] = 0;
                break;
 
            default:
                break;
            }
            if (last && last->type == AEL_LABEL ) {
                label = last->origin->u1.str;
            }
            else
                label = 0;
 
            if (ast_add_extension2(exten->context, 0 /*no replace*/, realext, pr->priority_num, (label?label:NULL), exten->cidmatch,
                                  app, strdup(appargs), ast_free_ptr, registrar, NULL, 0)) {
                ast_log(LOG_WARNING, "Unable to add step at priority '%d' of extension '%s'\n", pr->priority_num,
                        exten->name);
            }
            last = pr;
        }
        exten = exten->next_exten;
    } while ( exten );
}

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

Referenced by ast_compile_ael2().

ael2_print()

void ael2_print	(	char *	fname,
		pval *	tree
	)

Definition at line 382 of file pval.c.

{
    FILE *fin = fopen(fname,"w");
    if ( !fin ) {
        ast_log(LOG_ERROR, "Couldn't open %s for writing.\n", fname);
        return;
    }
    print_pval_list(fin, tree, 0);
    fclose(fin);
}

References ast_log, LOG_ERROR, and print_pval_list().

ael2_semantic_check()

void ael2_semantic_check	(	pval *	item,
		int *	arg_errs,
		int *	arg_warns,
		int *	arg_notes
	)

Definition at line 2885 of file pval.c.

{
 
#ifdef AAL_ARGCHECK
    int argapp_errs =0;
    char *rfilename;
#endif
    struct argapp *apps=0;
 
    if (!item)
        return; /* don't check an empty tree */
#ifdef AAL_ARGCHECK
    rfilename = ast_alloca(10 + strlen(ast_config_AST_VAR_DIR));
    sprintf(rfilename, "%s/applist", ast_config_AST_VAR_DIR);
 
    apps = argdesc_parse(rfilename, &argapp_errs); /* giveth */
#endif
    current_db = item;
    errs = warns = notes = 0;
 
    check_context_names();
    check_pval(item, apps, 0);
 
#ifdef AAL_ARGCHECK
    argdesc_destroy(apps);  /* taketh away */
#endif
    current_db = 0;
 
    *arg_errs = errs;
    *arg_warns = warns;
    *arg_notes = notes;
}

References ast_alloca, ast_config_AST_VAR_DIR, check_context_names(), check_pval(), current_db, errs, item, notes, and warns.

Referenced by pbx_load_module().

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.

{
    pval *p,*p2;
    struct ast_context *context;
    char buf[2000];
    struct ael_extension *exten;
    struct ael_extension *exten_list = 0;
 
    /* Reset the counter so that we get consistent labels between reloads */
    control_statement_count = 0;
 
    for (p=root; p; p=p->next ) { /* do the globals first, so they'll be there
                                     when we try to eval them */
        switch (p->type) {
        case PV_GLOBALS:
            /* just VARDEC elements */
            for (p2=p->u1.list; p2; p2=p2->next) {
                char buf2[2000];
                snprintf(buf2,sizeof(buf2),"%s=%s", p2->u1.str, p2->u2.val);
                pbx_builtin_setvar(NULL, buf2);
            }
            break;
        default:
            break;
        }
    }
 
    for (p=root; p; p=p->next ) {
        pval *lp;
        int argc;
 
        switch (p->type) {
        case PV_MACRO:
 
            context = ast_context_find_or_create(local_contexts, local_table, p->u1.str, registrar);
 
            exten = new_exten();
            exten->context = context;
            exten->name = strdup("~~s~~");
            argc = 1;
            for (lp=p->u2.arglist; lp; lp=lp->next) {
                /* for each arg, set up a "Set" command */
                struct ael_priority *np2 = new_prio();
                np2->type = AEL_APPCALL;
                np2->app = strdup("MSet");
                snprintf(buf,sizeof(buf),"LOCAL(%s)=${ARG%d}", lp->u1.str, argc++);
                remove_spaces_before_equals(buf);
                np2->appargs = strdup(buf);
                linkprio(exten, np2, NULL);
            }
 
            /* CONTAINS APPCALLS, CATCH, just like extensions... */
            if (gen_prios(exten, p->u1.str, p->u3.macro_statements, 0, context)) {
                return -1;
            }
            if (exten->return_needed) {  /* most likely, this will go away */
                struct ael_priority *np2 = new_prio();
                np2->type = AEL_APPCALL;
                np2->app = strdup("NoOp");
                snprintf(buf,sizeof(buf),"End of Macro %s-%s",p->u1.str, exten->name);
                np2->appargs = strdup(buf);
                linkprio(exten, np2, NULL);
                exten-> return_target = np2;
            }
 
            set_priorities(exten);
            attach_exten(&exten_list, exten);
            break;
 
        case PV_GLOBALS:
            /* already done */
            break;
 
        case PV_CONTEXT:
            context = ast_context_find_or_create(local_contexts, local_table, p->u1.str, registrar);
 
            /* contexts contain: ignorepat, includes, switches, eswitches, extensions,  */
            for (p2=p->u2.statements; p2; p2=p2->next) {
                pval *p3;
                char *s3;
 
                switch (p2->type) {
                case PV_EXTENSION:
                    exten = new_exten();
                    exten->name = strdup(p2->u1.str);
                    exten->context = context;
 
                    if( (s3=strchr(exten->name, '/') ) != 0 )
                    {
                        *s3 = 0;
                        exten->cidmatch = s3+1;
                    }
 
                    if ( p2->u3.hints )
                        exten->hints = strdup(p2->u3.hints);
                    exten->regexten = p2->u4.regexten;
                    if (gen_prios(exten, p->u1.str, p2->u2.statements, 0, context)) {
                        return -1;
                    }
                    if (exten->return_needed) { /* returns don't generate a goto eoe (end of extension) any more, just a Return() app call) */
                        struct ael_priority *np2 = new_prio();
                        np2->type = AEL_APPCALL;
                        np2->app = strdup("NoOp");
                        snprintf(buf,sizeof(buf),"End of Extension %s", exten->name);
                        np2->appargs = strdup(buf);
                        linkprio(exten, np2, NULL);
                        exten-> return_target = np2;
                    }
                    /* is the last priority in the extension a label? Then add a trailing no-op */
                    if ( exten->plist_last && exten->plist_last->type == AEL_LABEL ) {
                        struct ael_priority *np2 = new_prio();
                        np2->type = AEL_APPCALL;
                        np2->app = strdup("NoOp");
                        snprintf(buf,sizeof(buf),"A NoOp to follow a trailing label %s", exten->plist_last->origin->u1.str);
                        np2->appargs = strdup(buf);
                        linkprio(exten, np2, NULL);
                    }
 
                    set_priorities(exten);
                    attach_exten(&exten_list, exten);
                    break;
 
                case PV_IGNOREPAT:
                    ast_context_add_ignorepat2(context, p2->u1.str, registrar);
                    break;
 
                case PV_INCLUDES:
                    for (p3 = p2->u1.list; p3 ;p3=p3->next) {
                        if ( p3->u2.arglist ) {
                            snprintf(buf,sizeof(buf), "%s,%s,%s,%s,%s",
                                     p3->u1.str,
                                     p3->u2.arglist->u1.str,
                                     p3->u2.arglist->next->u1.str,
                                     p3->u2.arglist->next->next->u1.str,
                                     p3->u2.arglist->next->next->next->u1.str);
                            ast_context_add_include2(context, buf, registrar);
                        } else
                            ast_context_add_include2(context, p3->u1.str, registrar);
                    }
                    break;
 
                case PV_SWITCHES:
                    for (p3 = p2->u1.list; p3 ;p3=p3->next) {
                        char *c = strchr(p3->u1.str, '/');
                        if (c) {
                            *c = '\0';
                            c++;
                        } else
                            c = "";
 
                        ast_context_add_switch2(context, p3->u1.str, c, 0, registrar);
                    }
                    break;
 
                case PV_ESWITCHES:
                    for (p3 = p2->u1.list; p3 ;p3=p3->next) {
                        char *c = strchr(p3->u1.str, '/');
                        if (c) {
                            *c = '\0';
                            c++;
                        } else
                            c = "";
 
                        ast_context_add_switch2(context, p3->u1.str, c, 1, registrar);
                    }
                    break;
                default:
                    break;
                }
            }
 
            break;
 
        default:
            /* huh? what? */
            break;
 
        }
    }
 
    /* Create default "h" bubble context */
    if (ast_custom_function_find("DIALPLAN_EXISTS") && ast_custom_function_find("STACK_PEEK")) {
        int i;
        const char *h_context = "ael-builtin-h-bubble";
        struct ael_priority *np;
        struct {
            int priority;
            const char *app;
            const char *arg;
        } steps[] = {
            /* Start high, to avoid conflict with existing h extensions */
            { 1, "Goto", "9991" },
            /* Save the context, because after the StackPop, it disappears */
            { 9991, "Set", "~~parentcxt~~=${STACK_PEEK(1,c,1)}" },
            /* If we're not in a Gosub frame, exit */
            { 9992, "GotoIf", "$[\"${~~parentcxt~~}\"=\"\"]?9996" },
            /* Check for an "h" extension in that context */
            { 9993, "GotoIf", "${DIALPLAN_EXISTS(${~~parentcxt~~},h,1)}?9994:9996" },
            /* Pop off the stack frame to prevent an infinite loop */
            { 9994, "StackPop", "" },
            /* Finally, go there. */
            { 9995, "Goto", "${~~parentcxt~~},h,1" },
            /* Just an empty priority for jumping out early */
            { 9996, "NoOp", "" }
        };
        context = ast_context_find_or_create(local_contexts, local_table, h_context, registrar);
        if (context_used(exten_list, context)) {
            int found = 0;
            while (!found) {
                /* Pick a new context name that is not used. */
                char h_context_template[] = "/tmp/ael-builtin-h-bubble-XXXXXX";
                int fd = mkstemp(h_context_template);
                unlink(h_context_template);
                close(fd);
                context = ast_context_find_or_create(local_contexts, local_table, h_context_template + 5, registrar);
                found = !context_used(exten_list, context);
            }
            h_context = ast_get_context_name(context);
        }
        exten = new_exten();
        exten->context = context;
        exten->name = strdup("h");
 
        for (i = 0; i < ARRAY_LEN(steps); i++) {
            np = new_prio();
            np->type = AEL_APPCALL;
            np->priority_num = steps[i].priority;
            np->app = strdup(steps[i].app);
            np->appargs = strdup(steps[i].arg);
            linkprio(exten, np, NULL);
        }
        attach_exten(&exten_list, exten);
 
        /* Include the default "h" bubble context in each macro context */
        for (exten = exten_list; exten; exten = exten->next_exten) {
            /* All macros contain a "~~s~~" extension, and it's the first created.  If
             * we perchance get a non-macro context, it's no big deal; the logic is
             * designed to exit out smoothly if not called from within a Gosub. */
            if (!strcmp(exten->name, "~~s~~")) {
                ast_context_add_include2(exten->context, h_context, registrar);
            }
        }
    }
 
    /* moved these from being done after a macro or extension were processed,
       to after all processing is done, for the sake of fixing gotos to labels inside cases... */
    /* I guess this would be considered 2nd pass of compiler now... */
    fix_gotos_in_extensions(exten_list); /* find and fix extension ref in gotos to labels that are in case statements */
    add_extensions(exten_list);   /* actually makes calls to create priorities in ast_contexts -- feeds dialplan to asterisk */
    destroy_extensions(exten_list);  /* all that remains is an empty husk, discard of it as is proper */
 
    return 0;
}

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

Referenced by pbx_load_module().

attach_exten()

static void attach_exten ( struct ael_extension **  list, struct ael_extension *  newmem  )

static

Definition at line 4318 of file pval.c.

{
    /* travel to the end of the list... */
    struct ael_extension *lptr;
    if( !*list ) {
        *list = newmem;
        return;
    }
    lptr = *list;
 
    while( lptr->next_exten ) {
        lptr = lptr->next_exten;
    }
    /* lptr should now pointing to the last element in the list; it has a null next_exten pointer */
    lptr->next_exten = newmem;
}

References ael_extension::next_exten.

Referenced by ast_compile_ael2().

check_abstract_reference()

static void check_abstract_reference ( pval *  abstract_context )

static

Definition at line 2329 of file pval.c.

{
    pval *i,*j;
    /* find some context includes that reference this context */
 
 
    /* otherwise, print out a warning */
    for (i=current_db; i; i=i->next) {
        if (i->type == PV_CONTEXT) {
            for (j=i->u2. statements; j; j=j->next) {
                if ( j->type == PV_INCLUDES ) {
                    struct pval *p4;
                    for (p4=j->u1.list; p4; p4=p4->next) {
                        /* for each context pointed to, find it, then find a context/label that matches the
                           target here! */
                        if ( !strcmp(p4->u1.str, abstract_context->u1.str) )
                            return; /* found a match! */
                    }
                }
            }
        }
    }
    ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: Couldn't find a reference to this abstract context (%s) in any other context!\n",
            abstract_context->filename, abstract_context->startline, abstract_context->endline, abstract_context->u1.str);
    warns++;
}

References ast_log, current_db, pval::endline, pval::filename, pval::list, LOG_WARNING, pval::next, PV_CONTEXT, PV_INCLUDES, pval::startline, pval::str, pval::type, pval::u1, pval::u2, and warns.

Referenced by check_pval_item().

check_app_args()

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

Definition at line 2130 of file pval.c.

{
#ifdef AAL_ARGCHECK
    struct argdesc *ad = app->args;
    pval *pa;
    int z;
 
    for (pa = arglist; pa; pa=pa->next) {
        if (!ad) {
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Extra argument %s not in application call to %s !\n",
                    arglist->filename, arglist->startline, arglist->endline, pa->u1.str, app->name);
            warns++;
            return 1;
        } else {
            /* find the first entry in the ad list that will match */
            do {
                if ( ad->dtype == ARGD_VARARG ) /* once we hit the VARARG, all bets are off. Discontinue the comparisons */
                    break;
 
                z= option_matches( ad, pa, app);
                if (!z) {
                    if ( !arglist )
                        arglist=appcall;
 
                    if (ad->type == ARGD_REQUIRED) {
                        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
                                arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
                        warns++;
                        return 1;
                    }
                } else if (z && ad->dtype == ARGD_OPTIONSET) {
                    option_matches_j( ad, pa, app);
                }
                ad = ad->next;
            } while (ad && !z);
        }
    }
    /* any app nodes left, that are not optional? */
    for ( ; ad; ad=ad->next) {
        if (ad->type == ARGD_REQUIRED && ad->dtype != ARGD_VARARG) {
            if ( !arglist )
                arglist=appcall;
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
                    arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
            warns++;
            return 1;
        }
    }
    return 0;
#else
    return 0;
#endif
}

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

Referenced by check_pval_item().

check_break()

static int check_break ( pval *  item )

static

Definition at line 1038 of file pval.c.

{
    pval *p = item;
 
    while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
        /* a break is allowed in WHILE, FOR, CASE, DEFAULT, PATTERN; otherwise, it don't make
           no sense */
        if( p->type == PV_CASE || p->type == PV_DEFAULT || p->type == PV_PATTERN
            || p->type == PV_WHILE || p->type == PV_FOR   ) {
            return 1;
        }
        p = p->dad;
    }
    ast_log(LOG_ERROR,"Error: file %s, line %d-%d: 'break' not in switch, for, or while statement!\n",
            item->filename, item->startline, item->endline);
    errs++;
 
    return 0;
}

References ast_log, pval::dad, errs, item, LOG_ERROR, PV_CASE, PV_CONTEXT, PV_DEFAULT, PV_FOR, PV_MACRO, PV_PATTERN, PV_WHILE, and pval::type.

Referenced by check_pval_item().

check_context_names()

static void check_context_names ( void  )

static

Definition at line 2310 of file pval.c.

{
    pval *i,*j;
    for (i=current_db; i; i=i->next) {
        if (i->type == PV_CONTEXT || i->type == PV_MACRO) {
            for (j=i->next; j; j=j->next) {
                if ( j->type == PV_CONTEXT || j->type == PV_MACRO ) {
                    if ( !strcmp(i->u1.str, j->u1.str) && !(i->u3.abstract&2) && !(j->u3.abstract&2) )
                    {
                        ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: The context name (%s) is also declared in file %s, line %d-%d! (and neither is marked 'extend')\n",
                                i->filename, i->startline, i->endline, i->u1.str,  j->filename, j->startline, j->endline);
                        warns++;
                    }
                }
            }
        }
    }
}

References pval::abstract, ast_log, current_db, pval::endline, pval::filename, LOG_WARNING, pval::next, PV_CONTEXT, PV_MACRO, pval::startline, pval::str, pval::type, pval::u1, pval::u3, and warns.

Referenced by ael2_semantic_check().

check_continue()

static int check_continue ( pval *  item )

static

Definition at line 1058 of file pval.c.

{
    pval *p = item;
 
    while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
        /* a break is allowed in WHILE, FOR, CASE, DEFAULT, PATTERN; otherwise, it don't make
           no sense */
        if( p->type == PV_WHILE || p->type == PV_FOR   ) {
            return 1;
        }
        p = p->dad;
    }
    ast_log(LOG_ERROR,"Error: file %s, line %d-%d: 'continue' not in 'for' or 'while' statement!\n",
            item->filename, item->startline, item->endline);
    errs++;
 
    return 0;
}

References ast_log, pval::dad, errs, item, LOG_ERROR, PV_CONTEXT, PV_FOR, PV_MACRO, PV_WHILE, and pval::type.

Referenced by check_pval_item().

check_day()

static void check_day ( pval *  DAY )

static

Definition at line 937 of file pval.c.

{
    char *day;
    char *c;
    /* The following line is coincidence, really! */
    int s, e;
 
    day = ast_strdupa(DAY->u1.str);
 
    /* Check for all days */
    if (ast_strlen_zero(day) || !strcmp(day, "*")) {
        return;
    }
    /* Get start and ending days */
    c = strchr(day, '-');
    if (c) {
        *c = '\0';
        c++;
    }
    /* Find the start */
    if (sscanf(day, "%2d", &s) != 1) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start day of month (%s) must be a number!\n",
                DAY->filename, DAY->startline, DAY->endline, day);
        warns++;
    }
    else if ((s < 1) || (s > 31)) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start day of month (%s) must be a number in the range [1-31]!\n",
                DAY->filename, DAY->startline, DAY->endline, day);
        warns++;
    }
    s--;
    if (c) {
        if (sscanf(c, "%2d", &e) != 1) {
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end day of month (%s) must be a number!\n",
                    DAY->filename, DAY->startline, DAY->endline, c);
            warns++;
        }
        else if ((e < 1) || (e > 31)) {
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end day of month (%s) must be a number in the range [1-31]!\n",
                    DAY->filename, DAY->startline, DAY->endline, day);
            warns++;
        }
        e--;
    } else
        e = s;
}

References ast_log, ast_strdupa, ast_strlen_zero(), c, DAY, LOG_WARNING, and warns.

Referenced by check_pval_item().

check_dow()

static void check_dow ( pval *  DOW )

static

get_dow: Get day of week

Definition at line 898 of file pval.c.

{
    char *dow;
    char *c;
    /* The following line is coincidence, really! */
    int s, e;
 
    dow = ast_strdupa(DOW->u1.str);
 
    /* Check for all days */
    if (ast_strlen_zero(dow) || !strcmp(dow, "*"))
        return;
    /* Get start and ending days */
    c = strchr(dow, '-');
    if (c) {
        *c = '\0';
        c++;
    } else
        c = NULL;
    /* Find the start */
    s = 0;
    while ((s < 7) && strcasecmp(dow, days[s])) s++;
    if (s >= 7) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The day (%s) must be one of 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', or 'sat'!\n",
                DOW->filename, DOW->startline, DOW->endline, dow);
        warns++;
    }
    if (c) {
        e = 0;
        while ((e < 7) && strcasecmp(c, days[e])) e++;
        if (e >= 7) {
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end day (%s) must be one of 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', or 'sat'!\n",
                    DOW->filename, DOW->startline, DOW->endline, c);
            warns++;
        }
    } else
        e = s;
}

References ast_log, ast_strdupa, ast_strlen_zero(), c, days, pval::endline, pval::filename, LOG_WARNING, NULL, pval::startline, pval::str, pval::u1, and warns.

Referenced by check_pval_item().

check_expr2_input()

static void check_expr2_input ( pval *  expr, char *  str  )

static

Definition at line 801 of file pval.c.

{
    int spaces = strspn(str,"\t \n");
    if ( !strncmp(str+spaces,"$[",2) ) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The expression '%s' is redundantly wrapped in '$[ ]'. \n",
                expr->filename, expr->startline, expr->endline, str);
        warns++;
    }
}

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

Referenced by check_pval_item().

check_goto()

static void check_goto ( pval *  item )

static

Definition at line 1225 of file pval.c.

{
    if (!item->u1.list) {
        return;
    }
 
    /* check for the target of the goto-- does it exist? */
    if ( !(item->u1.list)->next && !(item->u1.list)->u1.str ) {
        ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  empty label reference found!\n",
                item->filename, item->startline, item->endline);
        errs++;
    }
 
    /* just one item-- the label should be in the current extension */
    if (!item->u1.list->next && !strstr(item->u1.list->u1.str,"${")) {
        struct pval *z = get_extension_or_contxt(item);
        struct pval *x = 0;
        if (z)
            x = find_label_in_current_extension((char*)((item->u1.list)->u1.str), z); /* if in macro, use current context instead */
        /* printf("Called find_label_in_current_extension with arg %s; current_extension is %x: %d\n",
           (char*)((item->u1.list)->u1.str), current_extension?current_extension:current_context, current_extension?current_extension->type:current_context->type); */
        if (!x) {
            ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  no label %s exists in the current extension!\n",
                    item->filename, item->startline, item->endline, item->u1.list->u1.str);
            errs++;
        }
        else
            return;
    }
 
    /* TWO items */
    if (item->u1.list->next && !item->u1.list->next->next) {
        /* two items */
        /* printf("Calling find_label_in_current_context with args %s, %s\n",
           (char*)((item->u1.list)->u1.str), (char *)item->u1.list->next->u1.str); */
        if (!strstr((item->u1.list)->u1.str,"${")
            && !strstr(item->u1.list->next->u1.str,"${") ) /* Don't try to match variables */ {
            struct pval *z = get_contxt(item);
            struct pval *x = 0;
 
            if (z)
                x = find_label_in_current_context((char *)item->u1.list->u1.str, (char *)item->u1.list->next->u1.str, z);
 
            if (!x) {
                ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  no label '%s,%s' exists in the current context, or any of its inclusions!\n",
                        item->filename, item->startline, item->endline, item->u1.list->u1.str, item->u1.list->next->u1.str );
                errs++;
            }
            else
                return;
        }
    }
 
    /* All 3 items! */
    if (item->u1.list->next && item->u1.list->next->next) {
        /* all three */
        pval *first = item->u1.list;
        pval *second = item->u1.list->next;
        pval *third = item->u1.list->next->next;
 
        /* printf("Calling find_label_in_current_db with args %s, %s, %s\n",
           (char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str); */
        if (!strstr((item->u1.list)->u1.str,"${")
            && !strstr(item->u1.list->next->u1.str,"${")
            && !strstr(item->u1.list->next->next->u1.str,"${")) /* Don't try to match variables */ {
            struct pval *x = find_label_in_current_db((char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str);
            if (!x) {
                struct pval *p3;
                struct pval *found = 0;
                struct pval *that_context = find_context(item->u1.list->u1.str);
 
                /* the target of the goto could be in an included context!! Fancy that!! */
                /* look for includes in the current context */
                if (that_context) {
                    for (p3=that_context->u2.statements; p3; p3=p3->next) {
                        if (p3->type == PV_INCLUDES) {
                            struct pval *p4;
                            for (p4=p3->u1.list; p4; p4=p4->next) {
                                /* for each context pointed to, find it, then find a context/label that matches the
                                   target here! */
                                char *incl_context = p4->u1.str;
                                /* find a matching context name */
                                struct pval *that_other_context = find_context(incl_context);
                                if (that_other_context) {
                                    struct pval *x3;
                                    x3 = find_label_in_current_context((char *)item->u1.list->next->u1.str, (char *)item->u1.list->next->next->u1.str, that_other_context);
                                    if (x3) {
                                        found = x3;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    if (!found) {
                        ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  no label %s|%s exists in the context %s or its inclusions!\n",
                                item->filename, item->startline, item->endline, item->u1.list->next->u1.str, item->u1.list->next->next->u1.str, item->u1.list->u1.str );
                        errs++;
                    } else {
                        struct pval *mac = in_macro(item); /* is this goto inside a macro? */
                        if( mac ) {    /* yes! */
                            struct pval *targ = in_context(found);
                            if( mac != targ )
                            {
                                ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: It's bad form to have a goto in a macro to a target outside the macro!\n",
                                        item->filename, item->startline, item->endline);
                                warns++;
                            }
                        }
                    }
                } else {
                    /* here is where code would go to check for target existence in extensions.conf files */
#ifdef STANDALONE
                    struct pbx_find_info pfiq = {.stacklen = 0 };
                    extern int localized_pbx_load_module(void);
                    /* if this is a standalone, we will need to make sure the
                       localized load of extensions.conf is done */
                    if (!extensions_dot_conf_loaded) {
                        localized_pbx_load_module();
                        extensions_dot_conf_loaded++;
                    }
 
                    pbx_find_extension(NULL, NULL, &pfiq, first->u1.str, second->u1.str, atoi(third->u1.str),
                                            atoi(third->u1.str) ? NULL : third->u1.str, NULL,
                                            atoi(third->u1.str) ? E_MATCH : E_FINDLABEL);
 
                    if (pfiq.status != STATUS_SUCCESS) {
                        ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: goto:  Couldn't find goto target %s|%s|%s, not even in extensions.conf!\n",
                                item->filename, item->startline, item->endline, first->u1.str, second->u1.str, third->u1.str);
                        warns++;
                    }
#else
                    ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: goto:  Couldn't find goto target %s|%s|%s in the AEL code!\n",
                            item->filename, item->startline, item->endline, first->u1.str, second->u1.str, third->u1.str);
                    warns++;
#endif
                }
            } else {
                struct pval *mac = in_macro(item); /* is this goto inside a macro? */
                if( mac ) {    /* yes! */
                    struct pval *targ = in_context(x);
                    if( mac != targ )
                    {
                        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: It's bad form to have a goto in a macro to a target outside the macro!\n",
                                item->filename, item->startline, item->endline);
                        warns++;
                    }
                }
            }
        }
    }
}

References ast_log, E_FINDLABEL, E_MATCH, errs, find_context(), find_label_in_current_context(), find_label_in_current_db(), find_label_in_current_extension(), first, get_contxt(), get_extension_or_contxt(), in_context(), in_macro(), item, pval::list, localized_pbx_load_module(), LOG_ERROR, LOG_WARNING, pval::next, NULL, pbx_find_extension(), PV_INCLUDES, pbx_find_info::stacklen, pval::statements, pbx_find_info::status, STATUS_SUCCESS, pval::str, pval::type, pval::u1, pval::u2, and warns.

Referenced by check_pval_item(), and find_pval_goto_item().

check_includes()

static void check_includes ( pval *  includes )

static

Definition at line 811 of file pval.c.

{
    struct pval *p4;
    for (p4=includes->u1.list; p4; p4=p4->next) {
        /* for each context pointed to, find it, then find a context/label that matches the
           target here! */
        char *incl_context = p4->u1.str;
        /* find a matching context name */
        struct pval *that_other_context = find_context(incl_context);
        if (!that_other_context && strcmp(incl_context, "parkedcalls") != 0) {
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The included context '%s' cannot be found.\n\
 (You may ignore this warning if '%s' exists in extensions.conf, or is created by another module. I cannot check for those.)\n",
                    includes->filename, includes->startline, includes->endline, incl_context, incl_context);
            warns++;
        }
    }
}

References ast_log, pval::endline, pval::filename, find_context(), pval::list, LOG_WARNING, pval::next, pval::startline, pval::str, pval::u1, and warns.

Referenced by check_pval_item().

check_label()

static void check_label ( pval *  item )

static

Definition at line 1106 of file pval.c.

{
    struct pval *curr;
    struct pval *x;
    int alright = 0;
 
    /* A label outside an extension just plain does not make sense! */
 
    curr = item;
 
    while( curr ) {
        if( curr->type == PV_MACRO || curr->type == PV_EXTENSION   ) {
            alright = 1;
            break;
        }
        curr = curr->dad;
    }
    if( !alright )
    {
        ast_log(LOG_ERROR,"Error: file %s, line %d-%d: Label %s is not within an extension or macro!\n",
                item->filename, item->startline, item->endline, item->u1.str);
        errs++;
    }
 
 
    /* basically, ensure that a label is not repeated in a context. Period.
       The method:  well, for each label, find the first label in the context
       with the same name. If it's not the current label, then throw an error. */
 
 
    /* printf("==== check_label:   ====\n"); */
    if( !current_extension )
        curr = current_context;
    else
        curr = current_extension;
 
    x = find_first_label_in_current_context((char *)item->u1.str, curr);
    /* printf("Hey, check_label found with item = %x, and x is %x, and currcont is %x, label name is %s\n", item,x, current_context, (char *)item->u1.str); */
    if( x && x != item )
    {
        ast_log(LOG_ERROR,"Error: file %s, line %d-%d: Duplicate label %s! Previously defined at file %s, line %d.\n",
                item->filename, item->startline, item->endline, item->u1.str, x->filename, x->startline);
        errs++;
    }
    /* printf("<<<<< check_label:   ====\n"); */
}

References ast_log, current_context, current_extension, pval::dad, errs, pval::filename, find_first_label_in_current_context(), item, LOG_ERROR, PV_EXTENSION, PV_MACRO, pval::startline, and pval::type.

Referenced by check_pval_item().

check_macro_returns()

static void check_macro_returns ( pval *  macro )

static

Definition at line 650 of file pval.c.

{
    pval *i;
    if (!macro->u3.macro_statements)
    {
        pval *z = calloc(1, sizeof(struct pval));
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The macro %s is empty! I will insert a return.\n",
                macro->filename, macro->startline, macro->endline, macro->u1.str);
 
        z->type = PV_RETURN;
        z->startline = macro->startline;
        z->endline = macro->endline;
        z->startcol = macro->startcol;
        z->endcol = macro->endcol;
        z->filename = strdup(macro->filename);
 
        macro->u3.macro_statements = z;
        return;
    }
    for (i=macro->u3.macro_statements; i; i=i->next) {
        /* if the last statement in the list is not return, then insert a return there */
        if (i->next == NULL) {
            if (i->type != PV_RETURN) {
                pval *z = calloc(1, sizeof(struct pval));
                ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The macro %s does not end with a return; I will insert one.\n",
                        macro->filename, macro->startline, macro->endline, macro->u1.str);
 
                z->type = PV_RETURN;
                z->startline = macro->startline;
                z->endline = macro->endline;
                z->startcol = macro->startcol;
                z->endcol = macro->endcol;
                z->filename = strdup(macro->filename);
 
                i->next = z;
                return;
            }
        }
    }
    return;
}

References ast_log, calloc, pval::endcol, pval::endline, pval::filename, LOG_WARNING, pval::macro_statements, pval::next, NULL, PV_RETURN, pval::startcol, pval::startline, pval::str, strdup, pval::type, pval::u1, and pval::u3.

Referenced by check_pval_item().

check_month()

static void check_month ( pval *  MON )

static

Definition at line 1000 of file pval.c.

{
    char *mon;
    char *c;
    /* The following line is coincidence, really! */
    int s, e;
 
    mon = ast_strdupa(MON->u1.str);
 
    /* Check for all days */
    if (ast_strlen_zero(mon) || !strcmp(mon, "*"))
        return ;
    /* Get start and ending days */
    c = strchr(mon, '-');
    if (c) {
        *c = '\0';
        c++;
    }
    /* Find the start */
    s = 0;
    while ((s < 12) && strcasecmp(mon, months[s])) s++;
    if (s >= 12) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start month (%s) must be a one of: 'jan', 'feb', ..., 'dec'!\n",
                MON->filename, MON->startline, MON->endline, mon);
        warns++;
    }
    if (c) {
        e = 0;
        while ((e < 12) && strcasecmp(mon, months[e])) e++;
        if (e >= 12) {
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end month (%s) must be a one of: 'jan', 'feb', ..., 'dec'!\n",
                    MON->filename, MON->startline, MON->endline, c);
            warns++;
        }
    } else
        e = s;
}

References ast_log, ast_strdupa, ast_strlen_zero(), c, pval::endline, pval::filename, LOG_WARNING, months, pval::startline, pval::str, pval::u1, and warns.

Referenced by check_pval_item().

check_pval()

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

Definition at line 2865 of file pval.c.

{
    pval *i;
 
    /* checks to do:
       1. Do goto's point to actual labels?
       2. Do macro calls reference a macro?
       3. Does the number of macro args match the definition?
       4. Is a macro call missing its & at the front?
       5. Application calls-- we could check syntax for existing applications,
          but I need some sort of universal description bnf for a general
          sort of method for checking arguments, in number, maybe even type, at least.
          Don't want to hand code checks for hundreds of applications.
    */
 
    for (i=item; i; i=i->next) {
        check_pval_item(i,apps,in_globals);
    }
}

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

Referenced by ael2_semantic_check(), and check_pval_item().

check_pval_item()

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

Definition at line 2357 of file pval.c.

{
    pval *lp;
#ifdef AAL_ARGCHECK
    struct argapp *app, *found;
#endif
    struct pval *macro_def;
    struct pval *app_def;
 
    char errmsg[4096];
    char *strp;
 
    switch (item->type) {
    case PV_WORD:
        /* fields: item->u1.str == string associated with this (word).
                   item->u2.arglist  == pval list of 4 PV_WORD elements for time values (only in PV_INCLUDES) */
        break;
 
    case PV_MACRO:
        /* fields: item->u1.str     == name of macro
                   item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
 
                   item->u3.macro_statements == pval list of statements in macro body.
        */
        in_abstract_context = 0;
        current_context = item;
        current_extension = 0;
 
        check_macro_returns(item);
 
        for (lp=item->u2.arglist; lp; lp=lp->next) {
 
        }
        check_pval(item->u3.macro_statements, apps,in_globals);
        break;
 
    case PV_CONTEXT:
        /* fields: item->u1.str     == name of context
                   item->u2.statements == pval list of statements in context body
                   item->u3.abstract == int 1 if an abstract keyword were present
        */
        current_context = item;
        current_extension = 0;
        if ( item->u3.abstract ) {
            in_abstract_context = 1;
            check_abstract_reference(item);
        } else
            in_abstract_context = 0;
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_MACRO_CALL:
        /* fields: item->u1.str     == name of macro to call
                   item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
        */
#ifdef STANDALONE
        /* if this is a standalone, we will need to make sure the
           localized load of extensions.conf is done */
        if (!extensions_dot_conf_loaded) {
            localized_pbx_load_module();
            extensions_dot_conf_loaded++;
        }
#endif
        macro_def = find_macro(item->u1.str);
        if (!macro_def) {
#ifdef STANDALONE
            struct pbx_find_info pfiq = {.stacklen = 0 };
            struct pbx_find_info pfiq2 = {.stacklen = 0 };
 
            /* look for the macro in the extensions.conf world */
            pbx_find_extension(NULL, NULL, &pfiq, item->u1.str, "s", 1, NULL, NULL, E_MATCH);
 
            if (pfiq.status != STATUS_SUCCESS) {
                char namebuf2[256];
                snprintf(namebuf2, 256, "macro-%s", item->u1.str);
 
                /* look for the macro in the extensions.conf world */
                pbx_find_extension(NULL, NULL, &pfiq2, namebuf2, "s", 1, NULL, NULL, E_MATCH);
 
                if (pfiq2.status == STATUS_SUCCESS) {
                    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",
                            item->filename, item->startline, item->endline, item->u1.str, item->u1.str);
                    warns++;
                } else {
                    ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to non-existent %s! (Not even in the extensions.conf stuff!)\n",
                            item->filename, item->startline, item->endline, item->u1.str);
                    warns++;
                }
            }
#else
            ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to %s cannot be found in the AEL code!\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
 
#endif
#ifdef THIS_IS_1DOT4
            char namebuf2[256];
            snprintf(namebuf2, 256, "macro-%s", item->u1.str);
 
            /* look for the macro in the extensions.conf world */
            pbx_find_extension(NULL, NULL, &pfiq, namebuf2, "s", 1, NULL, NULL, E_MATCH);
 
            if (pfiq.status != STATUS_SUCCESS) {
                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",
                        item->filename, item->startline, item->endline, item->u1.str);
                warns++;
            }
 
#endif
 
        } else if (macro_def->type != PV_MACRO) {
            ast_log(LOG_ERROR,"Error: file %s, line %d-%d: macro call to %s references a context, not a macro!\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            errs++;
        } else {
            /* macro_def is a MACRO, so do the args match in number? */
            int hereargs = 0;
            int thereargs = 0;
 
            for (lp=item->u2.arglist; lp; lp=lp->next) {
                hereargs++;
            }
            for (lp=macro_def->u2.arglist; lp; lp=lp->next) {
                thereargs++;
            }
            if (hereargs != thereargs ) {
                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",
                        item->filename, item->startline, item->endline, item->u1.str, hereargs, thereargs);
                errs++;
            }
        }
        break;
 
    case PV_APPLICATION_CALL:
        /* fields: item->u1.str     == name of application to call
                   item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
        */
        /* Need to check to see if the application is available! */
        app_def = find_context(item->u1.str);
        if (app_def && app_def->type == PV_MACRO) {
            ast_log(LOG_ERROR,"Error: file %s, line %d-%d: application call to %s references an existing macro, but had no & preceding it!\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            errs++;
        }
        if (strcasecmp(item->u1.str,"GotoIf") == 0
            || strcasecmp(item->u1.str,"GotoIfTime") == 0
            || strcasecmp(item->u1.str,"while") == 0
            || strcasecmp(item->u1.str,"endwhile") == 0
            || strcasecmp(item->u1.str,"random") == 0
            || strcasecmp(item->u1.str,"gosub") == 0
            || strcasecmp(item->u1.str,"gosubif") == 0
            || strcasecmp(item->u1.str,"continuewhile") == 0
            || strcasecmp(item->u1.str,"endwhile") == 0
            || strcasecmp(item->u1.str,"execif") == 0
            || strcasecmp(item->u1.str,"execiftime") == 0
            || strcasecmp(item->u1.str,"exitwhile") == 0
            || strcasecmp(item->u1.str,"goto") == 0
            || strcasecmp(item->u1.str,"macro") == 0
            || strcasecmp(item->u1.str,"macroexclusive") == 0
            || strcasecmp(item->u1.str,"macroif") == 0
            || strcasecmp(item->u1.str,"stackpop") == 0
            || strcasecmp(item->u1.str,"execIf") == 0 ) {
            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",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        }
        if (strcasecmp(item->u1.str,"macroexit") == 0) {
                ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: I am converting the MacroExit call here to a return statement.\n",
                        item->filename, item->startline, item->endline);
                item->type = PV_RETURN;
                free(item->u1.str);
                item->u1.str = 0;
        }
 
#ifdef AAL_ARGCHECK
        found = 0;
        for (app=apps; app; app=app->next) {
            if (strcasecmp(app->name, item->u1.str) == 0) {
                found =app;
                break;
            }
        }
        if (!found) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: application call to %s not listed in applist database!\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        } else
            check_app_args(item, item->u2.arglist, app);
#endif
        break;
 
    case PV_CASE:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        /* Make sure sequence of statements under case is terminated with  goto, return, or break */
        /* find the last statement */
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_PATTERN:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        /* Make sure sequence of statements under case is terminated with  goto, return, or break */
        /* find the last statement */
 
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_DEFAULT:
        /* fields:
                   item->u2.statements == pval list of statements under the case
        */
 
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_CATCH:
        /* fields: item->u1.str     == name of extension to catch
                   item->u2.statements == pval list of statements in context body
        */
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_SWITCHES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        check_pval(item->u1.list, apps,in_globals);
        break;
 
    case PV_ESWITCHES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        check_pval(item->u1.list, apps,in_globals);
        break;
 
    case PV_INCLUDES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        check_pval(item->u1.list, apps,in_globals);
        check_includes(item);
        for (lp=item->u1.list; lp; lp=lp->next){
            char *incl_context = lp->u1.str;
            struct pval *that_context = find_context(incl_context);
 
            if ( lp->u2.arglist ) {
                check_timerange(lp->u2.arglist);
                check_dow(lp->u2.arglist->next);
                check_day(lp->u2.arglist->next->next);
                check_month(lp->u2.arglist->next->next->next);
            }
 
            if (that_context) {
                find_pval_gotos(that_context->u2.statements,0);
 
            }
        }
        break;
 
    case PV_STATEMENTBLOCK:
        /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
        */
        check_pval(item->u1.list, apps,in_globals);
        break;
 
    case PV_VARDEC:
        /* fields: item->u1.str     == variable name
                   item->u2.val     == variable value to assign
        */
        /* the RHS of a vardec is encapsulated in a $[] expr. Is it legal? */
        if( !in_globals ) { /* don't check stuff inside the globals context; no wrapping in $[ ] there... */
            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);
            ast_expr_register_extra_error_info(errmsg);
            ast_expr(item->u2.val, expr_output, sizeof(expr_output),NULL);
            ast_expr_clear_extra_error_info();
            if ( strpbrk(item->u2.val,"~!-+<>=*/&^") && !strstr(item->u2.val,"${") ) {
                ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
                        item->filename, item->startline, item->endline, item->u2.val);
                warns++;
            }
            check_expr2_input(item,item->u2.val);
        }
        break;
 
    case PV_LOCALVARDEC:
        /* fields: item->u1.str     == variable name
                   item->u2.val     == variable value to assign
        */
        /* the RHS of a vardec is encapsulated in a $[] expr. Is it legal? */
        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);
        ast_expr_register_extra_error_info(errmsg);
        ast_expr(item->u2.val, expr_output, sizeof(expr_output),NULL);
        ast_expr_clear_extra_error_info();
        if ( strpbrk(item->u2.val,"~!-+<>=*/&^") && !strstr(item->u2.val,"${") ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
                    item->filename, item->startline, item->endline, item->u2.val);
            warns++;
        }
        check_expr2_input(item,item->u2.val);
        break;
 
    case PV_GOTO:
        /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
                   item->u1.list->u1.str  == where the data on a PV_WORD will always be.
        */
        /* don't check goto's in abstract contexts */
        if ( in_abstract_context )
            break;
 
        check_goto(item);
        break;
 
    case PV_LABEL:
        /* fields: item->u1.str     == label name
        */
        if ( strspn(item->u1.str, "0123456789") == strlen(item->u1.str) ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: label '%s' is numeric, this is bad practice!\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        }
 
        check_label(item);
        break;
 
    case PV_FOR:
        /* fields: item->u1.for_init     == a string containing the initializer
                   item->u2.for_test     == a string containing the loop test
                   item->u3.for_inc      == a string containing the loop increment
 
                   item->u4.for_statements == a pval list of statements in the for ()
        */
        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);
        ast_expr_register_extra_error_info(errmsg);
 
        strp = strchr(item->u1.for_init, '=');
        if (strp) {
            ast_expr(strp+1, expr_output, sizeof(expr_output),NULL);
        }
        ast_expr(item->u2.for_test, expr_output, sizeof(expr_output),NULL);
        strp = strchr(item->u3.for_inc, '=');
        if (strp) {
            ast_expr(strp+1, expr_output, sizeof(expr_output),NULL);
        }
        if ( strpbrk(item->u2.for_test,"~!-+<>=*/&^") && !strstr(item->u2.for_test,"${") ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
                    item->filename, item->startline, item->endline, item->u2.for_test);
            warns++;
        }
        if ( strpbrk(item->u3.for_inc,"~!-+<>=*/&^") && !strstr(item->u3.for_inc,"${") ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
                    item->filename, item->startline, item->endline, item->u3.for_inc);
            warns++;
        }
        check_expr2_input(item,item->u2.for_test);
        check_expr2_input(item,item->u3.for_inc);
 
        ast_expr_clear_extra_error_info();
        check_pval(item->u4.for_statements, apps,in_globals);
        break;
 
    case PV_WHILE:
        /* fields: item->u1.str        == the while conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the while ()
        */
        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);
        ast_expr_register_extra_error_info(errmsg);
        ast_expr(item->u1.str, expr_output, sizeof(expr_output),NULL);
        ast_expr_clear_extra_error_info();
        if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        }
        check_expr2_input(item,item->u1.str);
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_BREAK:
        /* fields: none
        */
        check_break(item);
        break;
 
    case PV_RETURN:
        /* fields: none
        */
        break;
 
    case PV_CONTINUE:
        /* fields: none
        */
        check_continue(item);
        break;
 
    case PV_RANDOM:
        /* fields: item->u1.str        == the random number expression, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        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);
        ast_expr_register_extra_error_info(errmsg);
        ast_expr(item->u1.str, expr_output, sizeof(expr_output),NULL);
        ast_expr_clear_extra_error_info();
        if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: random expression '%s' has operators, but no variables. Interesting...\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        }
        check_expr2_input(item,item->u1.str);
        check_pval(item->u2.statements, apps,in_globals);
        if (item->u3.else_statements) {
            check_pval(item->u3.else_statements, apps,in_globals);
        }
        break;
 
    case PV_IFTIME:
        /* fields: item->u1.list        == the if time values, 4 of them, each in PV_WORD, linked list
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        if ( item->u2.arglist ) {
            check_timerange(item->u1.list);
            check_dow(item->u1.list->next);
            check_day(item->u1.list->next->next);
            check_month(item->u1.list->next->next->next);
        }
 
        check_pval(item->u2.statements, apps,in_globals);
        if (item->u3.else_statements) {
            check_pval(item->u3.else_statements, apps,in_globals);
        }
        break;
 
    case PV_IF:
        /* fields: item->u1.str        == the if conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        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);
        ast_expr_register_extra_error_info(errmsg);
        ast_expr(item->u1.str, expr_output, sizeof(expr_output),NULL);
        ast_expr_clear_extra_error_info();
        if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
            ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression '%s' has operators, but no variables. Interesting...\n",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        }
        check_expr2_input(item,item->u1.str);
        check_pval(item->u2.statements, apps,in_globals);
        if (item->u3.else_statements) {
            check_pval(item->u3.else_statements, apps,in_globals);
        }
        break;
 
    case PV_SWITCH:
        /* fields: item->u1.str        == the switch expression
 
                   item->u2.statements == a pval list of statements in the switch,
                                            (will be case statements, most likely!)
        */
        /* we can check the switch expression, see if it matches any of the app variables...
           if it does, then, are all the possible cases accounted for? */
        check_switch_expr(item, apps);
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_EXTENSION:
        /* fields: item->u1.str        == the extension name, label, whatever it's called
 
                   item->u2.statements == a pval list of statements in the extension
                   item->u3.hints      == a char * hint argument
                   item->u4.regexten   == an int boolean. non-zero says that regexten was specified
        */
        current_extension = item ;
 
        check_pval(item->u2.statements, apps,in_globals);
        break;
 
    case PV_IGNOREPAT:
        /* fields: item->u1.str        == the ignorepat data
        */
        break;
 
    case PV_GLOBALS:
        /* fields: item->u1.statements     == pval list of statements, usually vardecs
        */
        in_abstract_context = 0;
        check_pval(item->u1.statements, apps, 1);
        break;
    default:
        break;
    }
}

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

Referenced by check_pval().

check_switch_expr()

void check_switch_expr	(	pval *	item,
		struct argapp *	apps
	)

Definition at line 2184 of file pval.c.

{
#ifdef AAL_ARGCHECK
    /* get and clean the variable name */
    char *buff1, *p;
    struct argapp *a,*a2;
    struct appsetvar *v,*v2;
    struct argchoice *c;
    pval *t;
 
    p = item->u1.str;
    while (p && *p && (*p == ' ' || *p == '\t' || *p == '$' || *p == '{' ) )
        p++;
 
    buff1 = ast_strdupa(p);
 
    while (strlen(buff1) > 0 && ( buff1[strlen(buff1)-1] == '}' || buff1[strlen(buff1)-1] == ' ' || buff1[strlen(buff1)-1] == '\t'))
        buff1[strlen(buff1)-1] = 0;
    /* buff1 now contains the variable name */
    v = 0;
    for (a=apps; a; a=a->next) {
        for (v=a->setvars;v;v=v->next) {
            if (strcmp(v->name,buff1) == 0) {
                break;
            }
        }
        if ( v )
            break;
    }
    if (v && v->vals) {
        /* we have a match, to a variable that has a set of determined values */
        int def= 0;
        int pat = 0;
        int f1 = 0;
 
        /* first of all, does this switch have a default case ? */
        for (t=item->u2.statements; t; t=t->next) {
            if (t->type == PV_DEFAULT) {
                def =1;
                break;
            }
            if (t->type == PV_PATTERN) {
                pat++;
            }
        }
        if (def || pat) /* nothing to check. All cases accounted for! */
            return;
        for (c=v->vals; c; c=c->next) {
            f1 = 0;
            for (t=item->u2.statements; t; t=t->next) {
                if (t->type == PV_CASE || t->type == PV_PATTERN) {
                    if (!strcmp(t->u1.str,c->name)) {
                        f1 = 1;
                        break;
                    }
                }
            }
            if (!f1) {
                ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: switch with expression(%s) does not handle the case of %s !\n",
                        item->filename, item->startline, item->endline, item->u1.str, c->name);
                warns++;
            }
        }
        /* next, is there an app call in the current exten, that would set this var? */
        f1 = 0;
        t = current_extension->u2.statements;
        if ( t && t->type == PV_STATEMENTBLOCK )
            t = t->u1.statements;
        for (; t && t != item; t=t->next) {
            if (t->type == PV_APPLICATION_CALL) {
                /* find the application that matches the u1.str */
                for (a2=apps; a2; a2=a2->next) {
                    if (strcasecmp(a2->name, t->u1.str)==0) {
                        for (v2=a2->setvars; v2; v2=v2->next) {
                            if (strcmp(v2->name, buff1) == 0) {
                                /* found an app that sets the var */
                                f1 = 1;
                                break;
                            }
                        }
                    }
                    if (f1)
                        break;
                }
            }
            if (f1)
                break;
        }
 
        /* see if it sets the var */
        if (!f1) {
            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",
                    item->filename, item->startline, item->endline, item->u1.str);
            warns++;
        }
    }
#else
    pval *t,*tl=0,*p2;
    int def= 0;
 
    /* first of all, does this switch have a default case ? */
    for (t=item->u2.statements; t; t=t->next) {
        if (t->type == PV_DEFAULT) {
            def =1;
            break;
        }
        tl = t;
    }
    if (def) /* nothing to check. All cases accounted for! */
        return;
    /* if no default, warn and insert a default case at the end */
    p2 = tl->next = calloc(1, sizeof(struct pval));
 
    p2->type = PV_DEFAULT;
    p2->startline = tl->startline;
    p2->endline = tl->endline;
    p2->startcol = tl->startcol;
    p2->endcol = tl->endcol;
    p2->filename = strdup(tl->filename);
    ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: A default case was automatically added to the switch.\n",
            p2->filename, p2->startline, p2->endline);
    warns++;
 
#endif
}

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

Referenced by check_pval_item().

check_timerange()

static void check_timerange ( pval *  p )

static

Definition at line 830 of file pval.c.

{
    char *times;
    char *e;
    int s1, s2;
    int e1, e2;
 
    times = ast_strdupa(p->u1.str);
 
    /* Star is all times */
    if (ast_strlen_zero(times) || !strcmp(times, "*")) {
        return;
    }
    /* Otherwise expect a range */
    e = strchr(times, '-');
    if (!e) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The time range format (%s) requires a '-' surrounded by two 24-hour times of day!\n",
                p->filename, p->startline, p->endline, times);
        warns++;
        return;
    }
    *e = '\0';
    e++;
    while (*e && !isdigit(*e))
        e++;
    if (!*e) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The time range format (%s) is missing the end time!\n",
                p->filename, p->startline, p->endline, p->u1.str);
        warns++;
    }
    if (sscanf(times, "%2d:%2d", &s1, &s2) != 2) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start time (%s) isn't quite right!\n",
                p->filename, p->startline, p->endline, times);
        warns++;
    }
    if (sscanf(e, "%2d:%2d", &e1, &e2) != 2) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end time (%s) isn't quite right!\n",
                p->filename, p->startline, p->endline, times);
        warns++;
    }
 
    s1 = s1 * 30 + s2/2;
    if ((s1 < 0) || (s1 >= 24*30)) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start time (%s) is out of range!\n",
                p->filename, p->startline, p->endline, times);
        warns++;
    }
    e1 = e1 * 30 + e2/2;
    if ((e1 < 0) || (e1 >= 24*30)) {
        ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end time (%s) is out of range!\n",
                p->filename, p->startline, p->endline, e);
        warns++;
    }
    return;
}

References ast_log, ast_strdupa, ast_strlen_zero(), pval::endline, pval::filename, LOG_WARNING, pval::startline, pval::str, pval::u1, and warns.

Referenced by check_pval_item().

contains_switch()

int contains_switch

(

pval *

item

)

Definition at line 3329 of file pval.c.

{
    pval *i;
 
    for (i=item; i; i=i->next) {
        if (find_switch_item(i))
            return 1;
    }
    return 0;
}

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

Referenced by find_switch_item(), and gen_prios().

context_used()

static int context_used ( struct ael_extension *  exten_list, struct ast_context *  context  )

static

Definition at line 4398 of file pval.c.

{
    struct ael_extension *exten;
    /* Check the simple elements first */
    if (ast_walk_context_extensions(context, NULL) || ast_context_includes_count(context) || ast_context_ignorepats_count(context) || ast_context_switches_count(context)) {
        return 1;
    }
    for (exten = exten_list; exten; exten = exten->next_exten) {
        if (exten->context == context) {
            return 1;
        }
    }
    return 0;
}

References ast_context_ignorepats_count(), ast_context_includes_count(), ast_context_switches_count(), ast_walk_context_extensions(), voicemailpwcheck::context, ael_extension::context, ael_extension::next_exten, and NULL.

Referenced by ast_compile_ael2().

destroy_extensions()

void destroy_extensions

(

struct ael_extension *

exten

)

Definition at line 2978 of file pval.c.

{
    struct ael_extension *ne, *nen;
    for (ne=exten; ne; ne=nen) {
        struct ael_priority *pe, *pen;
 
        if (ne->name)
            free(ne->name);
 
        /* cidmatch fields are allocated with name, and freed when
           the name field is freed. Don't do a free for this field,
           unless you LIKE to see a crash! */
 
        if (ne->hints)
            free(ne->hints);
 
        for (pe=ne->plist; pe; pe=pen) {
            pen = pe->next;
            if (pe->app)
                free(pe->app);
            pe->app = 0;
            if (pe->appargs)
                free(pe->appargs);
            pe->appargs = 0;
            pe->origin = 0;
            pe->goto_true = 0;
            pe->goto_false = 0;
            free(pe);
        }
        nen = ne->next_exten;
        ne->next_exten = 0;
        ne->plist =0;
        ne->plist_last = 0;
        ne->next_exten = 0;
        ne->loop_break = 0;
        ne->loop_continue = 0;
        free(ne);
    }
}

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

Referenced by ast_compile_ael2().

destroy_pval()

void destroy_pval

(

pval *

item

)

Definition at line 4940 of file pval.c.

{
    pval *i,*nxt;
 
    for (i=item; i; i=nxt) {
        nxt = i->next;
 
        destroy_pval_item(i);
    }
}

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

Referenced by destroy_pval_item(), pbx_load_module(), pvalIfTimeSetCondition(), pvalIncludesAddIncludeWithTimeConstraints(), yydestruct(), and yyparse().

destroy_pval_item()

void destroy_pval_item

(

pval *

item

)

Definition at line 4672 of file pval.c.

{
    if (item == NULL) {
        ast_log(LOG_WARNING, "null item\n");
        return;
    }
 
    if (item->filename)
        free(item->filename);
 
    switch (item->type) {
    case PV_WORD:
        /* fields: item->u1.str == string associated with this (word). */
        if (item->u1.str )
            free(item->u1.str);
        if ( item->u2.arglist )
            destroy_pval(item->u2.arglist);
        break;
 
    case PV_MACRO:
        /* fields: item->u1.str     == name of macro
                   item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
 
                   item->u3.macro_statements == pval list of statements in macro body.
        */
        destroy_pval(item->u2.arglist);
        if (item->u1.str )
            free(item->u1.str);
        destroy_pval(item->u3.macro_statements);
        break;
 
    case PV_CONTEXT:
        /* fields: item->u1.str     == name of context
                   item->u2.statements == pval list of statements in context body
                   item->u3.abstract == int 1 if an abstract keyword were present
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_MACRO_CALL:
        /* fields: item->u1.str     == name of macro to call
                   item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.arglist);
        break;
 
    case PV_APPLICATION_CALL:
        /* fields: item->u1.str     == name of application to call
                   item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.arglist);
        break;
 
    case PV_CASE:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_PATTERN:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_DEFAULT:
        /* fields:
                   item->u2.statements == pval list of statements under the case
        */
        destroy_pval(item->u2.statements);
        break;
 
    case PV_CATCH:
        /* fields: item->u1.str     == name of extension to catch
                   item->u2.statements == pval list of statements in context body
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_SWITCHES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        destroy_pval(item->u1.list);
        break;
 
    case PV_ESWITCHES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        destroy_pval(item->u1.list);
        break;
 
    case PV_INCLUDES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
                   item->u2.arglist  == pval list of 4 PV_WORD elements for time values
        */
        destroy_pval(item->u1.list);
        break;
 
    case PV_STATEMENTBLOCK:
        /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
        */
        destroy_pval(item->u1.list);
        break;
 
    case PV_LOCALVARDEC:
    case PV_VARDEC:
        /* fields: item->u1.str     == variable name
                   item->u2.val     == variable value to assign
        */
        if (item->u1.str)
            free(item->u1.str);
        if (item->u2.val)
            free(item->u2.val);
        break;
 
    case PV_GOTO:
        /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
                   item->u1.list->u1.str  == where the data on a PV_WORD will always be.
        */
 
        destroy_pval(item->u1.list);
        break;
 
    case PV_LABEL:
        /* fields: item->u1.str     == label name
        */
        if (item->u1.str)
            free(item->u1.str);
        break;
 
    case PV_FOR:
        /* fields: item->u1.for_init     == a string containing the initializer
                   item->u2.for_test     == a string containing the loop test
                   item->u3.for_inc      == a string containing the loop increment
 
                   item->u4.for_statements == a pval list of statements in the for ()
        */
        if (item->u1.for_init)
            free(item->u1.for_init);
        if (item->u2.for_test)
            free(item->u2.for_test);
        if (item->u3.for_inc)
            free(item->u3.for_inc);
        destroy_pval(item->u4.for_statements);
        break;
 
    case PV_WHILE:
        /* fields: item->u1.str        == the while conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the while ()
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_BREAK:
        /* fields: none
        */
        break;
 
    case PV_RETURN:
        /* fields: none
        */
        break;
 
    case PV_CONTINUE:
        /* fields: none
        */
        break;
 
    case PV_IFTIME:
        /* fields: item->u1.list        == the 4 time values, in PV_WORD structs, linked list
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        destroy_pval(item->u1.list);
        destroy_pval(item->u2.statements);
        if (item->u3.else_statements) {
            destroy_pval(item->u3.else_statements);
        }
        break;
 
    case PV_RANDOM:
        /* fields: item->u1.str        == the random percentage, as supplied by user
 
                   item->u2.statements == a pval list of statements in the true part ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        fall thru to If */
    case PV_IF:
        /* fields: item->u1.str        == the if conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        if (item->u3.else_statements) {
            destroy_pval(item->u3.else_statements);
        }
        break;
 
    case PV_SWITCH:
        /* fields: item->u1.str        == the switch expression
 
                   item->u2.statements == a pval list of statements in the switch,
                                            (will be case statements, most likely!)
        */
        if (item->u1.str)
            free(item->u1.str);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_EXTENSION:
        /* fields: item->u1.str        == the extension name, label, whatever it's called
 
                   item->u2.statements == a pval list of statements in the extension
                   item->u3.hints      == a char * hint argument
                   item->u4.regexten   == an int boolean. non-zero says that regexten was specified
        */
        if (item->u1.str)
            free(item->u1.str);
        if (item->u3.hints)
            free(item->u3.hints);
        destroy_pval(item->u2.statements);
        break;
 
    case PV_IGNOREPAT:
        /* fields: item->u1.str        == the ignorepat data
        */
        if (item->u1.str)
            free(item->u1.str);
        break;
 
    case PV_GLOBALS:
        /* fields: item->u1.statements     == pval list of statements, usually vardecs
        */
        destroy_pval(item->u1.statements);
        break;
    }
    free(item);
}

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

Referenced by destroy_pval().

extension_matches()

static int extension_matches ( pval *  here, const char *  exten, const char *  pattern  )

static

Definition at line 694 of file pval.c.

{
    int err1;
    regex_t preg;
 
    /* simple case, they match exactly, the pattern and exten name */
    if (strcmp(pattern,exten) == 0)
        return 1;
 
    if (pattern[0] == '_') {
        char reg1[2000];
        const char *p;
        char *r = reg1;
 
        if ( strlen(pattern)*5 >= 2000 ) /* safety valve */ {
            ast_log(LOG_ERROR,"Error: The pattern %s is way too big. Pattern matching cancelled.\n",
                    pattern);
            return 0;
        }
        /* form a regular expression from the pattern, and then match it against exten */
        *r++ = '^'; /* what if the extension is a pattern ?? */
        *r++ = '_'; /* what if the extension is a pattern ?? */
        *r++ = '?';
        for (p=pattern+1; *p; p++) {
            switch ( *p ) {
            case 'X':
                *r++ = '[';
                *r++ = '0';
                *r++ = '-';
                *r++ = '9';
                *r++ = 'X';
                *r++ = ']';
                break;
 
            case 'Z':
                *r++ = '[';
                *r++ = '1';
                *r++ = '-';
                *r++ = '9';
                *r++ = 'Z';
                *r++ = ']';
                break;
 
            case 'N':
                *r++ = '[';
                *r++ = '2';
                *r++ = '-';
                *r++ = '9';
                *r++ = 'N';
                *r++ = ']';
                break;
 
            case '[':
                while ( *p && *p != ']' ) {
                    *r++ = *p++;
                }
                *r++ = ']';
                if ( *p != ']') {
                    ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The extension pattern '%s' is missing a closing bracket \n",
                            here->filename, here->startline, here->endline, pattern);
                }
                break;
 
            case '.':
            case '!':
                *r++ = '.';
                *r++ = '*';
                break;
            case '*': /* regex metacharacter */
            case '+': /* regex metacharacter */
                *r++ = '\\';
                /* fall through */
            default:
                *r++ = *p;
                break;
 
            }
        }
        *r++ = '$'; /* what if the extension is a pattern ?? */
        *r++ = *p++; /* put in the closing null */
        err1 = regcomp(&preg, reg1, REG_NOSUB|REG_EXTENDED);
        if ( err1 ) {
            char errmess[500];
            regerror(err1,&preg,errmess,sizeof(errmess));
            regfree(&preg);
            ast_log(LOG_WARNING, "Regcomp of %s failed, error code %d\n",
                    reg1, err1);
            return 0;
        }
        err1 = regexec(&preg, exten, 0, 0, 0);
        regfree(&preg);
 
        if ( err1 ) {
            /* ast_log(LOG_NOTICE,"*****************************[%d]Extension %s did not match %s(%s)\n",
               err1,exten, pattern, reg1); */
            return 0; /* no match */
        } else {
            /* ast_log(LOG_NOTICE,"*****************************Extension %s matched %s\n",
               exten, pattern); */
            return 1;
        }
    }
 
    return 0;
}

References ast_log, pval::endline, pval::filename, LOG_ERROR, LOG_WARNING, and pval::startline.

Referenced by match_pval_item().

find_context()

struct pval * find_context

(

char *

name

)

Definition at line 1953 of file pval.c.

{
    return_on_context_match = 1;
    count_labels = 0;
    match_context = name;
    match_exten = "*";  /* don't really need to set these, shouldn't be reached */
    match_label = "*";
    return match_pval(current_db);
}

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

Referenced by check_goto(), check_includes(), check_pval_item(), find_first_label_in_current_context(), find_label_in_current_context(), find_pval_goto_item(), and get_goto_target().

find_first_label_in_current_context()

struct pval * find_first_label_in_current_context ( char *  label, pval *  curr_cont  )

static

Definition at line 1839 of file pval.c.

{
    /* printf("  --- Got args %s, %s\n", exten, label); */
    struct pval *ret;
    struct pval *p3;
 
    count_labels = 0;
    return_on_context_match = 0;
    match_context = "*";
    match_exten = "*";
    match_label = label;
 
    ret =  match_pval(curr_cont);
    if (ret)
        return ret;
 
    /* the target of the goto could be in an included context!! Fancy that!! */
    /* look for includes in the current context */
    for (p3=curr_cont->u2.statements; p3; p3=p3->next) {
        if (p3->type == PV_INCLUDES) {
            struct pval *p4;
            for (p4=p3->u1.list; p4; p4=p4->next) {
                /* for each context pointed to, find it, then find a context/label that matches the
                   target here! */
                char *incl_context = p4->u1.str;
                /* find a matching context name */
                struct pval *that_context = find_context(incl_context);
                if (that_context) {
                    struct pval *x3;
                    x3 = find_first_label_in_current_context(label, that_context);
                    if (x3) {
                        return x3;
                    }
                }
            }
        }
    }
    return 0;
}

References count_labels, find_context(), find_first_label_in_current_context(), pval::list, match_context, match_exten, match_label, match_pval(), pval::next, PV_INCLUDES, return_on_context_match, pval::statements, pval::str, pval::type, pval::u1, and pval::u2.

Referenced by check_label(), and find_first_label_in_current_context().

find_label_in_current_context()

struct pval * find_label_in_current_context ( char *  exten, char *  label, pval *  curr_cont  )

static

Definition at line 1879 of file pval.c.

{
    /* printf("  --- Got args %s, %s\n", exten, label); */
    struct pval *ret;
    struct pval *p3;
 
    count_labels = 0;
    return_on_context_match = 0;
    match_context = "*";
    match_exten = exten;
    match_label = label;
    ret =  match_pval(curr_cont->u2.statements);
    if (ret)
        return ret;
 
    /* the target of the goto could be in an included context!! Fancy that!! */
    /* look for includes in the current context */
    for (p3=curr_cont->u2.statements; p3; p3=p3->next) {
        if (p3->type == PV_INCLUDES) {
            struct pval *p4;
            for (p4=p3->u1.list; p4; p4=p4->next) {
                /* for each context pointed to, find it, then find a context/label that matches the
                   target here! */
                char *incl_context = p4->u1.str;
                /* find a matching context name */
                struct pval *that_context = find_context(incl_context);
                if (that_context) {
                    struct pval *x3;
                    x3 = find_label_in_current_context(exten, label, that_context);
                    if (x3) {
                        return x3;
                    }
                }
            }
        }
    }
    return 0;
}

References count_labels, find_context(), find_label_in_current_context(), pval::list, match_context, match_exten, match_label, match_pval(), pval::next, PV_INCLUDES, return_on_context_match, pval::statements, pval::str, pval::type, pval::u1, and pval::u2.

Referenced by check_goto(), find_label_in_current_context(), and get_goto_target().

find_label_in_current_db()

static struct pval * find_label_in_current_db ( const char *  context, const char *  exten, const char *  label  )

static

Definition at line 1929 of file pval.c.

{
    /* printf("  --- Got args %s, %s, %s\n", context, exten, label); */
    count_labels = 0;
    return_on_context_match = 0;
 
    match_context = context;
    match_exten = exten;
    match_label = label;
 
    return match_pval(current_db);
}

References voicemailpwcheck::context, count_labels, current_db, match_context, match_exten, match_label, match_pval(), and return_on_context_match.

Referenced by check_goto(), and get_goto_target().

find_label_in_current_extension()

static struct pval * find_label_in_current_extension ( const char *  label, pval *  curr_ext  )

static

Definition at line 1918 of file pval.c.

{
    /* printf("  --- Got args %s\n", label); */
    count_labels = 0;
    return_on_context_match = 0;
    match_context = "*";
    match_exten = "*";
    match_label = label;
    return match_pval(curr_ext);
}

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

Referenced by check_goto(), and get_goto_target().

find_macro()

struct pval * find_macro

(

char *

name

)

Definition at line 1943 of file pval.c.

{
    return_on_context_match = 1;
    count_labels = 0;
    match_context = name;
    match_exten = "*";  /* don't really need to set these, shouldn't be reached */
    match_label = "*";
    return match_pval(current_db);
}

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

Referenced by check_pval_item().

find_pval_goto_item()

static void find_pval_goto_item ( pval *  item, int  lev  )

static

Definition at line 1379 of file pval.c.

{
    struct pval *p4;
 
    if (lev>100) {
        ast_log(LOG_ERROR,"find_pval_goto in infinite loop! item_type: %u\n\n", item->type);
        return;
    }
 
    switch ( item->type ) {
    case PV_MACRO:
        /* fields: item->u1.str     == name of macro
                   item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
 
                   item->u3.macro_statements == pval list of statements in macro body.
        */
 
        /* printf("Descending into macro %s at line %d\n", item->u1.str, item->startline); */
        find_pval_gotos(item->u3.macro_statements,lev+1); /* if we're just searching for a context, don't bother descending into them */
 
        break;
 
    case PV_CONTEXT:
        /* fields: item->u1.str     == name of context
                   item->u2.statements == pval list of statements in context body
                   item->u3.abstract == int 1 if an abstract keyword were present
        */
        break;
 
    case PV_CASE:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        /* printf("Descending into Case of %s\n", item->u1.str); */
        find_pval_gotos(item->u2.statements,lev+1);
        break;
 
    case PV_PATTERN:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        /* printf("Descending into Pattern of %s\n", item->u1.str); */
        find_pval_gotos(item->u2.statements,lev+1);
        break;
 
    case PV_DEFAULT:
        /* fields:
                   item->u2.statements == pval list of statements under the case
        */
        /* printf("Descending into default\n"); */
        find_pval_gotos(item->u2.statements,lev+1);
        break;
 
    case PV_CATCH:
        /* fields: item->u1.str     == name of extension to catch
                   item->u2.statements == pval list of statements in context body
        */
        /* printf("Descending into catch of %s\n", item->u1.str); */
        find_pval_gotos(item->u2.statements,lev+1);
        break;
 
    case PV_STATEMENTBLOCK:
        /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
        */
        /* printf("Descending into statement block\n"); */
        find_pval_gotos(item->u1.list,lev+1);
        break;
 
    case PV_GOTO:
        /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
                   item->u1.list->u1.str  == where the data on a PV_WORD will always be.
        */
        check_goto(item);  /* THE WHOLE FUNCTION OF THIS ENTIRE ROUTINE!!!! */
        break;
 
    case PV_INCLUDES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        for (p4=item->u1.list; p4; p4=p4->next) {
            /* for each context pointed to, find it, then find a context/label that matches the
               target here! */
            char *incl_context = p4->u1.str;
            /* find a matching context name */
            struct pval *that_context = find_context(incl_context);
            if (that_context && that_context->u2.statements) {
                /* printf("Descending into include of '%s' at line %d; that_context=%s, that_context type=%d\n", incl_context, item->startline, that_context->u1.str, that_context->type); */
                find_pval_gotos(that_context->u2.statements,lev+1); /* keep working up the includes */
            }
        }
        break;
 
    case PV_FOR:
        /* fields: item->u1.for_init     == a string containing the initializer
                   item->u2.for_test     == a string containing the loop test
                   item->u3.for_inc      == a string containing the loop increment
 
                   item->u4.for_statements == a pval list of statements in the for ()
        */
        /* printf("Descending into for at line %d\n", item->startline); */
        find_pval_gotos(item->u4.for_statements,lev+1);
        break;
 
    case PV_WHILE:
        /* fields: item->u1.str        == the while conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the while ()
        */
        /* printf("Descending into while at line %d\n", item->startline); */
        find_pval_gotos(item->u2.statements,lev+1);
        break;
 
    case PV_RANDOM:
        /* fields: item->u1.str        == the random number expression, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
         fall thru to PV_IF */
 
    case PV_IFTIME:
        /* fields: item->u1.list        == the time values, 4 of them, as PV_WORD structs in a list
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        fall thru to PV_IF*/
    case PV_IF:
        /* fields: item->u1.str        == the if conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        /* printf("Descending into random/iftime/if at line %d\n", item->startline); */
        find_pval_gotos(item->u2.statements,lev+1);
 
        if (item->u3.else_statements) {
            /* printf("Descending into random/iftime/if's ELSE at line %d\n", item->startline); */
            find_pval_gotos(item->u3.else_statements,lev+1);
        }
        break;
 
    case PV_SWITCH:
        /* fields: item->u1.str        == the switch expression
 
                   item->u2.statements == a pval list of statements in the switch,
                                            (will be case statements, most likely!)
        */
        /* printf("Descending into switch at line %d\n", item->startline); */
        find_pval_gotos(item->u3.else_statements,lev+1);
        break;
 
    case PV_EXTENSION:
        /* fields: item->u1.str        == the extension name, label, whatever it's called
 
                   item->u2.statements == a pval list of statements in the extension
                   item->u3.hints      == a char * hint argument
                   item->u4.regexten   == an int boolean. non-zero says that regexten was specified
        */
 
        /* printf("Descending into extension %s at line %d\n", item->u1.str, item->startline); */
        find_pval_gotos(item->u2.statements,lev+1);
        break;
 
    default:
        break;
    }
}

References ast_log, check_goto(), find_context(), find_pval_gotos(), item, LOG_ERROR, pval::next, PV_CASE, PV_CATCH, PV_CONTEXT, PV_DEFAULT, PV_EXTENSION, PV_FOR, PV_GOTO, PV_IF, PV_IFTIME, PV_INCLUDES, PV_MACRO, PV_PATTERN, PV_RANDOM, PV_STATEMENTBLOCK, PV_SWITCH, PV_WHILE, pval::statements, pval::str, aco_type::type, pval::u1, and pval::u2.

Referenced by find_pval_gotos().

find_pval_gotos()

static void find_pval_gotos ( pval *  item, int  lev  )

static

Definition at line 1550 of file pval.c.

{
    pval *i;
 
    for (i=item; i; i=i->next) {
        /* printf("About to call pval_goto_item, itemcount=%d, itemtype=%d\n", item_count, i->type); */
        find_pval_goto_item(i, lev);
    }
}

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

Referenced by check_pval_item(), and find_pval_goto_item().

find_switch_item()

int find_switch_item

(

pval *

item

)

Definition at line 3090 of file pval.c.

{
    switch ( item->type ) {
    case PV_LOCALVARDEC:
        /* fields: item->u1.str == string associated with this (word). */
        break;
 
    case PV_WORD:
        /* fields: item->u1.str == string associated with this (word). */
        break;
 
    case PV_MACRO:
        /* fields: item->u1.str     == name of macro
                   item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
 
                   item->u3.macro_statements == pval list of statements in macro body.
        */
        /* had better not see this */
        if (contains_switch(item->u3.macro_statements))
            return 1;
        break;
 
    case PV_CONTEXT:
        /* fields: item->u1.str     == name of context
                   item->u2.statements == pval list of statements in context body
                   item->u3.abstract == int 1 if an abstract keyword were present
        */
        /* had better not see this */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_MACRO_CALL:
        /* fields: item->u1.str     == name of macro to call
                   item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
        */
        break;
 
    case PV_APPLICATION_CALL:
        /* fields: item->u1.str     == name of application to call
                   item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
                   item->u2.arglist->u1.str  == argument
                   item->u2.arglist->next   == next arg
        */
        break;
 
    case PV_CASE:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        /* had better not see this */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_PATTERN:
        /* fields: item->u1.str     == value of case
                   item->u2.statements == pval list of statements under the case
        */
        /* had better not see this */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_DEFAULT:
        /* fields:
                   item->u2.statements == pval list of statements under the case
        */
        /* had better not see this */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_CATCH:
        /* fields: item->u1.str     == name of extension to catch
                   item->u2.statements == pval list of statements in context body
        */
        /* had better not see this */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_SWITCHES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        break;
 
    case PV_ESWITCHES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
        */
        break;
 
    case PV_INCLUDES:
        /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
                   item->u2.arglist  == pval list of 4 PV_WORD elements for time values
        */
        break;
 
    case PV_STATEMENTBLOCK:
        /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
        */
        if (contains_switch(item->u1.list) )
            return 1;
        break;
 
    case PV_VARDEC:
        /* fields: item->u1.str     == variable name
                   item->u2.val     == variable value to assign
        */
        break;
 
    case PV_GOTO:
        /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
                   item->u1.list->u1.str  == where the data on a PV_WORD will always be.
        */
        break;
 
    case PV_LABEL:
        /* fields: item->u1.str     == label name
        */
        break;
 
    case PV_FOR:
        /* fields: item->u1.for_init     == a string containing the initializer
                   item->u2.for_test     == a string containing the loop test
                   item->u3.for_inc      == a string containing the loop increment
 
                   item->u4.for_statements == a pval list of statements in the for ()
        */
        if (contains_switch(item->u4.for_statements))
            return 1;
        break;
 
    case PV_WHILE:
        /* fields: item->u1.str        == the while conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the while ()
        */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_BREAK:
        /* fields: none
        */
        break;
 
    case PV_RETURN:
        /* fields: none
        */
        break;
 
    case PV_CONTINUE:
        /* fields: none
        */
        break;
 
    case PV_IFTIME:
        /* fields: item->u1.list        == there are 4 linked PV_WORDs here.
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        if (contains_switch(item->u2.statements))
            return 1;
        if ( item->u3.else_statements ) {
            if (contains_switch(item->u3.else_statements))
                return 1;
        }
        break;
 
    case PV_RANDOM:
        /* fields: item->u1.str        == the random number expression, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        if (contains_switch(item->u2.statements))
            return 1;
        if ( item->u3.else_statements ) {
            if (contains_switch(item->u3.else_statements))
                return 1;
        }
        break;
 
    case PV_IF:
        /* fields: item->u1.str        == the if conditional, as supplied by user
 
                   item->u2.statements == a pval list of statements in the if ()
                   item->u3.else_statements == a pval list of statements in the else
                                               (could be zero)
        */
        if (contains_switch(item->u2.statements))
            return 1;
        if ( item->u3.else_statements ) {
            if (contains_switch(item->u3.else_statements))
                return 1;
        }
        break;
 
    case PV_SWITCH:
        /* fields: item->u1.str        == the switch expression
 
                   item->u2.statements == a pval list of statements in the switch,
                                            (will be case statements, most likely!)
        */
        return 1; /* JACKPOT */
        break;
 
    case PV_EXTENSION:
        /* fields: item->u1.str        == the extension name, label, whatever it's called
 
                   item->u2.statements == a pval list of statements in the extension
                   item->u3.hints      == a char * hint argument
                   item->u4.regexten   == an int boolean. non-zero says that regexten was specified
        */
        if (contains_switch(item->u2.statements))
            return 1;
        break;
 
    case PV_IGNOREPAT:
        /* fields: item->u1.str        == the ignorepat data
        */
        break;
 
    case PV_GLOBALS:
        /* fields: item->u1.statements     == pval list of statements, usually vardecs
        */
        break;
    }
    return 0;
}

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

Referenced by contains_switch().

fix_gotos_in_extensions()

static void fix_gotos_in_extensions ( struct ael_extension *  exten )

static

Definition at line 4355 of file pval.c.

{
    struct ael_extension *e;
    for(e=exten;e;e=e->next_exten) {
 
        struct ael_priority *p;
        for(p=e->plist;p;p=p->next) {
 
            if( p->origin && p->origin->type == PV_GOTO && p->origin->u3.goto_target_in_case ) {
 
                /* fix the extension of the goto target to the actual extension in the post-compiled dialplan */
 
                pval *target = p->origin->u2.goto_target;
                struct ael_extension *z = target->u3.compiled_label;
                pval *pv2 = p->origin;
                char buf1[500];
                char *apparg_save = p->appargs;
 
                p->appargs = 0;
                if (!pv2->u1.list->next) /* just one  -- it won't hurt to repeat the extension */ {
                    snprintf(buf1,sizeof(buf1),"%s,%s", z->name, pv2->u1.list->u1.str);
                    p->appargs = strdup(buf1);
 
                } else if (pv2->u1.list->next && !pv2->u1.list->next->next) /* two */ {
                    snprintf(buf1,sizeof(buf1),"%s,%s", z->name, pv2->u1.list->next->u1.str);
                    p->appargs = strdup(buf1);
                } else if (pv2->u1.list->next && pv2->u1.list->next->next) {
                    snprintf(buf1,sizeof(buf1),"%s,%s,%s", pv2->u1.list->u1.str,
                             z->name,
                             pv2->u1.list->next->next->u1.str);
                    p->appargs = strdup(buf1);
                }
                else
                    printf("WHAT? The goto doesn't fall into one of three cases for GOTO????\n");
 
                if( apparg_save ) {
                    free(apparg_save);
                }
            }
        }
    }
}

References ael_priority::appargs, buf1, pval::compiled_label, free(), pval::goto_target, pval::goto_target_in_case, pval::list, ael_extension::name, ael_priority::next, pval::next, ael_extension::next_exten, ael_priority::origin, ael_extension::plist, PV_GOTO, pval::str, strdup, pval::type, pval::u1, pval::u2, and pval::u3.

Referenced by ast_compile_ael2().

gen_match_to_pattern()

static void gen_match_to_pattern ( char *  pattern, char *  result  )

static

Definition at line 3061 of file pval.c.

{
    /* the result will be a string that will be matched by pattern */
    char *p=pattern, *t=result;
    while (*p) {
        if (*p == 'x' || *p == 'n' || *p == 'z' || *p == 'X' || *p == 'N' || *p == 'Z')
            *t++ = '9';
        else if (*p == '[') {
            char *z = p+1;
            while (*z != ']')
                z++;
            if (*(z+1)== ']')
                z++;
            *t++=*(p+1); /* use the first char in the set */
            p = z;
        } else {
            *t++ = *p;
        }
        p++;
    }
    *t++ = 0; /* cap it off */
}

References result.

Referenced by gen_prios().

gen_prios()

static int gen_prios ( struct ael_extension *  exten, char *  label, pval *  statement, struct ael_extension *  mother_exten, struct ast_context *  this_context  )

static

Definition at line 3341 of file pval.c.

{
    pval *p,*p2,*p3;
    struct ael_priority *pr;
    struct ael_priority *for_init, *for_test, *for_inc, *for_loop, *for_end;
    struct ael_priority *while_test, *while_loop, *while_end;
    struct ael_priority *switch_set, *switch_test, *switch_end, *fall_thru, *switch_empty;
    struct ael_priority *if_test, *if_end, *if_skip, *if_false;
#ifdef OLD_RAND_ACTION
    struct ael_priority *rand_test, *rand_end, *rand_skip;
#endif
    RAII_VAR(char *, buf1, NULL, free);
    RAII_VAR(char *, buf2, NULL, free);
    RAII_VAR(char *, new_label, NULL, free);
    char *strp, *strp2;
    int default_exists;
    int local_control_statement_count;
    int first;
    struct ael_priority *loop_break_save;
    struct ael_priority *loop_continue_save;
    struct ael_extension *switch_case,*switch_null;
 
    if (!(buf1 = malloc(BUF_SIZE))) {
        return -1;
    }
    if (!(buf2 = malloc(BUF_SIZE))) {
        return -1;
    }
    if (!(new_label = malloc(BUF_SIZE))) {
        return -1;
    }
 
    if ((mother_exten && !mother_exten->checked_switch) || (exten && !exten->checked_switch)) {
        if (contains_switch(statement)) { /* only run contains_switch if you haven't checked before */
            if (mother_exten) {
                if (!mother_exten->has_switch) {
                    for (first = 1; first >= 0; first--) {
                        switch_set = new_prio();
                        switch_set->type = AEL_APPCALL;
                        switch_set->app = strdup("MSet");
                        /* Are we likely inside a gosub subroutine? */
                        if (!strcmp(mother_exten->name, "~~s~~") && first) {
                            /* If we're not actually within a gosub, this will fail, but the
                             * second time through, it will get set.  If we are within gosub,
                             * the second time through is redundant, but acceptable. */
                            switch_set->appargs = strdup("LOCAL(~~EXTEN~~)=${EXTEN}");
                        } else {
                            switch_set->appargs = strdup("~~EXTEN~~=${EXTEN}");
                            first = 0;
                        }
                        linkprio(exten, switch_set, mother_exten);
                        mother_exten->has_switch = 1;
                        mother_exten->checked_switch = 1;
                        if (exten) {
                            exten->has_switch = 1;
                            exten->checked_switch = 1;
                        }
                    }
                }
            } else if (exten) {
                if (!exten->has_switch) {
                    for (first = 1; first >= 0; first--) {
                        switch_set = new_prio();
                        switch_set->type = AEL_APPCALL;
                        switch_set->app = strdup("MSet");
                        /* Are we likely inside a gosub subroutine? */
                        if (!strcmp(exten->name, "~~s~~")) {
                            /* If we're not actually within a gosub, this will fail, but the
                             * second time through, it will get set.  If we are within gosub,
                             * the second time through is redundant, but acceptable. */
                            switch_set->appargs = strdup("LOCAL(~~EXTEN~~)=${EXTEN}");
                        } else {
                            switch_set->appargs = strdup("~~EXTEN~~=${EXTEN}");
                            first = 0;
                        }
                        linkprio(exten, switch_set, mother_exten);
                        exten->has_switch = 1;
                        exten->checked_switch = 1;
                        if (mother_exten) {
                            mother_exten->has_switch = 1;
                            mother_exten->checked_switch = 1;
                        }
                    }
                }
            }
        } else {
            if (mother_exten) {
                mother_exten->checked_switch = 1;
            }
            if (exten) {
                exten->checked_switch = 1;
            }
        }
    }
    for (p=statement; p; p=p->next) {
        switch (p->type) {
        case PV_VARDEC:
            pr = new_prio();
            pr->type = AEL_APPCALL;
            snprintf(buf1, BUF_SIZE, "%s=$[%s]", p->u1.str, p->u2.val);
            pr->app = strdup("MSet");
            remove_spaces_before_equals(buf1);
            pr->appargs = strdup(buf1);
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_LOCALVARDEC:
            pr = new_prio();
            pr->type = AEL_APPCALL;
            snprintf(buf1, BUF_SIZE, "LOCAL(%s)=$[%s]", p->u1.str, p->u2.val);
            pr->app = strdup("MSet");
            remove_spaces_before_equals(buf1);
            pr->appargs = strdup(buf1);
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_GOTO:
            pr = new_prio();
            pr->type = AEL_APPCALL;
            p->u2.goto_target = get_goto_target(p);
            if( p->u2.goto_target ) {
                p->u3.goto_target_in_case = label_inside_case(p->u2.goto_target);
            }
 
            if (!p->u1.list->next) /* just one */ {
                pr->app = strdup("Goto");
                if (!mother_exten)
                    pr->appargs = strdup(p->u1.list->u1.str);
                else {  /* for the case of simple within-extension gotos in case/pattern/default statement blocks: */
                    snprintf(buf1, BUF_SIZE, "%s,%s", mother_exten->name, p->u1.list->u1.str);
                    pr->appargs = strdup(buf1);
                }
 
            } else if (p->u1.list->next && !p->u1.list->next->next) /* two */ {
                snprintf(buf1, BUF_SIZE, "%s,%s", p->u1.list->u1.str, p->u1.list->next->u1.str);
                pr->app = strdup("Goto");
                pr->appargs = strdup(buf1);
            } else if (p->u1.list->next && p->u1.list->next->next) {
                snprintf(buf1, BUF_SIZE, "%s,%s,%s", p->u1.list->u1.str,
                        p->u1.list->next->u1.str,
                        p->u1.list->next->next->u1.str);
                pr->app = strdup("Goto");
                pr->appargs = strdup(buf1);
            }
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_LABEL:
            pr = new_prio();
            pr->type = AEL_LABEL;
            pr->origin = p;
            p->u3.compiled_label = exten;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_FOR:
            control_statement_count++;
            loop_break_save = exten->loop_break; /* save them, then restore before leaving */
            loop_continue_save = exten->loop_continue;
            snprintf(new_label, BUF_SIZE, "for_%s_%d", label, control_statement_count);
            for_init = new_prio();
            for_inc = new_prio();
            for_test = new_prio();
            for_loop = new_prio();
            for_end = new_prio();
            for_init->type = AEL_APPCALL;
            for_inc->type = AEL_APPCALL;
            for_test->type = AEL_FOR_CONTROL;
            for_test->goto_false = for_end;
            for_loop->type = AEL_CONTROL1; /* simple goto */
            for_end->type = AEL_APPCALL;
            for_init->app = strdup("MSet");
 
            strcpy(buf2,p->u1.for_init);
            remove_spaces_before_equals(buf2);
            strp = strchr(buf2, '=');
            if (strp) {
                strp2 = strchr(p->u1.for_init, '=');
                *(strp+1) = 0;
                strcat(buf2,"$[");
                strncat(buf2,strp2+1, BUF_SIZE-strlen(strp2+1)-2);
                strcat(buf2,"]");
                for_init->appargs = strdup(buf2);
            } else {
                strp2 = p->u1.for_init;
                while (*strp2 && isspace(*strp2))
                    strp2++;
                if (*strp2 == '&') { /* itsa macro call */
                    char *strp3 = strp2+1;
                    while (*strp3 && isspace(*strp3))
                        strp3++;
                    strcpy(buf2, strp3);
                    strp3 = strchr(buf2,'(');
                    if (strp3) {
                        *strp3 = ',';
                    }
                    strp3 = strrchr(buf2, ')');
                    if (strp3)
                        *strp3 = 0; /* remove the closing paren */
                    for_init->appargs = strdup(buf2);
                    free(for_init->app);
                    for_init->app = strdup("Gosub");
                } else {  /* must be a regular app call */
                    char *strp3;
                    strcpy(buf2, strp2);
                    strp3 = strchr(buf2,'(');
                    if (strp3) {
                        *strp3 = 0;
                        free(for_init->app);
                        for_init->app = strdup(buf2);
                        for_init->appargs = strdup(strp3+1);
                        strp3 = strrchr(for_init->appargs, ')');
                        if (strp3)
                            *strp3 = 0; /* remove the closing paren */
                    }
                }
            }
 
            strcpy(buf2,p->u3.for_inc);
            remove_spaces_before_equals(buf2);
            strp = strchr(buf2, '=');
            if (strp) {  /* there's an = in this part; that means an assignment. set it up */
                strp2 = strchr(p->u3.for_inc, '=');
                *(strp+1) = 0;
                strcat(buf2,"$[");
                strncat(buf2,strp2+1, BUF_SIZE-strlen(strp2+1)-2);
                strcat(buf2,"]");
                for_inc->appargs = strdup(buf2);
                for_inc->app = strdup("MSet");
            } else {
                strp2 = p->u3.for_inc;
                while (*strp2 && isspace(*strp2))
                    strp2++;
                if (*strp2 == '&') { /* itsa macro call  */
                    char *strp3 = strp2+1;
                    while (*strp3 && isspace(*strp3))
                        strp3++;
                    strcpy(buf2, strp3);
                    strp3 = strchr(buf2,'(');
                    if (strp3) {
                        *strp3 = ',';
                    }
                    strp3 = strrchr(buf2, ')');
                    if (strp3)
                        *strp3 = 0; /* remove the closing paren */
 
                    for_inc->appargs = strdup(buf2);
 
                    for_inc->app = strdup("Gosub");
                } else {  /* must be a regular app call */
                    char *strp3;
                    strcpy(buf2, strp2);
                    strp3 = strchr(buf2,'(');
                    if (strp3) {
                        *strp3 = 0;
                        for_inc->app = strdup(buf2);
                        for_inc->appargs = strdup(strp3+1);
                        strp3 = strrchr(for_inc->appargs, ')');
                        if (strp3)
                            *strp3 = 0; /* remove the closing paren */
                    }
                }
            }
            snprintf(buf1, BUF_SIZE, "$[%s]",p->u2.for_test);
            for_test->app = 0;
            for_test->appargs = strdup(buf1);
            for_loop->goto_true = for_test;
            snprintf(buf1, BUF_SIZE, "Finish for_%s_%d", label, control_statement_count);
            for_end->app = strdup("NoOp");
            for_end->appargs = strdup(buf1);
            /* link & load! */
            linkprio(exten, for_init, mother_exten);
            linkprio(exten, for_test, mother_exten);
 
            /* now, put the body of the for loop here */
            exten->loop_break = for_end;
            exten->loop_continue = for_inc;
 
            if (gen_prios(exten, new_label, p->u4.for_statements, mother_exten, this_context)) { /* this will link in all the statements here */
                return -1;
            }
 
            linkprio(exten, for_inc, mother_exten);
            linkprio(exten, for_loop, mother_exten);
            linkprio(exten, for_end, mother_exten);
 
 
            exten->loop_break = loop_break_save;
            exten->loop_continue = loop_continue_save;
            for_loop->origin = p;
            break;
 
        case PV_WHILE:
            control_statement_count++;
            loop_break_save = exten->loop_break; /* save them, then restore before leaving */
            loop_continue_save = exten->loop_continue;
            snprintf(new_label, BUF_SIZE, "while_%s_%d", label, control_statement_count);
            while_test = new_prio();
            while_loop = new_prio();
            while_end = new_prio();
            while_test->type = AEL_FOR_CONTROL;
            while_test->goto_false = while_end;
            while_loop->type = AEL_CONTROL1; /* simple goto */
            while_end->type = AEL_APPCALL;
            snprintf(buf1, BUF_SIZE, "$[%s]",p->u1.str);
            while_test->app = 0;
            while_test->appargs = strdup(buf1);
            while_loop->goto_true = while_test;
            snprintf(buf1, BUF_SIZE, "Finish while_%s_%d", label, control_statement_count);
            while_end->app = strdup("NoOp");
            while_end->appargs = strdup(buf1);
 
            linkprio(exten, while_test, mother_exten);
 
            /* now, put the body of the for loop here */
            exten->loop_break = while_end;
            exten->loop_continue = while_test;
 
            if (gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context)) { /* this will link in all the while body statements here */
                return -1;
            }
 
            linkprio(exten, while_loop, mother_exten);
            linkprio(exten, while_end, mother_exten);
 
 
            exten->loop_break = loop_break_save;
            exten->loop_continue = loop_continue_save;
            while_loop->origin = p;
            break;
 
        case PV_SWITCH:
            control_statement_count++;
            local_control_statement_count = control_statement_count;
            loop_break_save = exten->loop_break; /* save them, then restore before leaving */
            loop_continue_save = exten->loop_continue;
            snprintf(new_label, BUF_SIZE, "sw_%s_%d", label, control_statement_count);
            switch_test = new_prio();
            switch_end = new_prio();
            switch_test->type = AEL_APPCALL;
            switch_end->type = AEL_APPCALL;
            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", control_statement_count, p->u1.str);
            switch_test->app = strdup("Goto");
            switch_test->appargs = strdup(buf1);
            snprintf(buf1, BUF_SIZE, "Finish switch_%s_%d", label, control_statement_count);
            switch_end->app = strdup("NoOp");
            switch_end->appargs = strdup(buf1);
            switch_end->origin = p;
            switch_end->exten = exten;
 
            linkprio(exten, switch_test, mother_exten);
            linkprio(exten, switch_end, mother_exten);
 
            exten->loop_break = switch_end;
            exten->loop_continue = 0;
            default_exists = 0;
 
            for (p2=p->u2.statements; p2; p2=p2->next) {
                /* now, for each case/default put the body of the for loop here */
                if (p2->type == PV_CASE) {
                    /* ok, generate a extension and link it in */
                    switch_case = new_exten();
                    if (mother_exten && mother_exten->checked_switch) {
                        switch_case->has_switch = mother_exten->has_switch;
                        switch_case->checked_switch = mother_exten->checked_switch;
                    }
                    if (exten && exten->checked_switch) {
                        switch_case->has_switch = exten->has_switch;
                        switch_case->checked_switch = exten->checked_switch;
                    }
                    switch_case->context = this_context;
                    switch_case->is_switch = 1;
                    /* the break/continue locations are inherited from parent */
                    switch_case->loop_break = exten->loop_break;
                    switch_case->loop_continue = exten->loop_continue;
 
                    linkexten(exten,switch_case);
                    snprintf(buf1, BUF_SIZE, "sw_%d_%s", local_control_statement_count, p2->u1.str);
                    switch_case->name = strdup(buf1);
                    snprintf(new_label, BUF_SIZE, "sw_%s_%s_%d", label, p2->u1.str, local_control_statement_count);
 
                    if (gen_prios(switch_case, new_label, p2->u2.statements, exten, this_context)) { /* this will link in all the case body statements here */
                        return -1;
                    }
 
                    /* here is where we write code to "fall thru" to the next case... if there is one... */
                    for (p3=p2->u2.statements; p3; p3=p3->next) {
                        if (!p3->next)
                            break;
                    }
                    /* p3 now points the last statement... */
                    if (!p3 || ( p3->type != PV_GOTO && p3->type != PV_BREAK && p3->type != PV_RETURN) ) {
                        /* is there a following CASE/PATTERN/DEFAULT? */
                        if (p2->next && p2->next->type == PV_CASE) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", local_control_statement_count, p2->next->u1.str);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (p2->next && p2->next->type == PV_PATTERN) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            gen_match_to_pattern(p2->next->u1.str, buf2);
                            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", local_control_statement_count, buf2);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (p2->next && p2->next->type == PV_DEFAULT) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            snprintf(buf1, BUF_SIZE, "sw_%d_.,10", local_control_statement_count);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (!p2->next) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_CONTROL1;
                            fall_thru->goto_true = switch_end;
                            fall_thru->app = strdup("Goto");
                            linkprio(switch_case, fall_thru, mother_exten);
                        }
                    }
                    if (switch_case->return_needed) { /* returns don't generate a goto eoe (end of extension) any more, just a Return() app call) */
                        char buf[2000];
                        struct ael_priority *np2 = new_prio();
                        np2->type = AEL_APPCALL;
                        np2->app = strdup("NoOp");
                        snprintf(buf, BUF_SIZE, "End of Extension %s", switch_case->name);
                        np2->appargs = strdup(buf);
                        linkprio(switch_case, np2, mother_exten);
                        switch_case-> return_target = np2;
                    }
                } else if (p2->type == PV_PATTERN) {
                    /* ok, generate a extension and link it in */
                    switch_case = new_exten();
                    if (mother_exten && mother_exten->checked_switch) {
                        switch_case->has_switch = mother_exten->has_switch;
                        switch_case->checked_switch = mother_exten->checked_switch;
                    }
                    if (exten && exten->checked_switch) {
                        switch_case->has_switch = exten->has_switch;
                        switch_case->checked_switch = exten->checked_switch;
                    }
                    switch_case->context = this_context;
                    switch_case->is_switch = 1;
                    /* the break/continue locations are inherited from parent */
                    switch_case->loop_break = exten->loop_break;
                    switch_case->loop_continue = exten->loop_continue;
 
                    linkexten(exten,switch_case);
                    snprintf(buf1, BUF_SIZE, "_sw_%d_%s", local_control_statement_count, p2->u1.str);
                    switch_case->name = strdup(buf1);
                    snprintf(new_label, BUF_SIZE, "sw_%s_%s_%d", label, p2->u1.str, local_control_statement_count);
 
                    if (gen_prios(switch_case, new_label, p2->u2.statements, exten, this_context)) { /* this will link in all the while body statements here */
                        return -1;
                    }
                    /* here is where we write code to "fall thru" to the next case... if there is one... */
                    for (p3=p2->u2.statements; p3; p3=p3->next) {
                        if (!p3->next)
                            break;
                    }
                    /* p3 now points the last statement... */
                    if (!p3 || ( p3->type != PV_GOTO && p3->type != PV_BREAK && p3->type != PV_RETURN)) {
                        /* is there a following CASE/PATTERN/DEFAULT? */
                        if (p2->next && p2->next->type == PV_CASE) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", local_control_statement_count, p2->next->u1.str);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (p2->next && p2->next->type == PV_PATTERN) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            gen_match_to_pattern(p2->next->u1.str, buf2);
                            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", local_control_statement_count, buf2);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (p2->next && p2->next->type == PV_DEFAULT) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            snprintf(buf1, BUF_SIZE, "sw_%d_.,10", local_control_statement_count);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (!p2->next) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_CONTROL1;
                            fall_thru->goto_true = switch_end;
                            fall_thru->app = strdup("Goto");
                            linkprio(switch_case, fall_thru, mother_exten);
                        }
                    }
                    if (switch_case->return_needed) { /* returns don't generate a goto eoe (end of extension) any more, just a Return() app call) */
                        char buf[2000];
                        struct ael_priority *np2 = new_prio();
                        np2->type = AEL_APPCALL;
                        np2->app = strdup("NoOp");
                        snprintf(buf,sizeof(buf),"End of Extension %s", switch_case->name);
                        np2->appargs = strdup(buf);
                        linkprio(switch_case, np2, mother_exten);
                        switch_case-> return_target = np2;
                    }
                } else if (p2->type == PV_DEFAULT) {
                    /* ok, generate a extension and link it in */
                    switch_case = new_exten();
                    if (mother_exten && mother_exten->checked_switch) {
                        switch_case->has_switch = mother_exten->has_switch;
                        switch_case->checked_switch = mother_exten->checked_switch;
                    }
                    if (exten && exten->checked_switch) {
                        switch_case->has_switch = exten->has_switch;
                        switch_case->checked_switch = exten->checked_switch;
                    }
                    switch_case->context = this_context;
                    switch_case->is_switch = 1;
 
                    /* new: the default case intros a pattern with ., which covers ALMOST everything.
                       but it doesn't cover a NULL pattern. So, we'll define a null extension to match
                       that goto's the default extension. */
 
                    default_exists++;
                    switch_null = new_exten();
                    if (mother_exten && mother_exten->checked_switch) {
                        switch_null->has_switch = mother_exten->has_switch;
                        switch_null->checked_switch = mother_exten->checked_switch;
                    }
                    if (exten && exten->checked_switch) {
                        switch_null->has_switch = exten->has_switch;
                        switch_null->checked_switch = exten->checked_switch;
                    }
                    switch_null->context = this_context;
                    switch_null->is_switch = 1;
                    switch_empty = new_prio();
                    snprintf(buf1, BUF_SIZE, "sw_%d_.,10", local_control_statement_count);
                    switch_empty->app = strdup("Goto");
                    switch_empty->appargs = strdup(buf1);
                    linkprio(switch_null, switch_empty, mother_exten);
                    snprintf(buf1, BUF_SIZE, "sw_%d_", local_control_statement_count);
                    switch_null->name = strdup(buf1);
                    switch_null->loop_break = exten->loop_break;
                    switch_null->loop_continue = exten->loop_continue;
                    linkexten(exten,switch_null);
 
                    /* the break/continue locations are inherited from parent */
                    switch_case->loop_break = exten->loop_break;
                    switch_case->loop_continue = exten->loop_continue;
                    linkexten(exten,switch_case);
                    snprintf(buf1, BUF_SIZE, "_sw_%d_.", local_control_statement_count);
                    switch_case->name = strdup(buf1);
 
                    snprintf(new_label, BUF_SIZE, "sw_%s_default_%d", label, local_control_statement_count);
 
                    if (gen_prios(switch_case, new_label, p2->u2.statements, exten, this_context)) { /* this will link in all the default:  body statements here */
                        return -1;
                    }
 
                    /* here is where we write code to "fall thru" to the next case... if there is one... */
                    for (p3=p2->u2.statements; p3; p3=p3->next) {
                        if (!p3->next)
                            break;
                    }
                    /* p3 now points the last statement... */
                    if (!p3 || (p3->type != PV_GOTO && p3->type != PV_BREAK && p3->type != PV_RETURN)) {
                        /* is there a following CASE/PATTERN/DEFAULT? */
                        if (p2->next && p2->next->type == PV_CASE) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", local_control_statement_count, p2->next->u1.str);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (p2->next && p2->next->type == PV_PATTERN) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            gen_match_to_pattern(p2->next->u1.str, buf2);
                            snprintf(buf1, BUF_SIZE, "sw_%d_%s,10", local_control_statement_count, buf2);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (p2->next && p2->next->type == PV_DEFAULT) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_APPCALL;
                            fall_thru->app = strdup("Goto");
                            snprintf(buf1, BUF_SIZE, "sw_%d_.,10", local_control_statement_count);
                            fall_thru->appargs = strdup(buf1);
                            linkprio(switch_case, fall_thru, mother_exten);
                        } else if (!p2->next) {
                            fall_thru = new_prio();
                            fall_thru->type = AEL_CONTROL1;
                            fall_thru->goto_true = switch_end;
                            fall_thru->app = strdup("Goto");
                            linkprio(switch_case, fall_thru, mother_exten);
                        }
                    }
                    if (switch_case->return_needed) { /* returns don't generate a goto eoe (end of extension) any more, just a Return() app call) */
                        char buf[2000];
                        struct ael_priority *np2 = new_prio();
                        np2->type = AEL_APPCALL;
                        np2->app = strdup("NoOp");
                        snprintf(buf,sizeof(buf),"End of Extension %s", switch_case->name);
                        np2->appargs = strdup(buf);
                        linkprio(switch_case, np2, mother_exten);
                        switch_case-> return_target = np2;
                    }
                } else {
                    /* what could it be??? */
                }
            }
 
            exten->loop_break = loop_break_save;
            exten->loop_continue = loop_continue_save;
            switch_test->origin = p;
            switch_end->origin = p;
            break;
 
        case PV_MACRO_CALL:
            pr = new_prio();
            pr->type = AEL_APPCALL;
            snprintf(buf1, BUF_SIZE, "%s,~~s~~,1", p->u1.str);
            first = 1;
            for (p2 = p->u2.arglist; p2; p2 = p2->next) {
                if (first)
                {
                    strcat(buf1,"(");
                    first = 0;
                }
                else
                    strcat(buf1,",");
                strcat(buf1,p2->u1.str);
            }
            if (!first)
                strcat(buf1,")");
 
            pr->app = strdup("Gosub");
            pr->appargs = strdup(buf1);
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_APPLICATION_CALL:
            pr = new_prio();
            pr->type = AEL_APPCALL;
            buf1[0] = 0;
            for (p2 = p->u2.arglist; p2; p2 = p2->next) {
                if (p2 != p->u2.arglist )
                    strcat(buf1,",");
                strcat(buf1,p2->u1.str);
            }
            pr->app = strdup(p->u1.str);
            pr->appargs = strdup(buf1);
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_BREAK:
            pr = new_prio();
            pr->type = AEL_CONTROL1; /* simple goto */
            pr->goto_true = exten->loop_break;
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_RETURN: /* hmmmm */
            pr = new_prio();
            pr->type = AEL_RETURN; /* simple Return */
            /* exten->return_needed++; */
            pr->app = strdup("Return");
            pr->appargs = strdup("");
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_CONTINUE:
            pr = new_prio();
            pr->type = AEL_CONTROL1; /* simple goto */
            pr->goto_true = exten->loop_continue;
            pr->origin = p;
            linkprio(exten, pr, mother_exten);
            break;
 
        case PV_IFTIME:
            control_statement_count++;
            snprintf(new_label, BUF_SIZE, "iftime_%s_%d", label, control_statement_count);
 
            if_test = new_prio();
            if_test->type = AEL_IFTIME_CONTROL;
            snprintf(buf1, BUF_SIZE, "%s,%s,%s,%s",
                     p->u1.list->u1.str,
                     p->u1.list->next->u1.str,
                     p->u1.list->next->next->u1.str,
                     p->u1.list->next->next->next->u1.str);
            if_test->app = 0;
            if_test->appargs = strdup(buf1);
            if_test->origin = p;
 
            if_end = new_prio();
            if_end->type = AEL_APPCALL;
            snprintf(buf1, BUF_SIZE, "Finish iftime_%s_%d", label, control_statement_count);
            if_end->app = strdup("NoOp");
            if_end->appargs = strdup(buf1);
 
            if (p->u3.else_statements) {
                if_skip = new_prio();
                if_skip->type = AEL_CONTROL1; /* simple goto */
                if_skip->goto_true = if_end;
                if_skip->origin  = p;
 
            } else {
                if_skip = 0;
 
                if_test->goto_false = if_end;
            }
 
            if_false = new_prio();
            if_false->type = AEL_CONTROL1;
            if (p->u3.else_statements) {
                if_false->goto_true = if_skip; /* +1 */
            } else {
                if_false->goto_true = if_end;
            }
 
            /* link & load! */
            linkprio(exten, if_test, mother_exten);
            linkprio(exten, if_false, mother_exten);
 
            /* now, put the body of the if here */
 
            if (gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context)) { /* this will link in all the statements here */
                return -1;
            }
 
            if (p->u3.else_statements) {
                linkprio(exten, if_skip, mother_exten);
                if (gen_prios(exten, new_label, p->u3.else_statements, mother_exten, this_context)) { /* this will link in all the statements here */
                    return -1;
                }
            }
 
            linkprio(exten, if_end, mother_exten);
 
            break;
 
        case PV_RANDOM:
        case PV_IF:
            control_statement_count++;
            snprintf(new_label, BUF_SIZE, "if_%s_%d", label, control_statement_count);
 
            if_test = new_prio();
            if_end = new_prio();
            if_test->type = AEL_IF_CONTROL;
            if_end->type = AEL_APPCALL;
            if ( p->type == PV_RANDOM )
                snprintf(buf1, BUF_SIZE, "$[${RAND(0,99)} < (%s)]", p->u1.str);
            else
                snprintf(buf1, BUF_SIZE, "$[%s]", p->u1.str);
            if_test->app = 0;
            if_test->appargs = strdup(buf1);
            snprintf(buf1, BUF_SIZE, "Finish if_%s_%d", label, control_statement_count);
            if_end->app = strdup("NoOp");
            if_end->appargs = strdup(buf1);
            if_test->origin = p;
 
            if (p->u3.else_statements) {
                if_skip = new_prio();
                if_skip->type = AEL_CONTROL1; /* simple goto */
                if_skip->goto_true = if_end;
                if_test->goto_false = if_skip;;
            } else {
                if_skip = 0;
                if_test->goto_false = if_end;;
            }
 
            /* link & load! */
            linkprio(exten, if_test, mother_exten);
 
            /* now, put the body of the if here */
 
            if (gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context)) { /* this will link in all the statements here */
                return -1;
            }
 
            if (p->u3.else_statements) {
                linkprio(exten, if_skip, mother_exten);
                if (gen_prios(exten, new_label, p->u3.else_statements, mother_exten, this_context)) { /* this will link in all the statements here */
                    return -1;
                }
            }
 
            linkprio(exten, if_end, mother_exten);
 
            break;
 
        case PV_STATEMENTBLOCK:
            if (gen_prios(exten, label, p->u1.list, mother_exten, this_context)) { /* recurse into the block */
                return -1;
            }
            break;
 
        case PV_CATCH:
            control_statement_count++;
            /* generate an extension with name of catch, put all catch stats
               into this exten! */
            switch_case = new_exten();
            if (mother_exten && mother_exten->checked_switch) {
                switch_case->has_switch = mother_exten->has_switch;
                switch_case->checked_switch = mother_exten->checked_switch;
            }
            if (exten && exten->checked_switch) {
                switch_case->has_switch = exten->has_switch;
                switch_case->checked_switch = exten->checked_switch;
            }
 
            switch_case->context = this_context;
            linkexten(exten,switch_case);
            switch_case->name = strdup(p->u1.str);
            snprintf(new_label, BUF_SIZE, "catch_%s_%d",p->u1.str, control_statement_count);
 
            if (gen_prios(switch_case, new_label, p->u2.statements, mother_exten,this_context)) { /* this will link in all the catch body statements here */
                return -1;
            }
            if (switch_case->return_needed) { /* returns now generate a Return() app call, no longer a goto to the end of the exten */
                char buf[2000];
                struct ael_priority *np2 = new_prio();
                np2->type = AEL_APPCALL;