pbx/pbx_ael.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2006, Digium, Inc.
   5  *
   6  * Steve Murphy <murf@parsetree.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Compile symbolic Asterisk Extension Logic into Asterisk extensions, version 2.
  22  *
  23  */
  24
  25 #include "asterisk.h"
  26
  27 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  28
  29 #include <sys/types.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include <regex.h>
  37 #include <sys/stat.h>
  38
  39 #include "asterisk/pbx.h"
  40 #include "asterisk/config.h"
  41 #include "asterisk/module.h"
  42 #include "asterisk/logger.h"
  43 #include "asterisk/cli.h"
  44 #include "asterisk/app.h"
  45 #include "asterisk/callerid.h"
  46 #include "asterisk/ael_structs.h"
  47 #ifdef AAL_ARGCHECK
  48 #include "asterisk/argdesc.h"
  49 #endif
  50
  51 static char expr_output[2096];
  52
  53 /* these functions are in ../ast_expr2.fl */
  54
  55 #define DEBUG_READ   (1 << 0)
  56 #define DEBUG_TOKENS (1 << 1)
  57 #define DEBUG_MACROS (1 << 2)
  58 #define DEBUG_CONTEXTS (1 << 3)
  59
  60 static char *config = "extensions.ael";
  61 static char *registrar = "pbx_ael";
  62 static int pbx_load_module(void);
  63
  64 static int errs, warns;
  65 static int notes;
  66
  67 #ifndef AAL_ARGCHECK
  68 /* for the time being, short circuit all the AAL related structures
  69    without permanently removing the code; after/during the AAL
  70    development, this code can be properly re-instated
  71 */
  72
  73 /*! \brief null definitions for structs passed down the infrastructure */
  74 struct argapp
  75 {
  76         struct argapp *next;
  77 };
  78
  79 #endif
  80
  81 #ifdef AAL_ARGCHECK
  82 int option_matches_j( struct argdesc *should, pval *is, struct argapp *app);
  83 int option_matches( struct argdesc *should, pval *is, struct argapp *app);
  84 int ael_is_funcname(char *name);
  85 #endif
  86
  87 int check_app_args(pval *appcall, pval *arglist, struct argapp *app);
  88 void check_pval(pval *item, struct argapp *apps, int in_globals);
  89 void check_pval_item(pval *item, struct argapp *apps, int in_globals);
  90 void check_switch_expr(pval *item, struct argapp *apps);
  91 void ast_expr_register_extra_error_info(char *errmsg);
  92 void ast_expr_clear_extra_error_info(void);
  93 int  ast_expr(char *expr, char *buf, int length);
  94 struct pval *find_macro(char *name);
  95 struct pval *find_context(char *name);
  96 struct pval *find_context(char *name);
  97 struct pval *find_macro(char *name);
  98 struct ael_priority *new_prio(void);
  99 struct ael_extension *new_exten(void);
 100 void linkprio(struct ael_extension *exten, struct ael_priority *prio);
 101 void destroy_extensions(struct ael_extension *exten);
 102 static void linkexten(struct ael_extension *exten, struct ael_extension *add);
 103 static void gen_prios(struct ael_extension *exten, char *label, pval *statement, struct ael_extension *mother_exten, struct ast_context *context );
 104 void set_priorities(struct ael_extension *exten);
 105 void add_extensions(struct ael_extension *exten);
 106 void ast_compile_ael2(struct ast_context **local_contexts, struct pval *root);
 107 void destroy_pval(pval *item);
 108 void destroy_pval_item(pval *item);
 109 int is_float(char *arg );
 110 int is_int(char *arg );
 111 int is_empty(char *arg);
 112 static pval *current_db;
 113 static pval *current_context;
 114 static pval *current_extension;
 115
 116 static const char *match_context;
 117 static const char *match_exten;
 118 static const char *match_label;
 119 static int in_abstract_context;
 120 static int count_labels; /* true, put matcher in label counting mode */
 121 static int label_count;  /* labels are only meant to be counted in a context or exten */
 122 static int return_on_context_match;
 123 static pval *last_matched_label;
 124 struct pval *match_pval(pval *item);
 125 static void check_timerange(pval *p);
 126 static void check_dow(pval *DOW);
 127 static void check_day(pval *DAY);
 128 static void check_month(pval *MON);
 129 static void check_expr2_input(pval *expr, char *str);
 130 static int extension_matches(pval *here, const char *exten, const char *pattern);
 131 static void check_goto(pval *item);
 132 static void find_pval_goto_item(pval *item, int lev);
 133 static void find_pval_gotos(pval *item, int lev);
 134 static int check_break(pval *item);
 135 static int check_continue(pval *item);
 136 static void check_label(pval *item);
 137 static void check_macro_returns(pval *macro);
 138
 139 static struct pval *find_label_in_current_context(char *exten, char *label, pval *curr_cont);
 140 static struct pval *find_first_label_in_current_context(char *label, pval *curr_cont);
 141 static void print_pval_list(FILE *fin, pval *item, int depth);
 142
 143 static struct pval *find_label_in_current_extension(const char *label, pval *curr_ext);
 144 static struct pval *find_label_in_current_db(const char *context, const char *exten, const char *label);
 145 static pval *get_goto_target(pval *item);
 146 static int label_inside_case(pval *label);
 147 static void attach_exten(struct ael_extension **list, struct ael_extension *newmem);
 148 static void fix_gotos_in_extensions(struct ael_extension *exten);
 149 static pval *get_extension_or_contxt(pval *p);
 150 static pval *get_contxt(pval *p);
 151 static void remove_spaces_before_equals(char *str);
 152 static void substitute_commas(char *str);
 153
 154 /*! \brief I am adding this code to substitute commas with vertbars in the args to apps */
 155 static void substitute_commas(char *str)
 156 {
 157         char *p = str;
 158
 159         while (p && *p)
 160         {
 161                 if (*p == ',' && ((p != str && *(p-1) != '\\')
 162                                 || p == str))
 163                         *p = '|';
 164                 if (*p == '\\' && *(p+1) == ',') { /* learning experience: the '\,' is turned into just ',' by pbx_config; So we need to do the same */
 165                         char *q = p;
 166                         while (*q) {  /* move the ',' and everything after it up 1 char */
 167                                 *q = *(q+1);
 168                                 q++;
 169                         }
 170                 }
 171                 p++;
 172         }
 173 }
 174
 175
 176 /* PRETTY PRINTER FOR AEL:  ============================================================================= */
 177
 178 static void print_pval(FILE *fin, pval *item, int depth)
 179 {
 180         int i;
 181         pval *lp;
 182
 183         for (i=0; i<depth; i++) {
 184                 fprintf(fin, "\t"); /* depth == indentation */
 185         }
 186
 187         switch ( item->type ) {
 188         case PV_WORD:
 189                 fprintf(fin,"%s;\n", item->u1.str); /* usually, words are encapsulated in something else */
 190                 break;
 191
 192         case PV_MACRO:
 193                 fprintf(fin,"macro %s(", item->u1.str);
 194                 for (lp=item->u2.arglist; lp; lp=lp->next) {
 195                         if (lp != item->u2.arglist )
 196                                 fprintf(fin,", ");
 197                         fprintf(fin,"%s", lp->u1.str);
 198                 }
 199                 fprintf(fin,") {\n");
 200                 print_pval_list(fin,item->u3.macro_statements,depth+1);
 201                 for (i=0; i<depth; i++) {
 202                         fprintf(fin,"\t"); /* depth == indentation */
 203                 }
 204                 fprintf(fin,"};\n\n");
 205                 break;
 206
 207         case PV_CONTEXT:
 208                 if ( item->u3.abstract )
 209                         fprintf(fin,"abstract context %s {\n", item->u1.str);
 210                 else
 211                         fprintf(fin,"context %s {\n", item->u1.str);
 212                 print_pval_list(fin,item->u2.statements,depth+1);
 213                 for (i=0; i<depth; i++) {
 214                         fprintf(fin,"\t"); /* depth == indentation */
 215                 }
 216                 fprintf(fin,"};\n\n");
 217                 break;
 218
 219         case PV_MACRO_CALL:
 220                 fprintf(fin,"&%s(", item->u1.str);
 221                 for (lp=item->u2.arglist; lp; lp=lp->next) {
 222                         if ( lp != item->u2.arglist )
 223                                 fprintf(fin,", ");
 224                         fprintf(fin,"%s", lp->u1.str);
 225                 }
 226                 fprintf(fin,");\n");
 227                 break;
 228
 229         case PV_APPLICATION_CALL:
 230                 fprintf(fin,"%s(", item->u1.str);
 231                 for (lp=item->u2.arglist; lp; lp=lp->next) {
 232                         if ( lp != item->u2.arglist )
 233                                 fprintf(fin,",");
 234                         fprintf(fin,"%s", lp->u1.str);
 235                 }
 236                 fprintf(fin,");\n");
 237                 break;
 238
 239         case PV_CASE:
 240                 fprintf(fin,"case %s:\n", item->u1.str);
 241                 print_pval_list(fin,item->u2.statements, depth+1);
 242                 break;
 243
 244         case PV_PATTERN:
 245                 fprintf(fin,"pattern %s:\n", item->u1.str);
 246                 print_pval_list(fin,item->u2.statements, depth+1);
 247                 break;
 248
 249         case PV_DEFAULT:
 250                 fprintf(fin,"default:\n");
 251                 print_pval_list(fin,item->u2.statements, depth+1);
 252                 break;
 253
 254         case PV_CATCH:
 255                 fprintf(fin,"catch %s {\n", item->u1.str);
 256                 print_pval_list(fin,item->u2.statements, depth+1);
 257                 for (i=0; i<depth; i++) {
 258                         fprintf(fin,"\t"); /* depth == indentation */
 259                 }
 260                 fprintf(fin,"};\n");
 261                 break;
 262
 263         case PV_SWITCHES:
 264                 fprintf(fin,"switches {\n");
 265                 print_pval_list(fin,item->u1.list,depth+1);
 266                 for (i=0; i<depth; i++) {
 267                         fprintf(fin,"\t"); /* depth == indentation */
 268                 }
 269                 fprintf(fin,"};\n");
 270                 break;
 271
 272         case PV_ESWITCHES:
 273                 fprintf(fin,"eswitches {\n");
 274                 print_pval_list(fin,item->u1.list,depth+1);
 275                 for (i=0; i<depth; i++) {
 276                         fprintf(fin,"\t"); /* depth == indentation */
 277                 }
 278                 fprintf(fin,"};\n");
 279                 break;
 280
 281         case PV_INCLUDES:
 282                 fprintf(fin,"includes {\n");
 283                 for (lp=item->u1.list; lp; lp=lp->next) {
 284                         for (i=0; i<depth+1; i++) {
 285                                 fprintf(fin,"\t"); /* depth == indentation */
 286                         }
 287                         fprintf(fin,"%s", lp->u1.str); /* usually, words are encapsulated in something else */
 288                         if ( lp->u2.arglist )
 289                                 fprintf(fin,"|%s|%s|%s|%s",
 290                                                 lp->u2.arglist->u1.str,
 291                                                 lp->u2.arglist->next->u1.str,
 292                                                 lp->u2.arglist->next->next->u1.str,
 293                                                 lp->u2.arglist->next->next->next->u1.str
 294                                         );
 295                         fprintf(fin,";\n"); /* usually, words are encapsulated in something else */
 296                 }
 297
 298                 print_pval_list(fin,item->u1.list,depth+1);
 299                 for (i=0; i<depth; i++) {
 300                         fprintf(fin,"\t"); /* depth == indentation */
 301                 }
 302                 fprintf(fin,"};\n");
 303                 break;
 304
 305         case PV_STATEMENTBLOCK:
 306                 fprintf(fin,"{\n");
 307                 print_pval_list(fin,item->u1.list, depth+1);
 308                 for (i=0; i<depth; i++) {
 309                         fprintf(fin,"\t"); /* depth == indentation */
 310                 }
 311                 fprintf(fin,"};\n");
 312                 break;
 313
 314         case PV_VARDEC:
 315                 fprintf(fin,"%s=%s;\n", item->u1.str, item->u2.val);
 316                 break;
 317
 318         case PV_GOTO:
 319                 fprintf(fin,"goto %s", item->u1.list->u1.str);
 320                 if ( item->u1.list->next )
 321                         fprintf(fin,"|%s", item->u1.list->next->u1.str);
 322                 if ( item->u1.list->next && item->u1.list->next->next )
 323                         fprintf(fin,"|%s", item->u1.list->next->next->u1.str);
 324                 fprintf(fin,"\n");
 325                 break;
 326
 327         case PV_LABEL:
 328                 fprintf(fin,"%s:\n", item->u1.str);
 329                 break;
 330
 331         case PV_FOR:
 332                 fprintf(fin,"for (%s; %s; %s)\n", item->u1.for_init, item->u2.for_test, item->u3.for_inc);
 333                 print_pval_list(fin,item->u4.for_statements,depth+1);
 334                 break;
 335
 336         case PV_WHILE:
 337                 fprintf(fin,"while (%s)\n", item->u1.str);
 338                 print_pval_list(fin,item->u2.statements,depth+1);
 339                 break;
 340
 341         case PV_BREAK:
 342                 fprintf(fin,"break;\n");
 343                 break;
 344
 345         case PV_RETURN:
 346                 fprintf(fin,"return;\n");
 347                 break;
 348
 349         case PV_CONTINUE:
 350                 fprintf(fin,"continue;\n");
 351                 break;
 352
 353         case PV_RANDOM:
 354         case PV_IFTIME:
 355         case PV_IF:
 356                 if ( item->type == PV_IFTIME ) {
 357
 358                         fprintf(fin,"ifTime ( %s|%s|%s|%s )\n",
 359                                         item->u1.list->u1.str,
 360                                         item->u1.list->next->u1.str,
 361                                         item->u1.list->next->next->u1.str,
 362                                         item->u1.list->next->next->next->u1.str
 363                                         );
 364                 } else if ( item->type == PV_RANDOM ) {
 365                         fprintf(fin,"random ( %s )\n", item->u1.str );
 366                 } else
 367                         fprintf(fin,"if ( %s )\n", item->u1.str);
 368                 if ( item->u2.statements && item->u2.statements->next ) {
 369                         for (i=0; i<depth; i++) {
 370                                 fprintf(fin,"\t"); /* depth == indentation */
 371                         }
 372                         fprintf(fin,"{\n");
 373                         print_pval_list(fin,item->u2.statements,depth+1);
 374                         for (i=0; i<depth; i++) {
 375                                 fprintf(fin,"\t"); /* depth == indentation */
 376                         }
 377                         if ( item->u3.else_statements )
 378                                 fprintf(fin,"}\n");
 379                         else
 380                                 fprintf(fin,"};\n");
 381                 } else if (item->u2.statements ) {
 382                         print_pval_list(fin,item->u2.statements,depth+1);
 383                 } else {
 384                         if (item->u3.else_statements )
 385                                 fprintf(fin, " {} ");
 386                         else
 387                                 fprintf(fin, " {}; ");
 388                 }
 389                 if ( item->u3.else_statements ) {
 390                         for (i=0; i<depth; i++) {
 391                                 fprintf(fin,"\t"); /* depth == indentation */
 392                         }
 393                         fprintf(fin,"else\n");
 394                         print_pval_list(fin,item->u3.else_statements, depth);
 395                 }
 396                 break;
 397
 398         case PV_SWITCH:
 399                 fprintf(fin,"switch( %s ) {\n", item->u1.str);
 400                 print_pval_list(fin,item->u2.statements,depth+1);
 401                 for (i=0; i<depth; i++) {
 402                         fprintf(fin,"\t"); /* depth == indentation */
 403                 }
 404                 fprintf(fin,"}\n");
 405                 break;
 406
 407         case PV_EXTENSION:
 408                 if ( item->u4.regexten )
 409                         fprintf(fin, "regexten ");
 410                 if ( item->u3.hints )
 411                         fprintf(fin,"hints(%s) ", item->u3.hints);
 412
 413                 fprintf(fin,"%s => \n", item->u1.str);
 414                 print_pval_list(fin,item->u2.statements,depth+1);
 415                 break;
 416
 417         case PV_IGNOREPAT:
 418                 fprintf(fin,"ignorepat => %s\n", item->u1.str);
 419                 break;
 420
 421         case PV_GLOBALS:
 422                 fprintf(fin,"globals {\n");
 423                 print_pval_list(fin,item->u1.statements,depth+1);
 424                 for (i=0; i<depth; i++) {
 425                         fprintf(fin,"\t"); /* depth == indentation */
 426                 }
 427                 fprintf(fin,"}\n");
 428                 break;
 429         }
 430 }
 431
 432 static void print_pval_list(FILE *fin, pval *item, int depth)
 433 {
 434         pval *i;
 435
 436         for (i=item; i; i=i->next) {
 437                 print_pval(fin, i, depth);
 438         }
 439 }
 440
 441 #if 0
 442 static void ael2_print(char *fname, pval *tree)
 443 {
 444         FILE *fin = fopen(fname,"w");
 445         if ( !fin ) {
 446                 ast_log(LOG_ERROR, "Couldn't open %s for writing.\n", fname);
 447                 return;
 448         }
 449         print_pval_list(fin, tree, 0);
 450         fclose(fin);
 451 }
 452 #endif
 453
 454
 455 /* EMPTY TEMPLATE FUNCS FOR AEL TRAVERSAL:  ============================================================================= */
 456
 457 void traverse_pval_template(pval *item, int depth);
 458 void traverse_pval_item_template(pval *item, int depth);
 459
 460
 461 void traverse_pval_item_template(pval *item, int depth)/* depth comes in handy for a pretty print (indentation),
 462                                                                                                                   but you may not need it */
 463 {
 464         pval *lp;
 465
 466         switch ( item->type ) {
 467         case PV_WORD:
 468                 /* fields: item->u1.str == string associated with this (word). */
 469                 break;
 470
 471         case PV_MACRO:
 472                 /* fields: item->u1.str     == name of macro
 473                            item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
 474                                    item->u2.arglist->u1.str  == argument
 475                                    item->u2.arglist->next   == next arg
 476
 477                                    item->u3.macro_statements == pval list of statements in macro body.
 478                 */
 479                 for (lp=item->u2.arglist; lp; lp=lp->next) {
 480
 481                 }
 482                 traverse_pval_item_template(item->u3.macro_statements,depth+1);
 483                 break;
 484
 485         case PV_CONTEXT:
 486                 /* fields: item->u1.str     == name of context
 487                            item->u2.statements == pval list of statements in context body
 488                                    item->u3.abstract == int 1 if an abstract keyword were present
 489                 */
 490                 traverse_pval_item_template(item->u2.statements,depth+1);
 491                 break;
 492
 493         case PV_MACRO_CALL:
 494                 /* fields: item->u1.str     == name of macro to call
 495                            item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
 496                                    item->u2.arglist->u1.str  == argument
 497                                    item->u2.arglist->next   == next arg
 498                 */
 499                 for (lp=item->u2.arglist; lp; lp=lp->next) {
 500                 }
 501                 break;
 502
 503         case PV_APPLICATION_CALL:
 504                 /* fields: item->u1.str     == name of application to call
 505                            item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
 506                                    item->u2.arglist->u1.str  == argument
 507                                    item->u2.arglist->next   == next arg
 508                 */
 509                 for (lp=item->u2.arglist; lp; lp=lp->next) {
 510                 }
 511                 break;
 512
 513         case PV_CASE:
 514                 /* fields: item->u1.str     == value of case
 515                            item->u2.statements == pval list of statements under the case
 516                 */
 517                 traverse_pval_item_template(item->u2.statements,depth+1);
 518                 break;
 519
 520         case PV_PATTERN:
 521                 /* fields: item->u1.str     == value of case
 522                            item->u2.statements == pval list of statements under the case
 523                 */
 524                 traverse_pval_item_template(item->u2.statements,depth+1);
 525                 break;
 526
 527         case PV_DEFAULT:
 528                 /* fields:
 529                            item->u2.statements == pval list of statements under the case
 530                 */
 531                 traverse_pval_item_template(item->u2.statements,depth+1);
 532                 break;
 533
 534         case PV_CATCH:
 535                 /* fields: item->u1.str     == name of extension to catch
 536                            item->u2.statements == pval list of statements in context body
 537                 */
 538                 traverse_pval_item_template(item->u2.statements,depth+1);
 539                 break;
 540
 541         case PV_SWITCHES:
 542                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
 543                 */
 544                 traverse_pval_item_template(item->u1.list,depth+1);
 545                 break;
 546
 547         case PV_ESWITCHES:
 548                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
 549                 */
 550                 traverse_pval_item_template(item->u1.list,depth+1);
 551                 break;
 552
 553         case PV_INCLUDES:
 554                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
 555                            item->u2.arglist  == pval list of 4 PV_WORD elements for time values
 556                 */
 557                 traverse_pval_item_template(item->u1.list,depth+1);
 558                 traverse_pval_item_template(item->u2.arglist,depth+1);
 559                 break;
 560
 561         case PV_STATEMENTBLOCK:
 562                 /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
 563                 */
 564                 traverse_pval_item_template(item->u1.list,depth+1);
 565                 break;
 566
 567         case PV_VARDEC:
 568                 /* fields: item->u1.str     == variable name
 569                            item->u2.val     == variable value to assign
 570                 */
 571                 break;
 572
 573         case PV_GOTO:
 574                 /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
 575                            item->u1.list->u1.str  == where the data on a PV_WORD will always be.
 576                 */
 577
 578                 if ( item->u1.list->next )
 579                         ;
 580                 if ( item->u1.list->next && item->u1.list->next->next )
 581                         ;
 582
 583                 break;
 584
 585         case PV_LABEL:
 586                 /* fields: item->u1.str     == label name
 587                 */
 588                 break;
 589
 590         case PV_FOR:
 591                 /* fields: item->u1.for_init     == a string containing the initalizer
 592                            item->u2.for_test     == a string containing the loop test
 593                            item->u3.for_inc      == a string containing the loop increment
 594
 595                                    item->u4.for_statements == a pval list of statements in the for ()
 596                 */
 597                 traverse_pval_item_template(item->u4.for_statements,depth+1);
 598                 break;
 599
 600         case PV_WHILE:
 601                 /* fields: item->u1.str        == the while conditional, as supplied by user
 602
 603                                    item->u2.statements == a pval list of statements in the while ()
 604                 */
 605                 traverse_pval_item_template(item->u2.statements,depth+1);
 606                 break;
 607
 608         case PV_BREAK:
 609                 /* fields: none
 610                 */
 611                 break;
 612
 613         case PV_RETURN:
 614                 /* fields: none
 615                 */
 616                 break;
 617
 618         case PV_CONTINUE:
 619                 /* fields: none
 620                 */
 621                 break;
 622
 623         case PV_IFTIME:
 624                 /* fields: item->u1.list        == there are 4 linked PV_WORDs here.
 625
 626                                    item->u2.statements == a pval list of statements in the if ()
 627                                    item->u3.else_statements == a pval list of statements in the else
 628                                                                                            (could be zero)
 629                 */
 630                 traverse_pval_item_template(item->u2.statements,depth+1);
 631                 if ( item->u3.else_statements ) {
 632                         traverse_pval_item_template(item->u3.else_statements,depth+1);
 633                 }
 634                 break;
 635
 636         case PV_RANDOM:
 637                 /* fields: item->u1.str        == the random number expression, as supplied by user
 638
 639                                    item->u2.statements == a pval list of statements in the if ()
 640                                    item->u3.else_statements == a pval list of statements in the else
 641                                                                                            (could be zero)
 642                 */
 643                 traverse_pval_item_template(item->u2.statements,depth+1);
 644                 if ( item->u3.else_statements ) {
 645                         traverse_pval_item_template(item->u3.else_statements,depth+1);
 646                 }
 647                 break;
 648
 649         case PV_IF:
 650                 /* fields: item->u1.str        == the if conditional, as supplied by user
 651
 652                                    item->u2.statements == a pval list of statements in the if ()
 653                                    item->u3.else_statements == a pval list of statements in the else
 654                                                                                            (could be zero)
 655                 */
 656                 traverse_pval_item_template(item->u2.statements,depth+1);
 657                 if ( item->u3.else_statements ) {
 658                         traverse_pval_item_template(item->u3.else_statements,depth+1);
 659                 }
 660                 break;
 661
 662         case PV_SWITCH:
 663                 /* fields: item->u1.str        == the switch expression
 664
 665                                    item->u2.statements == a pval list of statements in the switch,
 666                                                                                         (will be case statements, most likely!)
 667                 */
 668                 traverse_pval_item_template(item->u2.statements,depth+1);
 669                 break;
 670
 671         case PV_EXTENSION:
 672                 /* fields: item->u1.str        == the extension name, label, whatever it's called
 673
 674                                    item->u2.statements == a pval list of statements in the extension
 675                                    item->u3.hints      == a char * hint argument
 676                                    item->u4.regexten   == an int boolean. non-zero says that regexten was specified
 677                 */
 678                 traverse_pval_item_template(item->u2.statements,depth+1);
 679                 break;
 680
 681         case PV_IGNOREPAT:
 682                 /* fields: item->u1.str        == the ignorepat data
 683                 */
 684                 break;
 685
 686         case PV_GLOBALS:
 687                 /* fields: item->u1.statements     == pval list of statements, usually vardecs
 688                 */
 689                 traverse_pval_item_template(item->u1.statements,depth+1);
 690                 break;
 691         }
 692 }
 693
 694 void traverse_pval_template(pval *item, int depth) /* depth comes in handy for a pretty print (indentation),
 695                                                                                                           but you may not need it */
 696 {
 697         pval *i;
 698
 699         for (i=item; i; i=i->next) {
 700                 traverse_pval_item_template(i, depth);
 701         }
 702 }
 703
 704
 705 /* SEMANTIC CHECKING FOR AEL:  ============================================================================= */
 706
 707 /*   (not all that is syntactically legal is good! */
 708
 709
 710 static void check_macro_returns(pval *macro)
 711 {
 712         pval *i;
 713         if (!macro->u3.macro_statements)
 714         {
 715                 pval *z = calloc(1, sizeof(struct pval));
 716                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The macro %s is empty! I will insert a return.\n",
 717                                 macro->filename, macro->startline, macro->endline, macro->u1.str);
 718
 719                 z->type = PV_RETURN;
 720                 z->startline = macro->startline;
 721                 z->endline = macro->endline;
 722                 z->startcol = macro->startcol;
 723                 z->endcol = macro->endcol;
 724                 z->filename = strdup(macro->filename);
 725
 726                 macro->u3.macro_statements = z;
 727                 return;
 728         }
 729         for (i=macro->u3.macro_statements; i; i=i->next) {
 730                 /* if the last statement in the list is not return, then insert a return there */
 731                 if (i->next == NULL) {
 732                         if (i->type != PV_RETURN) {
 733                                 pval *z = calloc(1, sizeof(struct pval));
 734                                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The macro %s does not end with a return; I will insert one.\n",
 735                                                 macro->filename, macro->startline, macro->endline, macro->u1.str);
 736
 737                                 z->type = PV_RETURN;
 738                                 z->startline = macro->startline;
 739                                 z->endline = macro->endline;
 740                                 z->startcol = macro->startcol;
 741                                 z->endcol = macro->endcol;
 742                                 z->filename = strdup(macro->filename);
 743
 744                                 i->next = z;
 745                                 return;
 746                         }
 747                 }
 748         }
 749         return;
 750 }
 751
 752
 753
 754 static int extension_matches(pval *here, const char *exten, const char *pattern)
 755 {
 756         int err1;
 757         regex_t preg;
 758
 759         /* simple case, they match exactly, the pattern and exten name */
 760         if (!strcmp(pattern,exten) == 0)
 761                 return 1;
 762
 763         if (pattern[0] == '_') {
 764                 char reg1[2000];
 765                 const char *p;
 766                 char *r = reg1;
 767
 768                 if ( strlen(pattern)*5 >= 2000 ) /* safety valve */ {
 769                         ast_log(LOG_ERROR,"Error: The pattern %s is way too big. Pattern matching cancelled.\n",
 770                                         pattern);
 771                         return 0;
 772                 }
 773                 /* form a regular expression from the pattern, and then match it against exten */
 774                 *r++ = '^'; /* what if the extension is a pattern ?? */
 775                 *r++ = '_'; /* what if the extension is a pattern ?? */
 776                 *r++ = '?';
 777                 for (p=pattern+1; *p; p++) {
 778                         switch ( *p ) {
 779                         case 'X':
 780                                 *r++ = '[';
 781                                 *r++ = '0';
 782                                 *r++ = '-';
 783                                 *r++ = '9';
 784                                 *r++ = 'X';
 785                                 *r++ = ']';
 786                                 break;
 787
 788                         case 'Z':
 789                                 *r++ = '[';
 790                                 *r++ = '1';
 791                                 *r++ = '-';
 792                                 *r++ = '9';
 793                                 *r++ = 'Z';
 794                                 *r++ = ']';
 795                                 break;
 796
 797                         case 'N':
 798                                 *r++ = '[';
 799                                 *r++ = '2';
 800                                 *r++ = '-';
 801                                 *r++ = '9';
 802                                 *r++ = 'N';
 803                                 *r++ = ']';
 804                                 break;
 805
 806                         case '[':
 807                                 while ( *p && *p != ']' ) {
 808                                         *r++ = *p++;
 809                                 }
 810                                 if ( *p != ']') {
 811                                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The extension pattern '%s' is missing a closing bracket \n",
 812                                                         here->filename, here->startline, here->endline, pattern);
 813                                 }
 814                                 break;
 815
 816                         case '.':
 817                         case '!':
 818                                 *r++ = '.';
 819                                 *r++ = '*';
 820                                 break;
 821                         case '*':
 822                                 *r++ = '\\';
 823                                 *r++ = '*';
 824                                 break;
 825                         default:
 826                                 *r++ = *p;
 827                                 break;
 828
 829                         }
 830                 }
 831                 *r++ = '$'; /* what if the extension is a pattern ?? */
 832                 *r++ = *p++; /* put in the closing null */
 833                 err1 = regcomp(&preg, reg1, REG_NOSUB|REG_EXTENDED);
 834                 if ( err1 ) {
 835                         char errmess[500];
 836                         regerror(err1,&preg,errmess,sizeof(errmess));
 837                         regfree(&preg);
 838                         ast_log(LOG_WARNING, "Regcomp of %s failed, error code %d\n",
 839                                         reg1, err1);
 840                         return 0;
 841                 }
 842                 err1 = regexec(&preg, exten, 0, 0, 0);
 843                 regfree(&preg);
 844
 845                 if ( err1 ) {
 846                         /* ast_log(LOG_NOTICE,"*****************************[%d]Extension %s did not match %s(%s)\n",
 847                            err1,exten, pattern, reg1); */
 848                         return 0; /* no match */
 849                 } else {
 850                         /* ast_log(LOG_NOTICE,"*****************************Extension %s matched %s\n",
 851                            exten, pattern); */
 852                         return 1;
 853                 }
 854
 855
 856         } else {
 857                 if ( strcmp(exten,pattern) == 0 ) {
 858                         return 1;
 859                 } else
 860                         return 0;
 861         }
 862 }
 863
 864
 865 static void check_expr2_input(pval *expr, char *str)
 866 {
 867         int spaces = strspn(str,"\t \n");
 868         if ( !strncmp(str+spaces,"$[",2) ) {
 869                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The expression '%s' is redundantly wrapped in '$[ ]'. \n",
 870                                 expr->filename, expr->startline, expr->endline, str);
 871                 warns++;
 872         }
 873 }
 874
 875 static void check_includes(pval *includes)
 876 {
 877         struct pval *p4;
 878         for (p4=includes->u1.list; p4; p4=p4->next) {
 879                 /* for each context pointed to, find it, then find a context/label that matches the
 880                    target here! */
 881                 char *incl_context = p4->u1.str;
 882                 /* find a matching context name */
 883                 struct pval *that_other_context = find_context(incl_context);
 884                 if (!that_other_context && strcmp(incl_context, "parkedcalls") != 0) {
 885                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The included context '%s' cannot be found.\n",
 886                                         includes->filename, includes->startline, includes->endline, incl_context);
 887                         warns++;
 888                 }
 889         }
 890 }
 891
 892
 893 static void check_timerange(pval *p)
 894 {
 895         char *times;
 896         char *e;
 897         int s1, s2;
 898         int e1, e2;
 899
 900         times = ast_strdupa(p->u1.str);
 901
 902         /* Star is all times */
 903         if (ast_strlen_zero(times) || !strcmp(times, "*")) {
 904                 return;
 905         }
 906         /* Otherwise expect a range */
 907         e = strchr(times, '-');
 908         if (!e) {
 909                 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",
 910                                 p->filename, p->startline, p->endline, times);
 911                 warns++;
 912                 return;
 913         }
 914         *e = '\0';
 915         e++;
 916         while (*e && !isdigit(*e))
 917                 e++;
 918         if (!*e) {
 919                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The time range format (%s) is missing the end time!\n",
 920                                 p->filename, p->startline, p->endline, p->u1.str);
 921                 warns++;
 922         }
 923         if (sscanf(times, "%d:%d", &s1, &s2) != 2) {
 924                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start time (%s) isn't quite right!\n",
 925                                 p->filename, p->startline, p->endline, times);
 926                 warns++;
 927         }
 928         if (sscanf(e, "%d:%d", &e1, &e2) != 2) {
 929                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end time (%s) isn't quite right!\n",
 930                                 p->filename, p->startline, p->endline, times);
 931                 warns++;
 932         }
 933
 934         s1 = s1 * 30 + s2/2;
 935         if ((s1 < 0) || (s1 >= 24*30)) {
 936                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start time (%s) is out of range!\n",
 937                                 p->filename, p->startline, p->endline, times);
 938                 warns++;
 939         }
 940         e1 = e1 * 30 + e2/2;
 941         if ((e1 < 0) || (e1 >= 24*30)) {
 942                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end time (%s) is out of range!\n",
 943                                 p->filename, p->startline, p->endline, e);
 944                 warns++;
 945         }
 946         return;
 947 }
 948
 949 static char *days[] =
 950 {
 951         "sun",
 952         "mon",
 953         "tue",
 954         "wed",
 955         "thu",
 956         "fri",
 957         "sat",
 958 };
 959
 960 /*! \brief  get_dow: Get day of week */
 961 static void check_dow(pval *DOW)
 962 {
 963         char *dow;
 964         char *c;
 965         /* The following line is coincidence, really! */
 966         int s, e;
 967
 968         dow = ast_strdupa(DOW->u1.str);
 969
 970         /* Check for all days */
 971         if (ast_strlen_zero(dow) || !strcmp(dow, "*"))
 972                 return;
 973         /* Get start and ending days */
 974         c = strchr(dow, '-');
 975         if (c) {
 976                 *c = '\0';
 977                 c++;
 978         } else
 979                 c = NULL;
 980         /* Find the start */
 981         s = 0;
 982         while ((s < 7) && strcasecmp(dow, days[s])) s++;
 983         if (s >= 7) {
 984                 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",
 985                                 DOW->filename, DOW->startline, DOW->endline, dow);
 986                 warns++;
 987         }
 988         if (c) {
 989                 e = 0;
 990                 while ((e < 7) && strcasecmp(c, days[e])) e++;
 991                 if (e >= 7) {
 992                         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",
 993                                         DOW->filename, DOW->startline, DOW->endline, c);
 994                         warns++;
 995                 }
 996         } else
 997                 e = s;
 998 }
 999
