?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Turn a NOTICE into a DEBUG message.
[asterisk-bristuff.git] / pbx / pbx_ael.c
blob2af624c4f78ff2d2ea69f9ecff15fcb1e5d7d1a5
1 /*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 2006, Digium, Inc.
5 *
6 * Steve Murphy <murf@parsetree.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19 /*! \file
20 *
21 * \brief Compile symbolic Asterisk Extension Logic into Asterisk extensions, version 2.
22 *
23 */
24
25 #include "asterisk.h"
26
27 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
28
29 #include <sys/types.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <ctype.h>
35 #include <errno.h>
36 #include <regex.h>
37 #include <sys/stat.h>
38
39 #include "asterisk/pbx.h"
40 #include "asterisk/config.h"
41 #include "asterisk/module.h"
42 #include "asterisk/logger.h"
43 #include "asterisk/cli.h"
44 #include "asterisk/app.h"
45 #include "asterisk/callerid.h"
46 #include "asterisk/ael_structs.h"
47 #ifdef AAL_ARGCHECK
48 #include "asterisk/argdesc.h"
49 #endif
50
51 static char expr_output[2096];
52
53 /* these functions are in ../ast_expr2.fl */
54
55 #define DEBUG_READ (1 << 0)
56 #define DEBUG_TOKENS (1 << 1)
57 #define DEBUG_MACROS (1 << 2)
58 #define DEBUG_CONTEXTS (1 << 3)
59
60 static char *config = "extensions.ael";
61 static char *registrar = "pbx_ael";
62 static int pbx_load_module(void);
63
64 static int errs, warns;
65 static int notes;
66
67 #ifndef AAL_ARGCHECK
68 /* for the time being, short circuit all the AAL related structures
69 without permanently removing the code; after/during the AAL
70 development, this code can be properly re-instated
71 */
72
73 /* null definitions for structs passed down the infrastructure */
74 struct argapp
75 {
76 struct argapp *next;
77 };
78
79 #endif
80
81 #ifdef AAL_ARGCHECK
82 int option_matches_j( struct argdesc *should, pval *is, struct argapp *app);
83 int option_matches( struct argdesc *should, pval *is, struct argapp *app);
84 int ael_is_funcname(char *name);
85 #endif
86
87 int check_app_args(pval *appcall, pval *arglist, struct argapp *app);
88 void check_pval(pval *item, struct argapp *apps, int in_globals);
89 void check_pval_item(pval *item, struct argapp *apps, int in_globals);
90 void check_switch_expr(pval *item, struct argapp *apps);
91 void ast_expr_register_extra_error_info(char *errmsg);
92 void ast_expr_clear_extra_error_info(void);
93 int ast_expr(char *expr, char *buf, int length);
94 struct pval *find_macro(char *name);
95 struct pval *find_context(char *name);
96 struct pval *find_context(char *name);
97 struct pval *find_macro(char *name);
98 struct ael_priority *new_prio(void);
99 struct ael_extension *new_exten(void);
100 void linkprio(struct ael_extension *exten, struct ael_priority *prio);
101 void destroy_extensions(struct ael_extension *exten);
102 static void linkexten(struct ael_extension *exten, struct ael_extension *add);
103 static void gen_prios(struct ael_extension *exten, char *label, pval *statement, struct ael_extension *mother_exten, struct ast_context *context );
104 void set_priorities(struct ael_extension *exten);
105 void add_extensions(struct ael_extension *exten);
106 void ast_compile_ael2(struct ast_context **local_contexts, struct pval *root);
107 void destroy_pval(pval *item);
108 void destroy_pval_item(pval *item);
109 int is_float(char *arg );
110 int is_int(char *arg );
111 int is_empty(char *arg);
112 static pval *current_db=0;
113 static pval *current_context=0;
114 static pval *current_extension=0;
115
116 static const char *match_context;
117 static const char *match_exten;
118 static const char *match_label;
119 static int in_abstract_context;
120 static int count_labels; /* true, put matcher in label counting mode */
121 static int label_count; /* labels are only meant to be counted in a context or exten */
122 static int return_on_context_match;
123 static pval *last_matched_label;
124 struct pval *match_pval(pval *item);
125 static void check_timerange(pval *p);
126 static void check_dow(pval *DOW);
127 static void check_day(pval *DAY);
128 static void check_month(pval *MON);
129 static void check_expr2_input(pval *expr, char *str);
130 static int extension_matches(pval *here, const char *exten, const char *pattern);
131 static void check_goto(pval *item);
132 static void find_pval_goto_item(pval *item, int lev);
133 static void find_pval_gotos(pval *item, int lev);
134
135 static struct pval *find_label_in_current_context(char *exten, char *label, pval *curr_cont);
136 static struct pval *find_first_label_in_current_context(char *label, pval *curr_cont);
137 static void print_pval_list(FILE *fin, pval *item, int depth);
138
139 static struct pval *find_label_in_current_extension(const char *label, pval *curr_ext);
140 static struct pval *find_label_in_current_db(const char *context, const char *exten, const char *label);
141 static pval *get_goto_target(pval *item);
142 static int label_inside_case(pval *label);
143 static void attach_exten(struct ael_extension **list, struct ael_extension *newmem);
144 static void fix_gotos_in_extensions(struct ael_extension *exten);
145 static pval *get_extension_or_contxt(pval *p);
146 static pval *get_contxt(pval *p);
147 static void remove_spaces_before_equals(char *str);
148 static void substitute_commas(char *str);
149
150 /* I am adding this code to substitute commas with vertbars in the args to apps */
151 static void substitute_commas(char *str)
152 {
153 char *p = str;
154
155 while (p && *p)
156 {
157 if (*p == ',' && ((p != str && *(p-1) != '\\')
158 || p == str))
159 *p = '|';
160 if (*p == '\\' && *(p+1) == ',') { /* learning experience: the '\,' is turned into just ',' by pbx_config; So we need to do the same */
161 char *q = p;
162 while (*q) { /* move the ',' and everything after it up 1 char */
163 *q = *(q+1);
164 q++;
165 }
166 }
167 p++;
168 }
169 }
170
171
172 /* PRETTY PRINTER FOR AEL: ============================================================================= */
173
174 static void print_pval(FILE *fin, pval *item, int depth)
175 {
176 int i;
177 pval *lp;
178
179 for (i=0; i<depth; i++) {
180 fprintf(fin, "\t"); /* depth == indentation */
181 }
182
183 switch ( item->type ) {
184 case PV_WORD:
185 fprintf(fin,"%s;\n", item->u1.str); /* usually, words are encapsulated in something else */
186 break;
187
188 case PV_MACRO:
189 fprintf(fin,"macro %s(", item->u1.str);
190 for (lp=item->u2.arglist; lp; lp=lp->next) {
191 if (lp != item->u2.arglist )
192 fprintf(fin,", ");
193 fprintf(fin,"%s", lp->u1.str);
194 }
195 fprintf(fin,") {\n");
196 print_pval_list(fin,item->u3.macro_statements,depth+1);
197 for (i=0; i<depth; i++) {
198 fprintf(fin,"\t"); /* depth == indentation */
199 }
200 fprintf(fin,"};\n\n");
201 break;
202
203 case PV_CONTEXT:
204 if ( item->u3.abstract )
205 fprintf(fin,"abstract context %s {\n", item->u1.str);
206 else
207 fprintf(fin,"context %s {\n", item->u1.str);
208 print_pval_list(fin,item->u2.statements,depth+1);
209 for (i=0; i<depth; i++) {
210 fprintf(fin,"\t"); /* depth == indentation */
211 }
212 fprintf(fin,"};\n\n");
213 break;
214
215 case PV_MACRO_CALL:
216 fprintf(fin,"&%s(", item->u1.str);
217 for (lp=item->u2.arglist; lp; lp=lp->next) {
218 if ( lp != item->u2.arglist )
219 fprintf(fin,", ");
220 fprintf(fin,"%s", lp->u1.str);
221 }
222 fprintf(fin,");\n");
223 break;
224
225 case PV_APPLICATION_CALL:
226 fprintf(fin,"%s(", item->u1.str);
227 for (lp=item->u2.arglist; lp; lp=lp->next) {
228 if ( lp != item->u2.arglist )
229 fprintf(fin,",");
230 fprintf(fin,"%s", lp->u1.str);
231 }
232 fprintf(fin,");\n");
233 break;
234
235 case PV_CASE:
236 fprintf(fin,"case %s:\n", item->u1.str);
237 print_pval_list(fin,item->u2.statements, depth+1);
238 break;
239
240 case PV_PATTERN:
241 fprintf(fin,"pattern %s:\n", item->u1.str);
242 print_pval_list(fin,item->u2.statements, depth+1);
243 break;
244
245 case PV_DEFAULT:
246 fprintf(fin,"default:\n");
247 print_pval_list(fin,item->u2.statements, depth+1);
248 break;
249
250 case PV_CATCH:
251 fprintf(fin,"catch %s {\n", item->u1.str);
252 print_pval_list(fin,item->u2.statements, depth+1);
253 for (i=0; i<depth; i++) {
254 fprintf(fin,"\t"); /* depth == indentation */
255 }
256 fprintf(fin,"};\n");
257 break;
258
259 case PV_SWITCHES:
260 fprintf(fin,"switches {\n");
261 print_pval_list(fin,item->u1.list,depth+1);
262 for (i=0; i<depth; i++) {
263 fprintf(fin,"\t"); /* depth == indentation */
264 }
265 fprintf(fin,"};\n");
266 break;
267
268 case PV_ESWITCHES:
269 fprintf(fin,"eswitches {\n");
270 print_pval_list(fin,item->u1.list,depth+1);
271 for (i=0; i<depth; i++) {
272 fprintf(fin,"\t"); /* depth == indentation */
273 }
274 fprintf(fin,"};\n");
275 break;
276
277 case PV_INCLUDES:
278 fprintf(fin,"includes {\n");
279 for (lp=item->u1.list; lp; lp=lp->next) {
280 for (i=0; i<depth+1; i++) {
281 fprintf(fin,"\t"); /* depth == indentation */
282 }
283 fprintf(fin,"%s", lp->u1.str); /* usually, words are encapsulated in something else */
284 if ( lp->u2.arglist )
285 fprintf(fin,"|%s|%s|%s|%s",
286 lp->u2.arglist->u1.str,
287 lp->u2.arglist->next->u1.str,
288 lp->u2.arglist->next->next->u1.str,
289 lp->u2.arglist->next->next->next->u1.str
290 );
291 fprintf(fin,";\n"); /* usually, words are encapsulated in something else */
292 }
293
294 print_pval_list(fin,item->u1.list,depth+1);
295 for (i=0; i<depth; i++) {
296 fprintf(fin,"\t"); /* depth == indentation */
297 }
298 fprintf(fin,"};\n");
299 break;
300
301 case PV_STATEMENTBLOCK:
302 fprintf(fin,"{\n");
303 print_pval_list(fin,item->u1.list, depth+1);
304 for (i=0; i<depth; i++) {
305 fprintf(fin,"\t"); /* depth == indentation */
306 }
307 fprintf(fin,"};\n");
308 break;
309
310 case PV_VARDEC:
311 fprintf(fin,"%s=%s;\n", item->u1.str, item->u2.val);
312 break;
313
314 case PV_GOTO:
315 fprintf(fin,"goto %s", item->u1.list->u1.str);
316 if ( item->u1.list->next )
317 fprintf(fin,"|%s", item->u1.list->next->u1.str);
318 if ( item->u1.list->next && item->u1.list->next->next )
319 fprintf(fin,"|%s", item->u1.list->next->next->u1.str);
320 fprintf(fin,"\n");
321 break;
322
323 case PV_LABEL:
324 fprintf(fin,"%s:\n", item->u1.str);
325 break;
326
327 case PV_FOR:
328 fprintf(fin,"for (%s; %s; %s)\n", item->u1.for_init, item->u2.for_test, item->u3.for_inc);
329 print_pval_list(fin,item->u4.for_statements,depth+1);
330 break;
331
332 case PV_WHILE:
333 fprintf(fin,"while (%s)\n", item->u1.str);
334 print_pval_list(fin,item->u2.statements,depth+1);
335 break;
336
337 case PV_BREAK:
338 fprintf(fin,"break;\n");
339 break;
340
341 case PV_RETURN:
342 fprintf(fin,"return;\n");
343 break;
344
345 case PV_CONTINUE:
346 fprintf(fin,"continue;\n");
347 break;
348
349 case PV_RANDOM:
350 case PV_IFTIME:
351 case PV_IF:
352 if ( item->type == PV_IFTIME ) {
353
354 fprintf(fin,"ifTime ( %s|%s|%s|%s )\n",
355 item->u1.list->u1.str,
356 item->u1.list->next->u1.str,
357 item->u1.list->next->next->u1.str,
358 item->u1.list->next->next->next->u1.str
359 );
360 } else if ( item->type == PV_RANDOM ) {
361 fprintf(fin,"random ( %s )\n", item->u1.str );
362 } else
363 fprintf(fin,"if ( %s )\n", item->u1.str);
364 if ( item->u2.statements && item->u2.statements->next ) {
365 for (i=0; i<depth; i++) {
366 fprintf(fin,"\t"); /* depth == indentation */
367 }
368 fprintf(fin,"{\n");
369 print_pval_list(fin,item->u2.statements,depth+1);
370 for (i=0; i<depth; i++) {
371 fprintf(fin,"\t"); /* depth == indentation */
372 }
373 if ( item->u3.else_statements )
374 fprintf(fin,"}\n");
375 else
376 fprintf(fin,"};\n");
377 } else if (item->u2.statements ) {
378 print_pval_list(fin,item->u2.statements,depth+1);
379 } else {
380 if (item->u3.else_statements )
381 fprintf(fin, " {} ");
382 else
383 fprintf(fin, " {}; ");
384 }
385 if ( item->u3.else_statements ) {
386 for (i=0; i<depth; i++) {
387 fprintf(fin,"\t"); /* depth == indentation */
388 }
389 fprintf(fin,"else\n");
390 print_pval_list(fin,item->u3.else_statements, depth);
391 }
392 break;
393
394 case PV_SWITCH:
395 fprintf(fin,"switch( %s ) {\n", item->u1.str);
396 print_pval_list(fin,item->u2.statements,depth+1);
397 for (i=0; i<depth; i++) {
398 fprintf(fin,"\t"); /* depth == indentation */
399 }
400 fprintf(fin,"}\n");
401 break;
402
403 case PV_EXTENSION:
404 if ( item->u4.regexten )
405 fprintf(fin, "regexten ");
406 if ( item->u3.hints )
407 fprintf(fin,"hints(%s) ", item->u3.hints);
408
409 fprintf(fin,"%s => \n", item->u1.str);
410 print_pval_list(fin,item->u2.statements,depth+1);
411 break;
412
413 case PV_IGNOREPAT:
414 fprintf(fin,"ignorepat => %s\n", item->u1.str);
415 break;
416
417 case PV_GLOBALS:
418 fprintf(fin,"globals {\n");
419 print_pval_list(fin,item->u1.statements,depth+1);
420 for (i=0; i<depth; i++) {
421 fprintf(fin,"\t"); /* depth == indentation */
422 }
423 fprintf(fin,"}\n");
424 break;
425 }
426 }
427
428 static void print_pval_list(FILE *fin, pval *item, int depth)
429 {
430 pval *i;
431
432 for (i=item; i; i=i->next) {
433 print_pval(fin, i, depth);
434 }
435 }
436
437 #if 0
438 static void ael2_print(char *fname, pval *tree)
439 {
440 FILE *fin = fopen(fname,"w");
441 if ( !fin ) {
442 ast_log(LOG_ERROR, "Couldn't open %s for writing.\n", fname);
443 return;
444 }
445 print_pval_list(fin, tree, 0);
446 fclose(fin);
447 }
448 #endif
449
450
451 /* EMPTY TEMPLATE FUNCS FOR AEL TRAVERSAL: ============================================================================= */
452
453 void traverse_pval_template(pval *item, int depth);
454 void traverse_pval_item_template(pval *item, int depth);
455
456
457 void traverse_pval_item_template(pval *item, int depth)/* depth comes in handy for a pretty print (indentation),
458 but you may not need it */
459 {
460 pval *lp;
461
462 switch ( item->type ) {
463 case PV_WORD:
464 /* fields: item->u1.str == string associated with this (word). */
465 break;
466
467 case PV_MACRO:
468 /* fields: item->u1.str == name of macro
469 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
470 item->u2.arglist->u1.str == argument
471 item->u2.arglist->next == next arg
472
473 item->u3.macro_statements == pval list of statements in macro body.
474 */
475 for (lp=item->u2.arglist; lp; lp=lp->next) {
476
477 }
478 traverse_pval_item_template(item->u3.macro_statements,depth+1);
479 break;
480
481 case PV_CONTEXT:
482 /* fields: item->u1.str == name of context
483 item->u2.statements == pval list of statements in context body
484 item->u3.abstract == int 1 if an abstract keyword were present
485 */
486 traverse_pval_item_template(item->u2.statements,depth+1);
487 break;
488
489 case PV_MACRO_CALL:
490 /* fields: item->u1.str == name of macro to call
491 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
492 item->u2.arglist->u1.str == argument
493 item->u2.arglist->next == next arg
494 */
495 for (lp=item->u2.arglist; lp; lp=lp->next) {
496 }
497 break;
498
499 case PV_APPLICATION_CALL:
500 /* fields: item->u1.str == name of application to call
501 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
502 item->u2.arglist->u1.str == argument
503 item->u2.arglist->next == next arg
504 */
505 for (lp=item->u2.arglist; lp; lp=lp->next) {
506 }
507 break;
508
509 case PV_CASE:
510 /* fields: item->u1.str == value of case
511 item->u2.statements == pval list of statements under the case
512 */
513 traverse_pval_item_template(item->u2.statements,depth+1);
514 break;
515
516 case PV_PATTERN:
517 /* fields: item->u1.str == value of case
518 item->u2.statements == pval list of statements under the case
519 */
520 traverse_pval_item_template(item->u2.statements,depth+1);
521 break;
522
523 case PV_DEFAULT:
524 /* fields:
525 item->u2.statements == pval list of statements under the case
526 */
527 traverse_pval_item_template(item->u2.statements,depth+1);
528 break;
529
530 case PV_CATCH:
531 /* fields: item->u1.str == name of extension to catch
532 item->u2.statements == pval list of statements in context body
533 */
534 traverse_pval_item_template(item->u2.statements,depth+1);
535 break;
536
537 case PV_SWITCHES:
538 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
539 */
540 traverse_pval_item_template(item->u1.list,depth+1);
541 break;
542
543 case PV_ESWITCHES:
544 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
545 */
546 traverse_pval_item_template(item->u1.list,depth+1);
547 break;
548
549 case PV_INCLUDES:
550 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
551 item->u2.arglist == pval list of 4 PV_WORD elements for time values
552 */
553 traverse_pval_item_template(item->u1.list,depth+1);
554 traverse_pval_item_template(item->u2.arglist,depth+1);
555 break;
556
557 case PV_STATEMENTBLOCK:
558 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
559 */
560 traverse_pval_item_template(item->u1.list,depth+1);
561 break;
562
563 case PV_VARDEC:
564 /* fields: item->u1.str == variable name
565 item->u2.val == variable value to assign
566 */
567 break;
568
569 case PV_GOTO:
570 /* fields: item->u1.list == pval list of PV_WORD target names, up to 3, in order as given by user.
571 item->u1.list->u1.str == where the data on a PV_WORD will always be.
572 */
573
574 if ( item->u1.list->next )
575 ;
576 if ( item->u1.list->next && item->u1.list->next->next )
577 ;
578
579 break;
580
581 case PV_LABEL:
582 /* fields: item->u1.str == label name
583 */
584 break;
585
586 case PV_FOR:
587 /* fields: item->u1.for_init == a string containing the initalizer
588 item->u2.for_test == a string containing the loop test
589 item->u3.for_inc == a string containing the loop increment
590
591 item->u4.for_statements == a pval list of statements in the for ()
592 */
593 traverse_pval_item_template(item->u4.for_statements,depth+1);
594 break;
595
596 case PV_WHILE:
597 /* fields: item->u1.str == the while conditional, as supplied by user
598
599 item->u2.statements == a pval list of statements in the while ()
600 */
601 traverse_pval_item_template(item->u2.statements,depth+1);
602 break;
603
604 case PV_BREAK:
605 /* fields: none
606 */
607 break;
608
609 case PV_RETURN:
610 /* fields: none
611 */
612 break;
613
614 case PV_CONTINUE:
615 /* fields: none
616 */
617 break;
618
619 case PV_IFTIME:
620 /* fields: item->u1.list == there are 4 linked PV_WORDs here.
621
622 item->u2.statements == a pval list of statements in the if ()
623 item->u3.else_statements == a pval list of statements in the else
624 (could be zero)
625 */
626 traverse_pval_item_template(item->u2.statements,depth+1);
627 if ( item->u3.else_statements ) {
628 traverse_pval_item_template(item->u3.else_statements,depth+1);
629 }
630 break;
631
632 case PV_RANDOM:
633 /* fields: item->u1.str == the random number expression, as supplied by user
634
635 item->u2.statements == a pval list of statements in the if ()
636 item->u3.else_statements == a pval list of statements in the else
637 (could be zero)
638 */
639 traverse_pval_item_template(item->u2.statements,depth+1);
640 if ( item->u3.else_statements ) {
641 traverse_pval_item_template(item->u3.else_statements,depth+1);
642 }
643 break;
644
645 case PV_IF:
646 /* fields: item->u1.str == the if conditional, as supplied by user
647
648 item->u2.statements == a pval list of statements in the if ()
649 item->u3.else_statements == a pval list of statements in the else
650 (could be zero)
651 */
652 traverse_pval_item_template(item->u2.statements,depth+1);
653 if ( item->u3.else_statements ) {
654 traverse_pval_item_template(item->u3.else_statements,depth+1);
655 }
656 break;
657
658 case PV_SWITCH:
659 /* fields: item->u1.str == the switch expression
660
661 item->u2.statements == a pval list of statements in the switch,
662 (will be case statements, most likely!)
663 */
664 traverse_pval_item_template(item->u2.statements,depth+1);
665 break;
666
667 case PV_EXTENSION:
668 /* fields: item->u1.str == the extension name, label, whatever it's called
669
670 item->u2.statements == a pval list of statements in the extension
671 item->u3.hints == a char * hint argument
672 item->u4.regexten == an int boolean. non-zero says that regexten was specified
673 */
674 traverse_pval_item_template(item->u2.statements,depth+1);
675 break;
676
677 case PV_IGNOREPAT:
678 /* fields: item->u1.str == the ignorepat data
679 */
680 break;
681
682 case PV_GLOBALS:
683 /* fields: item->u1.statements == pval list of statements, usually vardecs
684 */
685 traverse_pval_item_template(item->u1.statements,depth+1);
686 break;
687 }
688 }
689
690 void traverse_pval_template(pval *item, int depth) /* depth comes in handy for a pretty print (indentation),
691 but you may not need it */
692 {
693 pval *i;
694
695 for (i=item; i; i=i->next) {
696 traverse_pval_item_template(i, depth);
697 }
698 }
699
700
701 /* SEMANTIC CHECKING FOR AEL: ============================================================================= */
702
703 /* (not all that is syntactically legal is good! */
704
705
706
707 static int extension_matches(pval *here, const char *exten, const char *pattern)
708 {
709 int err1;
710 regex_t preg;
711
712 /* simple case, they match exactly, the pattern and exten name */
713 if( !strcmp(pattern,exten) == 0 )
714 return 1;
715
716 if ( pattern[0] == '_' ) {
717 char reg1[2000];
718 const char *p;
719 char *r = reg1;
720
721 if ( strlen(pattern)*5 >= 2000 ) /* safety valve */ {
722 ast_log(LOG_ERROR,"Error: The pattern %s is way too big. Pattern matching cancelled.\n",
723 pattern);
724 return 0;
725 }
726 /* form a regular expression from the pattern, and then match it against exten */
727 *r++ = '^'; /* what if the extension is a pattern ?? */
728 *r++ = '_'; /* what if the extension is a pattern ?? */
729 *r++ = '?';
730 for (p=pattern+1; *p; p++) {
731 switch ( *p ) {
732 case 'X':
733 *r++ = '[';
734 *r++ = '0';
735 *r++ = '-';
736 *r++ = '9';
737 *r++ = 'X';
738 *r++ = ']';
739 break;
740
741 case 'Z':
742 *r++ = '[';
743 *r++ = '1';
744 *r++ = '-';
745 *r++ = '9';
746 *r++ = 'Z';
747 *r++ = ']';
748 break;
749
750 case 'N':
751 *r++ = '[';
752 *r++ = '2';
753 *r++ = '-';
754 *r++ = '9';
755 *r++ = 'N';
756 *r++ = ']';
757 break;
758
759 case '[':
760 while ( *p && *p != ']' ) {
761 *r++ = *p++;
762 }
763 if ( *p != ']') {
764 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The extension pattern '%s' is missing a closing bracket \n",
765 here->filename, here->startline, here->endline, pattern);
766 }
767 break;
768
769 case '.':
770 case '!':
771 *r++ = '.';
772 *r++ = '*';
773 break;
774 case '*':
775 *r++ = '\\';
776 *r++ = '*';
777 break;
778 default:
779 *r++ = *p;
780 break;
781
782 }
783 }
784 *r++ = '$'; /* what if the extension is a pattern ?? */
785 *r++ = *p++; /* put in the closing null */
786 err1 = regcomp(&preg, reg1, REG_NOSUB|REG_EXTENDED);
787 if ( err1 ) {
788 char errmess[500];
789 regerror(err1,&preg,errmess,sizeof(errmess));
790 regfree(&preg);
791 ast_log(LOG_WARNING, "Regcomp of %s failed, error code %d\n",
792 reg1, err1);
793 return 0;
794 }
795 err1 = regexec(&preg, exten, 0, 0, 0);
796 regfree(&preg);
797
798 if ( err1 ) {
799 /* ast_log(LOG_NOTICE,"*****************************[%d]Extension %s did not match %s(%s)\n",
800 err1,exten, pattern, reg1); */
801 return 0; /* no match */
802 } else {
803 /* ast_log(LOG_NOTICE,"*****************************Extension %s matched %s\n",
804 exten, pattern); */
805 return 1;
806 }
807
808
809 } else {
810 if ( strcmp(exten,pattern) == 0 ) {
811 return 1;
812 } else
813 return 0;
814 }
815 }
816
817
818 static void check_expr2_input(pval *expr, char *str)
819 {
820 int spaces = strspn(str,"\t \n");
821 if ( !strncmp(str+spaces,"$[",2) ) {
822 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The expression '%s' is redundantly wrapped in '$[ ]'. \n",
823 expr->filename, expr->startline, expr->endline, str);
824 warns++;
825 }
826 }
827
828 static void check_includes(pval *includes)
829 {
830 struct pval *p4;
831 for (p4=includes->u1.list; p4; p4=p4->next) {
832 /* for each context pointed to, find it, then find a context/label that matches the
833 target here! */
834 char *incl_context = p4->u1.str;
835 /* find a matching context name */
836 struct pval *that_other_context = find_context(incl_context);
837 if (!that_other_context && strcmp(incl_context, "parkedcalls") != 0) {
838 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The included context '%s' cannot be found.\n\
839 (You may ignore this warning if '%s' exists in extensions.conf, or is created by another module. I cannot check for those.)\n",
840 includes->filename, includes->startline, includes->endline, incl_context, incl_context);
841 warns++;
842 }
843 }
844 }
845
846
847 static void check_timerange(pval *p)
848 {
849 char *times;
850 char *e;
851 int s1, s2;
852 int e1, e2;
853
854 times = ast_strdupa(p->u1.str);
855
856 /* Star is all times */
857 if (ast_strlen_zero(times) || !strcmp(times, "*")) {
858 return;
859 }
860 /* Otherwise expect a range */
861 e = strchr(times, '-');
862 if (!e) {
863 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",
864 p->filename, p->startline, p->endline, times);
865 warns++;
866 return;
867 }
868 *e = '\0';
869 e++;
870 while (*e && !isdigit(*e))
871 e++;
872 if (!*e) {
873 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The time range format (%s) is missing the end time!\n",
874 p->filename, p->startline, p->endline, p->u1.str);
875 warns++;
876 }
877 if (sscanf(times, "%d:%d", &s1, &s2) != 2) {
878 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start time (%s) isn't quite right!\n",
879 p->filename, p->startline, p->endline, times);
880 warns++;
881 }
882 if (sscanf(e, "%d:%d", &e1, &e2) != 2) {
883 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end time (%s) isn't quite right!\n",
884 p->filename, p->startline, p->endline, times);
885 warns++;
886 }
887
888 s1 = s1 * 30 + s2/2;
889 if ((s1 < 0) || (s1 >= 24*30)) {
890 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start time (%s) is out of range!\n",
891 p->filename, p->startline, p->endline, times);
892 warns++;
893 }
894 e1 = e1 * 30 + e2/2;
895 if ((e1 < 0) || (e1 >= 24*30)) {
896 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end time (%s) is out of range!\n",
897 p->filename, p->startline, p->endline, e);
898 warns++;
899 }
900 return;
901 }
902
903 static char *days[] =
904 {
905 "sun",
906 "mon",
907 "tue",
908 "wed",
909 "thu",
910 "fri",
911 "sat",
912 };
913
914 /*! \brief get_dow: Get day of week */
915 static void check_dow(pval *DOW)
916 {
917 char *dow;
918 char *c;
919 /* The following line is coincidence, really! */
920 int s, e;
921
922 dow = ast_strdupa(DOW->u1.str);
923
924 /* Check for all days */
925 if (ast_strlen_zero(dow) || !strcmp(dow, "*"))
926 return;
927 /* Get start and ending days */
928 c = strchr(dow, '-');
929 if (c) {
930 *c = '\0';
931 c++;
932 } else
933 c = NULL;
934 /* Find the start */
935 s = 0;
936 while ((s < 7) && strcasecmp(dow, days[s])) s++;
937 if (s >= 7) {
938 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",
939 DOW->filename, DOW->startline, DOW->endline, dow);
940 warns++;
941 }
942 if (c) {
943 e = 0;
944 while ((e < 7) && strcasecmp(c, days[e])) e++;
945 if (e >= 7) {
946 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",
947 DOW->filename, DOW->startline, DOW->endline, c);
948 warns++;
949 }
950 } else
951 e = s;
952 }
953
954 static void check_day(pval *DAY)
955 {
956 char *day;
957 char *c;
958 /* The following line is coincidence, really! */
959 int s, e;
960
961 day = ast_strdupa(DAY->u1.str);
962
963 /* Check for all days */
964 if (ast_strlen_zero(day) || !strcmp(day, "*")) {
965 return;
966 }
967 /* Get start and ending days */
968 c = strchr(day, '-');
969 if (c) {
970 *c = '\0';
971 c++;
972 }
973 /* Find the start */
974 if (sscanf(day, "%d", &s) != 1) {
975 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start day of month (%s) must be a number!\n",
976 DAY->filename, DAY->startline, DAY->endline, day);
977 warns++;
978 }
979 else if ((s < 1) || (s > 31)) {
980 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",
981 DAY->filename, DAY->startline, DAY->endline, day);
982 warns++;
983 }
984 s--;
985 if (c) {
986 if (sscanf(c, "%d", &e) != 1) {
987 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end day of month (%s) must be a number!\n",
988 DAY->filename, DAY->startline, DAY->endline, c);
989 warns++;
990 }
991 else if ((e < 1) || (e > 31)) {
992 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",
993 DAY->filename, DAY->startline, DAY->endline, day);
994 warns++;
995 }
996 e--;
997 } else
998 e = s;
999 }
1000
1001 static char *months[] =
1002 {
1003 "jan",
1004 "feb",
1005 "mar",
1006 "apr",
1007 "may",
1008 "jun",
1009 "jul",
1010 "aug",
1011 "sep",
1012 "oct",
1013 "nov",
1014 "dec",
1015 };
1016
1017 static void check_month(pval *MON)
1018 {
1019 char *mon;
1020 char *c;
1021 /* The following line is coincidence, really! */
1022 int s, e;
1023
1024 mon = ast_strdupa(MON->u1.str);
1025
1026 /* Check for all days */
1027 if (ast_strlen_zero(mon) || !strcmp(mon, "*"))
1028 return ;
1029 /* Get start and ending days */
1030 c = strchr(mon, '-');
1031 if (c) {
1032 *c = '\0';
1033 c++;
1034 }
1035 /* Find the start */
1036 s = 0;
1037 while ((s < 12) && strcasecmp(mon, months[s])) s++;
1038 if (s >= 12) {
1039 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The start month (%s) must be a one of: 'jan', 'feb', ..., 'dec'!\n",
1040 MON->filename, MON->startline, MON->endline, mon);
1041 warns++;
1042 }
1043 if (c) {
1044 e = 0;
1045 while ((e < 12) && strcasecmp(mon, months[e])) e++;
1046 if (e >= 12) {
1047 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: The end month (%s) must be a one of: 'jan', 'feb', ..., 'dec'!\n",
1048 MON->filename, MON->startline, MON->endline, c);
1049 warns++;
1050 }
1051 } else
1052 e = s;
1053 }
1054
1055 static int check_break(pval *item)
1056 {
1057 pval *p = item;
1058
1059 while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
1060 /* a break is allowed in WHILE, FOR, CASE, DEFAULT, PATTERN; otherwise, it don't make
1061 no sense */
1062 if( p->type == PV_CASE || p->type == PV_DEFAULT || p->type == PV_PATTERN
1063 || p->type == PV_WHILE || p->type == PV_FOR ) {
1064 return 1;
1065 }
1066 p = p->dad;
1067 }
1068 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: 'break' not in switch, for, or while statement!\n",
1069 item->filename, item->startline, item->endline);
1070 errs++;
1071
1072 return 0;
1073 }
1074
1075 static int check_continue(pval *item)
1076 {
1077 pval *p = item;
1078
1079 while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
1080 /* a break is allowed in WHILE, FOR, CASE, DEFAULT, PATTERN; otherwise, it don't make
1081 no sense */
1082 if( p->type == PV_WHILE || p->type == PV_FOR ) {
1083 return 1;
1084 }
1085 p = p->dad;
1086 }
1087 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: 'continue' not in 'for' or 'while' statement!\n",
1088 item->filename, item->startline, item->endline);
1089 errs++;
1090
1091 return 0;
1092 }
1093
1094
1095 /* general purpose goto finder */
1096
1097 static void check_label(pval *item)
1098 {
1099 /* basically, ensure that a label is not repeated in a context. Period.
1100 The method: well, for each label, find the first label in the context
1101 with the same name. If it's not the current label, then throw an error. */
1102 struct pval *curr;
1103 struct pval *x;
1104
1105 /* printf("==== check_label: ====\n"); */
1106 if( !current_extension )
1107 curr = current_context;
1108 else
1109 curr = current_extension;
1110
1111 x = find_first_label_in_current_context((char *)item->u1.str, curr);
1112 /* 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); */
1113 if( x && x != item )
1114 {
1115 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: Duplicate label %s! Previously defined at file %s, line %d.\n",
1116 item->filename, item->startline, item->endline, item->u1.str, x->filename, x->startline);
1117 errs++;
1118 }
1119 /* printf("<<<<< check_label: ====\n"); */
1120 }
1121
1122 static pval *get_goto_target(pval *item)
1123 {
1124 /* just one item-- the label should be in the current extension */
1125 pval *curr_ext = get_extension_or_contxt(item); /* containing exten, or macro */
1126 pval *curr_cont;
1127
1128 if (item->u1.list && !item->u1.list->next && !strstr((item->u1.list)->u1.str,"${")) {
1129 struct pval *x = find_label_in_current_extension((char*)((item->u1.list)->u1.str), curr_ext);
1130 return x;
1131 }
1132
1133 curr_cont = get_contxt(item);
1134
1135 /* TWO items */
1136 if (item->u1.list->next && !item->u1.list->next->next) {
1137 if (!strstr((item->u1.list)->u1.str,"${")
1138 && !strstr(item->u1.list->next->u1.str,"${") ) /* Don't try to match variables */ {
1139 struct pval *x = find_label_in_current_context((char *)item->u1.list->u1.str, (char *)item->u1.list->next->u1.str, curr_cont);
1140 return x;
1141 }
1142 }
1143
1144 /* All 3 items! */
1145 if (item->u1.list->next && item->u1.list->next->next) {
1146 /* all three */
1147 pval *first = item->u1.list;
1148 pval *second = item->u1.list->next;
1149 pval *third = item->u1.list->next->next;
1150
1151 if (!strstr((item->u1.list)->u1.str,"${")
1152 && !strstr(item->u1.list->next->u1.str,"${")
1153 && !strstr(item->u1.list->next->next->u1.str,"${")) /* Don't try to match variables */ {
1154 struct pval *x = find_label_in_current_db((char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str);
1155 if (!x) {
1156
1157 struct pval *p3;
1158 struct pval *that_context = find_context(item->u1.list->u1.str);
1159
1160 /* the target of the goto could be in an included context!! Fancy that!! */
1161 /* look for includes in the current context */
1162 if (that_context) {
1163 for (p3=that_context->u2.statements; p3; p3=p3->next) {
1164 if (p3->type == PV_INCLUDES) {
1165 struct pval *p4;
1166 for (p4=p3->u1.list; p4; p4=p4->next) {
1167 /* for each context pointed to, find it, then find a context/label that matches the
1168 target here! */
1169 char *incl_context = p4->u1.str;
1170 /* find a matching context name */
1171 struct pval *that_other_context = find_context(incl_context);
1172 if (that_other_context) {
1173 struct pval *x3;
1174 x3 = find_label_in_current_context((char *)item->u1.list->next->u1.str, (char *)item->u1.list->next->next->u1.str, that_other_context);
1175 if (x3) {
1176 return x3;
1177 }
1178 }
1179 }
1180 }
1181 }
1182 }
1183 }
1184 return x;
1185 }
1186 }
1187 return 0;
1188 }
1189
1190 static void check_goto(pval *item)
1191 {
1192 /* check for the target of the goto-- does it exist? */
1193 if ( !(item->u1.list)->next && !(item->u1.list)->u1.str ) {
1194 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto: empty label reference found!\n",
1195 item->filename, item->startline, item->endline);
1196 errs++;
1197 }
1198
1199 /* just one item-- the label should be in the current extension */
1200
1201 if (item->u1.list && !item->u1.list->next && !strstr((item->u1.list)->u1.str,"${")) {
1202 struct pval *z = get_extension_or_contxt(item);
1203 struct pval *x = 0;
1204 if (z)
1205 x = find_label_in_current_extension((char*)((item->u1.list)->u1.str), z); /* if in macro, use current context instead */
1206 /* printf("Called find_label_in_current_extension with arg %s; current_extension is %x: %d\n",
1207 (char*)((item->u1.list)->u1.str), current_extension?current_extension:current_context, current_extension?current_extension->type:current_context->type); */
1208 if (!x) {
1209 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto: no label %s exists in the current extension!\n",
1210 item->filename, item->startline, item->endline, item->u1.list->u1.str);
1211 errs++;
1212 }
1213 else
1214 return;
1215 }
1216
1217 /* TWO items */
1218 if (item->u1.list->next && !item->u1.list->next->next) {
1219 /* two items */
1220 /* printf("Calling find_label_in_current_context with args %s, %s\n",
1221 (char*)((item->u1.list)->u1.str), (char *)item->u1.list->next->u1.str); */
1222 if (!strstr((item->u1.list)->u1.str,"${")
1223 && !strstr(item->u1.list->next->u1.str,"${") ) /* Don't try to match variables */ {
1224 struct pval *z = get_contxt(item);
1225 struct pval *x = 0;
1226
1227 if (z)
1228 x = find_label_in_current_context((char *)item->u1.list->u1.str, (char *)item->u1.list->next->u1.str, z);
1229
1230 if (!x) {
1231 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",
1232 item->filename, item->startline, item->endline, item->u1.list->u1.str, item->u1.list->next->u1.str );
1233 errs++;
1234 }
1235 else
1236 return;
1237 }
1238 }
1239
1240 /* All 3 items! */
1241 if (item->u1.list->next && item->u1.list->next->next) {
1242 /* all three */
1243 pval *first = item->u1.list;
1244 pval *second = item->u1.list->next;
1245 pval *third = item->u1.list->next->next;
1246
1247 /* printf("Calling find_label_in_current_db with args %s, %s, %s\n",
1248 (char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str); */
1249 if (!strstr((item->u1.list)->u1.str,"${")
1250 && !strstr(item->u1.list->next->u1.str,"${")
1251 && !strstr(item->u1.list->next->next->u1.str,"${")) /* Don't try to match variables */ {
1252 struct pval *x = find_label_in_current_db((char*)first->u1.str, (char*)second->u1.str, (char*)third->u1.str);
1253 if (!x) {
1254 struct pval *p3;
1255 struct pval *found = 0;
1256 struct pval *that_context = find_context(item->u1.list->u1.str);
1257
1258 /* the target of the goto could be in an included context!! Fancy that!! */
1259 /* look for includes in the current context */
1260 if (that_context) {
1261 for (p3=that_context->u2.statements; p3; p3=p3->next) {
1262 if (p3->type == PV_INCLUDES) {
1263 struct pval *p4;
1264 for (p4=p3->u1.list; p4; p4=p4->next) {
1265 /* for each context pointed to, find it, then find a context/label that matches the
1266 target here! */
1267 char *incl_context = p4->u1.str;
1268 /* find a matching context name */
1269 struct pval *that_other_context = find_context(incl_context);
1270 if (that_other_context) {
1271 struct pval *x3;
1272 x3 = find_label_in_current_context((char *)item->u1.list->next->u1.str, (char *)item->u1.list->next->next->u1.str, that_other_context);
1273 if (x3) {
1274 found = x3;
1275 break;
1276 }
1277 }
1278 }
1279 }
1280 }
1281 if (!found) {
1282 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: goto: no label %s|%s exists in the context %s or its inclusions!\n",
1283 item->filename, item->startline, item->endline, item->u1.list->next->u1.str, item->u1.list->next->next->u1.str, item->u1.list->u1.str );
1284 errs++;
1285 }
1286 } else {
1287 /* here is where code would go to check for target existence in extensions.conf files */
1288 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: goto: no context %s could be found that matches the goto target!\n",
1289 item->filename, item->startline, item->endline, item->u1.list->u1.str);
1290 warns++; /* this is just a warning, because this context could be in extensions.conf or somewhere */
1291 }
1292 }
1293 }
1294 }
1295 }
1296
1297
1298 static void find_pval_goto_item(pval *item, int lev)
1299 {
1300 struct pval *p4;
1301 if (lev>100) {
1302 ast_log(LOG_ERROR,"find_pval_goto in infinite loop!\n\n");
1303 return;
1304 }
1305
1306 switch ( item->type ) {
1307 case PV_MACRO:
1308 /* fields: item->u1.str == name of macro
1309 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
1310 item->u2.arglist->u1.str == argument
1311 item->u2.arglist->next == next arg
1312
1313 item->u3.macro_statements == pval list of statements in macro body.
1314 */
1315
1316 /* printf("Descending into matching macro %s\n", match_context); */
1317 find_pval_gotos(item->u3.macro_statements,lev+1); /* if we're just searching for a context, don't bother descending into them */
1318
1319 break;
1320
1321 case PV_CONTEXT:
1322 /* fields: item->u1.str == name of context
1323 item->u2.statements == pval list of statements in context body
1324 item->u3.abstract == int 1 if an abstract keyword were present
1325 */
1326 break;
1327
1328 case PV_CASE:
1329 /* fields: item->u1.str == value of case
1330 item->u2.statements == pval list of statements under the case
1331 */
1332 find_pval_gotos(item->u2.statements,lev+1);
1333 break;
1334
1335 case PV_PATTERN:
1336 /* fields: item->u1.str == value of case
1337 item->u2.statements == pval list of statements under the case
1338 */
1339 find_pval_gotos(item->u2.statements,lev+1);
1340 break;
1341
1342 case PV_DEFAULT:
1343 /* fields:
1344 item->u2.statements == pval list of statements under the case
1345 */
1346 find_pval_gotos(item->u2.statements,lev+1);
1347 break;
1348
1349 case PV_CATCH:
1350 /* fields: item->u1.str == name of extension to catch
1351 item->u2.statements == pval list of statements in context body
1352 */
1353 find_pval_gotos(item->u2.statements,lev+1);
1354 break;
1355
1356 case PV_STATEMENTBLOCK:
1357 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
1358 */
1359 find_pval_gotos(item->u1.list,lev+1);
1360 break;
1361
1362 case PV_GOTO:
1363 /* fields: item->u1.list == pval list of PV_WORD target names, up to 3, in order as given by user.
1364 item->u1.list->u1.str == where the data on a PV_WORD will always be.
1365 */
1366 check_goto(item); /* THE WHOLE FUNCTION OF THIS ENTIRE ROUTINE!!!! */
1367 break;
1368
1369 case PV_INCLUDES:
1370 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
1371 */
1372 for (p4=item->u1.list; p4; p4=p4->next) {
1373 /* for each context pointed to, find it, then find a context/label that matches the
1374 target here! */
1375 char *incl_context = p4->u1.str;
1376 /* find a matching context name */
1377 struct pval *that_context = find_context(incl_context);
1378 if (that_context) {
1379 find_pval_gotos(that_context,lev+1); /* keep working up the includes */
1380 }
1381 }
1382 break;
1383
1384 case PV_FOR:
1385 /* fields: item->u1.for_init == a string containing the initalizer
1386 item->u2.for_test == a string containing the loop test
1387 item->u3.for_inc == a string containing the loop increment
1388
1389 item->u4.for_statements == a pval list of statements in the for ()
1390 */
1391 find_pval_gotos(item->u4.for_statements,lev+1);
1392 break;
1393
1394 case PV_WHILE:
1395 /* fields: item->u1.str == the while conditional, as supplied by user
1396
1397 item->u2.statements == a pval list of statements in the while ()
1398 */
1399 find_pval_gotos(item->u2.statements,lev+1);
1400 break;
1401
1402 case PV_RANDOM:
1403 /* fields: item->u1.str == the random number expression, as supplied by user
1404
1405 item->u2.statements == a pval list of statements in the if ()
1406 item->u3.else_statements == a pval list of statements in the else
1407 (could be zero)
1408 fall thru to PV_IF */
1409
1410 case PV_IFTIME:
1411 /* fields: item->u1.list == the time values, 4 of them, as PV_WORD structs in a list
1412
1413 item->u2.statements == a pval list of statements in the if ()
1414 item->u3.else_statements == a pval list of statements in the else
1415 (could be zero)
1416 fall thru to PV_IF*/
1417 case PV_IF:
1418 /* fields: item->u1.str == the if conditional, as supplied by user
1419
1420 item->u2.statements == a pval list of statements in the if ()
1421 item->u3.else_statements == a pval list of statements in the else
1422 (could be zero)
1423 */
1424 find_pval_gotos(item->u2.statements,lev+1);
1425
1426 if (item->u3.else_statements) {
1427 find_pval_gotos(item->u3.else_statements,lev+1);
1428 }
1429 break;
1430
1431 case PV_SWITCH:
1432 /* fields: item->u1.str == the switch expression
1433
1434 item->u2.statements == a pval list of statements in the switch,
1435 (will be case statements, most likely!)
1436 */
1437 find_pval_gotos(item->u3.else_statements,lev+1);
1438 break;
1439
1440 case PV_EXTENSION:
1441 /* fields: item->u1.str == the extension name, label, whatever it's called
1442
1443 item->u2.statements == a pval list of statements in the extension
1444 item->u3.hints == a char * hint argument
1445 item->u4.regexten == an int boolean. non-zero says that regexten was specified
1446 */
1447
1448 find_pval_gotos(item->u2.statements,lev+1);
1449 break;
1450
1451 default:
1452 break;
1453 }
1454 }
1455
1456 static void find_pval_gotos(pval *item,int lev)
1457 {
1458 pval *i;
1459
1460 for (i=item; i; i=i->next) {
1461
1462 find_pval_goto_item(i, lev);
1463 }
1464 }
1465
1466
1467
1468 /* general purpose label finder */
1469 static struct pval *match_pval_item(pval *item)
1470 {
1471 pval *x;
1472
1473 switch ( item->type ) {
1474 case PV_MACRO:
1475 /* fields: item->u1.str == name of macro
1476 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
1477 item->u2.arglist->u1.str == argument
1478 item->u2.arglist->next == next arg
1479
1480 item->u3.macro_statements == pval list of statements in macro body.
1481 */
1482 /* printf(" matching in MACRO %s, match_context=%s; retoncontmtch=%d; \n", item->u1.str, match_context, return_on_context_match); */
1483 if (!strcmp(match_context,"*") || !strcmp(item->u1.str, match_context)) {
1484
1485 /* printf("MACRO: match context is: %s\n", match_context); */
1486
1487 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 */ {
1488 /* printf("Returning on matching macro %s\n", match_context); */
1489 return item;
1490 }
1491
1492
1493 if (!return_on_context_match) {
1494 /* printf("Descending into matching macro %s/%s\n", match_context, item->u1.str); */
1495 if ((x=match_pval(item->u3.macro_statements))) {
1496 /* printf("Responded with pval match %x\n", x); */
1497 return x;
1498 }
1499 }
1500 } else {
1501 /* printf("Skipping context/macro %s\n", item->u1.str); */
1502 }
1503
1504 break;
1505
1506 case PV_CONTEXT:
1507 /* fields: item->u1.str == name of context
1508 item->u2.statements == pval list of statements in context body
1509 item->u3.abstract == int 1 if an abstract keyword were present
1510 */
1511 /* printf(" matching in CONTEXT\n"); */
1512 if (!strcmp(match_context,"*") || !strcmp(item->u1.str, match_context)) {
1513 if (return_on_context_match && !strcmp(item->u1.str, match_context)) {
1514 /* printf("Returning on matching context %s\n", match_context); */
1515 /* printf("non-CONTEXT: Responded with pval match %x\n", x); */
1516 return item;
1517 }
1518
1519 if (!return_on_context_match ) {
1520 /* printf("Descending into matching context %s\n", match_context); */
1521 if ((x=match_pval(item->u2.statements))) /* if we're just searching for a context, don't bother descending into them */ {
1522 /* printf("CONTEXT: Responded with pval match %x\n", x); */
1523 return x;
1524 }
1525 }
1526 } else {
1527 /* printf("Skipping context/macro %s\n", item->u1.str); */
1528 }
1529 break;
1530
1531 case PV_CASE:
1532 /* fields: item->u1.str == value of case
1533 item->u2.statements == pval list of statements under the case
1534 */
1535 /* printf(" matching in CASE\n"); */
1536 if ((x=match_pval(item->u2.statements))) {
1537 /* printf("CASE: Responded with pval match %x\n", x); */
1538 return x;
1539 }
1540 break;
1541
1542 case PV_PATTERN:
1543 /* fields: item->u1.str == value of case
1544 item->u2.statements == pval list of statements under the case
1545 */
1546 /* printf(" matching in PATTERN\n"); */
1547 if ((x=match_pval(item->u2.statements))) {
1548 /* printf("PATTERN: Responded with pval match %x\n", x); */
1549 return x;
1550 }
1551 break;
1552
1553 case PV_DEFAULT:
1554 /* fields:
1555 item->u2.statements == pval list of statements under the case
1556 */
1557 /* printf(" matching in DEFAULT\n"); */
1558 if ((x=match_pval(item->u2.statements))) {
1559 /* printf("DEFAULT: Responded with pval match %x\n", x); */
1560 return x;
1561 }
1562 break;
1563
1564 case PV_CATCH:
1565 /* fields: item->u1.str == name of extension to catch
1566 item->u2.statements == pval list of statements in context body
1567 */
1568 /* printf(" matching in CATCH\n"); */
1569 if (!strcmp(match_exten,"*") || extension_matches(item, match_exten, item->u1.str) ) {
1570 /* printf("Descending into matching catch %s => %s\n", match_exten, item->u1.str); */
1571 if (strcmp(match_label,"1") == 0) {
1572 if (item->u2.statements) {
1573 struct pval *p5 = item->u2.statements;
1574 while (p5 && p5->type == PV_LABEL) /* find the first non-label statement in this context. If it exists, there's a "1" */
1575 p5 = p5->next;
1576 if (p5)
1577 return p5;
1578 else
1579 return 0;
1580 }
1581 else
1582 return 0;
1583 }
1584
1585 if ((x=match_pval(item->u2.statements))) {
1586 /* printf("CATCH: Responded with pval match %x\n", (unsigned int)x); */
1587 return x;
1588 }
1589 } else {
1590 /* printf("Skipping catch %s\n", item->u1.str); */
1591 }
1592 break;
1593
1594 case PV_STATEMENTBLOCK:
1595 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
1596 */
1597 /* printf(" matching in STATEMENTBLOCK\n"); */
1598 if ((x=match_pval(item->u1.list))) {
1599 /* printf("STATEMENTBLOCK: Responded with pval match %x\n", x); */
1600 return x;
1601 }
1602 break;
1603
1604 case PV_LABEL:
1605 /* fields: item->u1.str == label name
1606 */
1607 /* printf("PV_LABEL %s (cont=%s, exten=%s\n",
1608 item->u1.str, current_context->u1.str, (current_extension?current_extension->u1.str:"<macro>"));*/
1609
1610 if (count_labels) {
1611 if (!strcmp(match_label, item->u1.str)) {
1612 label_count++;
1613 last_matched_label = item;
1614 }
1615
1616 } else {
1617 if (!strcmp(match_label, item->u1.str)) {
1618 /* printf("LABEL: Responded with pval match %x\n", x); */
1619 return item;
1620 }
1621 }
1622 break;
1623
1624 case PV_FOR:
1625 /* fields: item->u1.for_init == a string containing the initalizer
1626 item->u2.for_test == a string containing the loop test
1627 item->u3.for_inc == a string containing the loop increment
1628
1629 item->u4.for_statements == a pval list of statements in the for ()
1630 */
1631 /* printf(" matching in FOR\n"); */
1632 if ((x=match_pval(item->u4.for_statements))) {
1633 /* printf("FOR: Responded with pval match %x\n", x);*/
1634 return x;
1635 }
1636 break;
1637
1638 case PV_WHILE:
1639 /* fields: item->u1.str == the while conditional, as supplied by user
1640
1641 item->u2.statements == a pval list of statements in the while ()
1642 */
1643 /* printf(" matching in WHILE\n"); */
1644 if ((x=match_pval(item->u2.statements))) {
1645 /* printf("WHILE: Responded with pval match %x\n", x); */
1646 return x;
1647 }
1648 break;
1649
1650 case PV_RANDOM:
1651 /* fields: item->u1.str == the random number expression, as supplied by user
1652
1653 item->u2.statements == a pval list of statements in the if ()
1654 item->u3.else_statements == a pval list of statements in the else
1655 (could be zero)
1656 fall thru to PV_IF */
1657
1658 case PV_IFTIME:
1659 /* fields: item->u1.list == the time values, 4 of them, as PV_WORD structs in a list
1660
1661 item->u2.statements == a pval list of statements in the if ()
1662 item->u3.else_statements == a pval list of statements in the else
1663 (could be zero)
1664 fall thru to PV_IF*/
1665 case PV_IF:
1666 /* fields: item->u1.str == the if conditional, as supplied by user
1667
1668 item->u2.statements == a pval list of statements in the if ()
1669 item->u3.else_statements == a pval list of statements in the else
1670 (could be zero)
1671 */
1672 /* printf(" matching in IF/IFTIME/RANDOM\n"); */
1673 if ((x=match_pval(item->u2.statements))) {
1674 return x;
1675 }
1676 if (item->u3.else_statements) {
1677 if ((x=match_pval(item->u3.else_statements))) {
1678 /* printf("IF/IFTIME/RANDOM: Responded with pval match %x\n", x); */
1679 return x;
1680 }
1681 }
1682 break;
1683
1684 case PV_SWITCH:
1685 /* fields: item->u1.str == the switch expression
1686
1687 item->u2.statements == a pval list of statements in the switch,
1688 (will be case statements, most likely!)
1689 */
1690 /* printf(" matching in SWITCH\n"); */
1691 if ((x=match_pval(item->u2.statements))) {
1692 /* printf("SWITCH: Responded with pval match %x\n", x); */
1693 return x;
1694 }
1695 break;
1696
1697 case PV_EXTENSION:
1698 /* fields: item->u1.str == the extension name, label, whatever it's called
1699
1700 item->u2.statements == a pval list of statements in the extension
1701 item->u3.hints == a char * hint argument
1702 item->u4.regexten == an int boolean. non-zero says that regexten was specified
1703 */
1704 /* printf(" matching in EXTENSION\n"); */
1705 if (!strcmp(match_exten,"*") || extension_matches(item, match_exten, item->u1.str) ) {
1706 /* printf("Descending into matching exten %s => %s\n", match_exten, item->u1.str); */
1707 if (strcmp(match_label,"1") == 0) {
1708 if (item->u2.statements) {
1709 struct pval *p5 = item->u2.statements;
1710 while (p5 && p5->type == PV_LABEL) /* find the first non-label statement in this context. If it exists, there's a "1" */
1711 p5 = p5->next;
1712 if (p5)
1713 return p5;
1714 else
1715 return 0;
1716 }
1717 else
1718 return 0;
1719 }
1720
1721 if ((x=match_pval(item->u2.statements))) {
1722 /* printf("EXTENSION: Responded with pval match %x\n", x); */
1723 return x;
1724 }
1725 } else {
1726 /* printf("Skipping exten %s\n", item->u1.str); */
1727 }
1728 break;
1729 default:
1730 /* printf(" matching in default = %d\n", item->type); */
1731 break;
1732 }
1733 return 0;
1734 }
1735
1736 struct pval *match_pval(pval *item)
1737 {
1738 pval *i;
1739
1740 for (i=item; i; i=i->next) {
1741 pval *x;
1742 /* printf(" -- match pval: item %d\n", i->type); */
1743
1744 if ((x = match_pval_item(i))) {
1745 /* printf("match_pval: returning x=%x\n", (int)x); */
1746 return x; /* cut the search short */
1747 }
1748 }
1749 return 0;
1750 }
1751
1752 #if 0
1753 int count_labels_in_current_context(char *label)
1754 {
1755 label_count = 0;
1756 count_labels = 1;
1757 return_on_context_match = 0;
1758 match_pval(current_context->u2.statements);
1759
1760 return label_count;
1761 }
1762 #endif
1763
1764 struct pval *find_first_label_in_current_context(char *label, pval *curr_cont)
1765 {
1766 /* printf(" --- Got args %s, %s\n", exten, label); */
1767 struct pval *ret;
1768 struct pval *p3;
1769 struct pval *startpt = ((curr_cont->type==PV_MACRO)?curr_cont->u3.macro_statements: curr_cont->u2.statements);
1770
1771 count_labels = 0;
1772 return_on_context_match = 0;
1773 match_context = "*";
1774 match_exten = "*";
1775 match_label = label;
1776
1777 ret = match_pval(curr_cont);
1778 if (ret)
1779 return ret;
1780
1781 /* the target of the goto could be in an included context!! Fancy that!! */
1782 /* look for includes in the current context */
1783 for (p3=startpt; p3; p3=p3->next) {
1784 if (p3->type == PV_INCLUDES) {
1785 struct pval *p4;
1786 for (p4=p3->u1.list; p4; p4=p4->next) {
1787 /* for each context pointed to, find it, then find a context/label that matches the
1788 target here! */
1789 char *incl_context = p4->u1.str;
1790 /* find a matching context name */
1791 struct pval *that_context = find_context(incl_context);
1792 if (that_context) {
1793 struct pval *x3;
1794 x3 = find_first_label_in_current_context(label, that_context);
1795 if (x3) {
1796 return x3;
1797 }
1798 }
1799 }
1800 }
1801 }
1802 return 0;
1803 }
1804
1805 struct pval *find_label_in_current_context(char *exten, char *label, pval *curr_cont)
1806 {
1807 /* printf(" --- Got args %s, %s\n", exten, label); */
1808 struct pval *ret;
1809 struct pval *p3;
1810 struct pval *startpt;
1811
1812 count_labels = 0;
1813 return_on_context_match = 0;
1814 match_context = "*";
1815 match_exten = exten;
1816 match_label = label;
1817 if (curr_cont->type == PV_MACRO)
1818 startpt = curr_cont->u3.macro_statements;
1819 else
1820 startpt = curr_cont->u2.statements;
1821
1822 ret = match_pval(startpt);
1823 if (ret)
1824 return ret;
1825
1826 /* the target of the goto could be in an included context!! Fancy that!! */
1827 /* look for includes in the current context */
1828 for (p3=startpt; p3; p3=p3->next) {
1829 if (p3->type == PV_INCLUDES) {
1830 struct pval *p4;
1831 for (p4=p3->u1.list; p4; p4=p4->next) {
1832 /* for each context pointed to, find it, then find a context/label that matches the
1833 target here! */
1834 char *incl_context = p4->u1.str;
1835 /* find a matching context name */
1836 struct pval *that_context = find_context(incl_context);
1837 if (that_context) {
1838 struct pval *x3;
1839 x3 = find_label_in_current_context(exten, label, that_context);
1840 if (x3) {
1841 return x3;
1842 }
1843 }
1844 }
1845 }
1846 }
1847 return 0;
1848 }
1849
1850 static struct pval *find_label_in_current_extension(const char *label, pval *curr_ext)
1851 {
1852 /* printf(" --- Got args %s\n", label); */
1853 count_labels = 0;
1854 return_on_context_match = 0;
1855 match_context = "*";
1856 match_exten = "*";
1857 match_label = label;
1858 return match_pval(curr_ext);
1859 }
1860
1861 static struct pval *find_label_in_current_db(const char *context, const char *exten, const char *label)
1862 {
1863 /* printf(" --- Got args %s, %s, %s\n", context, exten, label); */
1864 count_labels = 0;
1865 return_on_context_match = 0;
1866
1867 match_context = context;
1868 match_exten = exten;
1869 match_label = label;
1870
1871 return match_pval(current_db);
1872 }
1873
1874
1875 struct pval *find_macro(char *name)
1876 {
1877 return_on_context_match = 1;
1878 count_labels = 0;
1879 match_context = name;
1880 match_exten = "*"; /* don't really need to set these, shouldn't be reached */
1881 match_label = "*";
1882 return match_pval(current_db);
1883 }
1884
1885 struct pval *find_context(char *name)
1886 {
1887 return_on_context_match = 1;
1888 count_labels = 0;
1889 match_context = name;
1890 match_exten = "*"; /* don't really need to set these, shouldn't be reached */
1891 match_label = "*";
1892 return match_pval(current_db);
1893 }
1894
1895 int is_float(char *arg )
1896 {
1897 char *s;
1898 for (s=arg; *s; s++) {
1899 if (*s != '.' && (*s < '0' || *s > '9'))
1900 return 0;
1901 }
1902 return 1;
1903 }
1904 int is_int(char *arg )
1905 {
1906 char *s;
1907 for (s=arg; *s; s++) {
1908 if (*s < '0' || *s > '9')
1909 return 0;
1910 }
1911 return 1;
1912 }
1913 int is_empty(char *arg)
1914 {
1915 if (!arg)
1916 return 1;
1917 if (*arg == 0)
1918 return 1;
1919 while (*arg) {
1920 if (*arg != ' ' && *arg != '\t')
1921 return 0;
1922 arg++;
1923 }
1924 return 1;
1925 }
1926
1927 #ifdef AAL_ARGCHECK
1928 int option_matches_j( struct argdesc *should, pval *is, struct argapp *app)
1929 {
1930 struct argchoice *ac;
1931 char *opcop,*q,*p;
1932
1933 switch (should->dtype) {
1934 case ARGD_OPTIONSET:
1935 if ( strstr(is->u1.str,"${") )
1936 return 0; /* no checking anything if there's a var reference in there! */
1937
1938 opcop = ast_strdupa(is->u1.str);
1939
1940 for (q=opcop;*q;q++) { /* erase the innards of X(innard) type arguments, so we don't get confused later */
1941 if ( *q == '(' ) {
1942 p = q+1;
1943 while (*p && *p != ')' )
1944 *p++ = '+';
1945 q = p+1;
1946 }
1947 }
1948
1949 for (ac=app->opts; ac; ac=ac->next) {
1950 if (strlen(ac->name)>1 && strchr(ac->name,'(') == 0 && strcmp(ac->name,is->u1.str) == 0) /* multichar option, no parens, and a match? */
1951 return 0;
1952 }
1953 for (ac=app->opts; ac; ac=ac->next) {
1954 if (strlen(ac->name)==1 || strchr(ac->name,'(')) {
1955 char *p = strchr(opcop,ac->name[0]); /* wipe out all matched options in the user-supplied string */
1956
1957 if (p && *p == 'j') {
1958 ast_log(LOG_ERROR, "Error: file %s, line %d-%d: The j option in the %s application call is not appropriate for AEL!\n",
1959 is->filename, is->startline, is->endline, app->name);
1960 errs++;
1961 }
1962
1963 if (p) {
1964 *p = '+';
1965 if (ac->name[1] == '(') {
1966 if (*(p+1) != '(') {
1967 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",
1968 is->filename, is->startline, is->endline, ac->name[0], app->name);
1969 warns++;
1970 }
1971 }
1972 }
1973 }
1974 }
1975 for (q=opcop; *q; q++) {
1976 if ( *q != '+' && *q != '(' && *q != ')') {
1977 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",
1978 is->filename, is->startline, is->endline, *q, app->name);
1979 warns++;
1980 }
1981 }
1982 return 1;
1983 break;
1984 default:
1985 return 0;
1986 }
1987
1988 }
1989
1990 int option_matches( struct argdesc *should, pval *is, struct argapp *app)
1991 {
1992 struct argchoice *ac;
1993 char *opcop;
1994
1995 switch (should->dtype) {
1996 case ARGD_STRING:
1997 if (is_empty(is->u1.str) && should->type == ARGD_REQUIRED)
1998 return 0;
1999 if (is->u1.str && strlen(is->u1.str) > 0) /* most will match */
2000 return 1;
2001 break;
2002
2003 case ARGD_INT:
2004 if (is_int(is->u1.str))
2005 return 1;
2006 else
2007 return 0;
2008 break;
2009
2010 case ARGD_FLOAT:
2011 if (is_float(is->u1.str))
2012 return 1;
2013 else
2014 return 0;
2015 break;
2016
2017 case ARGD_ENUM:
2018 if( !is->u1.str || strlen(is->u1.str) == 0 )
2019 return 1; /* a null arg in the call will match an enum, I guess! */
2020 for (ac=should->choices; ac; ac=ac->next) {
2021 if (strcmp(ac->name,is->u1.str) == 0)
2022 return 1;
2023 }
2024 return 0;
2025 break;
2026
2027 case ARGD_OPTIONSET:
2028 opcop = ast_strdupa(is->u1.str);
2029
2030 for (ac=app->opts; ac; ac=ac->next) {
2031 if (strlen(ac->name)>1 && strchr(ac->name,'(') == 0 && strcmp(ac->name,is->u1.str) == 0) /* multichar option, no parens, and a match? */
2032 return 1;
2033 }
2034 for (ac=app->opts; ac; ac=ac->next) {
2035 if (strlen(ac->name)==1 || strchr(ac->name,'(')) {
2036 char *p = strchr(opcop,ac->name[0]); /* wipe out all matched options in the user-supplied string */
2037
2038 if (p) {
2039 *p = '+';
2040 if (ac->name[1] == '(') {
2041 if (*(p+1) == '(') {
2042 char *q = p+1;
2043 while (*q && *q != ')') {
2044 *q++ = '+';
2045 }
2046 *q = '+';
2047 }
2048 }
2049 }
2050 }
2051 }
2052 return 1;
2053 break;
2054 case ARGD_VARARG:
2055 return 1; /* matches anything */
2056 break;
2057 }
2058 return 1; /* unless some for-sure match or non-match returns, then it must be close enough ... */
2059 }
2060 #endif
2061
2062 int check_app_args(pval* appcall, pval *arglist, struct argapp *app)
2063 {
2064 #ifdef AAL_ARGCHECK
2065 struct argdesc *ad = app->args;
2066 pval *pa;
2067 int z;
2068
2069 for (pa = arglist; pa; pa=pa->next) {
2070 if (!ad) {
2071 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Extra argument %s not in application call to %s !\n",
2072 arglist->filename, arglist->startline, arglist->endline, pa->u1.str, app->name);
2073 warns++;
2074 return 1;
2075 } else {
2076 /* find the first entry in the ad list that will match */
2077 do {
2078 if ( ad->dtype == ARGD_VARARG ) /* once we hit the VARARG, all bets are off. Discontinue the comparisons */
2079 break;
2080
2081 z= option_matches( ad, pa, app);
2082 if (!z) {
2083 if ( !arglist )
2084 arglist=appcall;
2085
2086 if (ad->type == ARGD_REQUIRED) {
2087 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
2088 arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
2089 warns++;
2090 return 1;
2091 }
2092 } else if (z && ad->dtype == ARGD_OPTIONSET) {
2093 option_matches_j( ad, pa, app);
2094 }
2095 ad = ad->next;
2096 } while (ad && !z);
2097 }
2098 }
2099 /* any app nodes left, that are not optional? */
2100 for ( ; ad; ad=ad->next) {
2101 if (ad->type == ARGD_REQUIRED && ad->dtype != ARGD_VARARG) {
2102 if ( !arglist )
2103 arglist=appcall;
2104 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Required argument %s not in application call to %s !\n",
2105 arglist->filename, arglist->startline, arglist->endline, ad->dtype==ARGD_OPTIONSET?"options":ad->name, app->name);
2106 warns++;
2107 return 1;
2108 }
2109 }
2110 return 0;
2111 #else
2112 return 0;
2113 #endif
2114 }
2115
2116 void check_switch_expr(pval *item, struct argapp *apps)
2117 {
2118 #ifdef AAL_ARGCHECK
2119 /* get and clean the variable name */
2120 char *buff1, *p;
2121 struct argapp *a,*a2;
2122 struct appsetvar *v,*v2;
2123 struct argchoice *c;
2124 pval *t;
2125
2126 p = item->u1.str;
2127 while (p && *p && (*p == ' ' || *p == '\t' || *p == '$' || *p == '{' ) )
2128 p++;
2129
2130 buff1 = ast_strdupa(p);
2131
2132 while (strlen(buff1) > 0 && ( buff1[strlen(buff1)-1] == '}' || buff1[strlen(buff1)-1] == ' ' || buff1[strlen(buff1)-1] == '\t'))
2133 buff1[strlen(buff1)-1] = 0;
2134 /* buff1 now contains the variable name */
2135 v = 0;
2136 for (a=apps; a; a=a->next) {
2137 for (v=a->setvars;v;v=v->next) {
2138 if (strcmp(v->name,buff1) == 0) {
2139 break;
2140 }
2141 }
2142 if ( v )
2143 break;
2144 }
2145 if (v && v->vals) {
2146 /* we have a match, to a variable that has a set of determined values */
2147 int def= 0;
2148 int pat = 0;
2149 int f1 = 0;
2150
2151 /* first of all, does this switch have a default case ? */
2152 for (t=item->u2.statements; t; t=t->next) {
2153 if (t->type == PV_DEFAULT) {
2154 def =1;
2155 break;
2156 }
2157 if (t->type == PV_PATTERN) {
2158 pat++;
2159 }
2160 }
2161 if (def || pat) /* nothing to check. All cases accounted for! */
2162 return;
2163 for (c=v->vals; c; c=c->next) {
2164 f1 = 0;
2165 for (t=item->u2.statements; t; t=t->next) {
2166 if (t->type == PV_CASE || t->type == PV_PATTERN) {
2167 if (!strcmp(t->u1.str,c->name)) {
2168 f1 = 1;
2169 break;
2170 }
2171 }
2172 }
2173 if (!f1) {
2174 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: switch with expression(%s) does not handle the case of %s !\n",
2175 item->filename, item->startline, item->endline, item->u1.str, c->name);
2176 warns++;
2177 }
2178 }
2179 /* next, is there an app call in the current exten, that would set this var? */
2180 f1 = 0;
2181 t = current_extension->u2.statements;
2182 if ( t && t->type == PV_STATEMENTBLOCK )
2183 t = t->u1.statements;
2184 for (; t && t != item; t=t->next) {
2185 if (t->type == PV_APPLICATION_CALL) {
2186 /* find the application that matches the u1.str */
2187 for (a2=apps; a2; a2=a2->next) {
2188 if (strcasecmp(a2->name, t->u1.str)==0) {
2189 for (v2=a2->setvars; v2; v2=v2->next) {
2190 if (strcmp(v2->name, buff1) == 0) {
2191 /* found an app that sets the var */
2192 f1 = 1;
2193 break;
2194 }
2195 }
2196 }
2197 if (f1)
2198 break;
2199 }
2200 }
2201 if (f1)
2202 break;
2203 }
2204
2205 /* see if it sets the var */
2206 if (!f1) {
2207 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",
2208 item->filename, item->startline, item->endline, item->u1.str);
2209 warns++;
2210 }
2211 }
2212 #else
2213 pval *t,*tl=0,*p2;
2214 int def= 0;
2215
2216 /* first of all, does this switch have a default case ? */
2217 for (t=item->u2.statements; t; t=t->next) {
2218 if (t->type == PV_DEFAULT) {
2219 def =1;
2220 break;
2221 }
2222 tl = t;
2223 }
2224 if (def) /* nothing to check. All cases accounted for! */
2225 return;
2226 /* if no default, warn and insert a default case at the end */
2227 p2 = tl->next = calloc(1, sizeof(struct pval));
2228
2229 p2->type = PV_DEFAULT;
2230 p2->startline = tl->startline;
2231 p2->endline = tl->endline;
2232 p2->startcol = tl->startcol;
2233 p2->endcol = tl->endcol;
2234 p2->filename = strdup(tl->filename);
2235 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: A default case was automatically added to the switch.\n",
2236 p2->filename, p2->startline, p2->endline);
2237 warns++;
2238
2239 #endif
2240 }
2241
2242 static void check_context_names(void)
2243 {
2244 pval *i,*j;
2245 for (i=current_db; i; i=i->next) {
2246 if (i->type == PV_CONTEXT || i->type == PV_MACRO) {
2247 for (j=i->next; j; j=j->next) {
2248 if ( j->type == PV_CONTEXT || j->type == PV_MACRO ) {
2249 if ( !strcmp(i->u1.str, j->u1.str) && !(i->u3.abstract&2) && !(j->u3.abstract&2) )
2250 {
2251 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: The context name (%s) is also declared in file %s, line %d-%d! (and neither is marked 'extend')\n",
2252 i->filename, i->startline, i->endline, i->u1.str, j->filename, j->startline, j->endline);
2253 errs++;
2254 }
2255 }
2256 }
2257 }
2258 }
2259 }
2260
2261 static void check_abstract_reference(pval *abstract_context)
2262 {
2263 pval *i,*j;
2264 /* find some context includes that reference this context */
2265
2266
2267 /* otherwise, print out a warning */
2268 for (i=current_db; i; i=i->next) {
2269 if (i->type == PV_CONTEXT) {
2270 for (j=i->u2. statements; j; j=j->next) {
2271 if ( j->type == PV_INCLUDES ) {
2272 struct pval *p4;
2273 for (p4=j->u1.list; p4; p4=p4->next) {
2274 /* for each context pointed to, find it, then find a context/label that matches the
2275 target here! */
2276 if ( !strcmp(p4->u1.str, abstract_context->u1.str) )
2277 return; /* found a match! */
2278 }
2279 }
2280 }
2281 }
2282 }
2283 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",
2284 abstract_context->filename, abstract_context->startline, abstract_context->endline, abstract_context->u1.str);
2285 warns++;
2286 }
2287
2288
2289 void check_pval_item(pval *item, struct argapp *apps, int in_globals)
2290 {
2291 pval *lp;
2292 #ifdef AAL_ARGCHECK
2293 struct argapp *app, *found;
2294 #endif
2295 struct pval *macro_def;
2296 struct pval *app_def;
2297
2298 char errmsg[4096];
2299 char *strp;
2300
2301 switch (item->type) {
2302 case PV_WORD:
2303 /* fields: item->u1.str == string associated with this (word).
2304 item->u2.arglist == pval list of 4 PV_WORD elements for time values (only in PV_INCLUDES) */
2305 break;
2306
2307 case PV_MACRO:
2308 /* fields: item->u1.str == name of macro
2309 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
2310 item->u2.arglist->u1.str == argument
2311 item->u2.arglist->next == next arg
2312
2313 item->u3.macro_statements == pval list of statements in macro body.
2314 */
2315 in_abstract_context = 0;
2316 current_context = item;
2317 current_extension = 0;
2318 for (lp=item->u2.arglist; lp; lp=lp->next) {
2319
2320 }
2321 check_pval(item->u3.macro_statements, apps,in_globals);
2322 break;
2323
2324 case PV_CONTEXT:
2325 /* fields: item->u1.str == name of context
2326 item->u2.statements == pval list of statements in context body
2327 item->u3.abstract == int 1 if an abstract keyword were present
2328 */
2329 current_context = item;
2330 current_extension = 0;
2331 if ( item->u3.abstract ) {
2332 in_abstract_context = 1;
2333 check_abstract_reference(item);
2334 } else
2335 in_abstract_context = 0;
2336 check_pval(item->u2.statements, apps,in_globals);
2337 break;
2338
2339 case PV_MACRO_CALL:
2340 /* fields: item->u1.str == name of macro to call
2341 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
2342 item->u2.arglist->u1.str == argument
2343 item->u2.arglist->next == next arg
2344 */
2345 macro_def = find_macro(item->u1.str);
2346 if (!macro_def) {
2347 /* here is a good place to check to see if the definition is in extensions.conf! */
2348 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: macro call to non-existent %s ! Hopefully it is present in extensions.conf! \n",
2349 item->filename, item->startline, item->endline, item->u1.str);
2350 warns++;
2351 } else if (macro_def->type != PV_MACRO) {
2352 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: macro call to %s references a context, not a macro!\n",
2353 item->filename, item->startline, item->endline, item->u1.str);
2354 errs++;
2355 } else {
2356 /* macro_def is a MACRO, so do the args match in number? */
2357 int hereargs = 0;
2358 int thereargs = 0;
2359
2360 for (lp=item->u2.arglist; lp; lp=lp->next) {
2361 hereargs++;
2362 }
2363 for (lp=macro_def->u2.arglist; lp; lp=lp->next) {
2364 thereargs++;
2365 }
2366 if (hereargs != thereargs ) {
2367 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",
2368 item->filename, item->startline, item->endline, item->u1.str, hereargs, thereargs);
2369 errs++;
2370 }
2371 }
2372 break;
2373
2374 case PV_APPLICATION_CALL:
2375 /* fields: item->u1.str == name of application to call
2376 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
2377 item->u2.arglist->u1.str == argument
2378 item->u2.arglist->next == next arg
2379 */
2380 /* Need to check to see if the application is available! */
2381 app_def = find_context(item->u1.str);
2382 if (app_def && app_def->type == PV_MACRO) {
2383 ast_log(LOG_ERROR,"Error: file %s, line %d-%d: application call to %s references an existing macro, but had no & preceding it!\n",
2384 item->filename, item->startline, item->endline, item->u1.str);
2385 errs++;
2386 }
2387 if (strcasecmp(item->u1.str,"GotoIf") == 0
2388 || strcasecmp(item->u1.str,"GotoIfTime") == 0
2389 || strcasecmp(item->u1.str,"while") == 0
2390 || strcasecmp(item->u1.str,"endwhile") == 0
2391 || strcasecmp(item->u1.str,"random") == 0
2392 || strcasecmp(item->u1.str,"execIf") == 0 ) {
2393 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: application call to %s needs to be re-written using AEL if, while, goto, etc. keywords instead!\n",
2394 item->filename, item->startline, item->endline, item->u1.str);
2395 warns++;
2396 }
2397 #ifdef AAL_ARGCHECK
2398 found = 0;
2399 for (app=apps; app; app=app->next) {
2400 if (strcasecmp(app->name, item->u1.str) == 0) {
2401 found =app;
2402 break;
2403 }
2404 }
2405 if (!found) {
2406 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: application call to %s not listed in applist database!\n",
2407 item->filename, item->startline, item->endline, item->u1.str);
2408 warns++;
2409 } else
2410 check_app_args(item, item->u2.arglist, app);
2411 #endif
2412 break;
2413
2414 case PV_CASE:
2415 /* fields: item->u1.str == value of case
2416 item->u2.statements == pval list of statements under the case
2417 */
2418 /* Make sure sequence of statements under case is terminated with goto, return, or break */
2419 /* find the last statement */
2420 check_pval(item->u2.statements, apps,in_globals);
2421 break;
2422
2423 case PV_PATTERN:
2424 /* fields: item->u1.str == value of case
2425 item->u2.statements == pval list of statements under the case
2426 */
2427 /* Make sure sequence of statements under case is terminated with goto, return, or break */
2428 /* find the last statement */
2429
2430 check_pval(item->u2.statements, apps,in_globals);
2431 break;
2432
2433 case PV_DEFAULT:
2434 /* fields:
2435 item->u2.statements == pval list of statements under the case
2436 */
2437
2438 check_pval(item->u2.statements, apps,in_globals);
2439 break;
2440
2441 case PV_CATCH:
2442 /* fields: item->u1.str == name of extension to catch
2443 item->u2.statements == pval list of statements in context body
2444 */
2445 check_pval(item->u2.statements, apps,in_globals);
2446 break;
2447
2448 case PV_SWITCHES:
2449 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
2450 */
2451 check_pval(item->u1.list, apps,in_globals);
2452 break;
2453
2454 case PV_ESWITCHES:
2455 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
2456 */
2457 check_pval(item->u1.list, apps,in_globals);
2458 break;
2459
2460 case PV_INCLUDES:
2461 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
2462 */
2463 check_pval(item->u1.list, apps,in_globals);
2464 check_includes(item);
2465 for (lp=item->u1.list; lp; lp=lp->next){
2466 char *incl_context = lp->u1.str;
2467 struct pval *that_context = find_context(incl_context);
2468
2469 if ( lp->u2.arglist ) {
2470 check_timerange(lp->u2.arglist);
2471 check_dow(lp->u2.arglist->next);
2472 check_day(lp->u2.arglist->next->next);
2473 check_month(lp->u2.arglist->next->next->next);
2474 }
2475
2476 if (that_context) {
2477 find_pval_gotos(that_context->u2.statements,0);
2478
2479 }
2480 }
2481 break;
2482
2483 case PV_STATEMENTBLOCK:
2484 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
2485 */
2486 check_pval(item->u1.list, apps,in_globals);
2487 break;
2488
2489 case PV_VARDEC:
2490 /* fields: item->u1.str == variable name
2491 item->u2.val == variable value to assign
2492 */
2493 /* the RHS of a vardec is encapsulated in a $[] expr. Is it legal? */
2494 if( !in_globals ) { /* don't check stuff inside the globals context; no wrapping in $[ ] there... */
2495 snprintf(errmsg,sizeof(errmsg), "file %s, line %d, columns %d-%d, variable declaration expr '%s':", config, item->startline, item->startcol, item->endcol, item->u2.val);
2496 ast_expr_register_extra_error_info(errmsg);
2497 ast_expr(item->u2.val, expr_output, sizeof(expr_output));
2498 ast_expr_clear_extra_error_info();
2499 if ( strpbrk(item->u2.val,"~!-+<>=*/&^") && !strstr(item->u2.val,"${") ) {
2500 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2501 item->filename, item->startline, item->endline, item->u2.val);
2502 warns++;
2503 }
2504 check_expr2_input(item,item->u2.val);
2505 }
2506 break;
2507
2508 case PV_GOTO:
2509 /* fields: item->u1.list == pval list of PV_WORD target names, up to 3, in order as given by user.
2510 item->u1.list->u1.str == where the data on a PV_WORD will always be.
2511 */
2512 /* don't check goto's in abstract contexts */
2513 if ( in_abstract_context )
2514 break;
2515
2516 check_goto(item);
2517 break;
2518
2519 case PV_LABEL:
2520 /* fields: item->u1.str == label name
2521 */
2522 if ( strspn(item->u1.str, "0123456789") == strlen(item->u1.str) ) {
2523 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: label '%s' is numeric, this is bad practice!\n",
2524 item->filename, item->startline, item->endline, item->u1.str);
2525 warns++;
2526 }
2527
2528 check_label(item);
2529 break;
2530
2531 case PV_FOR:
2532 /* fields: item->u1.for_init == a string containing the initalizer
2533 item->u2.for_test == a string containing the loop test
2534 item->u3.for_inc == a string containing the loop increment
2535
2536 item->u4.for_statements == a pval list of statements in the for ()
2537 */
2538 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, for test expr '%s':", config, item->startline, item->startcol, item->endcol, item->u2.for_test);
2539 ast_expr_register_extra_error_info(errmsg);
2540
2541 strp = strchr(item->u1.for_init, '=');
2542 if (strp) {
2543 ast_expr(strp+1, expr_output, sizeof(expr_output));
2544 }
2545 ast_expr(item->u2.for_test, expr_output, sizeof(expr_output));
2546 strp = strchr(item->u3.for_inc, '=');
2547 if (strp) {
2548 ast_expr(strp+1, expr_output, sizeof(expr_output));
2549 }
2550 if ( strpbrk(item->u2.for_test,"~!-+<>=*/&^") && !strstr(item->u2.for_test,"${") ) {
2551 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2552 item->filename, item->startline, item->endline, item->u2.for_test);
2553 warns++;
2554 }
2555 if ( strpbrk(item->u3.for_inc,"~!-+<>=*/&^") && !strstr(item->u3.for_inc,"${") ) {
2556 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2557 item->filename, item->startline, item->endline, item->u3.for_inc);
2558 warns++;
2559 }
2560 check_expr2_input(item,item->u2.for_test);
2561 check_expr2_input(item,item->u3.for_inc);
2562
2563 ast_expr_clear_extra_error_info();
2564 check_pval(item->u4.for_statements, apps,in_globals);
2565 break;
2566
2567 case PV_WHILE:
2568 /* fields: item->u1.str == the while conditional, as supplied by user
2569
2570 item->u2.statements == a pval list of statements in the while ()
2571 */
2572 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, while expr '%s':", config, item->startline, item->startcol, item->endcol, item->u1.str);
2573 ast_expr_register_extra_error_info(errmsg);
2574 ast_expr(item->u1.str, expr_output, sizeof(expr_output));
2575 ast_expr_clear_extra_error_info();
2576 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2577 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression %s has operators, but no variables. Interesting...\n",
2578 item->filename, item->startline, item->endline, item->u1.str);
2579 warns++;
2580 }
2581 check_expr2_input(item,item->u1.str);
2582 check_pval(item->u2.statements, apps,in_globals);
2583 break;
2584
2585 case PV_BREAK:
2586 /* fields: none
2587 */
2588 check_break(item);
2589 break;
2590
2591 case PV_RETURN:
2592 /* fields: none
2593 */
2594 break;
2595
2596 case PV_CONTINUE:
2597 /* fields: none
2598 */
2599 check_continue(item);
2600 break;
2601
2602 case PV_RANDOM:
2603 /* fields: item->u1.str == the random number expression, as supplied by user
2604
2605 item->u2.statements == a pval list of statements in the if ()
2606 item->u3.else_statements == a pval list of statements in the else
2607 (could be zero)
2608 */
2609 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, random expr '%s':", config, item->startline, item->startcol, item->endcol, item->u1.str);
2610 ast_expr_register_extra_error_info(errmsg);
2611 ast_expr(item->u1.str, expr_output, sizeof(expr_output));
2612 ast_expr_clear_extra_error_info();
2613 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2614 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: random expression '%s' has operators, but no variables. Interesting...\n",
2615 item->filename, item->startline, item->endline, item->u1.str);
2616 warns++;
2617 }
2618 check_expr2_input(item,item->u1.str);
2619 check_pval(item->u2.statements, apps,in_globals);
2620 if (item->u3.else_statements) {
2621 check_pval(item->u3.else_statements, apps,in_globals);
2622 }
2623 break;
2624
2625 case PV_IFTIME:
2626 /* fields: item->u1.list == the if time values, 4 of them, each in PV_WORD, linked list
2627
2628 item->u2.statements == a pval list of statements in the if ()
2629 item->u3.else_statements == a pval list of statements in the else
2630 (could be zero)
2631 */
2632 if ( item->u2.arglist ) {
2633 check_timerange(item->u1.list);
2634 check_dow(item->u1.list->next);
2635 check_day(item->u1.list->next->next);
2636 check_month(item->u1.list->next->next->next);
2637 }
2638
2639 check_pval(item->u2.statements, apps,in_globals);
2640 if (item->u3.else_statements) {
2641 check_pval(item->u3.else_statements, apps,in_globals);
2642 }
2643 break;
2644
2645 case PV_IF:
2646 /* fields: item->u1.str == the if conditional, as supplied by user
2647
2648 item->u2.statements == a pval list of statements in the if ()
2649 item->u3.else_statements == a pval list of statements in the else
2650 (could be zero)
2651 */
2652 snprintf(errmsg,sizeof(errmsg),"file %s, line %d, columns %d-%d, if expr '%s':", config, item->startline, item->startcol, item->endcol, item->u1.str);
2653 ast_expr_register_extra_error_info(errmsg);
2654 ast_expr(item->u1.str, expr_output, sizeof(expr_output));
2655 ast_expr_clear_extra_error_info();
2656 if ( strpbrk(item->u1.str,"~!-+<>=*/&^") && !strstr(item->u1.str,"${") ) {
2657 ast_log(LOG_WARNING,"Warning: file %s, line %d-%d: expression '%s' has operators, but no variables. Interesting...\n",
2658 item->filename, item->startline, item->endline, item->u1.str);
2659 warns++;
2660 }
2661 check_expr2_input(item,item->u1.str);
2662 check_pval(item->u2.statements, apps,in_globals);
2663 if (item->u3.else_statements) {
2664 check_pval(item->u3.else_statements, apps,in_globals);
2665 }
2666 break;
2667
2668 case PV_SWITCH:
2669 /* fields: item->u1.str == the switch expression
2670
2671 item->u2.statements == a pval list of statements in the switch,
2672 (will be case statements, most likely!)
2673 */
2674 /* we can check the switch expression, see if it matches any of the app variables...
2675 if it does, then, are all the possible cases accounted for? */
2676 check_switch_expr(item, apps);
2677 check_pval(item->u2.statements, apps,in_globals);
2678 break;
2679
2680 case PV_EXTENSION:
2681 /* fields: item->u1.str == the extension name, label, whatever it's called
2682
2683 item->u2.statements == a pval list of statements in the extension
2684 item->u3.hints == a char * hint argument
2685 item->u4.regexten == an int boolean. non-zero says that regexten was specified
2686 */
2687 current_extension = item ;
2688
2689 check_pval(item->u2.statements, apps,in_globals);
2690 break;
2691
2692 case PV_IGNOREPAT:
2693 /* fields: item->u1.str == the ignorepat data
2694 */
2695 break;
2696
2697 case PV_GLOBALS:
2698 /* fields: item->u1.statements == pval list of statements, usually vardecs
2699 */
2700 in_abstract_context = 0;
2701 check_pval(item->u1.statements, apps, 1);
2702 break;
2703 default:
2704 break;
2705 }
2706 }
2707
2708 void check_pval(pval *item, struct argapp *apps, int in_globals)
2709 {
2710 pval *i;
2711
2712 /* checks to do:
2713 1. Do goto's point to actual labels?
2714 2. Do macro calls reference a macro?
2715 3. Does the number of macro args match the definition?
2716 4. Is a macro call missing its & at the front?
2717 5. Application calls-- we could check syntax for existing applications,
2718 but I need some some sort of universal description bnf for a general
2719 sort of method for checking arguments, in number, maybe even type, at least.
2720 Don't want to hand code checks for hundreds of applications.
2721 */
2722
2723 for (i=item; i; i=i->next) {
2724 check_pval_item(i,apps,in_globals);
2725 }
2726 }
2727
2728 static void ael2_semantic_check(pval *item, int *arg_errs, int *arg_warns, int *arg_notes)
2729 {
2730
2731 #ifdef AAL_ARGCHECK
2732 int argapp_errs =0;
2733 char *rfilename;
2734 #endif
2735 struct argapp *apps=0;
2736
2737 if (!item)
2738 return; /* don't check an empty tree */
2739 #ifdef AAL_ARGCHECK
2740 rfilename = alloca(10 + strlen(ast_config_AST_VAR_DIR));
2741 sprintf(rfilename, "%s/applist", ast_config_AST_VAR_DIR);
2742
2743 apps = argdesc_parse(rfilename, &argapp_errs); /* giveth */
2744 #endif
2745 current_db = item;
2746 errs = warns = notes = 0;
2747
2748 check_context_names();
2749 check_pval(item, apps, 0);
2750
2751 #ifdef AAL_ARGCHECK
2752 argdesc_destroy(apps); /* taketh away */
2753 #endif
2754 current_db = 0;
2755
2756 *arg_errs = errs;
2757 *arg_warns = warns;
2758 *arg_notes = notes;
2759 }
2760
2761 /* =============================================================================================== */
2762 /* "CODE" GENERATOR -- Convert the AEL representation to asterisk extension language */
2763 /* =============================================================================================== */
2764
2765 static int control_statement_count = 0;
2766
2767 struct ael_priority *new_prio(void)
2768 {
2769 struct ael_priority *x = (struct ael_priority *)calloc(sizeof(struct ael_priority),1);
2770 return x;
2771 }
2772
2773 struct ael_extension *new_exten(void)
2774 {
2775 struct ael_extension *x = (struct ael_extension *)calloc(sizeof(struct ael_extension),1);
2776 return x;
2777 }
2778
2779 void linkprio(struct ael_extension *exten, struct ael_priority *prio)
2780 {
2781 if (!exten->plist) {
2782 exten->plist = prio;
2783 exten->plist_last = prio;
2784 } else {
2785 exten->plist_last->next = prio;
2786 exten->plist_last = prio;
2787 }
2788 if( !prio->exten )
2789 prio->exten = exten; /* don't override the switch value */
2790 }
2791
2792 void destroy_extensions(struct ael_extension *exten)
2793 {
2794 struct ael_extension *ne, *nen;
2795 for (ne=exten; ne; ne=nen) {
2796 struct ael_priority *pe, *pen;
2797
2798 if (ne->name)
2799 free(ne->name);
2800
2801 /* cidmatch fields are allocated with name, and freed when
2802 the name field is freed. Don't do a free for this field,
2803 unless you LIKE to see a crash! */
2804
2805 if (ne->hints)
2806 free(ne->hints);
2807
2808 for (pe=ne->plist; pe; pe=pen) {
2809 pen = pe->next;
2810 if (pe->app)
2811 free(pe->app);
2812 pe->app = 0;
2813 if (pe->appargs)
2814 free(pe->appargs);
2815 pe->appargs = 0;
2816 pe->origin = 0;
2817 pe->goto_true = 0;
2818 pe->goto_false = 0;
2819 free(pe);
2820 }
2821 nen = ne->next_exten;
2822 ne->next_exten = 0;
2823 ne->plist =0;
2824 ne->plist_last = 0;
2825 ne->next_exten = 0;
2826 ne->loop_break = 0;
2827 ne->loop_continue = 0;
2828 free(ne);
2829 }
2830 }
2831
2832 static int label_inside_case(pval *label)
2833 {
2834 pval *p = label;
2835
2836 while( p && p->type != PV_MACRO && p->type != PV_CONTEXT ) /* early cutout, sort of */ {
2837 if( p->type == PV_CASE || p->type == PV_DEFAULT || p->type == PV_PATTERN ) {
2838 return 1;
2839 }
2840
2841 p = p->dad;
2842 }
2843 return 0;
2844 }
2845
2846 static void linkexten(struct ael_extension *exten, struct ael_extension *add)
2847 {
2848 add->next_exten = exten->next_exten; /* this will reverse the order. Big deal. */
2849 exten->next_exten = add;
2850 }
2851
2852 static void remove_spaces_before_equals(char *str)
2853 {
2854 char *p;
2855 while( str && *str && *str != '=' )
2856 {
2857 if( *str == ' ' || *str == '\n' || *str == '\r' || *str == '\t' )
2858 {
2859 p = str;
2860 while( *p )
2861 {
2862 *p = *(p+1);
2863 p++;
2864 }
2865 }
2866 else
2867 str++;
2868 }
2869 }
2870
2871 static void gen_match_to_pattern(char *pattern, char *result)
2872 {
2873 /* the result will be a string that will be matched by pattern */
2874 char *p=pattern, *t=result;
2875 while (*p) {
2876 if (*p == 'x' || *p == 'n' || *p == 'z' || *p == 'X' || *p == 'N' || *p == 'Z')
2877 *t++ = '9';
2878 else if (*p == '[') {
2879 char *z = p+1;
2880 while (*z != ']')
2881 z++;
2882 if (*(z+1)== ']')
2883 z++;
2884 *t++=*(p+1); /* use the first char in the set */
2885 p = z;
2886 } else {
2887 *t++ = *p;
2888 }
2889 p++;
2890 }
2891 *t++ = 0; /* cap it off */
2892 }
2893
2894 static void gen_prios(struct ael_extension *exten, char *label, pval *statement, struct ael_extension *mother_exten, struct ast_context *this_context )
2895 {
2896 pval *p,*p2,*p3;
2897 struct ael_priority *pr;
2898 struct ael_priority *for_init, *for_test, *for_inc, *for_loop, *for_end;
2899 struct ael_priority *while_test, *while_loop, *while_end;
2900 struct ael_priority *switch_test, *switch_end, *fall_thru, *switch_empty;
2901 struct ael_priority *if_test, *if_end, *if_skip, *if_false;
2902 #ifdef OLD_RAND_ACTION
2903 struct ael_priority *rand_test, *rand_end, *rand_skip;
2904 #endif
2905 char buf1[2000];
2906 char buf2[2000];
2907 char *strp, *strp2;
2908 char new_label[2000];
2909 int default_exists;
2910 int local_control_statement_count;
2911 struct ael_priority *loop_break_save;
2912 struct ael_priority *loop_continue_save;
2913 struct ael_extension *switch_case,*switch_null;
2914
2915 for (p=statement; p; p=p->next) {
2916 switch (p->type) {
2917 case PV_VARDEC:
2918 pr = new_prio();
2919 pr->type = AEL_APPCALL;
2920 snprintf(buf1,sizeof(buf1),"%s=$[%s]", p->u1.str, p->u2.val);
2921 pr->app = strdup("Set");
2922 remove_spaces_before_equals(buf1);
2923 pr->appargs = strdup(buf1);
2924 pr->origin = p;
2925 linkprio(exten, pr);
2926 break;
2927
2928 case PV_GOTO:
2929 pr = new_prio();
2930 pr->type = AEL_APPCALL;
2931 p->u2.goto_target = get_goto_target(p);
2932 if( p->u2.goto_target ) {
2933 p->u3.goto_target_in_case = p->u2.goto_target->u2.label_in_case = label_inside_case(p->u2.goto_target);
2934 }
2935
2936 if (!p->u1.list->next) /* just one */ {
2937 pr->app = strdup("Goto");
2938 if (!mother_exten)
2939 pr->appargs = strdup(p->u1.list->u1.str);
2940 else { /* for the case of simple within-extension gotos in case/pattern/default statement blocks: */
2941 snprintf(buf1,sizeof(buf1),"%s|%s", mother_exten->name, p->u1.list->u1.str);
2942 pr->appargs = strdup(buf1);
2943 }
2944
2945 } else if (p->u1.list->next && !p->u1.list->next->next) /* two */ {
2946 snprintf(buf1,sizeof(buf1),"%s|%s", p->u1.list->u1.str, p->u1.list->next->u1.str);
2947 pr->app = strdup("Goto");
2948 pr->appargs = strdup(buf1);
2949 } else if (p->u1.list->next && p->u1.list->next->next) {
2950 snprintf(buf1,sizeof(buf1),"%s|%s|%s", p->u1.list->u1.str,
2951 p->u1.list->next->u1.str,
2952 p->u1.list->next->next->u1.str);
2953 pr->app = strdup("Goto");
2954 pr->appargs = strdup(buf1);
2955 }
2956 pr->origin = p;
2957 linkprio(exten, pr);
2958 break;
2959
2960 case PV_LABEL:
2961 pr = new_prio();
2962 pr->type = AEL_LABEL;
2963 pr->origin = p;
2964 p->u3.compiled_label = exten;
2965 linkprio(exten, pr);
2966 break;
2967
2968 case PV_FOR:
2969 control_statement_count++;
2970 loop_break_save = exten->loop_break; /* save them, then restore before leaving */
2971 loop_continue_save = exten->loop_continue;
2972 snprintf(new_label,sizeof(new_label),"for-%s-%d", label, control_statement_count);
2973 for_init = new_prio();
2974 for_inc = new_prio();
2975 for_test = new_prio();
2976 for_loop = new_prio();
2977 for_end = new_prio();
2978 for_init->type = AEL_APPCALL;
2979 for_inc->type = AEL_APPCALL;
2980 for_test->type = AEL_FOR_CONTROL;
2981 for_test->goto_false = for_end;
2982 for_loop->type = AEL_CONTROL1; /* simple goto */
2983 for_end->type = AEL_APPCALL;
2984 for_init->app = strdup("Set");
2985
2986 strcpy(buf2,p->u1.for_init);
2987 remove_spaces_before_equals(buf2);
2988 strp = strchr(buf2, '=');
2989 if (strp) {
2990 strp2 = strchr(p->u1.for_init, '=');
2991 *(strp+1) = 0;
2992 strcat(buf2,"$[");
2993 strncat(buf2,strp2+1, sizeof(buf2)-strlen(strp2+1)-2);
2994 strcat(buf2,"]");
2995 for_init->appargs = strdup(buf2);
2996 /* for_init->app = strdup("Set"); just set! */
2997 } else {
2998 strp2 = p->u1.for_init;
2999 while (*strp2 && isspace(*strp2))
3000 strp2++;
3001 if (*strp2 == '&') { /* itsa macro call */
3002 char *strp3 = strp2+1;
3003 while (*strp3 && isspace(*strp3))
3004 strp3++;
3005 strcpy(buf2, strp3);
3006 strp3 = strchr(buf2,'(');
3007 if (strp3) {
3008 *strp3 = '|';
3009 }
3010 while ((strp3=strchr(buf2,','))) {
3011 *strp3 = '|';
3012 }
3013 strp3 = strrchr(buf2, ')');
3014 if (strp3)
3015 *strp3 = 0; /* remove the closing paren */
3016
3017 for_init->appargs = strdup(buf2);
3018 if (for_init->app)
3019 free(for_init->app);
3020 for_init->app = strdup("Macro");
3021 } else { /* must be a regular app call */
3022 char *strp3;
3023 strcpy(buf2, strp2);
3024 strp3 = strchr(buf2,'(');
3025 if (strp3) {
3026 *strp3 = 0;
3027 if (for_init->app)
3028 free(for_init->app);
3029 for_init->app = strdup(buf2);
3030 for_init->appargs = strdup(strp3+1);
3031 strp3 = strrchr(for_init->appargs, ')');
3032 if (strp3)
3033 *strp3 = 0; /* remove the closing paren */
3034 }
3035 }
3036 }
3037
3038 strcpy(buf2,p->u3.for_inc);
3039 remove_spaces_before_equals(buf2);
3040 strp = strchr(buf2, '=');
3041 if (strp) { /* there's an = in this part; that means an assignment. set it up */
3042 strp2 = strchr(p->u3.for_inc, '=');
3043 *(strp+1) = 0;
3044 strcat(buf2,"$[");
3045 strncat(buf2,strp2+1, sizeof(buf2)-strlen(strp2+1)-2);
3046 strcat(buf2,"]");
3047 for_inc->appargs = strdup(buf2);
3048 for_inc->app = strdup("Set");
3049 } else {
3050 strp2 = p->u3.for_inc;
3051 while (*strp2 && isspace(*strp2))
3052 strp2++;
3053 if (*strp2 == '&') { /* itsa macro call */
3054 char *strp3 = strp2+1;
3055 while (*strp3 && isspace(*strp3))
3056 strp3++;
3057 strcpy(buf2, strp3);
3058 strp3 = strchr(buf2,'(');
3059 if (strp3) {
3060 *strp3 = '|';
3061 }
3062 while ((strp3=strchr(buf2,','))) {
3063 *strp3 = '|';
3064 }
3065 strp3 = strrchr(buf2, ')');
3066 if (strp3)
3067 *strp3 = 0; /* remove the closing paren */
3068
3069 for_inc->appargs = strdup(buf2);
3070
3071 for_inc->app = strdup("Macro");
3072 } else { /* must be a regular app call */
3073 char *strp3;
3074 strcpy(buf2, strp2);
3075 strp3 = strchr(buf2,'(');
3076 if (strp3) {
3077 *strp3 = 0;
3078 for_inc->app = strdup(buf2);
3079 for_inc->appargs = strdup(strp3+1);
3080 strp3 = strrchr(for_inc->appargs, ')');
3081 if (strp3)
3082 *strp3 = 0; /* remove the closing paren */
3083 }
3084 }
3085 }
3086 snprintf(buf1,sizeof(buf1),"$[%s]",p->u2.for_test);
3087 for_test->app = 0;
3088 for_test->appargs = strdup(buf1);
3089 for_loop->goto_true = for_test;
3090 snprintf(buf1,sizeof(buf1),"Finish for-%s-%d", label, control_statement_count);
3091 for_end->app = strdup("NoOp");
3092 for_end->appargs = strdup(buf1);
3093 /* link & load! */
3094 linkprio(exten, for_init);
3095 linkprio(exten, for_test);
3096
3097 /* now, put the body of the for loop here */
3098 exten->loop_break = for_end;
3099 exten->loop_continue = for_inc;
3100
3101 gen_prios(exten, new_label, p->u4.for_statements, mother_exten, this_context); /* this will link in all the statements here */
3102
3103 linkprio(exten, for_inc);
3104 linkprio(exten, for_loop);
3105 linkprio(exten, for_end);
3106
3107
3108 exten->loop_break = loop_break_save;
3109 exten->loop_continue = loop_continue_save;
3110 for_loop->origin = p;
3111 break;
3112
3113 case PV_WHILE:
3114 control_statement_count++;
3115 loop_break_save = exten->loop_break; /* save them, then restore before leaving */
3116 loop_continue_save = exten->loop_continue;
3117 snprintf(new_label,sizeof(new_label),"while-%s-%d", label, control_statement_count);
3118 while_test = new_prio();
3119 while_loop = new_prio();
3120 while_end = new_prio();
3121 while_test->type = AEL_FOR_CONTROL;
3122 while_test->goto_false = while_end;
3123 while_loop->type = AEL_CONTROL1; /* simple goto */
3124 while_end->type = AEL_APPCALL;
3125 snprintf(buf1,sizeof(buf1),"$[%s]",p->u1.str);
3126 while_test->app = 0;
3127 while_test->appargs = strdup(buf1);
3128 while_loop->goto_true = while_test;
3129 snprintf(buf1,sizeof(buf1),"Finish while-%s-%d", label, control_statement_count);
3130 while_end->app = strdup("NoOp");
3131 while_end->appargs = strdup(buf1);
3132
3133 linkprio(exten, while_test);
3134
3135 /* now, put the body of the for loop here */
3136 exten->loop_break = while_end;
3137 exten->loop_continue = while_test;
3138
3139 gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context); /* this will link in all the while body statements here */
3140
3141 linkprio(exten, while_loop);
3142 linkprio(exten, while_end);
3143
3144
3145 exten->loop_break = loop_break_save;
3146 exten->loop_continue = loop_continue_save;
3147 while_loop->origin = p;
3148 break;
3149
3150 case PV_SWITCH:
3151 control_statement_count++;
3152 local_control_statement_count = control_statement_count;
3153 loop_break_save = exten->loop_break; /* save them, then restore before leaving */
3154 loop_continue_save = exten->loop_continue;
3155 snprintf(new_label,sizeof(new_label),"sw-%s-%d", label, control_statement_count);
3156
3157 switch_test = new_prio();
3158 switch_end = new_prio();
3159 switch_test->type = AEL_APPCALL;
3160 switch_end->type = AEL_APPCALL;
3161 strncpy(buf2,p->u1.str,sizeof(buf2));
3162 buf2[sizeof(buf2)-1] = 0; /* just in case */
3163 substitute_commas(buf2);
3164 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10",control_statement_count, buf2);
3165 switch_test->app = strdup("Goto");
3166 switch_test->appargs = strdup(buf1);
3167 snprintf(buf1,sizeof(buf1),"Finish switch-%s-%d", label, control_statement_count);
3168 switch_end->app = strdup("NoOp");
3169 switch_end->appargs = strdup(buf1);
3170 switch_end->origin = p;
3171 switch_end->exten = exten;
3172
3173 linkprio(exten, switch_test);
3174 linkprio(exten, switch_end);
3175
3176 exten->loop_break = switch_end;
3177 exten->loop_continue = 0;
3178 default_exists = 0;
3179
3180 for (p2=p->u2.statements; p2; p2=p2->next) {
3181 /* now, for each case/default put the body of the for loop here */
3182 if (p2->type == PV_CASE) {
3183 /* ok, generate a extension and link it in */
3184 switch_case = new_exten();
3185 switch_case->context = this_context;
3186 switch_case->is_switch = 1;
3187 /* the break/continue locations are inherited from parent */
3188 switch_case->loop_break = exten->loop_break;
3189 switch_case->loop_continue = exten->loop_continue;
3190
3191 linkexten(exten,switch_case);
3192 strncpy(buf2,p2->u1.str,sizeof(buf2));
3193 buf2[sizeof(buf2)-1] = 0; /* just in case */
3194 substitute_commas(buf2);
3195 snprintf(buf1,sizeof(buf1),"sw-%d-%s", local_control_statement_count, buf2);
3196 switch_case->name = strdup(buf1);
3197 snprintf(new_label,sizeof(new_label),"sw-%s-%s-%d", label, buf2, local_control_statement_count);
3198
3199 gen_prios(switch_case, new_label, p2->u2.statements, exten, this_context); /* this will link in all the case body statements here */
3200
3201 /* here is where we write code to "fall thru" to the next case... if there is one... */
3202 for (p3=p2->u2.statements; p3; p3=p3->next) {
3203 if (!p3->next)
3204 break;
3205 }
3206 /* p3 now points the last statement... */
3207 if (!p3 || ( p3->type != PV_GOTO && p3->type != PV_BREAK && p3->type != PV_RETURN) ) {
3208 /* is there a following CASE/PATTERN/DEFAULT? */
3209 if (p2->next && p2->next->type == PV_CASE) {
3210 fall_thru = new_prio();
3211 fall_thru->type = AEL_APPCALL;
3212 fall_thru->app = strdup("Goto");
3213 strncpy(buf2,p2->next->u1.str,sizeof(buf2));
3214 buf2[sizeof(buf2)-1] = 0; /* just in case */
3215 substitute_commas(buf2);
3216 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10",local_control_statement_count, buf2);
3217 fall_thru->appargs = strdup(buf1);
3218 linkprio(switch_case, fall_thru);
3219 } else if (p2->next && p2->next->type == PV_PATTERN) {
3220 fall_thru = new_prio();
3221 fall_thru->type = AEL_APPCALL;
3222 fall_thru->app = strdup("Goto");
3223 gen_match_to_pattern(p2->next->u1.str, buf2);
3224 substitute_commas(buf2);
3225 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10", local_control_statement_count, buf2);
3226 fall_thru->appargs = strdup(buf1);
3227 linkprio(switch_case, fall_thru);
3228 } else if (p2->next && p2->next->type == PV_DEFAULT) {
3229 fall_thru = new_prio();
3230 fall_thru->type = AEL_APPCALL;
3231 fall_thru->app = strdup("Goto");
3232 snprintf(buf1,sizeof(buf1),"sw-%d-.|10",local_control_statement_count);
3233 fall_thru->appargs = strdup(buf1);
3234 linkprio(switch_case, fall_thru);
3235 } else if (!p2->next) {
3236 fall_thru = new_prio();
3237 fall_thru->type = AEL_CONTROL1;
3238 fall_thru->goto_true = switch_end;
3239 fall_thru->app = strdup("Goto");
3240 linkprio(switch_case, fall_thru);
3241 }
3242 }
3243 if (switch_case->return_needed) {
3244 char buf[2000];
3245 struct ael_priority *np2 = new_prio();
3246 np2->type = AEL_APPCALL;
3247 np2->app = strdup("NoOp");
3248 snprintf(buf,sizeof(buf),"End of Extension %s", switch_case->name);
3249 np2->appargs = strdup(buf);
3250 linkprio(switch_case, np2);
3251 switch_case-> return_target = np2;
3252 }
3253 } else if (p2->type == PV_PATTERN) {
3254 /* ok, generate a extension and link it in */
3255 switch_case = new_exten();
3256 switch_case->context = this_context;
3257 switch_case->is_switch = 1;
3258 /* the break/continue locations are inherited from parent */
3259 switch_case->loop_break = exten->loop_break;
3260 switch_case->loop_continue = exten->loop_continue;
3261
3262 linkexten(exten,switch_case);
3263 strncpy(buf2,p2->u1.str,sizeof(buf2));
3264 buf2[sizeof(buf2)-1] = 0; /* just in case */
3265 substitute_commas(buf2);
3266 snprintf(buf1,sizeof(buf1),"_sw-%d-%s", local_control_statement_count, buf2);
3267 switch_case->name = strdup(buf1);
3268 snprintf(new_label,sizeof(new_label),"sw-%s-%s-%d", label, buf2, local_control_statement_count);
3269
3270 gen_prios(switch_case, new_label, p2->u2.statements, exten, this_context); /* this will link in all the while body statements here */
3271 /* here is where we write code to "fall thru" to the next case... if there is one... */
3272 for (p3=p2->u2.statements; p3; p3=p3->next) {
3273 if (!p3->next)
3274 break;
3275 }
3276 /* p3 now points the last statement... */
3277 if (!p3 || ( p3->type != PV_GOTO && p3->type != PV_BREAK && p3->type != PV_RETURN)) {
3278 /* is there a following CASE/PATTERN/DEFAULT? */
3279 if (p2->next && p2->next->type == PV_CASE) {
3280 fall_thru = new_prio();
3281 fall_thru->type = AEL_APPCALL;
3282 fall_thru->app = strdup("Goto");
3283 strncpy(buf2,p2->next->u1.str,sizeof(buf2));
3284 buf2[sizeof(buf2)-1] = 0; /* just in case */
3285 substitute_commas(buf2);
3286 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10",local_control_statement_count, buf2);
3287 fall_thru->appargs = strdup(buf1);
3288 linkprio(switch_case, fall_thru);
3289 } else if (p2->next && p2->next->type == PV_PATTERN) {
3290 fall_thru = new_prio();
3291 fall_thru->type = AEL_APPCALL;
3292 fall_thru->app = strdup("Goto");
3293 gen_match_to_pattern(p2->next->u1.str, buf2);
3294 substitute_commas(buf2);
3295 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10",local_control_statement_count, buf2);
3296 fall_thru->appargs = strdup(buf1);
3297 linkprio(switch_case, fall_thru);
3298 } else if (p2->next && p2->next->type == PV_DEFAULT) {
3299 fall_thru = new_prio();
3300 fall_thru->type = AEL_APPCALL;
3301 fall_thru->app = strdup("Goto");
3302 snprintf(buf1,sizeof(buf1),"sw-%d-.|10",local_control_statement_count);
3303 fall_thru->appargs = strdup(buf1);
3304 linkprio(switch_case, fall_thru);
3305 } else if (!p2->next) {
3306 fall_thru = new_prio();
3307 fall_thru->type = AEL_CONTROL1;
3308 fall_thru->goto_true = switch_end;
3309 fall_thru->app = strdup("Goto");
3310 linkprio(switch_case, fall_thru);
3311 }
3312 }
3313 if (switch_case->return_needed) {
3314 char buf[2000];
3315 struct ael_priority *np2 = new_prio();
3316 np2->type = AEL_APPCALL;
3317 np2->app = strdup("NoOp");
3318 snprintf(buf,sizeof(buf),"End of Extension %s", switch_case->name);
3319 np2->appargs = strdup(buf);
3320 linkprio(switch_case, np2);
3321 switch_case-> return_target = np2;
3322 }
3323 } else if (p2->type == PV_DEFAULT) {
3324 /* ok, generate a extension and link it in */
3325 switch_case = new_exten();
3326 switch_case->context = this_context;
3327 switch_case->is_switch = 1;
3328
3329 /* new: the default case intros a pattern with ., which covers ALMOST everything.
3330 but it doesn't cover a NULL pattern. So, we'll define a null extension to match
3331 that goto's the default extension. */
3332
3333 default_exists++;
3334 switch_null = new_exten();
3335 switch_null->context = this_context;
3336 switch_null->is_switch = 1;
3337 switch_empty = new_prio();
3338 snprintf(buf1,sizeof(buf1),"sw-%d-.|10",local_control_statement_count);
3339 switch_empty->app = strdup("Goto");
3340 switch_empty->appargs = strdup(buf1);
3341 linkprio(switch_null, switch_empty);
3342 snprintf(buf1,sizeof(buf1),"sw-%d-", local_control_statement_count);
3343 switch_null->name = strdup(buf1);
3344 switch_null->loop_break = exten->loop_break;
3345 switch_null->loop_continue = exten->loop_continue;
3346 linkexten(exten,switch_null);
3347
3348 /* the break/continue locations are inherited from parent */
3349 switch_case->loop_break = exten->loop_break;
3350 switch_case->loop_continue = exten->loop_continue;
3351 linkexten(exten,switch_case);
3352 snprintf(buf1,sizeof(buf1),"_sw-%d-.", local_control_statement_count);
3353 switch_case->name = strdup(buf1);
3354
3355 snprintf(new_label,sizeof(new_label),"sw-%s-default-%d", label, local_control_statement_count);
3356
3357 gen_prios(switch_case, new_label, p2->u2.statements, exten, this_context); /* this will link in all the default: body statements here */
3358
3359 /* here is where we write code to "fall thru" to the next case... if there is one... */
3360 for (p3=p2->u2.statements; p3; p3=p3->next) {
3361 if (!p3->next)
3362 break;
3363 }
3364 /* p3 now points the last statement... */
3365 if (!p3 || (p3->type != PV_GOTO && p3->type != PV_BREAK && p3->type != PV_RETURN)) {
3366 /* is there a following CASE/PATTERN/DEFAULT? */
3367 if (p2->next && p2->next->type == PV_CASE) {
3368 fall_thru = new_prio();
3369 fall_thru->type = AEL_APPCALL;
3370 fall_thru->app = strdup("Goto");
3371 strncpy(buf2,p2->next->u1.str,sizeof(buf2));
3372 buf2[sizeof(buf2)-1] = 0; /* just in case */
3373 substitute_commas(buf2);
3374 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10",local_control_statement_count, buf2);
3375 fall_thru->appargs = strdup(buf1);
3376 linkprio(switch_case, fall_thru);
3377 } else if (p2->next && p2->next->type == PV_PATTERN) {
3378 fall_thru = new_prio();
3379 fall_thru->type = AEL_APPCALL;
3380 fall_thru->app = strdup("Goto");
3381 gen_match_to_pattern(p2->next->u1.str, buf2);
3382 substitute_commas(buf2);
3383 snprintf(buf1,sizeof(buf1),"sw-%d-%s|10",local_control_statement_count, buf2);
3384 fall_thru->appargs = strdup(buf1);
3385 linkprio(switch_case, fall_thru);
3386 } else if (p2->next && p2->next->type == PV_DEFAULT) {
3387 fall_thru = new_prio();
3388 fall_thru->type = AEL_APPCALL;
3389 fall_thru->app = strdup("Goto");
3390 snprintf(buf1,sizeof(buf1),"sw-%d-.|10",local_control_statement_count);
3391 fall_thru->appargs = strdup(buf1);
3392 linkprio(switch_case, fall_thru);
3393 } else if (!p2->next) {
3394 fall_thru = new_prio();
3395 fall_thru->type = AEL_CONTROL1;
3396 fall_thru->goto_true = switch_end;
3397 fall_thru->app = strdup("Goto");
3398 linkprio(switch_case, fall_thru);
3399 }
3400 }
3401 if (switch_case->return_needed) {
3402 char buf[2000];
3403 struct ael_priority *np2 = new_prio();
3404 np2->type = AEL_APPCALL;
3405 np2->app = strdup("NoOp");
3406 snprintf(buf,sizeof(buf),"End of Extension %s", switch_case->name);
3407 np2->appargs = strdup(buf);
3408 linkprio(switch_case, np2);
3409 switch_case-> return_target = np2;
3410 }
3411 } else {
3412 /* what could it be??? */
3413 }
3414 }
3415
3416 exten->loop_break = loop_break_save;
3417 exten->loop_continue = loop_continue_save;
3418 switch_test->origin = p;
3419 switch_end->origin = p;
3420 break;
3421
3422 case PV_MACRO_CALL:
3423 pr = new_prio();
3424 pr->type = AEL_APPCALL;
3425 snprintf(buf1,sizeof(buf1),"%s", p->u1.str);
3426 for (p2 = p->u2.arglist; p2; p2 = p2->next) {
3427 strcat(buf1,"|");
3428 strcat(buf1,p2->u1.str);
3429 }
3430 pr->app = strdup("Macro");
3431 pr->appargs = strdup(buf1);
3432 pr->origin = p;
3433 linkprio(exten, pr);
3434 break;
3435
3436 case PV_APPLICATION_CALL:
3437 pr = new_prio();
3438 pr->type = AEL_APPCALL;
3439 buf1[0] = 0;
3440 for (p2 = p->u2.arglist; p2; p2 = p2->next) {
3441 if (p2 != p->u2.arglist )
3442 strcat(buf1,"|");
3443 substitute_commas(p2->u1.str);
3444 strcat(buf1,p2->u1.str);
3445 }
3446 pr->app = strdup(p->u1.str);
3447 pr->appargs = strdup(buf1);
3448 pr->origin = p;
3449 linkprio(exten, pr);
3450 break;
3451
3452 case PV_BREAK:
3453 pr = new_prio();
3454 pr->type = AEL_CONTROL1; /* simple goto */
3455 pr->goto_true = exten->loop_break;
3456 pr->origin = p;
3457 linkprio(exten, pr);
3458 break;
3459
3460 case PV_RETURN: /* hmmmm */
3461 pr = new_prio();
3462 pr->type = AEL_RETURN; /* simple goto */
3463 exten->return_needed++;
3464 pr->app = strdup("Goto");
3465 pr->appargs = strdup("");
3466 pr->origin = p;
3467 linkprio(exten, pr);
3468 break;
3469
3470 case PV_CONTINUE:
3471 pr = new_prio();
3472 pr->type = AEL_CONTROL1; /* simple goto */
3473 pr->goto_true = exten->loop_continue;
3474 pr->origin = p;
3475 linkprio(exten, pr);
3476 break;
3477
3478 #ifdef OLD_RAND_ACTION
3479 case PV_RANDOM:
3480 control_statement_count++;
3481 snprintf(new_label,sizeof(new_label),"rand-%s-%d", label, control_statement_count);
3482 rand_test = new_prio();
3483 rand_test->type = AEL_RAND_CONTROL;
3484 snprintf(buf1,sizeof(buf1),"$[%s]",
3485 p->u1.str );
3486 rand_test->app = 0;
3487 rand_test->appargs = strdup(buf1);
3488 rand_test->origin = p;
3489
3490 rand_end = new_prio();
3491 rand_end->type = AEL_APPCALL;
3492 snprintf(buf1,sizeof(buf1),"Finish rand-%s-%d", label, control_statement_count);
3493 rand_end->app = strdup("NoOp");
3494 rand_end->appargs = strdup(buf1);
3495
3496 rand_skip = new_prio();
3497 rand_skip->type = AEL_CONTROL1; /* simple goto */
3498 rand_skip->goto_true = rand_end;
3499 rand_skip->origin = p;
3500
3501 rand_test->goto_true = rand_skip; /* +1, really */
3502
3503 linkprio(exten, rand_test);
3504
3505 if (p->u3.else_statements) {
3506 gen_prios(exten, new_label, p->u3.else_statements, mother_exten, this_context); /* this will link in all the else statements here */
3507 }
3508
3509 linkprio(exten, rand_skip);
3510
3511 gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context); /* this will link in all the "true" statements here */
3512
3513 linkprio(exten, rand_end);
3514
3515 break;
3516 #endif
3517
3518 case PV_IFTIME:
3519 control_statement_count++;
3520 snprintf(new_label,sizeof(new_label),"iftime-%s-%d", label, control_statement_count);
3521
3522 if_test = new_prio();
3523 if_test->type = AEL_IFTIME_CONTROL;
3524 snprintf(buf1,sizeof(buf1),"%s|%s|%s|%s",
3525 p->u1.list->u1.str,
3526 p->u1.list->next->u1.str,
3527 p->u1.list->next->next->u1.str,
3528 p->u1.list->next->next->next->u1.str);
3529 if_test->app = 0;
3530 if_test->appargs = strdup(buf1);
3531 if_test->origin = p;
3532
3533 if_end = new_prio();
3534 if_end->type = AEL_APPCALL;
3535 snprintf(buf1,sizeof(buf1),"Finish iftime-%s-%d", label, control_statement_count);
3536 if_end->app = strdup("NoOp");
3537 if_end->appargs = strdup(buf1);
3538
3539 if (p->u3.else_statements) {
3540 if_skip = new_prio();
3541 if_skip->type = AEL_CONTROL1; /* simple goto */
3542 if_skip->goto_true = if_end;
3543 if_skip->origin = p;
3544
3545 } else {
3546 if_skip = 0;
3547
3548 if_test->goto_false = if_end;
3549 }
3550
3551 if_false = new_prio();
3552 if_false->type = AEL_CONTROL1;
3553 if (p->u3.else_statements) {
3554 if_false->goto_true = if_skip; /* +1 */
3555 } else {
3556 if_false->goto_true = if_end;
3557 }
3558
3559 /* link & load! */
3560 linkprio(exten, if_test);
3561 linkprio(exten, if_false);
3562
3563 /* now, put the body of the if here */
3564
3565 gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context); /* this will link in all the statements here */
3566
3567 if (p->u3.else_statements) {
3568 linkprio(exten, if_skip);
3569 gen_prios(exten, new_label, p->u3.else_statements, mother_exten, this_context); /* this will link in all the statements here */
3570
3571 }
3572
3573 linkprio(exten, if_end);
3574
3575 break;
3576
3577 case PV_RANDOM:
3578 case PV_IF:
3579 control_statement_count++;
3580 snprintf(new_label,sizeof(new_label),"if-%s-%d", label, control_statement_count);
3581
3582 if_test = new_prio();
3583 if_end = new_prio();
3584 if_test->type = AEL_IF_CONTROL;
3585 if_end->type = AEL_APPCALL;
3586 if ( p->type == PV_RANDOM )
3587 snprintf(buf1,sizeof(buf1),"$[${RAND(0,99)} < (%s)]",p->u1.str);
3588 else
3589 snprintf(buf1,sizeof(buf1),"$[%s]",p->u1.str);
3590 if_test->app = 0;
3591 if_test->appargs = strdup(buf1);
3592 snprintf(buf1,sizeof(buf1),"Finish if-%s-%d", label, control_statement_count);
3593 if_end->app = strdup("NoOp");
3594 if_end->appargs = strdup(buf1);
3595 if_test->origin = p;
3596
3597 if (p->u3.else_statements) {
3598 if_skip = new_prio();
3599 if_skip->type = AEL_CONTROL1; /* simple goto */
3600 if_skip->goto_true = if_end;
3601 if_test->goto_false = if_skip;;
3602 } else {
3603 if_skip = 0;
3604 if_test->goto_false = if_end;;
3605 }
3606
3607 /* link & load! */
3608 linkprio(exten, if_test);
3609
3610 /* now, put the body of the if here */
3611
3612 gen_prios(exten, new_label, p->u2.statements, mother_exten, this_context); /* this will link in all the statements here */
3613
3614 if (p->u3.else_statements) {
3615 linkprio(exten, if_skip);
3616 gen_prios(exten, new_label, p->u3.else_statements, mother_exten, this_context); /* this will link in all the statements here */
3617
3618 }
3619
3620 linkprio(exten, if_end);
3621
3622 break;
3623
3624 case PV_STATEMENTBLOCK:
3625 gen_prios(exten, label, p->u1.list, mother_exten, this_context ); /* recurse into the block */
3626 break;
3627
3628 case PV_CATCH:
3629 control_statement_count++;
3630 /* generate an extension with name of catch, put all catch stats
3631 into this exten! */
3632 switch_case = new_exten();
3633 switch_case->context = this_context;
3634 linkexten(exten,switch_case);
3635 switch_case->name = strdup(p->u1.str);
3636 snprintf(new_label,sizeof(new_label),"catch-%s-%d",p->u1.str, control_statement_count);
3637
3638 gen_prios(switch_case, new_label, p->u2.statements,mother_exten,this_context); /* this will link in all the catch body statements here */
3639 if (switch_case->return_needed) {
3640 char buf[2000];
3641 struct ael_priority *np2 = new_prio();
3642 np2->type = AEL_APPCALL;
3643 np2->app = strdup("NoOp");
3644 snprintf(buf,sizeof(buf),"End of Extension %s", switch_case->name);
3645 np2->appargs = strdup(buf);
3646 linkprio(switch_case, np2);
3647 switch_case-> return_target = np2;
3648 }
3649
3650 break;
3651 default:
3652 break;
3653 }
3654 }
3655 }
3656
3657 void set_priorities(struct ael_extension *exten)
3658 {
3659 int i;
3660 struct ael_priority *pr;
3661 do {
3662 if (exten->is_switch)
3663 i = 10;
3664 else if (exten->regexten)
3665 i=2;
3666 else
3667 i=1;
3668
3669 for (pr=exten->plist; pr; pr=pr->next) {
3670 pr->priority_num = i;
3671
3672 if (!pr->origin || (pr->origin && pr->origin->type != PV_LABEL) ) /* Labels don't show up in the dialplan,
3673 but we want them to point to the right
3674 priority, which would be the next line
3675 after the label; */
3676 i++;
3677 }
3678
3679 exten = exten->next_exten;
3680 } while ( exten );
3681 }
3682
3683 void add_extensions(struct ael_extension *exten)
3684 {
3685 struct ael_priority *pr;
3686 char *label=0;
3687 char realext[AST_MAX_EXTENSION];
3688 if (!exten) {
3689 ast_log(LOG_WARNING, "This file is Empty!\n" );
3690 return;
3691 }
3692 do {
3693 struct ael_priority *last = 0;
3694
3695 memset(realext, '\0', sizeof(realext));
3696 pbx_substitute_variables_helper(NULL, exten->name, realext, sizeof(realext) - 1);
3697 if (exten->hints) {
3698 if (ast_add_extension2(exten->context, 0 /*no replace*/, realext, PRIORITY_HINT, NULL, exten->cidmatch,
3699 exten->hints, NULL, ast_free, registrar)) {
3700 ast_log(LOG_WARNING, "Unable to add step at priority 'hint' of extension '%s'\n",
3701 exten->name);
3702 }
3703 }
3704
3705 for (pr=exten->plist; pr; pr=pr->next) {
3706 char app[2000];
3707 char appargs[2000];
3708
3709 /* before we can add the extension, we need to prep the app/appargs;
3710 the CONTROL types need to be done after the priority numbers are calculated.
3711 */
3712 if (pr->type == AEL_LABEL) /* don't try to put labels in the dialplan! */ {
3713 last = pr;
3714 continue;
3715 }
3716
3717 if (pr->app)
3718 strcpy(app, pr->app);
3719 else
3720 app[0] = 0;
3721 if (pr->appargs )
3722 strcpy(appargs, pr->appargs);
3723 else
3724 appargs[0] = 0;
3725 switch( pr->type ) {
3726 case AEL_APPCALL:
3727 /* easy case. Everything is all set up */
3728 break;
3729
3730 case AEL_CONTROL1: /* FOR loop, WHILE loop, BREAK, CONTINUE, IF, IFTIME */
3731 /* simple, unconditional goto. */
3732 strcpy(app,"Goto");
3733 if (pr->goto_true->origin && pr->goto_true->origin->type == PV_SWITCH ) {
3734 snprintf(appargs,sizeof(appargs),"%s|%d", pr->goto_true->exten->name, pr->goto_true->priority_num);
3735 } else if (pr->goto_true->origin && pr->goto_true->origin->type == PV_IFTIME && pr->goto_true->origin->u3.else_statements ) {
3736 snprintf(appargs,sizeof(appargs),"%d", pr->goto_true->priority_num+1);
3737 } else
3738 snprintf(appargs,sizeof(appargs),"%d", pr->goto_true->priority_num);
3739 break;
3740
3741 case AEL_FOR_CONTROL: /* WHILE loop test, FOR loop test */
3742 strcpy(app,"GotoIf");
3743 snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num);
3744 break;
3745
3746 case AEL_IF_CONTROL:
3747 strcpy(app,"GotoIf");
3748 if (pr->origin->u3.else_statements )
3749 snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num+1);
3750 else
3751 snprintf(appargs,sizeof(appargs),"%s?%d:%d", pr->appargs, pr->priority_num+1, pr->goto_false->priority_num);
3752 break;
3753
3754 case AEL_RAND_CONTROL:
3755 strcpy(app,"Random");
3756 snprintf(appargs,sizeof(appargs),"%s:%d", pr->appargs, pr->goto_true->priority_num+1);
3757 break;
3758
3759 case AEL_IFTIME_CONTROL:
3760 strcpy(app,"GotoIfTime");
3761 snprintf(appargs,sizeof(appargs),"%s?%d", pr->appargs, pr->priority_num+2);
3762 break;
3763
3764 case AEL_RETURN:
3765 strcpy(app,"Goto");
3766 snprintf(appargs,sizeof(appargs), "%d", exten->return_target->priority_num);
3767 break;
3768
3769 default:
3770 break;
3771 }
3772 if (last && last->type == AEL_LABEL ) {
3773 label = last->origin->u1.str;
3774 }
3775 else
3776 label = 0;
3777
3778 if (ast_add_extension2(exten->context, 0 /*no replace*/, realext, pr->priority_num, (label?label:NULL), exten->cidmatch,
3779 app, strdup(appargs), ast_free, registrar)) {
3780 ast_log(LOG_WARNING, "Unable to add step at priority '%d' of extension '%s'\n", pr->priority_num,
3781 exten->name);
3782 }
3783 last = pr;
3784 }
3785 exten = exten->next_exten;
3786 } while ( exten );
3787 }
3788
3789 static void attach_exten(struct ael_extension **list, struct ael_extension *newmem)
3790 {
3791 /* travel to the end of the list... */
3792 struct ael_extension *lptr;
3793 if( !*list ) {
3794 *list = newmem;
3795 return;
3796 }
3797 lptr = *list;
3798
3799 while( lptr->next_exten ) {
3800 lptr = lptr->next_exten;
3801 }
3802 /* lptr should now pointing to the last element in the list; it has a null next_exten pointer */
3803 lptr->next_exten = newmem;
3804 }
3805
3806 static pval *get_extension_or_contxt(pval *p)
3807 {
3808 while( p && p->type != PV_EXTENSION && p->type != PV_CONTEXT && p->type != PV_MACRO ) {
3809
3810 p = p->dad;
3811 }
3812
3813 return p;
3814 }
3815
3816 static pval *get_contxt(pval *p)
3817 {
3818 while( p && p->type != PV_CONTEXT && p->type != PV_MACRO ) {
3819
3820 p = p->dad;
3821 }
3822
3823 return p;
3824 }
3825
3826 static void fix_gotos_in_extensions(struct ael_extension *exten)
3827 {
3828 struct ael_extension *e;
3829 for(e=exten;e;e=e->next_exten) {
3830
3831 struct ael_priority *p;
3832 for(p=e->plist;p;p=p->next) {
3833
3834 if( p->origin && p->origin->type == PV_GOTO && p->origin->u3.goto_target_in_case ) {
3835
3836 /* fix the extension of the goto target to the actual extension in the post-compiled dialplan */
3837
3838 pval *target = p->origin->u2.goto_target;
3839 struct ael_extension *z = target->u3.compiled_label;
3840 pval *pv2 = p->origin;
3841 char buf1[500];
3842 char *apparg_save = p->appargs;
3843
3844 p->appargs = 0;
3845 if (!pv2->u1.list->next) /* just one -- it won't hurt to repeat the extension */ {
3846 snprintf(buf1,sizeof(buf1),"%s|%s", z->name, pv2->u1.list->u1.str);
3847 p->appargs = strdup(buf1);
3848
3849 } else if (pv2->u1.list->next && !pv2->u1.list->next->next) /* two */ {
3850 snprintf(buf1,sizeof(buf1),"%s|%s", z->name, pv2->u1.list->next->u1.str);
3851 p->appargs = strdup(buf1);
3852 } else if (pv2->u1.list->next && pv2->u1.list->next->next) {
3853 snprintf(buf1,sizeof(buf1),"%s|%s|%s", pv2->u1.list->u1.str,
3854 z->name,
3855 pv2->u1.list->next->next->u1.str);
3856 p->appargs = strdup(buf1);
3857 }
3858 else
3859 printf("WHAT? The goto doesn't fall into one of three cases for GOTO????\n");
3860
3861 if( apparg_save ) {
3862 free(apparg_save);
3863 }
3864 }
3865 }
3866 }
3867 }
3868
3869
3870 void ast_compile_ael2(struct ast_context **local_contexts, struct pval *root)
3871 {
3872 pval *p,*p2;
3873 struct ast_context *context;
3874 char buf[2000];
3875 struct ael_extension *exten;
3876 struct ael_extension *exten_list = 0;
3877
3878 for (p=root; p; p=p->next ) { /* do the globals first, so they'll be there
3879 when we try to eval them */
3880 switch (p->type) {
3881 case PV_GLOBALS:
3882 /* just VARDEC elements */
3883 for (p2=p->u1.list; p2; p2=p2->next) {
3884 char buf2[2000];
3885 snprintf(buf2,sizeof(buf2),"%s=%s", p2->u1.str, p2->u2.val);
3886 pbx_builtin_setvar(NULL, buf2);
3887 }
3888 break;
3889 default:
3890 break;
3891 }
3892 }
3893
3894 for (p=root; p; p=p->next ) {
3895 pval *lp;
3896 int argc;
3897
3898 switch (p->type) {
3899 case PV_MACRO:
3900 strcpy(buf,"macro-");
3901 strcat(buf,p->u1.str);
3902 context = ast_context_create(local_contexts, buf, registrar);
3903
3904 exten = new_exten();
3905 exten->context = context;
3906 exten->name = strdup("s");
3907 argc = 1;
3908 for (lp=p->u2.arglist; lp; lp=lp->next) {
3909 /* for each arg, set up a "Set" command */
3910 struct ael_priority *np2 = new_prio();
3911 np2->type = AEL_APPCALL;
3912 np2->app = strdup("Set");
3913 snprintf(buf,sizeof(buf),"%s=${ARG%d}", lp->u1.str, argc++);
3914 remove_spaces_before_equals(buf);
3915 np2->appargs = strdup(buf);
3916 linkprio(exten, np2);
3917 }
3918 /* add any includes */
3919 for (p2=p->u3.macro_statements; p2; p2=p2->next) {
3920 pval *p3;
3921
3922 switch (p2->type) {
3923 case PV_INCLUDES:
3924 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
3925 if ( p3->u2.arglist ) {
3926 snprintf(buf,sizeof(buf), "%s|%s|%s|%s|%s",
3927 p3->u1.str,
3928 p3->u2.arglist->u1.str,
3929 p3->u2.arglist->next->u1.str,
3930 p3->u2.arglist->next->next->u1.str,
3931 p3->u2.arglist->next->next->next->u1.str);
3932 ast_context_add_include2(context, buf, registrar);
3933 } else
3934 ast_context_add_include2(context, p3->u1.str, registrar);
3935 }
3936 break;
3937 default:
3938 break;
3939 }
3940 }
3941 /* CONTAINS APPCALLS, CATCH, just like extensions... */
3942 gen_prios(exten, p->u1.str, p->u3.macro_statements, 0, context );
3943 if (exten->return_needed) {
3944 struct ael_priority *np2 = new_prio();
3945 np2->type = AEL_APPCALL;
3946 np2->app = strdup("NoOp");
3947 snprintf(buf,sizeof(buf),"End of Macro %s-%s",p->u1.str, exten->name);
3948 np2->appargs = strdup(buf);
3949 linkprio(exten, np2);
3950 exten-> return_target = np2;
3951 }
3952
3953 set_priorities(exten);
3954 attach_exten(&exten_list, exten);
3955 break;
3956
3957 case PV_GLOBALS:
3958 /* already done */
3959 break;
3960
3961 case PV_CONTEXT:
3962 context = ast_context_find_or_create(local_contexts, p->u1.str, registrar);
3963
3964 /* contexts contain: ignorepat, includes, switches, eswitches, extensions, */
3965 for (p2=p->u2.statements; p2; p2=p2->next) {
3966 pval *p3;
3967 char *s3;
3968
3969 switch (p2->type) {
3970 case PV_EXTENSION:
3971 exten = new_exten();
3972 exten->name = strdup(p2->u1.str);
3973 exten->context = context;
3974
3975 if( (s3=strchr(exten->name, '/') ) != 0 )
3976 {
3977 *s3 = 0;
3978 exten->cidmatch = s3+1;
3979 }
3980
3981 if ( p2->u3.hints )
3982 exten->hints = strdup(p2->u3.hints);
3983 exten->regexten = p2->u4.regexten;
3984 gen_prios(exten, p->u1.str, p2->u2.statements, 0, context );
3985 if (exten->return_needed) {
3986 struct ael_priority *np2 = new_prio();
3987 np2->type = AEL_APPCALL;
3988 np2->app = strdup("NoOp");
3989 snprintf(buf,sizeof(buf),"End of Extension %s", exten->name);
3990 np2->appargs = strdup(buf);
3991 linkprio(exten, np2);
3992 exten-> return_target = np2;
3993 }
3994 /* is the last priority in the extension a label? Then add a trailing no-op */
3995 if( !exten->plist_last )
3996 {
3997 ast_log(LOG_WARNING, "Warning: file %s, line %d-%d: Empty Extension!\n",
3998 p2->filename, p2->startline, p2->endline);
3999 }
4000
4001 if ( exten->plist_last && exten->plist_last->type == AEL_LABEL ) {
4002 struct ael_priority *np2 = new_prio();
4003 np2->type = AEL_APPCALL;
4004 np2->app = strdup("NoOp");
4005 snprintf(buf,sizeof(buf),"A NoOp to follow a trailing label %s", exten->plist_last->origin->u1.str);
4006 np2->appargs = strdup(buf);
4007 linkprio(exten, np2);
4008 }
4009
4010 set_priorities(exten);
4011 attach_exten(&exten_list, exten);
4012 break;
4013
4014 case PV_IGNOREPAT:
4015 ast_context_add_ignorepat2(context, p2->u1.str, registrar);
4016 break;
4017
4018 case PV_INCLUDES:
4019 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
4020 if ( p3->u2.arglist ) {
4021 snprintf(buf,sizeof(buf), "%s|%s|%s|%s|%s",
4022 p3->u1.str,
4023 p3->u2.arglist->u1.str,
4024 p3->u2.arglist->next->u1.str,
4025 p3->u2.arglist->next->next->u1.str,
4026 p3->u2.arglist->next->next->next->u1.str);
4027 ast_context_add_include2(context, buf, registrar);
4028 } else
4029 ast_context_add_include2(context, p3->u1.str, registrar);
4030 }
4031 break;
4032
4033 case PV_SWITCHES:
4034 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
4035 char *c = strchr(p3->u1.str, '/');
4036 if (c) {
4037 *c = '\0';
4038 c++;
4039 } else
4040 c = "";
4041
4042 ast_context_add_switch2(context, p3->u1.str, c, 0, registrar);
4043 }
4044 break;
4045
4046 case PV_ESWITCHES:
4047 for (p3 = p2->u1.list; p3 ;p3=p3->next) {
4048 char *c = strchr(p3->u1.str, '/');
4049 if (c) {
4050 *c = '\0';
4051 c++;
4052 } else
4053 c = "";
4054
4055 ast_context_add_switch2(context, p3->u1.str, c, 1, registrar);
4056 }
4057 break;
4058 default:
4059 break;
4060 }
4061 }
4062
4063 break;
4064
4065 default:
4066 /* huh? what? */
4067 break;
4068
4069 }
4070 }
4071 /* moved these from being done after a macro or extension were processed,
4072 to after all processing is done, for the sake of fixing gotos to labels inside cases... */
4073 /* I guess this would be considered 2nd pass of compiler now... */
4074 fix_gotos_in_extensions(exten_list); /* find and fix extension ref in gotos to labels that are in case statements */
4075 add_extensions(exten_list); /* actually makes calls to create priorities in ast_contexts -- feeds dialplan to asterisk */
4076 destroy_extensions(exten_list); /* all that remains is an empty husk, discard of it as is proper */
4077
4078 }
4079
4080
4081 static int aeldebug = 0;
4082
4083 /* interface stuff */
4084
4085 /* if all the below are static, who cares if they are present? */
4086
4087 static int pbx_load_module(void)
4088 {
4089 int errs=0, sem_err=0, sem_warn=0, sem_note=0;
4090 char *rfilename;
4091 struct ast_context *local_contexts=NULL, *con;
4092 struct pval *parse_tree;
4093
4094 ast_log(LOG_NOTICE, "Starting AEL load process.\n");
4095 if (config[0] == '/')
4096 rfilename = (char *)config;
4097 else {
4098 rfilename = alloca(strlen(config) + strlen(ast_config_AST_CONFIG_DIR) + 2);
4099 sprintf(rfilename, "%s/%s", ast_config_AST_CONFIG_DIR, config);
4100 }
4101 ast_log(LOG_NOTICE, "AEL load process: calculated config file name '%s'.\n", rfilename);
4102
4103 if (access(rfilename,R_OK) != 0) {
4104 ast_log(LOG_NOTICE, "File %s not found; AEL declining load\n", rfilename);
4105 return AST_MODULE_LOAD_DECLINE;
4106 }
4107
4108 parse_tree = ael2_parse(rfilename, &errs);
4109 ast_log(LOG_NOTICE, "AEL load process: parsed config file name '%s'.\n", rfilename);
4110 ael2_semantic_check(parse_tree, &sem_err, &sem_warn, &sem_note);
4111 if (errs == 0 && sem_err == 0) {
4112 ast_log(LOG_NOTICE, "AEL load process: checked config file name '%s'.\n", rfilename);
4113 ast_compile_ael2(&local_contexts, parse_tree);
4114 ast_log(LOG_NOTICE, "AEL load process: compiled config file name '%s'.\n", rfilename);
4115
4116 ast_merge_contexts_and_delete(&local_contexts, registrar);
4117 ast_log(LOG_NOTICE, "AEL load process: merged config file name '%s'.\n", rfilename);
4118 for (con = ast_walk_contexts(NULL); con; con = ast_walk_contexts(con))
4119 ast_context_verify_includes(con);
4120 ast_log(LOG_NOTICE, "AEL load process: verified config file name '%s'.\n", rfilename);
4121 } else {
4122 ast_log(LOG_ERROR, "Sorry, but %d syntax errors and %d semantic errors were detected. It doesn't make sense to compile.\n", errs, sem_err);
4123 destroy_pval(parse_tree); /* free up the memory */
4124 return AST_MODULE_LOAD_DECLINE;
4125 }
4126 destroy_pval(parse_tree); /* free up the memory */
4127
4128 return AST_MODULE_LOAD_SUCCESS;
4129 }
4130
4131 /* CLI interface */
4132 static int ael2_debug_read(int fd, int argc, char *argv[])
4133 {
4134 aeldebug |= DEBUG_READ;
4135 return 0;
4136 }
4137
4138 static int ael2_debug_tokens(int fd, int argc, char *argv[])
4139 {
4140 aeldebug |= DEBUG_TOKENS;
4141 return 0;
4142 }
4143
4144 static int ael2_debug_macros(int fd, int argc, char *argv[])
4145 {
4146 aeldebug |= DEBUG_MACROS;
4147 return 0;
4148 }
4149
4150 static int ael2_debug_contexts(int fd, int argc, char *argv[])
4151 {
4152 aeldebug |= DEBUG_CONTEXTS;
4153 return 0;
4154 }
4155
4156 static int ael2_no_debug(int fd, int argc, char *argv[])
4157 {
4158 aeldebug = 0;
4159 return 0;
4160 }
4161
4162 static int ael2_reload(int fd, int argc, char *argv[])
4163 {
4164 return (pbx_load_module());
4165 }
4166
4167 static struct ast_cli_entry cli_ael_no_debug = {
4168 { "ael", "no", "debug", NULL },
4169 ael2_no_debug, NULL,
4170 NULL };
4171
4172 static struct ast_cli_entry cli_ael[] = {
4173 { { "ael", "reload", NULL },
4174 ael2_reload, "Reload AEL configuration" },
4175
4176 { { "ael", "debug", "read", NULL },
4177 ael2_debug_read, "Enable AEL read debug (does nothing)" },
4178
4179 { { "ael", "debug", "tokens", NULL },
4180 ael2_debug_tokens, "Enable AEL tokens debug (does nothing)" },
4181
4182 { { "ael", "debug", "macros", NULL },
4183 ael2_debug_macros, "Enable AEL macros debug (does nothing)" },
4184
4185 { { "ael", "debug", "contexts", NULL },
4186 ael2_debug_contexts, "Enable AEL contexts debug (does nothing)" },
4187
4188 { { "ael", "nodebug", NULL },
4189 ael2_no_debug, "Disable AEL debug messages",
4190 NULL, NULL, &cli_ael_no_debug },
4191 };
4192
4193 static int unload_module(void)
4194 {
4195 ast_context_destroy(NULL, registrar);
4196 ast_cli_unregister_multiple(cli_ael, sizeof(cli_ael) / sizeof(struct ast_cli_entry));
4197 return 0;
4198 }
4199
4200 static int load_module(void)
4201 {
4202 ast_cli_register_multiple(cli_ael, sizeof(cli_ael) / sizeof(struct ast_cli_entry));
4203 return (pbx_load_module());
4204 }
4205
4206 static int reload(void)
4207 {
4208 return pbx_load_module();
4209 }
4210
4211 #ifdef STANDALONE_AEL
4212 #define AST_MODULE "ael"
4213 int ael_external_load_module(void);
4214 int ael_external_load_module(void)
4215 {
4216 pbx_load_module();
4217 return 1;
4218 }
4219 #endif
4220
4221 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk Extension Language Compiler",
4222 .load = load_module,
4223 .unload = unload_module,
4224 .reload = reload,
4225 );
4226
4227
4228 /* DESTROY the PVAL tree ============================================================================ */
4229
4230
4231
4232 void destroy_pval_item(pval *item)
4233 {
4234 if (item == NULL) {
4235 ast_log(LOG_WARNING, "null item\n");
4236 return;
4237 }
4238
4239 if (item->filename)
4240 free(item->filename);
4241
4242 switch (item->type) {
4243 case PV_WORD:
4244 /* fields: item->u1.str == string associated with this (word). */
4245 if (item->u1.str )
4246 free(item->u1.str);
4247 if ( item->u2.arglist )
4248 destroy_pval(item->u2.arglist);
4249 break;
4250
4251 case PV_MACRO:
4252 /* fields: item->u1.str == name of macro
4253 item->u2.arglist == pval list of PV_WORD arguments of macro, as given by user
4254 item->u2.arglist->u1.str == argument
4255 item->u2.arglist->next == next arg
4256
4257 item->u3.macro_statements == pval list of statements in macro body.
4258 */
4259 destroy_pval(item->u2.arglist);
4260 if (item->u1.str )
4261 free(item->u1.str);
4262 destroy_pval(item->u3.macro_statements);
4263 break;
4264
4265 case PV_CONTEXT:
4266 /* fields: item->u1.str == name of context
4267 item->u2.statements == pval list of statements in context body
4268 item->u3.abstract == int 1 if an abstract keyword were present
4269 */
4270 if (item->u1.str)
4271 free(item->u1.str);
4272 destroy_pval(item->u2.statements);
4273 break;
4274
4275 case PV_MACRO_CALL:
4276 /* fields: item->u1.str == name of macro to call
4277 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
4278 item->u2.arglist->u1.str == argument
4279 item->u2.arglist->next == next arg
4280 */
4281 if (item->u1.str)
4282 free(item->u1.str);
4283 destroy_pval(item->u2.arglist);
4284 break;
4285
4286 case PV_APPLICATION_CALL:
4287 /* fields: item->u1.str == name of application to call
4288 item->u2.arglist == pval list of PV_WORD arguments of macro call, as given by user
4289 item->u2.arglist->u1.str == argument
4290 item->u2.arglist->next == next arg
4291 */
4292 if (item->u1.str)
4293 free(item->u1.str);
4294 destroy_pval(item->u2.arglist);
4295 break;
4296
4297 case PV_CASE:
4298 /* fields: item->u1.str == value of case
4299 item->u2.statements == pval list of statements under the case
4300 */
4301 if (item->u1.str)
4302 free(item->u1.str);
4303 destroy_pval(item->u2.statements);
4304 break;
4305
4306 case PV_PATTERN:
4307 /* fields: item->u1.str == value of case
4308 item->u2.statements == pval list of statements under the case
4309 */
4310 if (item->u1.str)
4311 free(item->u1.str);
4312 destroy_pval(item->u2.statements);
4313 break;
4314
4315 case PV_DEFAULT:
4316 /* fields:
4317 item->u2.statements == pval list of statements under the case
4318 */
4319 destroy_pval(item->u2.statements);
4320 break;
4321
4322 case PV_CATCH:
4323 /* fields: item->u1.str == name of extension to catch
4324 item->u2.statements == pval list of statements in context body
4325 */
4326 if (item->u1.str)
4327 free(item->u1.str);
4328 destroy_pval(item->u2.statements);
4329 break;
4330
4331 case PV_SWITCHES:
4332 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
4333 */
4334 destroy_pval(item->u1.list);
4335 break;
4336
4337 case PV_ESWITCHES:
4338 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
4339 */
4340 destroy_pval(item->u1.list);
4341 break;
4342
4343 case PV_INCLUDES:
4344 /* fields: item->u1.list == pval list of PV_WORD elements, one per entry in the list
4345 item->u2.arglist == pval list of 4 PV_WORD elements for time values
4346 */
4347 destroy_pval(item->u1.list);
4348 break;
4349
4350 case PV_STATEMENTBLOCK:
4351 /* fields: item->u1.list == pval list of statements in block, one per entry in the list
4352 */
4353 destroy_pval(item->u1.list);
4354 break;
4355
4356 case PV_VARDEC:
4357 /* fields: item->u1.str == variable name
4358 item->u2.val == variable value to assign
4359 */
4360 if (item->u1.str)
4361 free(item->u1.str);
4362 if (item->u2.val)
4363 free(item->u2.val);
4364 break;
4365
4366 case PV_GOTO:
4367 /* fields: item->u1.list == pval list of PV_WORD target names, up to 3, in order as given by user.
4368 item->u1.list->u1.str == where the data on a PV_WORD will always be.
4369 */
4370
4371 destroy_pval(item->u1.list);
4372 break;
4373
4374 case PV_LABEL:
4375 /* fields: item->u1.str == label name
4376 */
4377 if (item->u1.str)
4378 free(item->u1.str);
4379 break;
4380
4381 case PV_FOR:
4382 /* fields: item->u1.for_init == a string containing the initalizer
4383 item->u2.for_test == a string containing the loop test
4384 item->u3.for_inc == a string containing the loop increment
4385
4386 item->u4.for_statements == a pval list of statements in the for ()
4387 */
4388 if (item->u1.for_init)
4389 free(item->u1.for_init);
4390 if (item->u2.for_test)
4391 free(item->u2.for_test);
4392 if (item->u3.for_inc)
4393 free(item->u3.for_inc);
4394 destroy_pval(item->u4.for_statements);
4395 break;
4396
4397 case PV_WHILE:
4398 /* fields: item->u1.str == the while conditional, as supplied by user
4399
4400 item->u2.statements == a pval list of statements in the while ()
4401 */
4402 if (item->u1.str)
4403 free(item->u1.str);
4404 destroy_pval(item->u2.statements);
4405 break;
4406
4407 case PV_BREAK:
4408 /* fields: none
4409 */
4410 break;
4411
4412 case PV_RETURN:
4413 /* fields: none
4414 */
4415 break;
4416
4417 case PV_CONTINUE:
4418 /* fields: none
4419 */
4420 break;
4421
4422 case PV_IFTIME:
4423 /* fields: item->u1.list == the 4 time values, in PV_WORD structs, linked list
4424
4425 item->u2.statements == a pval list of statements in the if ()
4426 item->u3.else_statements == a pval list of statements in the else
4427 (could be zero)
4428 */
4429 destroy_pval(item->u1.list);
4430 destroy_pval(item->u2.statements);
4431 if (item->u3.else_statements) {
4432 destroy_pval(item->u3.else_statements);
4433 }
4434 break;
4435
4436 case PV_RANDOM:
4437 /* fields: item->u1.str == the random percentage, as supplied by user
4438
4439 item->u2.statements == a pval list of statements in the true part ()
4440 item->u3.else_statements == a pval list of statements in the else
4441 (could be zero)
4442 fall thru to If */
4443 case PV_IF:
4444 /* fields: item->u1.str == the if conditional, as supplied by user
4445
4446 item->u2.statements == a pval list of statements in the if ()
4447 item->u3.else_statements == a pval list of statements in the else
4448 (could be zero)
4449 */
4450 if (item->u1.str)
4451 free(item->u1.str);
4452 destroy_pval(item->u2.statements);
4453 if (item->u3.else_statements) {
4454 destroy_pval(item->u3.else_statements);
4455 }
4456 break;
4457
4458 case PV_SWITCH:
4459 /* fields: item->u1.str == the switch expression
4460
4461 item->u2.statements == a pval list of statements in the switch,
4462 (will be case statements, most likely!)
4463 */
4464 if (item->u1.str)
4465 free(item->u1.str);
4466 destroy_pval(item->u2.statements);
4467 break;
4468
4469 case PV_EXTENSION:
4470 /* fields: item->u1.str == the extension name, label, whatever it's called
4471
4472 item->u2.statements == a pval list of statements in the extension
4473 item->u3.hints == a char * hint argument
4474 item->u4.regexten == an int boolean. non-zero says that regexten was specified
4475 */
4476 if (item->u1.str)
4477 free(item->u1.str);
4478 if (item->u3.hints)
4479 free(item->u3.hints);
4480 destroy_pval(item->u2.statements);
4481 break;
4482
4483 case PV_IGNOREPAT:
4484 /* fields: item->u1.str == the ignorepat data
4485 */
4486 if (item->u1.str)
4487 free(item->u1.str);
4488 break;
4489
4490 case PV_GLOBALS:
4491 /* fields: item->u1.statements == pval list of statements, usually vardecs
4492 */
4493 destroy_pval(item->u1.statements);
4494 break;
4495 }
4496 free(item);
4497 }
4498
4499 void destroy_pval(pval *item)
4500 {
4501 pval *i,*nxt;
4502
4503 for (i=item; i; i=nxt) {
4504 nxt = i->next;
4505
4506 destroy_pval_item(i);
4507 }
4508 }
4509
4510 #ifdef AAL_ARGCHECK
4511 static char *ael_funclist[] =
4512 {
4513 "AGENT",
4514 "ARRAY",
4515 "BASE64_DECODE",
4516 "BASE64_ENCODE",
4517 "CALLERID",
4518 "CDR",
4519 "CHANNEL",
4520 "CHECKSIPDOMAIN",
4521 "CHECK_MD5",
4522 "CURL",
4523 "CUT",
4524 "DB",
4525 "DB_EXISTS",
4526 "DUNDILOOKUP",
4527 "ENUMLOOKUP",
4528 "ENV",
4529 "EVAL",
4530 "EXISTS",
4531 "FIELDQTY",
4532 "FILTER",
4533 "GROUP",
4534 "GROUP_COUNT",
4535 "GROUP_LIST",
4536 "GROUP_MATCH_COUNT",
4537 "IAXPEER",
4538 "IF",
4539 "IFTIME",
4540 "ISNULL",
4541 "KEYPADHASH",
4542 "LANGUAGE",
4543 "LEN",
4544 "MATH",
4545 "MD5",
4546 "MUSICCLASS",
4547 "QUEUEAGENTCOUNT",
4548 "QUEUE_MEMBER_COUNT",
4549 "QUEUE_MEMBER_LIST",
4550 "QUOTE",
4551 "RAND",
4552 "REGEX",
4553 "SET",
4554 "SHA1",
4555 "SIPCHANINFO",
4556 "SIPPEER",
4557 "SIP_HEADER",
4558 "SORT",
4559 "STAT",
4560 "STRFTIME",
4561 "STRPTIME",
4562 "TIMEOUT",
4563 "TXTCIDNAME",
4564 "URIDECODE",
4565 "URIENCODE",
4566 "VMCOUNT"
4567 };
4568
4569
4570 int ael_is_funcname(char *name)
4571 {
4572 int s,t;
4573 t = sizeof(ael_funclist)/sizeof(char*);
4574 s = 0;
4575 while ((s < t) && strcasecmp(name, ael_funclist[s]))
4576 s++;
4577 if ( s < t )
4578 return 1;
4579 else
4580 return 0;
4581 }
4582 #endif
Open Source Private Branch Exchange (PBX)