res/ael/pval.c

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