1000 static void check_day(pval *DAY)
1001 {
1002         char *day;
1003         char *c;
1004         /* The following line is coincidence, really! */
1005         int s, e;
1006
1007         day = ast_strdupa(DAY->u1.str);
1008
1009         /* Check for all days */
1010         if (ast_strlen_zero(day) || !strcmp(day, "*")) {
1011                 return;
1012         }
1013         /* Get start and ending days */
1014         c = strchr(day, '-');
1015         if (c) {
1016                 *c = '\0';
1017                 c++;
1018         }
1019         /* Find the start */
1020         if (sscanf(day, "%d", &s) != 1) {
1021                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start day of month (%s) must be a number!\n",
1022                                 DAY->filename, DAY->startline, DAY->endline, day);
1023                 warns++;
1024         }
1025         else if ((s < 1) || (s > 31)) {
1026                 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",
1027                                 DAY->filename, DAY->startline, DAY->endline, day);
1028                 warns++;
1029         }
1030         s--;
1031         if (c) {
1032                 if (sscanf(c, "%d", &e) != 1) {
1033                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end day of month (%s) must be a number!\n",
1034                                         DAY->filename, DAY->startline, DAY->endline, c);
1035                         warns++;
1036                 }
1037                 else if ((e < 1) || (e > 31)) {
1038                         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",
1039                                         DAY->filename, DAY->startline, DAY->endline, day);
1040                         warns++;
1041                 }
1042                 e--;
1043         } else
1044                 e = s;
1045 }
1046
1047 static char *months[] =
1048 {
1049         "jan",
1050         "feb",
1051         "mar",
1052         "apr",
1053         "may",
1054         "jun",
1055         "jul",
1056         "aug",
1057         "sep",
1058         "oct",
1059         "nov",
1060         "dec",
1061 };
1062
1063 static void check_month(pval *MON)
1064 {
1065         char *mon;
1066         char *c;
1067         /* The following line is coincidence, really! */
1068         int s, e;
1069
1070         mon = ast_strdupa(MON->u1.str);
1071
1072         /* Check for all days */
1073         if (ast_strlen_zero(mon) || !strcmp(mon, "*"))
1074                 return ;
1075         /* Get start and ending days */
1076         c = strchr(mon, '-');
1077         if (c) {
1078                 *c = '\0';
1079                 c++;
1080         }
1081         /* Find the start */
1082         s = 0;
1083         while ((s < 12) && strcasecmp(mon, months[s])) s++;
1084         if (s >= 12) {
1085                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start month (%s) must be a one of: 'jan', 'feb', ..., 'dec'!\n",
1086                                 MON->filename, MON->startline, MON->endline, mon);
1087                 warns++;
1088         }
1089         if (c) {
1090                 e = 0;
1091                 while ((e < 12) && strcasecmp(mon, months[e])) e++;
1092                 if (e >= 12) {
1093                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end month (%s) must be a one of: 'jan', 'feb', ..., 'dec'!\n",
1094                                         MON->filename, MON->startline, MON->endline, c);
1095                         warns++;
1096                 }
1097         } else
1098                 e = s;
1099 }
1100
1101 static int check_break(pval *item)
1102 {
1103         pval *p = item;
1104
1105         while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
1106                 /* a break is allowed in WHILE, FOR, CASE, DEFAULT, PATTERN; otherwise, it don't make
1107                    no sense */
1108                 if( p->type == PV_CASE || p->type == PV_DEFAULT || p->type == PV_PATTERN
1109                         || p->type == PV_WHILE || p->type == PV_FOR   ) {
1110                         return 1;
1111                 }
1112                 p = p->dad;
1113         }
1114         ast_log(LOG_ERROR,"Error: file %s, line %d-%d: 'break' not in switch, for, or while statement!\n",
1115                         item->filename, item->startline, item->endline);
1116         errs++;
1117
1118         return 0;
1119 }
1120
1121 static int check_continue(pval *item)
1122 {
1123         pval *p = item;
1124
1125         while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
1126                 /* a break is allowed in WHILE, FOR, CASE, DEFAULT, PATTERN; otherwise, it don't make
1127                    no sense */
1128                 if( p->type == PV_WHILE || p->type == PV_FOR   ) {
1129                         return 1;
1130                 }
1131                 p = p->dad;
1132         }
1133         ast_log(LOG_ERROR,"Error: file %s, line %d-%d: 'continue' not in 'for' or 'while' statement!\n",
1134                         item->filename, item->startline, item->endline);
1135         errs++;
1136
1137         return 0;
1138 }
1139
1140 static struct pval *in_macro(pval *item)
1141 {
1142         struct pval *curr;
1143         curr = item;
1144         while( curr ) {
1145                 if( curr->type == PV_MACRO  ) {
1146                         return curr;
1147                 }
1148                 curr = curr->dad;
1149         }
1150         return 0;
1151 }
1152
1153 static struct pval *in_context(pval *item)
1154 {
1155         struct pval *curr;
1156         curr = item;
1157         while( curr ) {
1158                 if( curr->type == PV_MACRO || curr->type == PV_CONTEXT ) {
1159                         return curr;
1160                 }
1161                 curr = curr->dad;
1162         }
1163         return 0;
1164 }
1165
1166
1167 /* general purpose goto finder */
1168
1169 static void check_label(pval *item)
1170 {
1171         struct pval *curr;
1172         struct pval *x;
1173         int alright = 0;
1174
1175         /* A label outside an extension just plain does not make sense! */
1176
1177         curr = item;
1178
1179         while( curr ) {
1180                 if( curr->type == PV_MACRO || curr->type == PV_EXTENSION   ) {
1181                         alright = 1;
1182                         break;
1183                 }
1184                 curr = curr->dad;
1185         }
1186         if( !alright )
1187         {
1188                 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: Label %s is not within an extension or macro!\n",
1189                                 item->filename, item->startline, item->endline, item->u1.str);
1190                 errs++;
1191         }
1192
1193
1194         /* basically, ensure that a label is not repeated in a context. Period.
1195            The method:  well, for each label, find the first label in the context
1196            with the same name. If it's not the current label, then throw an error. */
1197
1198
1199         /* printf("==== check_label:   ====\n"); */
1200         if( !current_extension )
1201                 curr = current_context;
1202         else
1203                 curr = current_extension;
1204
1205         x = find_first_label_in_current_context((char *)item->u1.str, curr);
1206         /* 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); */
1207         if( x && x != item )
1208         {
1209                 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: Duplicate label %s! Previously defined at file %s, line %d.\n",
1210                                 item->filename, item->startline, item->endline, item->u1.str, x->filename, x->startline);
1211                 errs++;
1212         }
1213         /* printf("<<<<< check_label:   ====\n"); */
1214 }
1215
1216 static pval *get_goto_target(pval *item)
1217 {
1218         /* just one item-- the label should be in the current extension */
1219         pval *curr_ext = get_extension_or_contxt(item); /* containing exten, or macro */
1220         pval *curr_cont;
1221
1222         if (item->u1.list && !item->u1.list->next && !strstr((item->u1.list)->u1.str,"${")) {
1223                 struct pval *x = find_label_in_current_extension((char*)((item->u1.list)->u1.str), curr_ext);
1224                         return x;
1225         }
1226
1227         curr_cont = get_contxt(item);
1228
1229         /* TWO items */
1230         if (item->u1.list->next && !item->u1.list->next->next) {
1231                 if (!strstr((item->u1.list)->u1.str,"${")
1232                         && !strstr(item->u1.list->next->u1.str,"${") ) /* Don't try to match variables */ {
1233                         struct pval *x = find_label_in_current_context((char *)item->u1.list->u1.str, (char *)item->u1.list->next->u1.str, curr_cont);
1234                                 return x;
1235                 }
1236         }
1237
1238         /* All 3 items! */
1239         if (item->u1.list->next && item->u1.list->next->next) {
1240                 /* all three */
1241                 pval *first = item->u1.list;
1242                 pval *second = item->u1.list->next;
1243                 pval *third = item->u1.list->next->next;
1244
1245                 if (!strstr((item->u1.list)->u1.str,"${")
1246                         && !strstr(item->u1.list->next->u1.str,"${")
1247                         && !strstr(item->u1.list->next->next->u1.str,"${")) /* Don't try to match variables */ {
1248                         struct pval *x = find_label_in_current_db((char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str);
1249                         if (!x) {
1250
1251                                 struct pval *p3;
1252                                 struct pval *that_context = find_context(item->u1.list->u1.str);
1253
1254                                 /* the target of the goto could be in an included context!! Fancy that!! */
1255                                 /* look for includes in the current context */
1256                                 if (that_context) {
1257                                         for (p3=that_context->u2.statements; p3; p3=p3->next) {
1258                                                 if (p3->type == PV_INCLUDES) {
1259                                                         struct pval *p4;
1260                                                         for (p4=p3->u1.list; p4; p4=p4->next) {
1261                                                                 /* for each context pointed to, find it, then find a context/label that matches the
1262                                                                    target here! */
1263                                                                 char *incl_context = p4->u1.str;
1264                                                                 /* find a matching context name */
1265                                                                 struct pval *that_other_context = find_context(incl_context);
1266                                                                 if (that_other_context) {
1267                                                                         struct pval *x3;
1268                                                                         x3 = find_label_in_current_context((char *)item->u1.list->next->u1.str, (char *)item->u1.list->next->next->u1.str, that_other_context);
1269                                                                         if (x3) {
1270                                                                                 return x3;
1271                                                                         }
1272                                                                 }
1273                                                         }
1274                                                 }
1275                                         }
1276                                 }
1277                         }
1278                         return x;
1279                 }
1280         }
1281         return 0;
1282 }
1283
1284 static void check_goto(pval *item)
1285 {
1286         /* check for the target of the goto-- does it exist? */
1287         if ( !(item->u1.list)->next && !(item->u1.list)->u1.str ) {
1288                 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  empty label reference found!\n",
1289                                 item->filename, item->startline, item->endline);
1290                 errs++;
1291         }
1292
1293         /* just one item-- the label should be in the current extension */
1294
1295         if (item->u1.list && !item->u1.list->next && !strstr((item->u1.list)->u1.str,"${")) {
1296                 struct pval *z = get_extension_or_contxt(item);
1297                 struct pval *x = 0;
1298                 if (z)
1299                         x = find_label_in_current_extension((char*)((item->u1.list)->u1.str), z); /* if in macro, use current context instead */
1300                 /* printf("Called find_label_in_current_extension with arg %s; current_extension is %x: %d\n",
1301                    (char*)((item->u1.list)->u1.str), current_extension?current_extension:current_context, current_extension?current_extension->type:current_context->type); */
1302                 if (!x) {
1303                         ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  no label %s exists in the current extension!\n",
1304                                         item->filename, item->startline, item->endline, item->u1.list->u1.str);
1305                         errs++;
1306                 }
1307                 else
1308                         return;
1309         }
1310
1311         /* TWO items */
1312         if (item->u1.list->next && !item->u1.list->next->next) {
1313                 /* two items */
1314                 /* printf("Calling find_label_in_current_context with args %s, %s\n",
1315                    (char*)((item->u1.list)->u1.str), (char *)item->u1.list->next->u1.str); */
1316                 if (!strstr((item->u1.list)->u1.str,"${")
1317                         && !strstr(item->u1.list->next->u1.str,"${") ) /* Don't try to match variables */ {
1318                         struct pval *z = get_contxt(item);
1319                         struct pval *x = 0;
1320
1321                         if (z)
1322                                 x = find_label_in_current_context((char *)item->u1.list->u1.str, (char *)item->u1.list->next->u1.str, z);
1323
1324                         if (!x) {
1325                                 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",
1326                                                 item->filename, item->startline, item->endline, item->u1.list->u1.str, item->u1.list->next->u1.str );
1327                                 errs++;
1328                         }
1329                         else
1330                                 return;
1331                 }
1332         }
1333
1334         /* All 3 items! */
1335         if (item->u1.list->next && item->u1.list->next->next) {
1336                 /* all three */
1337                 pval *first = item->u1.list;
1338                 pval *second = item->u1.list->next;
1339                 pval *third = item->u1.list->next->next;
1340
1341                 /* printf("Calling find_label_in_current_db with args %s, %s, %s\n",
1342                    (char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str); */
1343                 if (!strstr((item->u1.list)->u1.str,"${")
1344                         && !strstr(item->u1.list->next->u1.str,"${")
1345                         && !strstr(item->u1.list->next->next->u1.str,"${")) /* Don't try to match variables */ {
1346                         struct pval *x = find_label_in_current_db((char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str);
1347                         if (!x) {
1348                                 struct pval *p3;
1349                                 struct pval *found = 0;
1350                                 struct pval *that_context = find_context(item->u1.list->u1.str);
1351
1352                                 /* the target of the goto could be in an included context!! Fancy that!! */
1353                                 /* look for includes in the current context */
1354                                 if (that_context) {
1355                                         for (p3=that_context->u2.statements; p3; p3=p3->next) {
1356                                                 if (p3->type == PV_INCLUDES) {
1357                                                         struct pval *p4;
1358                                                         for (p4=p3->u1.list; p4; p4=p4->next) {
1359                                                                 /* for each context pointed to, find it, then find a context/label that matches the
1360                                                                    target here! */
1361                                                                 char *incl_context = p4->u1.str;
1362                                                                 /* find a matching context name */
1363                                                                 struct pval *that_other_context = find_context(incl_context);
1364                                                                 if (that_other_context) {
1365                                                                         struct pval *x3;
1366                                                                         x3 = find_label_in_current_context((char *)item->u1.list->next->u1.str, (char *)item->u1.list->next->next->u1.str, that_other_context);
1367                                                                         if (x3) {
1368                                                                                 found = x3;
1369                                                                                 break;
1370                                                                         }
1371                                                                 }
1372                                                         }
1373                                                 }
1374                                         }
1375                                         if (!found) {
1376                                                 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto:  no label %s|%s exists in the context %s or its inclusions!\n",
1377                                                                 item->filename, item->startline, item->endline, item->u1.list->next->u1.str, item->u1.list->next->next->u1.str, item->u1.list->u1.str );
1378                                                 errs++;
1379                                         } else {
1380                                                 struct pval *mac = in_macro(item); /* is this goto inside a macro? */
1381                                                 if( mac ) {    /* yes! */
1382                                                         struct pval *targ = in_context(found);
1383                                                         if( mac != targ )
1384                                                         {
1385                                                                 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",
1386                                                                                 item->filename, item->startline, item->endline);
1387                                                                 warns++;
1388                                                         }
1389                                                 }
1390                                         }
1391                                 } else {
1392                                         /* here is where code would go to check for target existence in extensions.conf files */
1393                                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: goto:  no context %s could be found that matches the goto target!\n",
1394                                                         item->filename, item->startline, item->endline, item->u1.list->u1.str);
1395                                         warns++; /* this is just a warning, because this context could be in extensions.conf or somewhere */
1396                                 }
1397                         } else {
1398                                 struct pval *mac = in_macro(item); /* is this goto inside a macro? */
1399                                 if( mac ) {    /* yes! */
1400                                         struct pval *targ = in_context(x);
1401                                         if( mac != targ )
1402                                         {
1403                                                 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",
1404                                                                 item->filename, item->startline, item->endline);
1405                                                 warns++;
1406                                         }
1407                                 }
1408                         }
1409                 }
1410         }
1411 }
1412
1413
1414 static void find_pval_goto_item(pval *item, int lev)
1415 {
1416         struct pval *p4;
1417         if (lev>100) {
1418                 ast_log(LOG_ERROR,"find_pval_goto in infinite loop!\n\n");
1419                 return;
1420         }
1421
1422         switch ( item->type ) {
1423         case PV_MACRO:
1424                 /* fields: item->u1.str     == name of macro
1425                            item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
1426                                    item->u2.arglist->u1.str  == argument
1427                                    item->u2.arglist->next   == next arg
1428
1429                                    item->u3.macro_statements == pval list of statements in macro body.
1430                 */
1431
1432                 /* printf("Descending into matching macro %s\n", match_context); */
1433                 find_pval_gotos(item->u3.macro_statements,lev+1); /* if we're just searching for a context, don't bother descending into them */
1434
1435                 break;
1436
1437         case PV_CONTEXT:
1438                 /* fields: item->u1.str     == name of context
1439                            item->u2.statements == pval list of statements in context body
1440                                    item->u3.abstract == int 1 if an abstract keyword were present
1441                 */
1442                 break;
1443
1444         case PV_CASE:
1445                 /* fields: item->u1.str     == value of case
1446                            item->u2.statements == pval list of statements under the case
1447                 */
1448                 find_pval_gotos(item->u2.statements,lev+1);
1449                 break;
1450
1451         case PV_PATTERN:
1452                 /* fields: item->u1.str     == value of case
1453                            item->u2.statements == pval list of statements under the case
1454                 */
1455                 find_pval_gotos(item->u2.statements,lev+1);
1456                 break;
1457
1458         case PV_DEFAULT:
1459                 /* fields:
1460                            item->u2.statements == pval list of statements under the case
1461                 */
1462                 find_pval_gotos(item->u2.statements,lev+1);
1463                 break;
1464
1465         case PV_CATCH:
1466                 /* fields: item->u1.str     == name of extension to catch
1467                            item->u2.statements == pval list of statements in context body
1468                 */
1469                 find_pval_gotos(item->u2.statements,lev+1);
1470                 break;
1471
1472         case PV_STATEMENTBLOCK:
1473                 /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
1474                 */
1475                 find_pval_gotos(item->u1.list,lev+1);
1476                 break;
1477
1478         case PV_GOTO:
1479                 /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
1480                            item->u1.list->u1.str  == where the data on a PV_WORD will always be.
1481                 */
1482                 check_goto(item);  /* THE WHOLE FUNCTION OF THIS ENTIRE ROUTINE!!!! */
1483                 break;
1484
1485         case PV_INCLUDES:
1486                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
1487                 */
1488                 for (p4=item->u1.list; p4; p4=p4->next) {
1489                         /* for each context pointed to, find it, then find a context/label that matches the
1490                            target here! */
1491                         char *incl_context = p4->u1.str;
1492                         /* find a matching context name */
1493                         struct pval *that_context = find_context(incl_context);
1494                         if (that_context) {
1495                                 find_pval_gotos(that_context,lev+1); /* keep working up the includes */
1496                         }
1497                 }
1498                 break;
1499
1500         case PV_FOR:
1501                 /* fields: item->u1.for_init     == a string containing the initalizer
1502                            item->u2.for_test     == a string containing the loop test
1503                            item->u3.for_inc      == a string containing the loop increment
1504
1505                                    item->u4.for_statements == a pval list of statements in the for ()
1506                 */
1507                 find_pval_gotos(item->u4.for_statements,lev+1);
1508                 break;
1509
1510         case PV_WHILE:
1511                 /* fields: item->u1.str        == the while conditional, as supplied by user
1512
1513                                    item->u2.statements == a pval list of statements in the while ()
1514                 */
1515                 find_pval_gotos(item->u2.statements,lev+1);
1516                 break;
1517
1518         case PV_RANDOM:
1519                 /* fields: item->u1.str        == the random number expression, as supplied by user
1520
1521                                    item->u2.statements == a pval list of statements in the if ()
1522                                    item->u3.else_statements == a pval list of statements in the else
1523                                                                                            (could be zero)
1524                  fall thru to PV_IF */
1525
1526         case PV_IFTIME:
1527                 /* fields: item->u1.list        == the time values, 4 of them, as PV_WORD structs in a list
1528
1529                                    item->u2.statements == a pval list of statements in the if ()
1530                                    item->u3.else_statements == a pval list of statements in the else
1531                                                                                            (could be zero)
1532                 fall thru to PV_IF*/
1533         case PV_IF:
1534                 /* fields: item->u1.str        == the if conditional, as supplied by user
1535
1536                                    item->u2.statements == a pval list of statements in the if ()
1537                                    item->u3.else_statements == a pval list of statements in the else
1538                                                                                            (could be zero)
1539                 */
1540                 find_pval_gotos(item->u2.statements,lev+1);
1541
1542                 if (item->u3.else_statements) {
1543                         find_pval_gotos(item->u3.else_statements,lev+1);
1544                 }
1545                 break;
1546
1547         case PV_SWITCH:
1548                 /* fields: item->u1.str        == the switch expression
1549
1550                                    item->u2.statements == a pval list of statements in the switch,
1551                                                                                         (will be case statements, most likely!)
1552                 */
1553                 find_pval_gotos(item->u3.else_statements,lev+1);
1554                 break;
1555
1556         case PV_EXTENSION:
1557                 /* fields: item->u1.str        == the extension name, label, whatever it's called
1558
1559                                    item->u2.statements == a pval list of statements in the extension
1560                                    item->u3.hints      == a char * hint argument
1561                                    item->u4.regexten   == an int boolean. non-zero says that regexten was specified
1562                 */
1563
1564                 find_pval_gotos(item->u2.statements,lev+1);
1565                 break;
1566
1567         default:
1568                 break;
1569         }
1570 }
1571
1572 static void find_pval_gotos(pval *item,int lev)
1573 {
1574         pval *i;
1575
1576         for (i=item; i; i=i->next) {
1577
1578                 find_pval_goto_item(i, lev);
1579         }
1580 }
1581
1582
1583
1584 /* general purpose label finder */
1585 static struct pval *match_pval_item(pval *item)
1586 {
1587         pval *x;
1588
1589         switch ( item->type ) {
1590         case PV_MACRO:
1591                 /* fields: item->u1.str     == name of macro
1592                            item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
1593                                    item->u2.arglist->u1.str  == argument
1594                                    item->u2.arglist->next   == next arg
1595
1596                                    item->u3.macro_statements == pval list of statements in macro body.
1597                 */
1598                 /* printf("    matching in MACRO %s, match_context=%s; retoncontmtch=%d; \n", item->u1.str, match_context, return_on_context_match); */
1599                 if (!strcmp(match_context,"*") || !strcmp(item->u1.str, match_context)) {
1600
1601                         /* printf("MACRO: match context is: %s\n", match_context); */
1602
1603                         if (return_on_context_match && !strcmp(item->u1.str, match_context)) /* if we're just searching for a context, don't bother descending into them */ {
1604                                 /* printf("Returning on matching macro %s\n", match_context); */
1605                                 return item;
1606                         }
1607
1608
1609                         if (!return_on_context_match) {
1610                                 /* printf("Descending into matching macro %s/%s\n", match_context, item->u1.str); */
1611                                 if ((x=match_pval(item->u3.macro_statements)))  {
1612                                         /* printf("Responded with pval match %x\n", x); */
1613                                         return x;
1614                                 }
1615                         }
1616                 } else {
1617                         /* printf("Skipping context/macro %s\n", item->u1.str); */
1618                 }
1619
1620                 break;
1621
1622         case PV_CONTEXT:
1623                 /* fields: item->u1.str     == name of context
1624                            item->u2.statements == pval list of statements in context body
1625                                    item->u3.abstract == int 1 if an abstract keyword were present
1626                 */
1627                 /* printf("    matching in CONTEXT\n"); */
1628                 if (!strcmp(match_context,"*") || !strcmp(item->u1.str, match_context)) {
1629                         if (return_on_context_match && !strcmp(item->u1.str, match_context)) {
1630                                 /* printf("Returning on matching context %s\n", match_context); */
1631                                 /* printf("non-CONTEXT: Responded with pval match %x\n", x); */
1632                                 return item;
1633                         }
1634
1635                         if (!return_on_context_match ) {
1636                                 /* printf("Descending into matching context %s\n", match_context); */
1637                                 if ((x=match_pval(item->u2.statements))) /* if we're just searching for a context, don't bother descending into them */ {
1638                                         /* printf("CONTEXT: Responded with pval match %x\n", x); */
1639                                         return x;
1640                                 }
1641                         }
1642                 } else {
1643                         /* printf("Skipping context/macro %s\n", item->u1.str); */
1644                 }
1645                 break;
1646
1647         case PV_CASE:
1648                 /* fields: item->u1.str     == value of case
1649                            item->u2.statements == pval list of statements under the case
1650                 */
1651                 /* printf("    matching in CASE\n"); */
1652                 if ((x=match_pval(item->u2.statements))) {
1653                         /* printf("CASE: Responded with pval match %x\n", x); */
1654                         return x;
1655                 }
1656                 break;
1657
1658         case PV_PATTERN:
1659                 /* fields: item->u1.str     == value of case
1660                            item->u2.statements == pval list of statements under the case
1661                 */
1662                 /* printf("    matching in PATTERN\n"); */
1663                 if ((x=match_pval(item->u2.statements))) {
1664                         /* printf("PATTERN: Responded with pval match %x\n", x); */
1665                         return x;
1666                 }
1667                 break;
1668
1669         case PV_DEFAULT:
1670                 /* fields:
1671                            item->u2.statements == pval list of statements under the case
1672                 */
1673                 /* printf("    matching in DEFAULT\n"); */
1674                 if ((x=match_pval(item->u2.statements))) {
1675                         /* printf("DEFAULT: Responded with pval match %x\n", x); */
1676                         return x;
1677                 }
1678                 break;
1679
1680         case PV_CATCH:
1681                 /* fields: item->u1.str     == name of extension to catch
1682                            item->u2.statements == pval list of statements in context body
1683                 */
1684                 /* printf("    matching in CATCH\n"); */
1685                 if (!strcmp(match_exten,"*") || extension_matches(item, match_exten, item->u1.str) ) {
1686                         /* printf("Descending into matching catch %s => %s\n", match_exten, item->u1.str); */
1687                         if (strcmp(match_label,"1") == 0) {
1688                                 if (item->u2.statements) {
1689                                         struct pval *p5 = item->u2.statements;
1690                                         while (p5 && p5->type == PV_LABEL)  /* find the first non-label statement in this context. If it exists, there's a "1" */
1691                                                 p5 = p5->next;
1692                                         if (p5)
1693                                                 return p5;
1694                                         else
1695                                                 return 0;
1696                                 }
1697                                 else
1698                                         return 0;
1699                         }
1700
1701                         if ((x=match_pval(item->u2.statements))) {
1702                                 /* printf("CATCH: Responded with pval match %x\n", (unsigned int)x); */
1703                                 return x;
1704                         }
1705                 } else {
1706                         /* printf("Skipping catch %s\n", item->u1.str); */
1707                 }
1708                 break;
1709
1710         case PV_STATEMENTBLOCK:
1711                 /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
1712                 */
1713                 /* printf("    matching in STATEMENTBLOCK\n"); */
1714                 if ((x=match_pval(item->u1.list))) {
1715                         /* printf("STATEMENTBLOCK: Responded with pval match %x\n", x); */
1716                         return x;
1717                 }
1718                 break;
1719
1720         case PV_LABEL:
1721                 /* fields: item->u1.str     == label name
1722                 */
1723                 /* printf("PV_LABEL %s (cont=%s, exten=%s\n",
1724                    item->u1.str, current_context->u1.str, (current_extension?current_extension->u1.str:"<macro>"));*/
1725
1726                 if (count_labels) {
1727                         if (!strcmp(match_label, item->u1.str)) {
1728                                 label_count++;
1729                                 last_matched_label = item;
1730                         }
1731
1732                 } else {
1733                         if (!strcmp(match_label, item->u1.str)) {
1734                                 /* printf("LABEL: Responded with pval match %x\n", x); */
1735                                 return item;
1736                         }
1737                 }
1738                 break;
1739
1740         case PV_FOR:
1741                 /* fields: item->u1.for_init     == a string containing the initalizer
1742                            item->u2.for_test     == a string containing the loop test
1743                            item->u3.for_inc      == a string containing the loop increment
1744
1745                                    item->u4.for_statements == a pval list of statements in the for ()
1746                 */
1747                 /* printf("    matching in FOR\n"); */
1748                 if ((x=match_pval(item->u4.for_statements))) {
1749                         /* printf("FOR: Responded with pval match %x\n", x);*/
1750                         return x;
1751                 }
1752                 break;
1753
1754         case PV_WHILE:
1755                 /* fields: item->u1.str        == the while conditional, as supplied by user
1756
1757                                    item->u2.statements == a pval list of statements in the while ()
1758                 */
1759                 /* printf("    matching in WHILE\n"); */
1760                 if ((x=match_pval(item->u2.statements))) {
1761                         /* printf("WHILE: Responded with pval match %x\n", x); */
1762                         return x;
1763                 }
1764                 break;
1765
1766         case PV_RANDOM:
1767                 /* fields: item->u1.str        == the random number expression, as supplied by user
1768
1769                                    item->u2.statements == a pval list of statements in the if ()
1770                                    item->u3.else_statements == a pval list of statements in the else
1771                                                                                            (could be zero)
1772                  fall thru to PV_IF */
1773
1774         case PV_IFTIME:
1775                 /* fields: item->u1.list        == the time values, 4 of them, as PV_WORD structs in a list
1776
1777                                    item->u2.statements == a pval list of statements in the if ()
1778                                    item->u3.else_statements == a pval list of statements in the else
1779                                                                                            (could be zero)
1780                 fall thru to PV_IF*/
1781         case PV_IF:
1782                 /* fields: item->u1.str        == the if conditional, as supplied by user
1783
1784                                    item->u2.statements == a pval list of statements in the if ()
1785                                    item->u3.else_statements == a pval list of statements in the else
1786                                                                                            (could be zero)
1787                 */
1788                 /* printf("    matching in IF/IFTIME/RANDOM\n"); */
1789                 if ((x=match_pval(item->u2.statements))) {
1790                         return x;
1791                 }
1792                 if (item->u3.else_statements) {
1793                         if ((x=match_pval(item->u3.else_statements))) {
1794                                 /* printf("IF/IFTIME/RANDOM: Responded with pval match %x\n", x); */
1795                                 return x;
1796                         }
1797                 }
1798                 break;
1799
1800         case PV_SWITCH:
1801                 /* fields: item->u1.str        == the switch expression
1802
1803                                    item->u2.statements == a pval list of statements in the switch,
1804                                                                                         (will be case statements, most likely!)
1805                 */
1806                 /* printf("    matching in SWITCH\n"); */
1807                 if ((x=match_pval(item->u2.statements))) {
1808                         /* printf("SWITCH: Responded with pval match %x\n", x); */
1809                         return x;
1810                 }
1811                 break;
1812
1813         case PV_EXTENSION:
1814                 /* fields: item->u1.str        == the extension name, label, whatever it's called
1815
1816                                    item->u2.statements == a pval list of statements in the extension
1817                                    item->u3.hints      == a char * hint argument
1818                                    item->u4.regexten   == an int boolean. non-zero says that regexten was specified
1819                 */
1820                 /* printf("    matching in EXTENSION\n"); */
1821                 if (!strcmp(match_exten,"*") || extension_matches(item, match_exten, item->u1.str) ) {
1822                         /* printf("Descending into matching exten %s => %s\n", match_exten, item->u1.str); */
1823                         if (strcmp(match_label,"1") == 0) {
1824                                 if (item->u2.statements) {
1825                                         struct pval *p5 = item->u2.statements;
1826                                         while (p5 && p5->type == PV_LABEL)  /* find the first non-label statement in this context. If it exists, there's a "1" */
1827                                                 p5 = p5->next;
1828                                         if (p5)
1829                                                 return p5;
1830                                         else
1831                                                 return 0;
1832                                 }
1833                                 else
1834                                         return 0;
1835                         }
1836
1837                         if ((x=match_pval(item->u2.statements))) {
1838                                 /* printf("EXTENSION: Responded with pval match %x\n", x); */
1839                                 return x;
1840                         }
1841                 } else {
1842                         /* printf("Skipping exten %s\n", item->u1.str); */
1843                 }
1844                 break;
1845         default:
1846                 /* printf("    matching in default = %d\n", item->type); */
1847                 break;
1848         }
1849         return 0;
1850 }
1851
1852 struct pval *match_pval(pval *item)
1853 {
1854         pval *i;
1855
1856         for (i=item; i; i=i->next) {
1857                 pval *x;
1858                 /* printf("   -- match pval: item %d\n", i->type); */
1859
1860                 if ((x = match_pval_item(i))) {
1861                         /* printf("match_pval: returning x=%x\n", (int)x); */
1862                         return x; /* cut the search short */
1863                 }
1864         }
1865         return 0;
1866 }
1867
1868 #if 0
1869 int count_labels_in_current_context(char *label)
1870 {
1871         label_count = 0;
1872         count_labels = 1;
1873         return_on_context_match = 0;
1874         match_pval(current_context->u2.statements);
1875
1876         return label_count;
1877 }
1878 #endif
1879
1880 struct pval *find_first_label_in_current_context(char *label, pval *curr_cont)
1881 {
1882         /* printf("  --- Got args %s, %s\n", exten, label); */
1883         struct pval *ret;
1884         struct pval *p3;
1885         struct pval *startpt = ((curr_cont->type==PV_MACRO)?curr_cont->u3.macro_statements: curr_cont->u2.statements);
1886
1887         count_labels = 0;
1888         return_on_context_match = 0;
1889         match_context = "*";
1890         match_exten = "*";
1891         match_label = label;
1892
1893         ret =  match_pval(curr_cont);
1894         if (ret)
1895                 return ret;
1896
1897         /* the target of the goto could be in an included context!! Fancy that!! */
1898         /* look for includes in the current context */
1899         for (p3=startpt; p3; p3=p3->next) {
1900                 if (p3->type == PV_INCLUDES) {
1901                         struct pval *p4;
1902                         for (p4=p3->u1.list; p4; p4=p4->next) {
1903                                 /* for each context pointed to, find it, then find a context/label that matches the
1904                                    target here! */
1905                                 char *incl_context = p4->u1.str;
1906                                 /* find a matching context name */
1907                                 struct pval *that_context = find_context(incl_context);
1908                                 if (that_context) {
1909                                         struct pval *x3;
1910                                         x3 = find_first_label_in_current_context(label, that_context);
1911                                         if (x3) {
1912                                                 return x3;
1913                                         }
1914                                 }
1915                         }
1916                 }
1917         }
1918         return 0;
1919 }
1920
1921 struct pval *find_label_in_current_context(char *exten, char *label, pval *curr_cont)
1922 {
1923         /* printf("  --- Got args %s, %s\n", exten, label); */
1924         struct pval *ret;
1925         struct pval *p3;
1926         struct pval *startpt;
1927
1928         count_labels = 0;
1929         return_on_context_match = 0;
1930         match_context = "*";
1931         match_exten = exten;
1932         match_label = label;
1933         if (curr_cont->type == PV_MACRO)
1934                 startpt = curr_cont->u3.macro_statements;
1935         else
1936                 startpt = curr_cont->u2.statements;
1937
1938         ret =  match_pval(startpt);
1939         if (ret)
1940                 return ret;
1941
1942         /* the target of the goto could be in an included context!! Fancy that!! */
1943         /* look for includes in the current context */
1944         for (p3=startpt; p3; p3=p3->next) {
1945                 if (p3->type == PV_INCLUDES) {
1946                         struct pval *p4;
1947                         for (p4=p3->u1.list; p4; p4=p4->next) {
1948                                 /* for each context pointed to, find it, then find a context/label that matches the
1949                                    target here! */
1950                                 char *incl_context = p4->u1.str;
1951                                 /* find a matching context name */
1952                                 struct pval *that_context = find_context(incl_context);
1953                                 if (that_context) {
1954                                         struct pval *x3;
1955                                         x3 = find_label_in_current_context(exten, label, that_context);
1956                                         if (x3) {
1957                                                 return x3;
1958                                         }
1959                                 }
1960                         }
1961                 }
1962         }
1963         return 0;
1964 }
1965
1966 static struct pval *find_label_in_current_extension(const char *label, pval *curr_ext)
1967 {
1968         /* printf("  --- Got args %s\n", label); */
1969         count_labels = 0;
1970         return_on_context_match = 0;
1971         match_context = "*";
1972         match_exten = "*";
1973         match_label = label;
1974         return match_pval(curr_ext);
1975 }
1976
1977 static struct pval *find_label_in_current_db(const char *context, const char *exten, const char *label)
1978 {
1979         /* printf("  --- Got args %s, %s, %s\n", context, exten, label); */
1980         count_labels = 0;
1981         return_on_context_match = 0;
1982
1983         match_context = context;
1984         match_exten = exten;
1985         match_label = label;
1986
1987         return match_pval(current_db);
1988 }
1989
1990
1991 struct pval *find_macro(char *name)
1992 {
1993         return_on_context_match = 1;
1994         count_labels = 0;
1995         match_context = name;
1996         match_exten = "*";  /* don't really need to set these, shouldn't be reached */
1997         match_label = "*";
1998         return match_pval(current_db);
1999 }
2000
2001 struct pval *find_context(char *name)
2002 {
2003         return_on_context_match = 1;
2004         count_labels = 0;
2005         match_context = name;
2006         match_exten = "*";  /* don't really need to set these, shouldn't be reached */
2007         match_label = "*";
2008         return match_pval(current_db);
2009 }
2010
2011 int is_float(char *arg )
2012 {
2013         char *s;
2014         for (s=arg; *s; s++) {
2015                 if (*s != '.' && (*s < '0' || *s > '9'))
2016                         return 0;
2017         }
2018         return 1;
2019 }
2020 int is_int(char *arg )
2021 {
2022         char *s;
2023         for (s=arg; *s; s++) {
2024                 if (*s < '0' || *s > '9')
2025                         return 0;
2026         }
2027         return 1;
2028 }
2029 int is_empty(char *arg)
2030 {
2031         if (!arg)
2032                 return 1;
2033         if (*arg == 0)
2034                 return 1;
2035         while (*arg) {
2036                 if (*arg != ' ' && *arg != '\t')
2037                         return 0;
2038                 arg++;
2039         }
2040         return 1;
2041 }
2042
2043 #ifdef AAL_ARGCHECK
2044 int option_matches_j( struct argdesc *should, pval *is, struct argapp *app)
2045 {
2046         struct argchoice *ac;
2047         char *opcop,*q,*p;
2048
2049         switch (should->dtype) {
2050         case ARGD_OPTIONSET:
2051                 if ( strstr(is->u1.str,"${") )
2052                         return 0;  /* no checking anything if there's a var reference in there! */
2053
2054                 opcop = ast_strdupa(is->u1.str);
2055
2056                 for (q=opcop;*q;q++) { /* erase the innards of X(innard) type arguments, so we don't get confused later */
2057                         if ( *q == '(' ) {
2058                                 p = q+1;
2059                                 while (*p && *p != ')' )
2060                                         *p++ = '+';
2061                                 q = p+1;
2062                         }
2063                 }
2064
2065                 for (ac=app->opts; ac; ac=ac->next) {
2066                         if (strlen(ac->name)>1  && strchr(ac->name,'(') == 0 && strcmp(ac->name,is->u1.str) == 0) /* multichar option, no parens, and a match? */
2067                                 return 0;
2068                 }
2069                 for (ac=app->opts; ac; ac=ac->next) {
2070                         if (strlen(ac->name)==1  ||  strchr(ac->name,'(')) {
2071                                 char *p = strchr(opcop,ac->name[0]);  /* wipe out all matched options in the user-supplied string */
2072
2073                                 if (p && *p == 'j') {
2074                                         ast_log(LOG_ERROR, "Error: file %s, line %d-%d: The j option in the %s application call is not appropriate for AEL!\n",
2075                                                         is->filename, is->startline, is->endline, app->name);
2076                                         errs++;
2077                                 }
2078
2079                                 if (p) {
2080                                         *p = '+';
2081                                         if (ac->name[1] == '(') {
2082                                                 if (*(p+1) != '(') {
2083                                                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The %c option in the %s application call should have an (argument), but doesn't!\n",
2084                                                                         is->filename, is->startline, is->endline, ac->name[0], app->name);
2085                                                         warns++;
2086                                                 }
2087                                         }
2088                                 }
2089                         }
2090                 }
2091                 for (q=opcop; *q; q++) {
2092                         if ( *q != '+' && *q != '(' && *q != ')') {
2093                                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The %c option in the %s application call is not available as an option!\n",
2094                                                 is->filename, is->startline, is->endline, *q, app->name);
2095                                 warns++;
2096                         }
2097                 }
2098                 return 1;
2099                 break;
2100         default:
2101                 return 0;
2102         }
2103
2104 }
2105
2106 int option_matches( struct argdesc *should, pval *is, struct argapp *app)
2107 {
2108         struct argchoice *ac;
2109         char *opcop;
2110
2111         switch (should->dtype) {
2112         case ARGD_STRING:
2113                 if (is_empty(is->u1.str) && should->type == ARGD_REQUIRED)
2114                         return 0;
2115                 if (is->u1.str && strlen(is->u1.str) > 0) /* most will match */
2116                         return 1;
2117                 break;
2118
2119         case ARGD_INT:
2120                 if (is_int(is->u1.str))
2121                         return 1;
2122                 else
2123                         return 0;
2124                 break;
2125
2126         case ARGD_FLOAT:
2127                 if (is_float(is->u1.str))
2128                         return 1;
2129                 else
2130                         return 0;
2131                 break;
2132
2133         case ARGD_ENUM:
2134                 if( !is->u1.str || strlen(is->u1.str) == 0 )
2135                         return 1; /* a null arg in the call will match an enum, I guess! */
2136                 for (ac=should->choices; ac; ac=ac->next) {
2137                         if (strcmp(ac->name,is->u1.str) == 0)
2138                                 return 1;
2139                 }
2140                 return 0;
2141                 break;
2142
2143         case ARGD_OPTIONSET:
2144                 opcop = ast_strdupa(is->u1.str);
2145
2146                 for (ac=app->opts; ac; ac=ac->next) {
2147                         if (strlen(ac->name)>1  && strchr(ac->name,'(') == 0 && strcmp(ac->name,is->u1.str) == 0) /* multichar option, no parens, and a match? */
2148                                 return 1;
2149                 }
2150                 for (ac=app->opts; ac; ac=ac->next) {
2151                         if (strlen(ac->name)==1  ||  strchr(ac->name,'(')) {
2152                                 char *p = strchr(opcop,ac->name[0]);  /* wipe out all matched options in the user-supplied string */
2153
2154                                 if (p) {
2155                                         *p = '+';
2156                                         if (ac->name[1] == '(') {
2157                                                 if (*(p+1) == '(') {
2158                                                         char *q = p+1;
2159                                                         while (*q && *q != ')') {
2160                                                                 *q++ = '+';
2161                                                         }
2162                                                         *q = '+';
2163                                                 }
2164                                         }
2165                                 }
2166                         }
2167                 }
2168                 return 1;
2169                 break;
2170         case ARGD_VARARG:
2171                 return 1; /* matches anything */
2172                 break;
2173         }
2174         return 1; /* unless some for-sure match or non-match returns, then it must be close enough ... */
2175 }
2176 #endif
2177
2178 int check_app_args(pval* appcall, pval *arglist, struct argapp *app)
2179 {
2180 #ifdef AAL_ARGCHECK
2181         struct argdesc *ad = app->args;
2182         pval *pa;
2183         int z;
2184
2185         for (pa = arglist; pa; pa=pa->next) {
2186                 if (!ad) {
2187                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Extra argument %s not in application call to %s !\n",
2188                                         arglist->filename, arglist->startline, arglist->endline, pa->u1.str, app->name);
2189                         warns++;
2190                         return 1;
2191                 } else {
2192                         /* find the first entry in the ad list that will match */
2193                         do {
2194                                 if ( ad->dtype == ARGD_VARARG ) /* once we hit the VARARG, all bets are off. Discontinue the comparisons */
2195                                         break;
2196
2197                                 z= option_matches( ad, pa, app);
2198                                 if (!z) {
2199                                         if ( !arglist )
2200                                                 arglist=appcall;
2201
2202                                         if (ad->type == ARGD_REQUIRED) {
2203                                                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
2204                                                                 arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
2205                                                 warns++;
2206                                                 return 1;
2207                                         }
2208                                 } else if (z && ad->dtype == ARGD_OPTIONSET) {
2209                                         option_matches_j( ad, pa, app);
2210                                 }
2211                                 ad = ad->next;
2212                         } while (ad && !z);
2213                 }
2214         }
2215         /* any app nodes left, that are not optional? */
2216         for ( ; ad; ad=ad->next) {
2217                 if (ad->type == ARGD_REQUIRED && ad->dtype != ARGD_VARARG) {
2218                         if ( !arglist )
2219                                 arglist=appcall;
2220                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
2221                                         arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
2222                         warns++;
2223                         return 1;
2224                 }
2225         }
2226         return 0;
2227 #else
2228         return 0;
2229 #endif
2230 }
2231
2232 void check_switch_expr(pval *item, struct argapp *apps)
2233 {
2234 #ifdef AAL_ARGCHECK
2235         /* get and clean the variable name */
2236         char *buff1, *p;
2237         struct argapp *a,*a2;
2238         struct appsetvar *v,*v2;
2239         struct argchoice *c;
2240         pval *t;
2241
2242         p = item->u1.str;
2243         while (p && *p && (*p == ' ' || *p == '\t' || *p == '$' || *p == '{' ) )
2244                 p++;
2245
2246         buff1 = ast_strdupa(p);
2247
2248         while (strlen(buff1) > 0 && ( buff1[strlen(buff1)-1] == '}' || buff1[strlen(buff1)-1] == ' ' || buff1[strlen(buff1)-1] == '\t'))
2249                 buff1[strlen(buff1)-1] = 0;
2250         /* buff1 now contains the variable name */
2251         v = 0;
2252         for (a=apps; a; a=a->next) {
2253                 for (v=a->setvars;v;v=v->next) {
2254                         if (strcmp(v->name,buff1) == 0) {
2255                                 break;
2256                         }
2257                 }
2258                 if ( v )
2259                         break;
2260         }
2261         if (v && v->vals) {
2262                 /* we have a match, to a variable that has a set of determined values */
2263                 int def= 0;
2264                 int pat = 0;
2265                 int f1 = 0;
2266
2267                 /* first of all, does this switch have a default case ? */
2268                 for (t=item->u2.statements; t; t=t->next) {
2269                         if (t->type == PV_DEFAULT) {
2270                                 def =1;
2271                                 break;
2272                         }
2273                         if (t->type == PV_PATTERN) {
2274                                 pat++;
2275                         }
2276                 }
2277                 if (def || pat) /* nothing to check. All cases accounted for! */
2278                         return;
2279                 for (c=v->vals; c; c=c->next) {
2280                         f1 = 0;
2281                         for (t=item->u2.statements; t; t=t->next) {
2282                                 if (t->type == PV_CASE || t->type == PV_PATTERN) {
2283                                         if (!strcmp(t->u1.str,c->name)) {
2284                                                 f1 = 1;
2285                                                 break;
2286                                         }
2287                                 }
2288                         }
2289                         if (!f1) {
2290                                 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: switch with expression(%s) does not handle the case of %s !\n",
2291                                                 item->filename, item->startline, item->endline, item->u1.str, c->name);
2292                                 warns++;
2293                         }
2294                 }
2295                 /* next, is there an app call in the current exten, that would set this var? */
2296                 f1 = 0;
2297                 t = current_extension->u2.statements;
2298                 if ( t && t->type == PV_STATEMENTBLOCK )
2299                         t = t->u1.statements;
2300                 for (; t && t != item; t=t->next) {
2301                         if (t->type == PV_APPLICATION_CALL) {
2302                                 /* find the application that matches the u1.str */
2303                                 for (a2=apps; a2; a2=a2->next) {
2304                                         if (strcasecmp(a2->name, t->u1.str)==0) {
2305                                                 for (v2=a2->setvars; v2; v2=v2->next) {
2306                                                         if (strcmp(v2->name, buff1) == 0) {
2307                                                                 /* found an app that sets the var */
2308                                                                 f1 = 1;
2309                                                                 break;
2310                                                         }
2311                                                 }
2312                                         }
2313                                         if (f1)
2314                                                 break;
2315                                 }
2316                         }
2317                         if (f1)
2318                                 break;
2319                 }
2320
2321                 /* see if it sets the var */
2322                 if (!f1) {
2323                         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",
2324                                         item->filename, item->startline, item->endline, item->u1.str);
2325                         warns++;
2326                 }
2327         }
2328 #endif
2329 }
2330
2331 static void check_context_names(void)
2332 {
2333         pval *i,*j;
2334         for (i=current_db; i; i=i->next) {
2335                 if (i->type == PV_CONTEXT || i->type == PV_MACRO) {
2336                         for (j=i->next; j; j=j->next) {
2337                                 if ( j->type == PV_CONTEXT || j->type == PV_MACRO ) {
2338                                         if ( !strcmp(i->u1.str, j->u1.str) )
2339                                         {
2340                                                 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: The context name (%s) is also declared in file %s, line %d-%d!\n",
2341                                                                 i->filename, i->startline, i->endline, i->u1.str,  j->filename, j->startline, j->endline);
2342                                                 errs++;
2343                                         }
2344                                 }
2345                         }
2346                 }
2347         }
2348 }
2349
2350 static void check_abstract_reference(pval *abstract_context)
2351 {
2352         pval *i,*j;
2353         /* find some context includes that reference this context */
2354
2355
2356         /* otherwise, print out a warning */
2357         for (i=current_db; i; i=i->next) {
2358                 if (i->type == PV_CONTEXT) {
2359                         for (j=i->u2. statements; j; j=j->next) {
2360                                 if ( j->type == PV_INCLUDES ) {
2361                                         struct pval *p4;
2362                                         for (p4=j->u1.list; p4; p4=p4->next) {
2363                                                 /* for each context pointed to, find it, then find a context/label that matches the
2364                                                    target here! */
2365                                                 if ( !strcmp(p4->u1.str, abstract_context->u1.str) )
2366                                                         return; /* found a match! */
2367                                         }
2368                                 }
2369                         }
2370                 }
2371         }
2372         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",
2373                         abstract_context->filename, abstract_context->startline, abstract_context->endline, abstract_context->u1.str);
2374         warns++;
2375 }
2376
2377
2378 void check_pval_item(pval *item, struct argapp *apps, int in_globals)
2379 {
2380         pval *lp;
2381 #ifdef AAL_ARGCHECK
2382         struct argapp *app, *found;
2383 #endif
2384         struct pval *macro_def;
2385         struct pval *app_def;
2386
2387         char errmsg[4096];
2388         char *strp;
2389
2390         switch (item->type) {
2391         case PV_WORD:
2392                 /* fields: item->u1.str == string associated with this (word).
2393                            item->u2.arglist  == pval list of 4 PV_WORD elements for time values (only in PV_INCLUDES) */
2394                 break;
2395
2396         case PV_MACRO:
2397                 /* fields: item->u1.str     == name of macro
2398                            item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
2399                                    item->u2.arglist->u1.str  == argument
2400                                    item->u2.arglist->next   == next arg
2401
2402                                    item->u3.macro_statements == pval list of statements in macro body.
2403                 */
2404                 in_abstract_context = 0;
2405                 current_context = item;
2406                 current_extension = 0;
2407
2408                 check_macro_returns(item);
2409
2410                 for (lp=item->u2.arglist; lp; lp=lp->next) {
2411
2412                 }
2413                 check_pval(item->u3.macro_statements, apps,in_globals);
2414                 break;
2415
2416         case PV_CONTEXT:
2417                 /* fields: item->u1.str     == name of context
2418                            item->u2.statements == pval list of statements in context body
2419                                    item->u3.abstract == int 1 if an abstract keyword were present
2420                 */
2421                 current_context = item;
2422                 current_extension = 0;
2423                 if ( item->u3.abstract ) {
2424                         in_abstract_context = 1;
2425                         check_abstract_reference(item);
2426                 } else
2427                         in_abstract_context = 0;
2428                 check_pval(item->u2.statements, apps,in_globals);
2429                 break;
2430
2431         case PV_MACRO_CALL:
2432                 /* fields: item->u1.str     == name of macro to call
2433                            item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
2434                                    item->u2.arglist->u1.str  == argument
2435                                    item->u2.arglist->next   == next arg
2436                 */
2437                 macro_def = find_macro(item->u1.str);
2438                 if (!macro_def) {
2439                         /* here is a good place to check to see if the definition is in extensions.conf! */
2440                         ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to non-existent %s ! Hopefully it is present in extensions.conf! \n",
2441                                         item->filename, item->startline, item->endline, item->u1.str);
2442                         warns++;
2443                 } else if (macro_def->type != PV_MACRO) {
2444                         ast_log(LOG_ERROR,"Error: file %s, line %d-%d: macro call to %s references a context, not a macro!\n",
2445                                         item->filename, item->startline, item->endline, item->u1.str);
2446                         errs++;
2447                 } else {
2448                         /* macro_def is a MACRO, so do the args match in number? */
2449                         int hereargs = 0;
2450                         int thereargs = 0;
2451
2452                         for (lp=item->u2.arglist; lp; lp=lp->next) {
2453                                 hereargs++;
2454                         }
2455                         for (lp=macro_def->u2.arglist; lp; lp=lp->next) {
2456                                 thereargs++;
2457                         }
2458                         if (hereargs != thereargs ) {
2459                                 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",
2460                                                 item->filename, item->startline, item->endline, item->u1.str, hereargs, thereargs);
2461                                 errs++;
2462                         }
2463                 }
2464                 break;
2465
2466         case PV_APPLICATION_CALL:
2467                 /* fields: item->u1.str     == name of application to call
2468                            item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
2469                                    item->u2.arglist->u1.str  == argument
2470                                    item->u2.arglist->next   == next arg
2471                 */
2472                 /* Need to check to see if the application is available! */
2473                 app_def = find_context(item->u1.str);
2474                 if (app_def && app_def->type == PV_MACRO) {
2475                         ast_log(LOG_ERROR,"Error: file %s, line %d-%d: application call to %s references an existing macro, but had no & preceding it!\n",
2476                                         item->filename, item->startline, item->endline, item->u1.str);
2477                         errs++;
2478                 }
2479                 if (strcasecmp(item->u1.str,"GotoIf") == 0
2480                         || strcasecmp(item->u1.str,"GotoIfTime") == 0
2481                         || strcasecmp(item->u1.str,"while") == 0
2482                         || strcasecmp(item->u1.str,"endwhile") == 0
2483                         || strcasecmp(item->u1.str,"random") == 0
2484                         || strcasecmp(item->u1.str,"gosub") == 0
2485                         || strcasecmp(item->u1.str,"return") == 0
2486                         || strcasecmp(item->u1.str,"gosubif") == 0
2487                         || strcasecmp(item->u1.str,"continuewhile") == 0
2488                         || strcasecmp(item->u1.str,"endwhile") == 0
2489                         || strcasecmp(item->u1.str,"execif") == 0
2490                         || strcasecmp(item->u1.str,"execiftime") == 0
2491                         || strcasecmp(item->u1.str,"exitwhile") == 0
2492                         || strcasecmp(item->u1.str,"goto") == 0
2493                         || strcasecmp(item->u1.str,"macro") == 0
2494                         || strcasecmp(item->u1.str,"macroexclusive") == 0
2495                         || strcasecmp(item->u1.str,"macroif") == 0
2496                         || strcasecmp(item->u1.str,"stackpop") == 0
2497                         || strcasecmp(item->u1.str,"execIf") == 0 ) {
2498                         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",
2499                                         item->filename, item->startline, item->endline, item->u1.str);
2500                         warns++;
2501                 }
2502                 if (strcasecmp(item->u1.str,"macroexit") == 0) {
2503                                 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: I am converting the MacroExit call here to a return statement.\n",
2504                                                 item->filename, item->startline, item->endline);
2505                                 item->type = PV_RETURN;
2506                                 free(item->u1.str);
2507                                 item->u1.str = 0;
2508                 }
2509
2510 #ifdef AAL_ARGCHECK
2511                 found = 0;
2512                 for (app=apps; app; app=app->next) {
2513                         if (strcasecmp(app->name, item->u1.str) == 0) {
2514                                 found =app;
2515                                 break;
2516                         }
2517                 }
2518                 if (!found) {
2519                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: application call to %s not listed in applist database!\n",
2520                                         item->filename, item->startline, item->endline, item->u1.str);
2521                         warns++;
2522                 } else
2523                         check_app_args(item, item->u2.arglist, app);
2524 #endif
2525                 break;
2526
2527         case PV_CASE:
2528                 /* fields: item->u1.str     == value of case
2529                            item->u2.statements == pval list of statements under the case
2530                 */
2531                 /* Make sure sequence of statements under case is terminated with  goto, return, or break */
2532                 /* find the last statement */
2533                 check_pval(item->u2.statements, apps,in_globals);
2534                 break;
2535
2536         case PV_PATTERN:
2537                 /* fields: item->u1.str     == value of case
2538                            item->u2.statements == pval list of statements under the case
2539                 */
2540                 /* Make sure sequence of statements under case is terminated with  goto, return, or break */
2541                 /* find the last statement */
2542
2543                 check_pval(item->u2.statements, apps,in_globals);
2544                 break;
2545
2546         case PV_DEFAULT:
2547                 /* fields:
2548                            item->u2.statements == pval list of statements under the case
2549                 */
2550
2551                 check_pval(item->u2.statements, apps,in_globals);
2552                 break;
2553
2554         case PV_CATCH:
2555                 /* fields: item->u1.str     == name of extension to catch
2556                            item->u2.statements == pval list of statements in context body
2557                 */
2558                 check_pval(item->u2.statements, apps,in_globals);
2559                 break;
2560
2561         case PV_SWITCHES:
2562                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
2563                 */
2564                 check_pval(item->u1.list, apps,in_globals);
2565                 break;
2566
2567         case PV_ESWITCHES:
2568                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
2569                 */
2570                 check_pval(item->u1.list, apps,in_globals);
2571                 break;
2572
2573         case PV_INCLUDES:
2574                 /* fields: item->u1.list     == pval list of PV_WORD elements, one per entry in the list
2575                 */
2576                 check_pval(item->u1.list, apps,in_globals);
2577                 check_includes(item);
2578                 for (lp=item->u1.list; lp; lp=lp->next){
2579                         char *incl_context = lp->u1.str;
2580                         struct pval *that_context = find_context(incl_context);
2581
2582                         if ( lp->u2.arglist ) {
2583                                 check_timerange(lp->u2.arglist);
2584                                 check_dow(lp->u2.arglist->next);
2585                                 check_day(lp->u2.arglist->next->next);
2586                                 check_month(lp->u2.arglist->next->next->next);
2587                         }
2588
2589                         if (that_context) {
2590                                 find_pval_gotos(that_context->u2.statements,0);
2591
2592                         }
2593                 }
2594                 break;
2595
2596         case PV_STATEMENTBLOCK:
2597                 /* fields: item->u1.list     == pval list of statements in block, one per entry in the list
2598                 */
2599                 check_pval(item->u1.list, apps,in_globals);
2600                 break;
2601
2602         case PV_VARDEC:
2603                 /* fields: item->u1.str     == variable name
2604                            item->u2.val     == variable value to assign
2605                 */
2606                 /* the RHS of a vardec is encapsulated in a $[] expr. Is it legal? */
2607                 if( !in_globals ) { /* don't check stuff inside the globals context; no wrapping in $[ ] there... */
2608                         snprintf(errmsg,sizeof(errmsg), "file %s, line %d, columns %d-%d, variable declaration expr '%s':", config, item->startline, item->startcol, item->endcol, item->u2.val);
2609                         ast_expr_register_extra_error_info(errmsg);
2610                         ast_expr(item->u2.val, expr_output, sizeof(expr_output));
2611                         ast_expr_clear_extra_error_info();
2612                         if ( strpbrk(item->u2.val,"~!-+<>=*/&^") && !strstr(item->u2.val,"${") ) {
2613                                 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2614                                                 item->filename, item->startline, item->endline, item->u2.val);
2615                                 warns++;
2616                         }
2617                         check_expr2_input(item,item->u2.val);
2618                 }
2619                 break;
2620
2621         case PV_GOTO:
2622                 /* fields: item->u1.list     == pval list of PV_WORD target names, up to 3, in order as given by user.
2623                            item->u1.list->u1.str  == where the data on a PV_WORD will always be.
2624                 */
2625                 /* don't check goto's in abstract contexts */
2626                 if ( in_abstract_context )
2627                         break;
2628
2629                 check_goto(item);
2630                 break;
2631
2632         case PV_LABEL:
2633                 /* fields: item->u1.str     == label name
2634                 */
2635                 if ( strspn(item->u1.str, "0123456789") == strlen(item->u1.str) ) {
2636                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: label '%s' is numeric, this is bad practice!\n",
2637                                         item->filename, item->startline, item->endline, item->u1.str);
2638                         warns++;
2639                 }
2640
2641                 check_label(item);
2642                 break;
2643
2644         case PV_FOR:
2645                 /* fields: item->u1.for_init     == a string containing the initalizer
2646                            item->u2.for_test     == a string containing the loop test
2647                            item->u3.for_inc      == a string containing the loop increment
2648
2649                                    item->u4.for_statements == a pval list of statements in the for ()
2650                 */
2651                 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, for test expr '%s':", config, item->startline, item->startcol, item->endcol, item->u2.for_test);
2652                 ast_expr_register_extra_error_info(errmsg);
2653
2654                 strp = strchr(item->u1.for_init, '=');
2655                 if (strp) {
2656                         ast_expr(strp+1, expr_output, sizeof(expr_output));
2657                 }
2658                 ast_expr(item->u2.for_test, expr_output, sizeof(expr_output));
2659                 strp = strchr(item->u3.for_inc, '=');
2660                 if (strp) {
2661                         ast_expr(strp+1, expr_output, sizeof(expr_output));
2662                 }
2663                 if ( strpbrk(item->u2.for_test,"~!-+<>=*/&^") && !strstr(item->u2.for_test,"${") ) {
2664                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2665                                         item->filename, item->startline, item->endline, item->u2.for_test);
2666                         warns++;
2667                 }
2668                 if ( strpbrk(item->u3.for_inc,"~!-+<>=*/&^") && !strstr(item->u3.for_inc,"${") ) {
2669                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2670                                         item->filename, item->startline, item->endline, item->u3.for_inc);
2671                         warns++;
2672                 }
2673                 check_expr2_input(item,item->u2.for_test);
2674                 check_expr2_input(item,item->u3.for_inc);
2675
2676                 ast_expr_clear_extra_error_info();
2677                 check_pval(item->u4.for_statements, apps,in_globals);
2678                 break;
2679
2680         case PV_WHILE:
2681                 /* fields: item->u1.str        == the while conditional, as supplied by user
2682
2683                                    item->u2.statements == a pval list of statements in the while ()
2684                 */
2685                 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, while expr '%s':", config, item->startline, item->startcol, item->endcol, item->u1.str);
2686                 ast_expr_register_extra_error_info(errmsg);
2687                 ast_expr(item->u1.str, expr_output, sizeof(expr_output));
2688                 ast_expr_clear_extra_error_info();
2689                 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2690                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2691                                         item->filename, item->startline, item->endline, item->u1.str);
2692                         warns++;
2693                 }
2694                 check_expr2_input(item,item->u1.str);
2695                 check_pval(item->u2.statements, apps,in_globals);
2696                 break;
2697
2698         case PV_BREAK:
2699                 /* fields: none
2700                 */
2701                 check_break(item);
2702                 break;
2703
2704         case PV_RETURN:
2705                 /* fields: none
2706                 */
2707                 break;
2708
2709         case PV_CONTINUE:
2710                 /* fields: none
2711                 */
2712                 check_continue(item);
2713                 break;
2714
2715         case PV_RANDOM:
2716                 /* fields: item->u1.str        == the random number expression, as supplied by user
2717
2718                                    item->u2.statements == a pval list of statements in the if ()
2719                                    item->u3.else_statements == a pval list of statements in the else
2720                                                                                            (could be zero)
2721                 */
2722                 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, random expr '%s':", config, item->startline, item->startcol, item->endcol, item->u1.str);
2723                 ast_expr_register_extra_error_info(errmsg);
2724                 ast_expr(item->u1.str, expr_output, sizeof(expr_output));
2725                 ast_expr_clear_extra_error_info();
2726                 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2727                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: random expression '%s' has operators, but no variables. Interesting...\n",
2728                                         item->filename, item->startline, item->endline, item->u1.str);
2729                         warns++;
2730                 }
2731                 check_expr2_input(item,item->u1.str);
2732                 check_pval(item->u2.statements, apps,in_globals);
2733                 if (item->u3.else_statements) {
2734                         check_pval(item->u3.else_statements, apps,in_globals);
2735                 }
2736                 break;
2737
2738         case PV_IFTIME:
2739                 /* fields: item->u1.list        == the if time values, 4 of them, each in PV_WORD, linked list
2740
2741                                    item->u2.statements == a pval list of statements in the if ()
2742                                    item->u3.else_statements == a pval list of statements in the else
2743                                                                                            (could be zero)
2744                 */
2745                 if ( item->u2.arglist ) {
2746                         check_timerange(item->u1.list);
2747                         check_dow(item->u1.list->next);
2748                         check_day(item->u1.list->next->next);
2749                         check_month(item->u1.list->next->next->next);
2750                 }
2751
2752                 check_pval(item->u2.statements, apps,in_globals);
2753                 if (item->u3.else_statements) {
2754                         check_pval(item->u3.else_statements, apps,in_globals);
2755                 }
2756                 break;
2757
2758         case PV_IF:
2759                 /* fields: item->u1.str        == the if conditional, as supplied by user
2760
2761                                    item->u2.statements == a pval list of statements in the if ()
2762                                    item->u3.else_statements == a pval list of statements in the else
2763                                                                                            (could be zero)
2764                 */
2765                 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, if expr '%s':", config, item->startline, item->startcol, item->endcol, item->u1.str);
2766                 ast_expr_register_extra_error_info(errmsg);
2767                 ast_expr(item->u1.str, expr_output, sizeof(expr_output));
2768                 ast_expr_clear_extra_error_info();
2769                 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2770                         ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression '%s' has operators, but no variables. Interesting...\n",
2771                                         item->filename, item->startline, item->endline, item->u1.str);
2772                         warns++;
2773                 }
2774                 check_expr2_input(item,item->u1.str);
2775                 check_pval(item->u2.statements, apps,in_globals);
2776                 if (item->u3.else_statements) {
2777                         check_pval(item->u3.else_statements, apps,in_globals);
2778                 }
2779                 break;
2780
2781         case PV_SWITCH:
2782                 /* fields: item->u1.str        == the switch expression
2783
2784                                    item->u2.statements == a pval list of statements in the switch,
2785                                                                                         (will be case statements, most likely!)
2786                 */
2787                 /* we can check the switch expression, see if it matches any of the app variables...
2788            if it does, then, are all the possible cases accounted for? */
2789                 check_switch_expr(item, apps);
2790                 check_pval(item->u2.statements, apps,in_globals);
2791                 break;
2792
2793         case PV_EXTENSION:
2794                 /* fields: item->u1.str        == the extension name, label, whatever it's called
2795
2796                                    item->u2.statements == a pval list of statements in the extension
2797                                    item->u3.hints      == a char * hint argument
2798                                    item->u4.regexten   == an int boolean. non-zero says that regexten was specified
2799                 */
2800                 current_extension = item ;
2801
2802                 check_pval(item->u2.statements, apps,in_globals);
2803                 break;
2804
2805         case PV_IGNOREPAT:
2806                 /* fields: item->u1.str        == the ignorepat data
2807                 */
2808                 break;
2809
2810         case PV_GLOBALS:
2811                 /* fields: item->u1.statements     == pval list of statements, usually vardecs
2812                 */
2813                 in_abstract_context = 0;
2814                 check_pval(item->u1.statements, apps, 1);
2815                 break;
2816         default:
2817                 break;
2818         }
2819 }
2820
2821 void check_pval(pval *item, struct argapp *apps, int in_globals)
2822 {
2823         pval *i;
2824
2825         /* checks to do:
2826            1. Do goto's point to actual labels?
2827            2. Do macro calls reference a macro?
2828            3. Does the number of macro args match the definition?
2829            4. Is a macro call missing its & at the front?
2830            5. Application calls-- we could check syntax for existing applications,
2831               but I need some some sort of universal description bnf for a general
2832                   sort of method for checking arguments, in number, maybe even type, at least.
2833                   Don't want to hand code checks for hundreds of applications.
2834         */