ead9501ee98f0ca75986109609b2221ac5fa820c
[asterisk/asterisk.git] / pbx / ael / ael.y
1 %{
2 /*
3  * Asterisk -- An open source telephony toolkit.
4  *
5  * Copyright (C) 2006, Digium, Inc.
6  *
7  * Steve Murphy <murf@parsetree.com>
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19 /*! \file
20  *
21  * \brief Bison Grammar description of AEL2.
22  *
23  */
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include "asterisk/logger.h"
28 #include "asterisk/utils.h"             /* ast_calloc() */
29 #include "asterisk/ael_structs.h"
30
31 /* create a new object with start-end marker */
32 static pval *npval(pvaltype type, int first_line, int last_line,
33         int first_column, int last_column);
34
35 static pval * linku1(pval *head, pval *tail);
36
37 void reset_parencount(yyscan_t yyscanner);
38 void reset_semicount(yyscan_t yyscanner);
39 void reset_argcount(yyscan_t yyscanner );
40
41 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
42 #define YYERROR_VERBOSE 1
43
44 extern char *my_file;
45 #ifdef AAL_ARGCHECK
46 int ael_is_funcname(char *name);
47 #endif
48 static char *ael_token_subst(char *mess);
49
50 %}
51
52
53 %union {
54         char *str;
55         struct pval *pval;
56 }
57
58 %{
59         /* declaring these AFTER the union makes things a lot simpler! */
60 void yyerror(YYLTYPE *locp, struct parse_io *parseio, char const *s);
61 int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
62
63 /* create a new object with start-end marker, simplified interface.
64  * Must be declared here because YYLTYPE is not known before
65  */
66 static pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last);
67 %}
68
69
70 %token KW_CONTEXT LC RC LP RP SEMI EQ COMMA COLON AMPER BAR AT
71 %token KW_MACRO KW_GLOBALS KW_IGNOREPAT KW_SWITCH KW_IF KW_IFTIME KW_ELSE KW_RANDOM KW_ABSTRACT
72 %token EXTENMARK KW_GOTO KW_JUMP KW_RETURN KW_BREAK KW_CONTINUE KW_REGEXTEN KW_HINT
73 %token KW_FOR KW_WHILE KW_CASE KW_PATTERN KW_DEFAULT KW_CATCH KW_SWITCHES KW_ESWITCHES
74 %token KW_INCLUDES
75
76 %token <str> word
77
78 %type <pval>includes
79 %type <pval>includeslist
80 %type <pval>switchlist
81 %type <pval>eswitches
82 %type <pval>switches
83 %type <pval>macro_statement
84 %type <pval>macro_statements
85 %type <pval>case_statement
86 %type <pval>case_statements
87 %type <pval>eval_arglist
88 %type <pval>application_call
89 %type <pval>application_call_head
90 %type <pval>macro_call
91 %type <pval>target jumptarget
92 %type <pval>statement
93 %type <pval>switch_head
94
95 %type <pval>if_head
96 %type <pval>random_head
97 %type <pval>iftime_head
98 %type <pval>statements
99 %type <pval>extension
100 %type <pval>ignorepat
101 %type <pval>element
102 %type <pval>elements
103 %type <pval>arglist
104 %type <pval>global_statement
105 %type <pval>global_statements
106 %type <pval>globals
107 %type <pval>macro
108 %type <pval>context
109 %type <pval>object
110 %type <pval>objects
111 %type <pval>file
112
113 %type <str>goto_word
114 %type <str>word_list
115 %type <str>word3_list
116 %type <str>includedname
117
118 /*
119  * OPTIONS
120  */
121
122 %locations      /* track source location using @n variables (yylloc in flex) */
123 %pure-parser    /* pass yylval and yylloc as arguments to yylex(). */
124 %name-prefix="ael_yy"
125 /*
126  * add an additional argument, parseio, to yyparse(),
127  * which is then accessible in the grammar actions
128  */
129 %parse-param {struct parse_io *parseio}
130
131 /* there will be two shift/reduce conflicts, they involve the if statement, where a single statement occurs not wrapped in curlies in the "true" section
132    the default action to shift will attach the else to the preceeding if. */
133 %expect 5
134 %error-verbose
135
136 /*
137  * declare destructors for objects.
138  * The former is for pval, the latter for strings.
139  * NOTE: we must not have a destructor for a 'file' object.
140  */
141 %destructor {
142                 destroy_pval($$);
143                 prev_word=0;
144         }       includes includeslist switchlist eswitches switches
145                 macro_statement macro_statements case_statement case_statements
146                 eval_arglist application_call application_call_head
147                 macro_call target jumptarget statement switch_head
148                 if_head random_head iftime_head statements extension
149                 ignorepat element elements arglist global_statement
150                 global_statements globals macro context object objects
151
152 %destructor { free($$);}  word word_list goto_word word3_list includedname
153
154
155 %%
156
157 file : objects  { $$ = parseio->pval = $1; }
158         ;
159
160 objects : object {$$=$1;}
161         | objects object
162                 {
163                         if ( $1 && $2 ) {
164                                 $$=$1;
165                                 linku1($$,$2);
166                         } else if ( $1 ) {
167                                 $$=$1;
168                         } else if ( $2 ) {
169                                 $$=$2;
170                         }
171                 }
172         | objects error {$$=$1;}
173         ;
174
175 object : context {$$=$1;}
176         | macro {$$=$1;}
177         | globals {$$=$1;}
178         | SEMI  {$$=0;/* allow older docs to be read */}
179         ;
180
181 context : KW_CONTEXT word LC elements RC {
182                 $$ = npval2(PV_CONTEXT, &@1, &@5);
183                 $$->u1.str = $2;
184                 $$->u2.statements = $4; }
185         | KW_CONTEXT word LC RC /* empty context OK */ {
186                 $$ = npval2(PV_CONTEXT, &@1, &@4);
187                 $$->u1.str = $2; }
188         | KW_CONTEXT KW_DEFAULT LC elements RC {
189                 $$ = npval2(PV_CONTEXT, &@1, &@5);
190                 $$->u1.str = strdup("default");
191                 $$->u2.statements = $4; }
192         | KW_CONTEXT KW_DEFAULT LC RC /* empty context OK */ {
193                 $$ = npval2(PV_CONTEXT, &@1, &@4);
194                 $$->u1.str = strdup("default"); }
195         | KW_ABSTRACT KW_CONTEXT word LC elements RC {
196                 $$ = npval2(PV_CONTEXT, &@1, &@6);
197                 $$->u1.str = $3;
198                 $$->u2.statements = $5;
199                 $$->u3.abstract = 1; }
200         | KW_ABSTRACT KW_CONTEXT word LC RC /* empty context OK */ {
201                 $$ = npval2(PV_CONTEXT, &@1, &@5);
202                 $$->u1.str = $3;
203                 $$->u3.abstract = 1; }
204         | KW_ABSTRACT KW_CONTEXT KW_DEFAULT LC elements RC  {
205                 $$ = npval2(PV_CONTEXT, &@1, &@6);
206                 $$->u1.str = strdup("default");
207                 $$->u2.statements = $5;
208                 $$->u3.abstract = 1; }
209         | KW_ABSTRACT KW_CONTEXT KW_DEFAULT LC RC /* empty context OK */ {
210                 $$ = npval2(PV_CONTEXT, &@1, &@5);
211                 $$->u1.str = strdup("default");
212                 $$->u3.abstract = 1; }
213         ;
214
215 macro : KW_MACRO word LP arglist RP LC macro_statements RC {
216                 $$ = npval2(PV_MACRO, &@1, &@8);
217                 $$->u1.str = $2; $$->u2.arglist = $4; $$->u3.macro_statements = $7; }
218         | KW_MACRO word LP arglist RP LC  RC {
219                 $$ = npval2(PV_MACRO, &@1, &@7);
220                 $$->u1.str = $2; $$->u2.arglist = $4; }
221         | KW_MACRO word LP RP LC macro_statements RC {
222                 $$ = npval2(PV_MACRO, &@1, &@7);
223                 $$->u1.str = $2;
224                 $$->u3.macro_statements = $6; }
225         | KW_MACRO word LP RP LC  RC {
226                 $$ = npval2(PV_MACRO, &@1, &@6);
227                 $$->u1.str = $2; }
228         ;
229
230 globals : KW_GLOBALS LC global_statements RC {
231                 $$ = npval2(PV_GLOBALS, &@1, &@4);
232                 $$->u1.statements = $3;}
233         | KW_GLOBALS LC RC { /* empty globals is OK */
234                 $$ = npval2(PV_GLOBALS, &@1, &@3); }
235         ;
236
237 global_statements : global_statement {$$=$1;}
238         | global_statements global_statement {$$=$1; linku1($$,$2);}
239         | global_statements error {$$=$1;}
240         ;
241
242 global_statement : word EQ { reset_semicount(parseio->scanner); }  word SEMI {
243                 $$ = npval2(PV_VARDEC, &@1, &@5);
244                 $$->u1.str = $1;
245                 $$->u2.val = $4; }
246         ;
247
248 arglist : word {
249                 $$= npval2(PV_WORD, &@1, &@1);
250                 $$->u1.str = $1; }
251         | arglist COMMA word {
252                 pval *z = npval2(PV_WORD, &@1, &@3);
253                 z->u1.str = $3;
254                 $$=$1;
255                 linku1($$,z); }
256         | arglist error {$$=$1;}
257         ;
258
259 elements : element { $$=$1;}
260         | error {$$=0;}
261         | elements element { if ( $1 && $2 ) {$$=$1; linku1($$,$2);}
262                                 else if ( $1 ) {$$=$1;}
263                                 else if ( $2 ) {$$=$2;} }
264         | elements error   { $$=$1;}
265         ;
266
267 element : extension {$$=$1;}
268         | includes {$$=$1;}
269         | switches {$$=$1;}
270         | eswitches {$$=$1;}
271         | ignorepat {$$=$1;}
272         | word EQ { reset_semicount(parseio->scanner); } word SEMI {
273                 $$ = npval2(PV_VARDEC, &@1, &@5);
274                 $$->u1.str = $1;
275                 $$->u2.val = $4; }
276         | word error {free($1); $$=0;}
277         | SEMI  {$$=0;/* allow older docs to be read */}
278         ;
279
280 ignorepat : KW_IGNOREPAT EXTENMARK word SEMI {
281                 $$ = npval2(PV_IGNOREPAT, &@1, &@4);
282                 $$->u1.str = $3;}
283         ;
284
285 extension : word EXTENMARK statement {
286                 $$ = npval2(PV_EXTENSION, &@1, &@3);
287                 $$->u1.str = $1;
288                 $$->u2.statements = $3; }
289         | KW_REGEXTEN word EXTENMARK statement {
290                 $$ = npval2(PV_EXTENSION, &@1, &@4);
291                 $$->u1.str = $2;
292                 $$->u2.statements = $4;
293                 $$->u4.regexten=1;}
294         | KW_HINT LP word3_list RP word EXTENMARK statement {
295                 $$ = npval2(PV_EXTENSION, &@1, &@7);
296                 $$->u1.str = $5;
297                 $$->u2.statements = $7;
298                 $$->u3.hints = $3;}
299         | KW_REGEXTEN KW_HINT LP word3_list RP word EXTENMARK statement {
300                 $$ = npval2(PV_EXTENSION, &@1, &@8);
301                 $$->u1.str = $6;
302                 $$->u2.statements = $8;
303                 $$->u4.regexten=1;
304                 $$->u3.hints = $4;}
305
306         ;
307
308 statements : statement {$$=$1;}
309         | statements statement {if ( $1 && $2 ) {$$=$1; linku1($$,$2);}
310                                                  else if ( $1 ) {$$=$1;}
311                                                  else if ( $2 ) {$$=$2;} }
312         | statements error {$$=$1;}
313         ;
314
315 if_head : KW_IF LP { reset_parencount(parseio->scanner); }  word_list RP {
316                 $$= npval2(PV_IF, &@1, &@5);
317                 $$->u1.str = $4; }
318         ;
319
320 random_head : KW_RANDOM LP { reset_parencount(parseio->scanner); } word_list RP {
321                 $$ = npval2(PV_RANDOM, &@1, &@5);
322                 $$->u1.str=$4;}
323         ;
324
325 iftime_head : KW_IFTIME LP word3_list COLON word3_list COLON word3_list
326                 BAR word3_list BAR word3_list BAR word3_list RP {
327                 $$ = npval2(PV_IFTIME, &@1, &@5); /* XXX really @5 or more ? */
328                 $$->u1.list = npval2(PV_WORD, &@3, &@3);
329                 asprintf(&($$->u1.list->u1.str), "%s:%s:%s", $3, $5, $7);
330                 free($3);
331                 free($5);
332                 free($7);
333                 $$->u1.list->next = npval2(PV_WORD, &@9, &@9);
334                 $$->u1.list->next->u1.str = $9;
335                 $$->u1.list->next->next = npval2(PV_WORD, &@11, &@11);
336                 $$->u1.list->next->next->u1.str = $11;
337                 $$->u1.list->next->next->next = npval2(PV_WORD, &@13, &@13);
338                 $$->u1.list->next->next->next->u1.str = $13;
339                 prev_word = 0;
340         }
341         | KW_IFTIME LP word BAR word3_list BAR word3_list BAR word3_list RP {
342                 $$ = npval2(PV_IFTIME, &@1, &@5); /* XXX @5 or greater ? */
343                 $$->u1.list = npval2(PV_WORD, &@3, &@3);
344                 $$->u1.list->u1.str = $3;
345                 $$->u1.list->next = npval2(PV_WORD, &@5, &@5);
346                 $$->u1.list->next->u1.str = $5;
347                 $$->u1.list->next->next = npval2(PV_WORD, &@7, &@7);
348                 $$->u1.list->next->next->u1.str = $7;
349                 $$->u1.list->next->next->next = npval2(PV_WORD, &@9, &@9);
350                 $$->u1.list->next->next->next->u1.str = $9;
351                 prev_word = 0;
352         }
353
354         ;
355
356 /* word_list is a hack to fix a problem with context switching between bison and flex;
357    by the time you register a new context with flex, you've already got a look-ahead token
358    from the old context, with no way to put it back and start afresh. So, we kludge this
359    and merge the words back together. */
360
361 word_list : word { $$ = $1;}
362         | word word {
363                 asprintf(&($$), "%s%s", $1, $2);
364                 free($1);
365                 free($2);
366                 prev_word = $$;}
367         ;
368
369 word3_list : word { $$ = $1;}
370         | word word {
371                 asprintf(&($$), "%s%s", $1, $2);
372                 free($1);
373                 free($2);
374                 prev_word = $$;}
375         | word word word {
376                 asprintf(&($$), "%s%s%s", $1, $2, $3);
377                 free($1);
378                 free($2);
379                 free($3);
380                 prev_word=$$;}
381         ;
382
383 goto_word : word { $$ = $1;}
384         | word word {
385                 asprintf(&($$), "%s%s", $1, $2);
386                 free($1);
387                 free($2);}
388         | word COLON word {
389                 asprintf(&($$), "%s:%s", $1, $3);
390                 free($1);
391                 free($3);}
392         ;
393
394 switch_head : KW_SWITCH LP { reset_parencount(parseio->scanner); } word RP  LC {
395                 $$ = npval2(PV_SWITCH, &@1, &@6);
396                 $$->u1.str = $4; }
397         ;
398
399 /*
400  * Definition of a statememt in our language
401  */
402 statement : LC statements RC {
403                 $$ = npval2(PV_STATEMENTBLOCK, &@1, &@3);
404                 $$->u1.list = $2; }
405         | word EQ {reset_semicount(parseio->scanner);} word SEMI {
406                 $$ = npval2(PV_VARDEC, &@1, &@5);
407                 $$->u1.str = $1;
408                 $$->u2.val = $4; }
409         | KW_GOTO target SEMI {
410                 $$ = npval2(PV_GOTO, &@1, &@3);
411                 $$->u1.list = $2;}
412         | KW_JUMP jumptarget SEMI {
413                 $$ = npval2(PV_GOTO, &@1, &@3);
414                 $$->u1.list = $2;}
415         | word COLON {
416                 $$ = npval2(PV_LABEL, &@1, &@2);
417                 $$->u1.str = $1; }
418         | KW_FOR LP {reset_semicount(parseio->scanner);} word SEMI
419                         {reset_semicount(parseio->scanner);} word SEMI
420                         {reset_parencount(parseio->scanner);} word RP statement {
421                 $$ = npval2(PV_FOR, &@1, &@12);
422                 $$->u1.for_init = $4;
423                 $$->u2.for_test=$7;
424                 $$->u3.for_inc = $10;
425                 $$->u4.for_statements = $12;}
426         | KW_WHILE LP {reset_parencount(parseio->scanner);} word RP statement {
427                 $$ = npval2(PV_WHILE, &@1, &@6);
428                 $$->u1.str = $4;
429                 $$->u2.statements = $6; }
430         | switch_head RC /* empty list OK */ {
431                 $$=$1;
432                 $$->endline = @2.last_line;
433                 $$->endcol = @2.last_column;}
434         | switch_head case_statements RC {
435                 $$=$1;
436                 $$->u2.statements = $2;
437                 $$->endline = @3.last_line;
438                 $$->endcol = @3.last_column;}
439         | AMPER macro_call SEMI {
440                 $$ = $2;
441                 $$->endline = @2.last_line;
442                 $$->endcol = @2.last_column;}
443         | application_call SEMI {
444                 $$ = $1;
445                 $$->endline = @2.last_line;
446                 $$->endcol = @2.last_column;}
447         | word SEMI {
448                 $$= npval2(PV_APPLICATION_CALL, &@1, &@2);
449                 $$->u1.str = $1;}
450         | application_call EQ {reset_semicount(parseio->scanner);} word SEMI {
451                 char *bufx;
452                 int tot=0;
453                 pval *pptr;
454                 $$ = npval2(PV_VARDEC, &@1, &@5);
455                 $$->u2.val=$4;
456                 /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
457                 /* string to big to fit in the buffer? */
458                 tot+=strlen($1->u1.str);
459                 for(pptr=$1->u2.arglist;pptr;pptr=pptr->next) {
460                         tot+=strlen(pptr->u1.str);
461                         tot++; /* for a sep like a comma */
462                 }
463                 tot+=4; /* for safety */
464                 bufx = ast_calloc(1, tot);
465                 strcpy(bufx,$1->u1.str);
466                 strcat(bufx,"(");
467                 /* XXX need to advance the pointer or the loop is very inefficient */
468                 for (pptr=$1->u2.arglist;pptr;pptr=pptr->next) {
469                         if ( pptr != $1->u2.arglist )
470                                 strcat(bufx,",");
471                         strcat(bufx,pptr->u1.str);
472                 }
473                 strcat(bufx,")");
474 #ifdef AAL_ARGCHECK
475                 if ( !ael_is_funcname($1->u1.str) )
476                         ast_log(LOG_WARNING, "==== File: %s, Line %d, Cols: %d-%d: Function call? The name %s is not in my internal list of function names\n",
477                                 my_file, @1.first_line, @1.first_column, @1.last_column, $1->u1.str);
478 #endif
479                 $$->u1.str = bufx;
480                 destroy_pval($1); /* the app call it is not, get rid of that chain */
481                 prev_word = 0;
482         }
483         | KW_BREAK SEMI { $$ = npval2(PV_BREAK, &@1, &@2); }
484         | KW_RETURN SEMI { $$ = npval2(PV_RETURN, &@1, &@2); }
485         | KW_CONTINUE SEMI { $$ = npval2(PV_CONTINUE, &@1, &@2); }
486         | random_head statement {
487                 $$=$1;
488                 $$->u2.statements = $2;
489                 $$->endline = @2.last_line;
490                 $$->endcol = @2.last_column;}
491         | random_head statement KW_ELSE statement {
492                 $$=$1;
493                 $$->u2.statements = $2;
494                 $$->endline = @2.last_line;
495                 $$->endcol = @2.last_column;
496                 $$->u3.else_statements = $4;}
497         | if_head statement {
498                 $$=$1;
499                 $$->u2.statements = $2;
500                 $$->endline = @2.last_line;
501                 $$->endcol = @2.last_column;}
502         | if_head statement KW_ELSE statement {
503                 $$=$1;
504                 $$->u2.statements = $2;
505                 $$->endline = @2.last_line;
506                 $$->endcol = @2.last_column;
507                 $$->u3.else_statements = $4;}
508         | iftime_head statement {
509                 $$=$1;
510                 $$->u2.statements = $2;
511                 $$->endline = @2.last_line;
512                 $$->endcol = @2.last_column;}
513         | iftime_head statement KW_ELSE statement {
514                 $$=$1;
515                 $$->u2.statements = $2;
516                 $$->endline = @2.last_line;
517                 $$->endcol = @2.last_column;
518                 $$->u3.else_statements = $4;}
519         | SEMI { $$=0; }
520         ;
521
522 target : goto_word { $$ = npval2(PV_WORD, &@1, &@1);
523                 $$->u1.str = $1;}
524         | goto_word BAR goto_word {
525                 $$ = npval2(PV_WORD, &@1, &@1);
526                 $$->u1.str = $1;
527                 $$->next = npval2(PV_WORD, &@3, &@3);
528                 $$->next->u1.str = $3;}
529         | goto_word COMMA goto_word {
530                 $$ = npval2(PV_WORD, &@1, &@1);
531                 $$->u1.str = $1;
532                 $$->next = npval2(PV_WORD, &@3, &@3);
533                 $$->next->u1.str = $3;}
534         | goto_word BAR goto_word BAR goto_word {
535                 $$ = npval2(PV_WORD, &@1, &@1);
536                 $$->u1.str = $1;
537                 $$->next = npval2(PV_WORD, &@3, &@3);
538                 $$->next->u1.str = $3;
539                 $$->next->next = npval2(PV_WORD, &@5, &@5);
540                 $$->next->next->u1.str = $5; }
541         | goto_word COMMA goto_word COMMA goto_word {
542                 $$ = npval2(PV_WORD, &@1, &@1);
543                 $$->u1.str = $1;
544                 $$->next = npval2(PV_WORD, &@3, &@3);
545                 $$->next->u1.str = $3;
546                 $$->next->next = npval2(PV_WORD, &@5, &@5);
547                 $$->next->next->u1.str = $5; }
548         | KW_DEFAULT BAR goto_word BAR goto_word {
549                 $$ = npval2(PV_WORD, &@1, &@1);
550                 $$->u1.str = strdup("default");
551                 $$->next = npval2(PV_WORD, &@3, &@3);
552                 $$->next->u1.str = $3;
553                 $$->next->next = npval2(PV_WORD, &@5, &@5);
554                 $$->next->next->u1.str = $5; }
555         | KW_DEFAULT COMMA goto_word COMMA goto_word {
556                 $$ = npval2(PV_WORD, &@1, &@1);
557                 $$->u1.str = strdup("default");
558                 $$->next = npval2(PV_WORD, &@3, &@3);
559                 $$->next->u1.str = $3;
560                 $$->next->next = npval2(PV_WORD, &@5, &@5);
561                 $$->next->next->u1.str = $5; }
562         ;
563
564 jumptarget : goto_word {
565                 $$ = npval2(PV_WORD, &@1, &@1);
566                 $$->u1.str = $1;
567                 $$->next = npval2(PV_WORD, &@1, &@1); /* XXX not really @1 */
568                 $$->next->u1.str = strdup("1");}  /*  jump extension[,priority][@context] */
569         | goto_word COMMA goto_word {
570                 $$ = npval2(PV_WORD, &@1, &@1);
571                 $$->u1.str = $1;
572                 $$->next = npval2(PV_WORD, &@3, &@3);
573                 $$->next->u1.str = $3;}
574         | goto_word COMMA word AT word {
575                 $$ = npval2(PV_WORD, &@1, &@1);
576                 $$->u1.str = $5;
577                 $$->next = npval2(PV_WORD, &@3, &@3);
578                 $$->next->u1.str = $1;
579                 $$->next->next = npval2(PV_WORD, &@5, &@5);
580                 $$->next->next->u1.str = $3; }
581         | goto_word AT goto_word {
582                 $$ = npval2(PV_WORD, &@1, &@1);
583                 $$->u1.str = $3;
584                 $$->next = npval2(PV_WORD, &@3, &@3);
585                 $$->next->u1.str = $1;
586                 $$->next->next = npval2(PV_WORD, &@3, &@3);
587                 $$->next->next->u1.str = strdup("1"); }
588         | goto_word COMMA word AT KW_DEFAULT {
589                 $$ = npval2(PV_WORD, &@1, &@1);
590                 $$->u1.str = strdup("default");
591                 $$->next = npval2(PV_WORD, &@3, &@3);
592                 $$->next->u1.str = $1;
593                 $$->next->next = npval2(PV_WORD, &@5, &@5);
594                 $$->next->next->u1.str = $3; }
595         | goto_word AT KW_DEFAULT {
596                 $$ = npval2(PV_WORD, &@1, &@1);
597                 $$->u1.str = strdup("default");
598                 $$->next = npval2(PV_WORD, &@3, &@3);
599                 $$->next->u1.str = $1;
600                 $$->next->next = npval2(PV_WORD, &@3, &@3);
601                 $$->next->next->u1.str = strdup("1"); }
602         ;
603
604 macro_call : word LP {reset_argcount(parseio->scanner);} eval_arglist RP {
605                 /* XXX original code had @2 but i think we need @5 */
606                 $$ = npval2(PV_MACRO_CALL, &@1, &@5);
607                 $$->u1.str = $1;
608                 $$->u2.arglist = $4;}
609         | word LP RP {
610                 $$= npval2(PV_MACRO_CALL, &@1, &@3);
611                 $$->u1.str = $1; }
612         ;
613
614 application_call_head: word {reset_argcount(parseio->scanner);} LP  {
615                 if (strcasecmp($1,"goto") == 0) {
616                         $$= npval2(PV_GOTO, &@1, &@3);
617                         free($1); /* won't be using this */
618                         ast_log(LOG_WARNING, "==== File: %s, Line %d, Cols: %d-%d: Suggestion: Use the goto statement instead of the Goto() application call in AEL.\n", my_file, @1.first_line, @1.first_column, @1.last_column );
619                 } else
620                         $$= npval2(PV_APPLICATION_CALL, &@1, &@3);
621                 $$->u1.str = $1; }
622         ;
623
624 application_call : application_call_head eval_arglist RP {$$ = $1;
625                 if( $$->type == PV_GOTO )
626                         $$->u1.list = $2;
627                 else
628                         $$->u2.arglist = $2;
629                 $$->endline = @3.last_line; $$->endcol = @3.last_column;}
630         | application_call_head RP {$$=$1;$$->endline = @2.last_line; $$->endcol = @2.last_column;}
631         ;
632
633 eval_arglist :  word_list { 
634                 $$= npval2(PV_WORD, &@1, &@1);
635                 $$->u1.str = $1;}
636         | /*nothing! */   {
637                 $$= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
638                 $$->u1.str = strdup(""); }
639         | eval_arglist COMMA  word {
640                 pval *z = npval2(PV_WORD, &@3, &@3);
641                 $$ = $1;
642                 linku1($1,z);
643                 z->u1.str = $3;}
644         | eval_arglist COMMA {
645                 pval *z = npval2(PV_WORD, &@2, &@2);
646                 $$ = $1;
647                 linku1($1,z);
648                 z->u1.str = strdup("");}
649         ;
650
651 case_statements: case_statement {$$=$1;}
652         | case_statements case_statement { if ( $1 && $2 ) {$$=$1; linku1($$,$2);}
653                                                  else if ( $1 ) {$$=$1;}
654                                                  else if ( $2 ) {$$=$2;} }
655         ;
656
657 case_statement: KW_CASE word COLON statements {
658                 $$ = npval2(PV_CASE, &@1, &@3); /* XXX 3 or 4 ? */
659                 $$->u1.str = $2;
660                 $$->u2.statements = $4;}
661         | KW_DEFAULT COLON statements {
662                 $$ = npval2(PV_DEFAULT, &@1, &@3);
663                 $$->u1.str = NULL;
664                 $$->u2.statements = $3;}
665         | KW_PATTERN word COLON statements {
666                 $$ = npval2(PV_PATTERN, &@1, &@4); /* XXX@3 or @4 ? */
667                 $$->u1.str = $2;
668                 $$->u2.statements = $4;}
669         | KW_CASE word COLON {
670                 $$ = npval2(PV_CASE, &@1, &@3);
671                 $$->u1.str = $2;}
672         | KW_DEFAULT COLON {
673                 $$ = npval2(PV_DEFAULT, &@1, &@2);
674                 $$->u1.str = NULL;}
675         | KW_PATTERN word COLON  {
676                 $$ = npval2(PV_PATTERN, &@1, &@3);
677                 $$->u1.str = $2;}
678         ;
679
680 macro_statements: macro_statement {$$ = $1;}
681         | macro_statements macro_statement { if ( $1 && $2 ) {$$=$1; linku1($$,$2);}
682                                                  else if ( $1 ) {$$=$1;}
683                                                  else if ( $2 ) {$$=$2;} }
684         ;
685
686 macro_statement : statement {$$=$1;}
687         | KW_CATCH word LC statements RC {
688                 $$ = npval2(PV_CATCH, &@1, &@5);
689                 $$->u1.str = $2;
690                 $$->u2.statements = $4;}
691         ;
692
693 switches : KW_SWITCHES LC switchlist RC {
694                 $$ = npval2(PV_SWITCHES, &@1, &@4);
695                 $$->u1.list = $3; }
696         | KW_SWITCHES LC RC /* empty switch list OK */ {
697                 $$ = npval2(PV_SWITCHES, &@1, &@3); }
698         ;
699
700 eswitches : KW_ESWITCHES LC switchlist RC {
701                 $$ = npval2(PV_ESWITCHES, &@1, &@4);
702                 $$->u1.list = $3; }
703         | KW_ESWITCHES LC  RC { /* empty switch list OK */
704                 $$ = npval2(PV_ESWITCHES, &@1, &@3); } /* if there's nothing to declare, why include it? */
705         ;
706
707 switchlist : word SEMI {
708                 $$ = npval2(PV_WORD, &@1, &@2);
709                 $$->u1.str = $1;}
710         | switchlist word SEMI {
711                 pval *z = npval2(PV_WORD, &@2, &@3);
712                 z->u1.str = $2;
713                 $$=$1;
714                 linku1($$,z); }
715         | switchlist error {$$=$1;}
716         ;
717
718 includeslist : includedname SEMI {
719                 $$ = npval2(PV_WORD, &@1, &@2);
720                 $$->u1.str = $1;}
721         | includedname BAR word3_list COLON word3_list COLON word3_list
722                         BAR word3_list BAR word3_list BAR word3_list SEMI {
723                 $$ = npval2(PV_WORD, &@1, &@2);
724                 $$->u1.str = $1;
725                 $$->u2.arglist = npval2(PV_WORD, &@3, &@7);
726                 asprintf( &($$->u2.arglist->u1.str), "%s:%s:%s", $3, $5, $7);
727                 free($3);
728                 free($5);
729                 free($7);
730                 $$->u2.arglist->next = npval2(PV_WORD, &@9, &@9);
731                 $$->u2.arglist->next->u1.str = $9;
732                 $$->u2.arglist->next->next = npval2(PV_WORD, &@11, &@11);
733                 $$->u2.arglist->next->next->u1.str = $11;
734                 $$->u2.arglist->next->next->next = npval2(PV_WORD, &@13, &@13);
735                 $$->u2.arglist->next->next->next->u1.str = $13;
736                 prev_word=0;
737         }
738         | includedname BAR word BAR word3_list BAR word3_list BAR word3_list SEMI {
739                 $$ = npval2(PV_WORD, &@1, &@2);
740                 $$->u1.str = $1;
741                 $$->u2.arglist = npval2(PV_WORD, &@3, &@3);
742                 $$->u2.arglist->u1.str = $3;
743                 $$->u2.arglist->next = npval2(PV_WORD, &@5, &@5);
744                 $$->u2.arglist->next->u1.str = $5;
745                 $$->u2.arglist->next->next = npval2(PV_WORD, &@7, &@7);
746                 $$->u2.arglist->next->next->u1.str = $7;
747                 $$->u2.arglist->next->next->next = npval2(PV_WORD, &@9, &@9);
748                 $$->u2.arglist->next->next->next->u1.str = $9;
749                 prev_word=0;
750         }
751         | includeslist includedname SEMI {
752                 pval *z = npval2(PV_WORD, &@2, &@3); /* XXX don't we need @1-@4 ?*/
753                 $$=$1;
754                 z->u1.str = $2;
755                 linku1($$,z); }
756         | includeslist includedname BAR word3_list COLON word3_list COLON word3_list
757                         BAR word3_list BAR word3_list BAR word3_list SEMI {
758                 pval *z = npval2(PV_WORD, &@2, &@3);
759                 $$=$1; z->u1.str = $2;
760                 linku1($$,z);
761                 z->u2.arglist = npval2(PV_WORD, &@4, &@4);
762                 asprintf( &($$->u2.arglist->u1.str), "%s:%s:%s", $4, $6, $8);
763                 free($4);
764                 free($6);
765                 free($8);
766                 z->u2.arglist->next = npval2(PV_WORD, &@10, &@10);
767                 z->u2.arglist->next->u1.str = $10;
768                 z->u2.arglist->next->next = npval2(PV_WORD, &@12, &@12);
769                 z->u2.arglist->next->next->u1.str = $12;
770                 z->u2.arglist->next->next->next = npval2(PV_WORD, &@14, &@14);
771                 z->u2.arglist->next->next->next->u1.str = $14;
772                 prev_word=0;
773         }
774         | includeslist includedname BAR word BAR word3_list BAR word3_list BAR word3_list SEMI {
775                 pval *z = npval2(PV_WORD, &@2, &@3);
776                 $$=$1;
777                 z->u1.str = $2; linku1($$,z);
778                 z->u2.arglist = npval2(PV_WORD, &@4, &@4);
779                 $$->u2.arglist->u1.str = $4;
780                 z->u2.arglist->next = npval2(PV_WORD, &@6, &@6);
781                 z->u2.arglist->next->u1.str = $6;
782                 z->u2.arglist->next->next = npval2(PV_WORD, &@8, &@8);
783                 z->u2.arglist->next->next->u1.str = $8;
784                 z->u2.arglist->next->next->next = npval2(PV_WORD, &@10, &@10);
785                 z->u2.arglist->next->next->next->u1.str = $10;
786                 prev_word=0;
787         }
788         | includeslist error {$$=$1;}
789         ;
790
791 includedname : word { $$ = $1;}
792         | KW_DEFAULT {$$=strdup("default");}
793         ;
794
795 includes : KW_INCLUDES LC includeslist RC {
796                 $$ = npval2(PV_INCLUDES, &@1, &@4);
797                 $$->u1.list = $3;}
798         | KW_INCLUDES LC RC {
799                 $$ = npval2(PV_INCLUDES, &@1, &@3);}
800         ;
801
802
803 %%
804
805 static char *token_equivs1[] =
806 {
807         "AMPER",
808         "AT",
809         "BAR",
810         "COLON",
811         "COMMA",
812         "EQ",
813         "EXTENMARK",
814         "KW_BREAK",
815         "KW_CASE",
816         "KW_CATCH",
817         "KW_CONTEXT",
818         "KW_CONTINUE",
819         "KW_DEFAULT",
820         "KW_ELSE",
821         "KW_ESWITCHES",
822         "KW_FOR",
823         "KW_GLOBALS",
824         "KW_GOTO",
825         "KW_HINT",
826         "KW_IFTIME",
827         "KW_IF",
828         "KW_IGNOREPAT",
829         "KW_INCLUDES"
830         "KW_JUMP",
831         "KW_MACRO",
832         "KW_PATTERN",
833         "KW_REGEXTEN",
834         "KW_RETURN",
835         "KW_SWITCHES",
836         "KW_SWITCH",
837         "KW_WHILE",
838         "LC",
839         "LP",
840         "RC",
841         "RP",
842         "SEMI",
843 };
844
845 static char *token_equivs2[] =
846 {
847         "&",
848         "@",
849         "|",
850         ":",
851         ",",
852         "=",
853         "=>",
854         "break",
855         "case",
856         "catch",
857         "context",
858         "continue",
859         "default",
860         "else",
861         "eswitches",
862         "for",
863         "globals",
864         "goto",
865         "hint",
866         "ifTime",
867         "if",
868         "ignorepat",
869         "includes"
870         "jump",
871         "macro",
872         "pattern",
873         "regexten",
874         "return",
875         "switches",
876         "switch",
877         "while",
878         "{",
879         "(",
880         "}",
881         ")",
882         ";",
883 };
884
885
886 static char *ael_token_subst(char *mess)
887 {
888         /* calc a length, malloc, fill, and return; yyerror had better free it! */
889         int len=0,i;
890         char *p;
891         char *res, *s,*t;
892         int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
893
894         for (p=mess; *p; p++) {
895                 for (i=0; i<token_equivs_entries; i++) {
896                         if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
897                         {
898                                 len+=strlen(token_equivs2[i])+2;
899                                 p += strlen(token_equivs1[i])-1;
900                                 break;
901                         }
902                 }
903                 len++;
904         }
905         res = ast_calloc(1, len+1);
906         res[0] = 0;
907         s = res;
908         for (p=mess; *p;) {
909                 int found = 0;
910                 for (i=0; i<token_equivs_entries; i++) {
911                         if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
912                                 *s++ = '\'';
913                                 for (t=token_equivs2[i]; *t;) {
914                                         *s++ = *t++;
915                                 }
916                                 *s++ = '\'';
917                                 p += strlen(token_equivs1[i]);
918                                 found = 1;
919                                 break;
920                         }
921                 }
922                 if( !found )
923                         *s++ = *p++;
924         }
925         *s++ = 0;
926         return res;
927 }
928
929 void yyerror(YYLTYPE *locp, struct parse_io *parseio,  char const *s)
930 {
931         char *s2 = ael_token_subst((char *)s);
932         if (locp->first_line == locp->last_line) {
933                 ast_log(LOG_ERROR, "==== File: %s, Line %d, Cols: %d-%d: Error: %s\n", my_file, locp->first_line, locp->first_column, locp->last_column, s2);
934         } else {
935                 ast_log(LOG_ERROR, "==== File: %s, Line %d Col %d  to Line %d Col %d: Error: %s\n", my_file, locp->first_line, locp->first_column, locp->last_line, locp->last_column, s2);
936         }
937         free(s2);
938         parseio->syntax_error_count++;
939 }
940
941 static struct pval *npval(pvaltype type, int first_line, int last_line,
942         int first_column, int last_column)
943 {
944         extern char *my_file;
945         pval *z = ast_calloc(1, sizeof(struct pval));
946         z->type = type;
947         z->startline = first_line;
948         z->endline = last_line;
949         z->startcol = first_column;
950         z->endcol = last_column;
951         z->filename = strdup(my_file);
952         return z;
953 }
954
955 static struct pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last)
956 {
957         return npval(type, first->first_line, last->last_line,
958                         first->first_column, last->last_column);
959 }
960
961 /* append second element to the list in the first one */
962 static pval * linku1(pval *head, pval *tail)
963 {
964         if (!head)
965                 return tail;
966         if (!head->next) {
967                 head->next = tail;
968         } else {
969                 head->u1_last->next = tail;
970         }
971         head->u1_last = tail;
972         return head;
973 }
974