#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "asterisk/logger.h"
#include "asterisk/lock.h"
#include "asterisk/hashtab.h"
#include "asterisk/ael_structs.h"
#include "asterisk/utils.h"
Go to the source code of this file.
Data Structures | |
union | yyalloc |
struct | YYLTYPE |
union | YYSTYPE |
Defines | |
#define | YY_(msgid) msgid |
#define | YY_LOCATION_PRINT(File, Loc) |
#define | YY_REDUCE_PRINT(Rule) |
#define | YY_STACK_PRINT(Bottom, Top) |
#define | YY_SYMBOL_PRINT(Title, Type, Value, Location) |
#define | YYABORT goto yyabortlab |
#define | YYACCEPT goto yyacceptlab |
#define | YYBACKUP(Token, Value) |
#define | YYBISON 1 |
#define | YYBISON_VERSION "2.4.1" |
#define | yychar ael_yychar |
#define | yyclearin (yychar = YYEMPTY) |
#define | YYCOPY(To, From, Count) |
#define | YYDEBUG 0 |
#define | yydebug ael_yydebug |
#define | YYDPRINTF(Args) |
#define | YYEMPTY (-2) |
#define | YYEOF 0 |
#define | YYERRCODE 256 |
#define | yyerrok (yyerrstatus = 0) |
#define | YYERROR goto yyerrorlab |
#define | yyerror ael_yyerror |
#define | YYERROR_VERBOSE 1 |
#define | YYERROR_VERBOSE 1 |
#define | YYFAIL goto yyerrlab |
#define | YYFINAL 17 |
#define | YYFREE free |
#define | YYID(n) (n) |
#define | YYINITDEPTH 200 |
#define | YYLAST 371 |
#define | YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) |
#define | yylex ael_yylex |
#define | YYLEX_PARAM ((struct parse_io *)parseio)->scanner |
#define | yylloc ael_yylloc |
#define | YYLLOC_DEFAULT(Current, Rhs, N) |
#define | YYLSP_NEEDED 1 |
#define | yyltype YYLTYPE |
#define | YYLTYPE_IS_DECLARED 1 |
#define | YYLTYPE_IS_TRIVIAL 1 |
#define | yylval ael_yylval |
#define | YYMALLOC malloc |
#define | YYMAXDEPTH 10000 |
#define | YYMAXUTOK 298 |
#define | yynerrs ael_yynerrs |
#define | YYNNTS 56 |
#define | YYNRULES 143 |
#define | YYNSTATES 283 |
#define | YYNTOKENS 44 |
#define | YYPACT_NINF -211 |
#define | yyparse ael_yyparse |
#define | YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) |
#define | YYPULL 1 |
#define | YYPURE 1 |
#define | YYPUSH 0 |
#define | YYRECOVERING() (!!yyerrstatus) |
#define | YYRHSLOC(Rhs, K) ((Rhs)[K]) |
#define | YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
#define | YYSIZE_T unsigned int |
#define | YYSKELETON_NAME "yacc.c" |
#define | YYSTACK_ALLOC YYMALLOC |
#define | YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
#define | YYSTACK_BYTES(N) |
#define | YYSTACK_FREE YYFREE |
#define | YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
#define | YYSTACK_RELOCATE(Stack_alloc, Stack) |
#define | yystype YYSTYPE |
#define | YYSTYPE_IS_DECLARED 1 |
#define | YYSTYPE_IS_TRIVIAL 1 |
#define | YYTABLE_NINF -134 |
#define | YYTERROR 1 |
#define | YYTOKEN_TABLE 0 |
#define | YYTRANSLATE(YYX) ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
#define | YYUNDEFTOK 2 |
#define | YYUSE(e) ((void) (e)) |
Typedefs | |
typedef short int | yytype_int16 |
typedef short int | yytype_int8 |
typedef unsigned short int | yytype_uint16 |
typedef unsigned char | yytype_uint8 |
Enumerations | |
enum | yytokentype { KW_CONTEXT = 258, LC = 259, RC = 260, LP = 261, RP = 262, SEMI = 263, EQ = 264, COMMA = 265, COLON = 266, AMPER = 267, BAR = 268, AT = 269, KW_MACRO = 270, KW_GLOBALS = 271, KW_IGNOREPAT = 272, KW_SWITCH = 273, KW_IF = 274, KW_IFTIME = 275, KW_ELSE = 276, KW_RANDOM = 277, KW_ABSTRACT = 278, KW_EXTEND = 279, EXTENMARK = 280, KW_GOTO = 281, KW_JUMP = 282, KW_RETURN = 283, KW_BREAK = 284, KW_CONTINUE = 285, KW_REGEXTEN = 286, KW_HINT = 287, KW_FOR = 288, KW_WHILE = 289, KW_CASE = 290, KW_PATTERN = 291, KW_DEFAULT = 292, KW_CATCH = 293, KW_SWITCHES = 294, KW_ESWITCHES = 295, KW_INCLUDES = 296, KW_LOCAL = 297, word = 298 } |
Functions | |
static char * | ael_token_subst (const char *mess) |
int | ael_yylex (YYSTYPE *yylval_param, YYLTYPE *yylloc_param, void *yyscanner) |
pval * | linku1 (pval *head, pval *tail) |
pval * | npval (pvaltype type, int first_line, int last_line, int first_column, int last_column) |
static pval * | npval2 (pvaltype type, YYLTYPE *first, YYLTYPE *last) |
static pval * | nword (char *string, YYLTYPE *pos) |
void | reset_argcount (yyscan_t yyscanner) |
void | reset_parencount (yyscan_t yyscanner) |
void | reset_semicount (yyscan_t yyscanner) |
static void | set_dads (pval *dad, pval *child_list) |
static pval * | update_last (pval *, YYLTYPE *) |
static void | yydestruct (char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parse_io *parseio) const |
void | yyerror (YYLTYPE *locp, struct parse_io *parseio, char const *s) |
int | yyparse (struct parse_io *parseio) |
int | yyparse () |
static char * | yystpcpy (char *yydest, const char *yysrc) |
static YYSIZE_T | yystrlen (char *yystr) const |
static YYSIZE_T | yysyntax_error (char *yyresult, int yystate, int yychar) |
static YYSIZE_T | yytnamerr (char *yyres, const char *yystr) |
Variables | |
ast_flags | ast_compat |
char * | my_file |
static char * | token_equivs1 [] |
static char * | token_equivs2 [] |
static const yytype_uint16 | yycheck [] |
static const yytype_uint8 | yydefact [] |
static const yytype_int16 | yydefgoto [] |
static const yytype_int16 | yypact [] |
static const yytype_int16 | yypgoto [] |
static const yytype_uint8 | yyr1 [] |
static const yytype_uint8 | yyr2 [] |
static const yytype_uint8 | yystos [] |
static const yytype_int16 | yytable [] |
static const char *const | yytname [] |
static const yytype_uint8 | yytranslate [] |
Definition in file ael.tab.c.
#define YY_LOCATION_PRINT | ( | File, | |||
Loc | ) |
#define YYPOPSTACK | ( | N | ) | (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) |
#define YYSTACK_BYTES | ( | N | ) |
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAXIMUM)
#define YYTRANSLATE | ( | YYX | ) | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
typedef short int yytype_int16 |
typedef short int yytype_int8 |
typedef unsigned short int yytype_uint16 |
typedef unsigned char yytype_uint8 |
enum yytokentype |
Definition at line 164 of file ael.tab.c.
00164 { 00165 KW_CONTEXT = 258, 00166 LC = 259, 00167 RC = 260, 00168 LP = 261, 00169 RP = 262, 00170 SEMI = 263, 00171 EQ = 264, 00172 COMMA = 265, 00173 COLON = 266, 00174 AMPER = 267, 00175 BAR = 268, 00176 AT = 269, 00177 KW_MACRO = 270, 00178 KW_GLOBALS = 271, 00179 KW_IGNOREPAT = 272, 00180 KW_SWITCH = 273, 00181 KW_IF = 274, 00182 KW_IFTIME = 275, 00183 KW_ELSE = 276, 00184 KW_RANDOM = 277, 00185 KW_ABSTRACT = 278, 00186 KW_EXTEND = 279, 00187 EXTENMARK = 280, 00188 KW_GOTO = 281, 00189 KW_JUMP = 282, 00190 KW_RETURN = 283, 00191 KW_BREAK = 284, 00192 KW_CONTINUE = 285, 00193 KW_REGEXTEN = 286, 00194 KW_HINT = 287, 00195 KW_FOR = 288, 00196 KW_WHILE = 289, 00197 KW_CASE = 290, 00198 KW_PATTERN = 291, 00199 KW_DEFAULT = 292, 00200 KW_CATCH = 293, 00201 KW_SWITCHES = 294, 00202 KW_ESWITCHES = 295, 00203 KW_INCLUDES = 296, 00204 KW_LOCAL = 297, 00205 word = 298 00206 };
static char * ael_token_subst | ( | const char * | mess | ) | [static] |
Definition at line 3853 of file ael.tab.c.
Referenced by yyerror().
03854 { 03855 /* calc a length, malloc, fill, and return; yyerror had better free it! */ 03856 int len=0,i; 03857 const char *p; 03858 char *res, *s,*t; 03859 int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*); 03860 03861 for (p=mess; *p; p++) { 03862 for (i=0; i<token_equivs_entries; i++) { 03863 if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) 03864 { 03865 len+=strlen(token_equivs2[i])+2; 03866 p += strlen(token_equivs1[i])-1; 03867 break; 03868 } 03869 } 03870 len++; 03871 } 03872 res = calloc(1, len+1); 03873 res[0] = 0; 03874 s = res; 03875 for (p=mess; *p;) { 03876 int found = 0; 03877 for (i=0; i<token_equivs_entries; i++) { 03878 if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) { 03879 *s++ = '\''; 03880 for (t=token_equivs2[i]; *t;) { 03881 *s++ = *t++; 03882 } 03883 *s++ = '\''; 03884 p += strlen(token_equivs1[i]); 03885 found = 1; 03886 break; 03887 } 03888 } 03889 if( !found ) 03890 *s++ = *p++; 03891 } 03892 *s++ = 0; 03893 return res; 03894 }
Definition at line 5837 of file pval.c.
References pval::next, pval::prev, and pval::u1_last.
05838 { 05839 if (!head) 05840 return tail; 05841 if (tail) { 05842 if (!head->next) { 05843 head->next = tail; 05844 } else { 05845 head->u1_last->next = tail; 05846 } 05847 head->u1_last = tail; 05848 tail->prev = head; /* the dad link only points to containers */ 05849 } 05850 return head; 05851 }
Definition at line 3927 of file ael.tab.c.
References pval::endcol, pval::endline, and last.
Referenced by yyparse().
03928 { 03929 obj->endline = last->last_line; 03930 obj->endcol = last->last_column; 03931 return obj; 03932 }
static void yydestruct | ( | char * | yymsg, | |
int | yytype, | |||
YYSTYPE * | yyvaluep, | |||
YYLTYPE * | yylocationp, | |||
struct parse_io * | parseio | |||
) | const [static] |
Definition at line 1439 of file ael.tab.c.
References destroy_pval(), free, prev_word, YYSTYPE::pval, YYSTYPE::str, YY_SYMBOL_PRINT, and YYUSE.
01446 { 01447 YYUSE (yyvaluep); 01448 YYUSE (yylocationp); 01449 YYUSE (parseio); 01450 01451 if (!yymsg) 01452 yymsg = "Deleting"; 01453 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 01454 01455 switch (yytype) 01456 { 01457 case 43: /* "word" */ 01458 01459 /* Line 1000 of yacc.c */ 01460 #line 183 "ael.y" 01461 { free((yyvaluep->str));}; 01462 01463 /* Line 1000 of yacc.c */ 01464 #line 1465 "ael.tab.c" 01465 break; 01466 case 46: /* "objects" */ 01467 01468 /* Line 1000 of yacc.c */ 01469 #line 170 "ael.y" 01470 { 01471 destroy_pval((yyvaluep->pval)); 01472 prev_word=0; 01473 }; 01474 01475 /* Line 1000 of yacc.c */ 01476 #line 1477 "ael.tab.c" 01477 break; 01478 case 47: /* "object" */ 01479 01480 /* Line 1000 of yacc.c */ 01481 #line 170 "ael.y" 01482 { 01483 destroy_pval((yyvaluep->pval)); 01484 prev_word=0; 01485 }; 01486 01487 /* Line 1000 of yacc.c */ 01488 #line 1489 "ael.tab.c" 01489 break; 01490 case 48: /* "context_name" */ 01491 01492 /* Line 1000 of yacc.c */ 01493 #line 183 "ael.y" 01494 { free((yyvaluep->str));}; 01495 01496 /* Line 1000 of yacc.c */ 01497 #line 1498 "ael.tab.c" 01498 break; 01499 case 49: /* "context" */ 01500 01501 /* Line 1000 of yacc.c */ 01502 #line 170 "ael.y" 01503 { 01504 destroy_pval((yyvaluep->pval)); 01505 prev_word=0; 01506 }; 01507 01508 /* Line 1000 of yacc.c */ 01509 #line 1510 "ael.tab.c" 01510 break; 01511 case 51: /* "macro" */ 01512 01513 /* Line 1000 of yacc.c */ 01514 #line 170 "ael.y" 01515 { 01516 destroy_pval((yyvaluep->pval)); 01517 prev_word=0; 01518 }; 01519 01520 /* Line 1000 of yacc.c */ 01521 #line 1522 "ael.tab.c" 01522 break; 01523 case 52: /* "globals" */ 01524 01525 /* Line 1000 of yacc.c */ 01526 #line 170 "ael.y" 01527 { 01528 destroy_pval((yyvaluep->pval)); 01529 prev_word=0; 01530 }; 01531 01532 /* Line 1000 of yacc.c */ 01533 #line 1534 "ael.tab.c" 01534 break; 01535 case 53: /* "global_statements" */ 01536 01537 /* Line 1000 of yacc.c */ 01538 #line 170 "ael.y" 01539 { 01540 destroy_pval((yyvaluep->pval)); 01541 prev_word=0; 01542 }; 01543 01544 /* Line 1000 of yacc.c */ 01545 #line 1546 "ael.tab.c" 01546 break; 01547 case 54: /* "assignment" */ 01548 01549 /* Line 1000 of yacc.c */ 01550 #line 170 "ael.y" 01551 { 01552 destroy_pval((yyvaluep->pval)); 01553 prev_word=0; 01554 }; 01555 01556 /* Line 1000 of yacc.c */ 01557 #line 1558 "ael.tab.c" 01558 break; 01559 case 56: /* "local_assignment" */ 01560 01561 /* Line 1000 of yacc.c */ 01562 #line 170 "ael.y" 01563 { 01564 destroy_pval((yyvaluep->pval)); 01565 prev_word=0; 01566 }; 01567 01568 /* Line 1000 of yacc.c */ 01569 #line 1570 "ael.tab.c" 01570 break; 01571 case 58: /* "arglist" */ 01572 01573 /* Line 1000 of yacc.c */ 01574 #line 170 "ael.y" 01575 { 01576 destroy_pval((yyvaluep->pval)); 01577 prev_word=0; 01578 }; 01579 01580 /* Line 1000 of yacc.c */ 01581 #line 1582 "ael.tab.c" 01582 break; 01583 case 59: /* "elements" */ 01584 01585 /* Line 1000 of yacc.c */ 01586 #line 170 "ael.y" 01587 { 01588 destroy_pval((yyvaluep->pval)); 01589 prev_word=0; 01590 }; 01591 01592 /* Line 1000 of yacc.c */ 01593 #line 1594 "ael.tab.c" 01594 break; 01595 case 60: /* "element" */ 01596 01597 /* Line 1000 of yacc.c */ 01598 #line 170 "ael.y" 01599 { 01600 destroy_pval((yyvaluep->pval)); 01601 prev_word=0; 01602 }; 01603 01604 /* Line 1000 of yacc.c */ 01605 #line 1606 "ael.tab.c" 01606 break; 01607 case 61: /* "ignorepat" */ 01608 01609 /* Line 1000 of yacc.c */ 01610 #line 170 "ael.y" 01611 { 01612 destroy_pval((yyvaluep->pval)); 01613 prev_word=0; 01614 }; 01615 01616 /* Line 1000 of yacc.c */ 01617 #line 1618 "ael.tab.c" 01618 break; 01619 case 62: /* "extension" */ 01620 01621 /* Line 1000 of yacc.c */ 01622 #line 170 "ael.y" 01623 { 01624 destroy_pval((yyvaluep->pval)); 01625 prev_word=0; 01626 }; 01627 01628 /* Line 1000 of yacc.c */ 01629 #line 1630 "ael.tab.c" 01630 break; 01631 case 63: /* "statements" */ 01632 01633 /* Line 1000 of yacc.c */ 01634 #line 170 "ael.y" 01635 { 01636 destroy_pval((yyvaluep->pval)); 01637 prev_word=0; 01638 }; 01639 01640 /* Line 1000 of yacc.c */ 01641 #line 1642 "ael.tab.c" 01642 break; 01643 case 64: /* "timerange" */ 01644 01645 /* Line 1000 of yacc.c */ 01646 #line 183 "ael.y" 01647 { free((yyvaluep->str));}; 01648 01649 /* Line 1000 of yacc.c */ 01650 #line 1651 "ael.tab.c" 01651 break; 01652 case 65: /* "timespec" */ 01653 01654 /* Line 1000 of yacc.c */ 01655 #line 170 "ael.y" 01656 { 01657 destroy_pval((yyvaluep->pval)); 01658 prev_word=0; 01659 }; 01660 01661 /* Line 1000 of yacc.c */ 01662 #line 1663 "ael.tab.c" 01663 break; 01664 case 66: /* "test_expr" */ 01665 01666 /* Line 1000 of yacc.c */ 01667 #line 183 "ael.y" 01668 { free((yyvaluep->str));}; 01669 01670 /* Line 1000 of yacc.c */ 01671 #line 1672 "ael.tab.c" 01672 break; 01673 case 68: /* "if_like_head" */ 01674 01675 /* Line 1000 of yacc.c */ 01676 #line 170 "ael.y" 01677 { 01678 destroy_pval((yyvaluep->pval)); 01679 prev_word=0; 01680 }; 01681 01682 /* Line 1000 of yacc.c */ 01683 #line 1684 "ael.tab.c" 01684 break; 01685 case 69: /* "word_list" */ 01686 01687 /* Line 1000 of yacc.c */ 01688 #line 183 "ael.y" 01689 { free((yyvaluep->str));}; 01690 01691 /* Line 1000 of yacc.c */ 01692 #line 1693 "ael.tab.c" 01693 break; 01694 case 71: /* "word3_list" */ 01695 01696 /* Line 1000 of yacc.c */ 01697 #line 183 "ael.y" 01698 { free((yyvaluep->str));}; 01699 01700 /* Line 1000 of yacc.c */ 01701 #line 1702 "ael.tab.c" 01702 break; 01703 case 72: /* "goto_word" */ 01704 01705 /* Line 1000 of yacc.c */ 01706 #line 183 "ael.y" 01707 { free((yyvaluep->str));}; 01708 01709 /* Line 1000 of yacc.c */ 01710 #line 1711 "ael.tab.c" 01711 break; 01712 case 73: /* "switch_statement" */ 01713 01714 /* Line 1000 of yacc.c */ 01715 #line 170 "ael.y" 01716 { 01717 destroy_pval((yyvaluep->pval)); 01718 prev_word=0; 01719 }; 01720 01721 /* Line 1000 of yacc.c */ 01722 #line 1723 "ael.tab.c" 01723 break; 01724 case 74: /* "statement" */ 01725 01726 /* Line 1000 of yacc.c */ 01727 #line 170 "ael.y" 01728 { 01729 destroy_pval((yyvaluep->pval)); 01730 prev_word=0; 01731 }; 01732 01733 /* Line 1000 of yacc.c */ 01734 #line 1735 "ael.tab.c" 01735 break; 01736 case 79: /* "opt_else" */ 01737 01738 /* Line 1000 of yacc.c */ 01739 #line 170 "ael.y" 01740 { 01741 destroy_pval((yyvaluep->pval)); 01742 prev_word=0; 01743 }; 01744 01745 /* Line 1000 of yacc.c */ 01746 #line 1747 "ael.tab.c" 01747 break; 01748 case 80: /* "target" */ 01749 01750 /* Line 1000 of yacc.c */ 01751 #line 170 "ael.y" 01752 { 01753 destroy_pval((yyvaluep->pval)); 01754 prev_word=0; 01755 }; 01756 01757 /* Line 1000 of yacc.c */ 01758 #line 1759 "ael.tab.c" 01759 break; 01760 case 81: /* "opt_pri" */ 01761 01762 /* Line 1000 of yacc.c */ 01763 #line 183 "ael.y" 01764 { free((yyvaluep->str));}; 01765 01766 /* Line 1000 of yacc.c */ 01767 #line 1768 "ael.tab.c" 01768 break; 01769 case 82: /* "jumptarget" */ 01770 01771 /* Line 1000 of yacc.c */ 01772 #line 170 "ael.y" 01773 { 01774 destroy_pval((yyvaluep->pval)); 01775 prev_word=0; 01776 }; 01777 01778 /* Line 1000 of yacc.c */ 01779 #line 1780 "ael.tab.c" 01780 break; 01781 case 83: /* "macro_call" */ 01782 01783 /* Line 1000 of yacc.c */ 01784 #line 170 "ael.y" 01785 { 01786 destroy_pval((yyvaluep->pval)); 01787 prev_word=0; 01788 }; 01789 01790 /* Line 1000 of yacc.c */ 01791 #line 1792 "ael.tab.c" 01792 break; 01793 case 85: /* "application_call_head" */ 01794 01795 /* Line 1000 of yacc.c */ 01796 #line 170 "ael.y" 01797 { 01798 destroy_pval((yyvaluep->pval)); 01799 prev_word=0; 01800 }; 01801 01802 /* Line 1000 of yacc.c */ 01803 #line 1804 "ael.tab.c" 01804 break; 01805 case 87: /* "application_call" */ 01806 01807 /* Line 1000 of yacc.c */ 01808 #line 170 "ael.y" 01809 { 01810 destroy_pval((yyvaluep->pval)); 01811 prev_word=0; 01812 }; 01813 01814 /* Line 1000 of yacc.c */ 01815 #line 1816 "ael.tab.c" 01816 break; 01817 case 88: /* "opt_word" */ 01818 01819 /* Line 1000 of yacc.c */ 01820 #line 183 "ael.y" 01821 { free((yyvaluep->str));}; 01822 01823 /* Line 1000 of yacc.c */ 01824 #line 1825 "ael.tab.c" 01825 break; 01826 case 89: /* "eval_arglist" */ 01827 01828 /* Line 1000 of yacc.c */ 01829 #line 170 "ael.y" 01830 { 01831 destroy_pval((yyvaluep->pval)); 01832 prev_word=0; 01833 }; 01834 01835 /* Line 1000 of yacc.c */ 01836 #line 1837 "ael.tab.c" 01837 break; 01838 case 90: /* "case_statements" */ 01839 01840 /* Line 1000 of yacc.c */ 01841 #line 170 "ael.y" 01842 { 01843 destroy_pval((yyvaluep->pval)); 01844 prev_word=0; 01845 }; 01846 01847 /* Line 1000 of yacc.c */ 01848 #line 1849 "ael.tab.c" 01849 break; 01850 case 91: /* "case_statement" */ 01851 01852 /* Line 1000 of yacc.c */ 01853 #line 170 "ael.y" 01854 { 01855 destroy_pval((yyvaluep->pval)); 01856 prev_word=0; 01857 }; 01858 01859 /* Line 1000 of yacc.c */ 01860 #line 1861 "ael.tab.c" 01861 break; 01862 case 92: /* "macro_statements" */ 01863 01864 /* Line 1000 of yacc.c */ 01865 #line 170 "ael.y" 01866 { 01867 destroy_pval((yyvaluep->pval)); 01868 prev_word=0; 01869 }; 01870 01871 /* Line 1000 of yacc.c */ 01872 #line 1873 "ael.tab.c" 01873 break; 01874 case 93: /* "macro_statement" */ 01875 01876 /* Line 1000 of yacc.c */ 01877 #line 170 "ael.y" 01878 { 01879 destroy_pval((yyvaluep->pval)); 01880 prev_word=0; 01881 }; 01882 01883 /* Line 1000 of yacc.c */ 01884 #line 1885 "ael.tab.c" 01885 break; 01886 case 94: /* "switches" */ 01887 01888 /* Line 1000 of yacc.c */ 01889 #line 170 "ael.y" 01890 { 01891 destroy_pval((yyvaluep->pval)); 01892 prev_word=0; 01893 }; 01894 01895 /* Line 1000 of yacc.c */ 01896 #line 1897 "ael.tab.c" 01897 break; 01898 case 95: /* "eswitches" */ 01899 01900 /* Line 1000 of yacc.c */ 01901 #line 170 "ael.y" 01902 { 01903 destroy_pval((yyvaluep->pval)); 01904 prev_word=0; 01905 }; 01906 01907 /* Line 1000 of yacc.c */ 01908 #line 1909 "ael.tab.c" 01909 break; 01910 case 96: /* "switchlist" */ 01911 01912 /* Line 1000 of yacc.c */ 01913 #line 170 "ael.y" 01914 { 01915 destroy_pval((yyvaluep->pval)); 01916 prev_word=0; 01917 }; 01918 01919 /* Line 1000 of yacc.c */ 01920 #line 1921 "ael.tab.c" 01921 break; 01922 case 97: /* "included_entry" */ 01923 01924 /* Line 1000 of yacc.c */ 01925 #line 170 "ael.y" 01926 { 01927 destroy_pval((yyvaluep->pval)); 01928 prev_word=0; 01929 }; 01930 01931 /* Line 1000 of yacc.c */ 01932 #line 1933 "ael.tab.c" 01933 break; 01934 case 98: /* "includeslist" */ 01935 01936 /* Line 1000 of yacc.c */ 01937 #line 170 "ael.y" 01938 { 01939 destroy_pval((yyvaluep->pval)); 01940 prev_word=0; 01941 }; 01942 01943 /* Line 1000 of yacc.c */ 01944 #line 1945 "ael.tab.c" 01945 break; 01946 case 99: /* "includes" */ 01947 01948 /* Line 1000 of yacc.c */ 01949 #line 170 "ael.y" 01950 { 01951 destroy_pval((yyvaluep->pval)); 01952 prev_word=0; 01953 }; 01954 01955 /* Line 1000 of yacc.c */ 01956 #line 1957 "ael.tab.c" 01957 break; 01958 01959 default: 01960 break; 01961 } 01962 }
Definition at line 3896 of file ael.tab.c.
References ael_token_subst(), ast_log(), YYLTYPE::first_column, YYLTYPE::first_line, free, YYLTYPE::last_column, YYLTYPE::last_line, LOG_ERROR, and parse_io::syntax_error_count.
03897 { 03898 char *s2 = ael_token_subst((char *)s); 03899 if (locp->first_line == locp->last_line) { 03900 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); 03901 } else { 03902 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); 03903 } 03904 free(s2); 03905 parseio->syntax_error_count++; 03906 }
int yyparse | ( | struct parse_io * | parseio | ) |
Definition at line 2004 of file ael.tab.c.
References pval::arglist, asprintf, ast_log(), calloc, destroy_pval(), pval::for_init, free, YYSTYPE::intval, linku1(), pval::list, LOG_WARNING, malloc, pval::next, npval(), npval2(), nword(), prev_word, PV_APPLICATION_CALL, PV_BREAK, PV_CASE, PV_CATCH, PV_CONTEXT, PV_CONTINUE, PV_DEFAULT, PV_ESWITCHES, PV_EXTENSION, PV_FOR, PV_GLOBALS, PV_GOTO, PV_IF, PV_IFTIME, PV_IGNOREPAT, PV_INCLUDES, PV_LABEL, PV_LOCALVARDEC, PV_MACRO, PV_MACRO_CALL, PV_PATTERN, PV_RANDOM, PV_RETURN, PV_STATEMENTBLOCK, PV_SWITCH, PV_SWITCHES, PV_VARDEC, PV_WHILE, PV_WORD, YYSTYPE::pval, reset_argcount(), reset_parencount(), reset_semicount(), set_dads(), pval::statements, pval::str, str, YYSTYPE::str, strdup, pval::u1, pval::u2, update_last(), pval::val, YY_, YY_REDUCE_PRINT, YY_STACK_PRINT, YY_SYMBOL_PRINT, YYABORT, YYACCEPT, yychar, yydestruct(), YYDPRINTF, YYEMPTY, YYEOF, yyerror, YYFINAL, YYID, YYINITDEPTH, YYLAST, YYLEX, yylloc, YYLLOC_DEFAULT, yyalloc::yyls_alloc, yylval, YYMAXDEPTH, yynerrs, YYNTOKENS, YYPACT_NINF, YYPOPSTACK, YYSIZE_T, yyalloc::yyss_alloc, YYSTACK_ALLOC, YYSTACK_ALLOC_MAXIMUM, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, yysyntax_error(), YYTABLE_NINF, YYTERROR, YYTRANSLATE, and yyalloc::yyvs_alloc.
02008 { 02009 /* The lookahead symbol. */ 02010 int yychar; 02011 02012 /* The semantic value of the lookahead symbol. */ 02013 YYSTYPE yylval; 02014 02015 /* Location data for the lookahead symbol. */ 02016 YYLTYPE yylloc; 02017 02018 /* Number of syntax errors so far. */ 02019 int yynerrs; 02020 02021 int yystate; 02022 /* Number of tokens to shift before error messages enabled. */ 02023 int yyerrstatus; 02024 02025 /* The stacks and their tools: 02026 `yyss': related to states. 02027 `yyvs': related to semantic values. 02028 `yyls': related to locations. 02029 02030 Refer to the stacks thru separate pointers, to allow yyoverflow 02031 to reallocate them elsewhere. */ 02032 02033 /* The state stack. */ 02034 yytype_int16 yyssa[YYINITDEPTH]; 02035 yytype_int16 *yyss; 02036 yytype_int16 *yyssp; 02037 02038 /* The semantic value stack. */ 02039 YYSTYPE yyvsa[YYINITDEPTH]; 02040 YYSTYPE *yyvs; 02041 YYSTYPE *yyvsp; 02042 02043 /* The location stack. */ 02044 YYLTYPE yylsa[YYINITDEPTH]; 02045 YYLTYPE *yyls; 02046 YYLTYPE *yylsp; 02047 02048 /* The locations where the error started and ended. */ 02049 YYLTYPE yyerror_range[2]; 02050 02051 YYSIZE_T yystacksize; 02052 02053 int yyn; 02054 int yyresult; 02055 /* Lookahead token as an internal (translated) token number. */ 02056 int yytoken; 02057 /* The variables used to return semantic value and location from the 02058 action routines. */ 02059 YYSTYPE yyval; 02060 YYLTYPE yyloc; 02061 02062 #if YYERROR_VERBOSE 02063 /* Buffer for error messages, and its allocated size. */ 02064 char yymsgbuf[128]; 02065 char *yymsg = yymsgbuf; 02066 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 02067 #endif 02068 02069 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 02070 02071 /* The number of symbols on the RHS of the reduced rule. 02072 Keep to zero when no symbol should be popped. */ 02073 int yylen = 0; 02074 02075 yytoken = 0; 02076 yyss = yyssa; 02077 yyvs = yyvsa; 02078 yyls = yylsa; 02079 yystacksize = YYINITDEPTH; 02080 02081 YYDPRINTF ((stderr, "Starting parse\n")); 02082 02083 yystate = 0; 02084 yyerrstatus = 0; 02085 yynerrs = 0; 02086 yychar = YYEMPTY; /* Cause a token to be read. */ 02087 02088 /* Initialize stack pointers. 02089 Waste one element of value and location stack 02090 so that they stay on the same level as the state stack. 02091 The wasted elements are never initialized. */ 02092 yyssp = yyss; 02093 yyvsp = yyvs; 02094 yylsp = yyls; 02095 02096 #if YYLTYPE_IS_TRIVIAL 02097 /* Initialize the default location before parsing starts. */ 02098 yylloc.first_line = yylloc.last_line = 1; 02099 yylloc.first_column = yylloc.last_column = 1; 02100 #endif 02101 02102 goto yysetstate; 02103 02104 /*------------------------------------------------------------. 02105 | yynewstate -- Push a new state, which is found in yystate. | 02106 `------------------------------------------------------------*/ 02107 yynewstate: 02108 /* In all cases, when you get here, the value and location stacks 02109 have just been pushed. So pushing a state here evens the stacks. */ 02110 yyssp++; 02111 02112 yysetstate: 02113 *yyssp = yystate; 02114 02115 if (yyss + yystacksize - 1 <= yyssp) 02116 { 02117 /* Get the current used size of the three stacks, in elements. */ 02118 YYSIZE_T yysize = yyssp - yyss + 1; 02119 02120 #ifdef yyoverflow 02121 { 02122 /* Give user a chance to reallocate the stack. Use copies of 02123 these so that the &'s don't force the real ones into 02124 memory. */ 02125 YYSTYPE *yyvs1 = yyvs; 02126 yytype_int16 *yyss1 = yyss; 02127 YYLTYPE *yyls1 = yyls; 02128 02129 /* Each stack pointer address is followed by the size of the 02130 data in use in that stack, in bytes. This used to be a 02131 conditional around just the two extra args, but that might 02132 be undefined if yyoverflow is a macro. */ 02133 yyoverflow (YY_("memory exhausted"), 02134 &yyss1, yysize * sizeof (*yyssp), 02135 &yyvs1, yysize * sizeof (*yyvsp), 02136 &yyls1, yysize * sizeof (*yylsp), 02137 &yystacksize); 02138 02139 yyls = yyls1; 02140 yyss = yyss1; 02141 yyvs = yyvs1; 02142 } 02143 #else /* no yyoverflow */ 02144 # ifndef YYSTACK_RELOCATE 02145 goto yyexhaustedlab; 02146 # else 02147 /* Extend the stack our own way. */ 02148 if (YYMAXDEPTH <= yystacksize) 02149 goto yyexhaustedlab; 02150 yystacksize *= 2; 02151 if (YYMAXDEPTH < yystacksize) 02152 yystacksize = YYMAXDEPTH; 02153 02154 { 02155 yytype_int16 *yyss1 = yyss; 02156 union yyalloc *yyptr = 02157 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 02158 if (! yyptr) 02159 goto yyexhaustedlab; 02160 YYSTACK_RELOCATE (yyss_alloc, yyss); 02161 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 02162 YYSTACK_RELOCATE (yyls_alloc, yyls); 02163 # undef YYSTACK_RELOCATE 02164 if (yyss1 != yyssa) 02165 YYSTACK_FREE (yyss1); 02166 } 02167 # endif 02168 #endif /* no yyoverflow */ 02169 02170 yyssp = yyss + yysize - 1; 02171 yyvsp = yyvs + yysize - 1; 02172 yylsp = yyls + yysize - 1; 02173 02174 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 02175 (unsigned long int) yystacksize)); 02176 02177 if (yyss + yystacksize - 1 <= yyssp) 02178 YYABORT; 02179 } 02180 02181 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 02182 02183 if (yystate == YYFINAL) 02184 YYACCEPT; 02185 02186 goto yybackup; 02187 02188 /*-----------. 02189 | yybackup. | 02190 `-----------*/ 02191 yybackup: 02192 02193 /* Do appropriate processing given the current state. Read a 02194 lookahead token if we need one and don't already have one. */ 02195 02196 /* First try to decide what to do without reference to lookahead token. */ 02197 yyn = yypact[yystate]; 02198 if (yyn == YYPACT_NINF) 02199 goto yydefault; 02200 02201 /* Not known => get a lookahead token if don't already have one. */ 02202 02203 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 02204 if (yychar == YYEMPTY) 02205 { 02206 YYDPRINTF ((stderr, "Reading a token: ")); 02207 yychar = YYLEX; 02208 } 02209 02210 if (yychar <= YYEOF) 02211 { 02212 yychar = yytoken = YYEOF; 02213 YYDPRINTF ((stderr, "Now at end of input.\n")); 02214 } 02215 else 02216 { 02217 yytoken = YYTRANSLATE (yychar); 02218 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 02219 } 02220 02221 /* If the proper action on seeing token YYTOKEN is to reduce or to 02222 detect an error, take that action. */ 02223 yyn += yytoken; 02224 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 02225 goto yydefault; 02226 yyn = yytable[yyn]; 02227 if (yyn <= 0) 02228 { 02229 if (yyn == 0 || yyn == YYTABLE_NINF) 02230 goto yyerrlab; 02231 yyn = -yyn; 02232 goto yyreduce; 02233 } 02234 02235 /* Count tokens shifted since error; after three, turn off error 02236 status. */ 02237 if (yyerrstatus) 02238 yyerrstatus--; 02239 02240 /* Shift the lookahead token. */ 02241 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 02242 02243 /* Discard the shifted token. */ 02244 yychar = YYEMPTY; 02245 02246 yystate = yyn; 02247 *++yyvsp = yylval; 02248 *++yylsp = yylloc; 02249 goto yynewstate; 02250 02251 02252 /*-----------------------------------------------------------. 02253 | yydefault -- do the default action for the current state. | 02254 `-----------------------------------------------------------*/ 02255 yydefault: 02256 yyn = yydefact[yystate]; 02257 if (yyn == 0) 02258 goto yyerrlab; 02259 goto yyreduce; 02260 02261 02262 /*-----------------------------. 02263 | yyreduce -- Do a reduction. | 02264 `-----------------------------*/ 02265 yyreduce: 02266 /* yyn is the number of a rule to reduce with. */ 02267 yylen = yyr2[yyn]; 02268 02269 /* If YYLEN is nonzero, implement the default value of the action: 02270 `$$ = $1'. 02271 02272 Otherwise, the following line sets YYVAL to garbage. 02273 This behavior is undocumented and Bison 02274 users should not rely upon it. Assigning to YYVAL 02275 unconditionally makes the parser a bit smaller, and it avoids a 02276 GCC warning that YYVAL may be used uninitialized. */ 02277 yyval = yyvsp[1-yylen]; 02278 02279 /* Default location. */ 02280 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); 02281 YY_REDUCE_PRINT (yyn); 02282 switch (yyn) 02283 { 02284 case 2: 02285 02286 /* Line 1455 of yacc.c */ 02287 #line 191 "ael.y" 02288 { (yyval.pval) = parseio->pval = (yyvsp[(1) - (1)].pval); ;} 02289 break; 02290 02291 case 3: 02292 02293 /* Line 1455 of yacc.c */ 02294 #line 194 "ael.y" 02295 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02296 break; 02297 02298 case 4: 02299 02300 /* Line 1455 of yacc.c */ 02301 #line 195 "ael.y" 02302 { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;} 02303 break; 02304 02305 case 5: 02306 02307 /* Line 1455 of yacc.c */ 02308 #line 196 "ael.y" 02309 {(yyval.pval)=(yyvsp[(1) - (2)].pval);;} 02310 break; 02311 02312 case 6: 02313 02314 /* Line 1455 of yacc.c */ 02315 #line 199 "ael.y" 02316 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02317 break; 02318 02319 case 7: 02320 02321 /* Line 1455 of yacc.c */ 02322 #line 200 "ael.y" 02323 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02324 break; 02325 02326 case 8: 02327 02328 /* Line 1455 of yacc.c */ 02329 #line 201 "ael.y" 02330 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02331 break; 02332 02333 case 9: 02334 02335 /* Line 1455 of yacc.c */ 02336 #line 202 "ael.y" 02337 {(yyval.pval)=0;/* allow older docs to be read */;} 02338 break; 02339 02340 case 10: 02341 02342 /* Line 1455 of yacc.c */ 02343 #line 205 "ael.y" 02344 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 02345 break; 02346 02347 case 11: 02348 02349 /* Line 1455 of yacc.c */ 02350 #line 206 "ael.y" 02351 { (yyval.str) = strdup("default"); ;} 02352 break; 02353 02354 case 12: 02355 02356 /* Line 1455 of yacc.c */ 02357 #line 209 "ael.y" 02358 { 02359 (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)])); 02360 (yyval.pval)->u1.str = (yyvsp[(3) - (6)].str); 02361 (yyval.pval)->u2.statements = (yyvsp[(5) - (6)].pval); 02362 set_dads((yyval.pval),(yyvsp[(5) - (6)].pval)); 02363 (yyval.pval)->u3.abstract = (yyvsp[(1) - (6)].intval);;} 02364 break; 02365 02366 case 13: 02367 02368 /* Line 1455 of yacc.c */ 02369 #line 218 "ael.y" 02370 { (yyval.intval) = 1; ;} 02371 break; 02372 02373 case 14: 02374 02375 /* Line 1455 of yacc.c */ 02376 #line 219 "ael.y" 02377 { (yyval.intval) = 0; ;} 02378 break; 02379 02380 case 15: 02381 02382 /* Line 1455 of yacc.c */ 02383 #line 220 "ael.y" 02384 { (yyval.intval) = 2; ;} 02385 break; 02386 02387 case 16: 02388 02389 /* Line 1455 of yacc.c */ 02390 #line 221 "ael.y" 02391 { (yyval.intval)=3; ;} 02392 break; 02393 02394 case 17: 02395 02396 /* Line 1455 of yacc.c */ 02397 #line 222 "ael.y" 02398 { (yyval.intval)=3; ;} 02399 break; 02400 02401 case 18: 02402 02403 /* Line 1455 of yacc.c */ 02404 #line 225 "ael.y" 02405 { 02406 (yyval.pval) = npval2(PV_MACRO, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)])); 02407 (yyval.pval)->u1.str = (yyvsp[(2) - (8)].str); (yyval.pval)->u2.arglist = (yyvsp[(4) - (8)].pval); (yyval.pval)->u3.macro_statements = (yyvsp[(7) - (8)].pval); 02408 set_dads((yyval.pval),(yyvsp[(7) - (8)].pval));;} 02409 break; 02410 02411 case 19: 02412 02413 /* Line 1455 of yacc.c */ 02414 #line 231 "ael.y" 02415 { 02416 (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); 02417 (yyval.pval)->u1.statements = (yyvsp[(3) - (4)].pval); 02418 set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;} 02419 break; 02420 02421 case 20: 02422 02423 /* Line 1455 of yacc.c */ 02424 #line 237 "ael.y" 02425 { (yyval.pval) = NULL; ;} 02426 break; 02427 02428 case 21: 02429 02430 /* Line 1455 of yacc.c */ 02431 #line 238 "ael.y" 02432 {(yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;} 02433 break; 02434 02435 case 22: 02436 02437 /* Line 1455 of yacc.c */ 02438 #line 239 "ael.y" 02439 {(yyval.pval)=(yyvsp[(2) - (2)].pval);;} 02440 break; 02441 02442 case 23: 02443 02444 /* Line 1455 of yacc.c */ 02445 #line 242 "ael.y" 02446 { reset_semicount(parseio->scanner); ;} 02447 break; 02448 02449 case 24: 02450 02451 /* Line 1455 of yacc.c */ 02452 #line 242 "ael.y" 02453 { 02454 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)])); 02455 (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str); 02456 (yyval.pval)->u2.val = (yyvsp[(4) - (5)].str); ;} 02457 break; 02458 02459 case 25: 02460 02461 /* Line 1455 of yacc.c */ 02462 #line 248 "ael.y" 02463 { reset_semicount(parseio->scanner); ;} 02464 break; 02465 02466 case 26: 02467 02468 /* Line 1455 of yacc.c */ 02469 #line 248 "ael.y" 02470 { 02471 (yyval.pval) = npval2(PV_LOCALVARDEC, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)])); 02472 (yyval.pval)->u1.str = (yyvsp[(2) - (6)].str); 02473 (yyval.pval)->u2.val = (yyvsp[(5) - (6)].str); ;} 02474 break; 02475 02476 case 27: 02477 02478 /* Line 1455 of yacc.c */ 02479 #line 255 "ael.y" 02480 { (yyval.pval) = NULL; ;} 02481 break; 02482 02483 case 28: 02484 02485 /* Line 1455 of yacc.c */ 02486 #line 256 "ael.y" 02487 { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;} 02488 break; 02489 02490 case 29: 02491 02492 /* Line 1455 of yacc.c */ 02493 #line 257 "ael.y" 02494 { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); ;} 02495 break; 02496 02497 case 30: 02498 02499 /* Line 1455 of yacc.c */ 02500 #line 258 "ael.y" 02501 {(yyval.pval)=(yyvsp[(1) - (2)].pval);;} 02502 break; 02503 02504 case 31: 02505 02506 /* Line 1455 of yacc.c */ 02507 #line 261 "ael.y" 02508 {(yyval.pval)=0;;} 02509 break; 02510 02511 case 32: 02512 02513 /* Line 1455 of yacc.c */ 02514 #line 262 "ael.y" 02515 { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;} 02516 break; 02517 02518 case 33: 02519 02520 /* Line 1455 of yacc.c */ 02521 #line 263 "ael.y" 02522 { (yyval.pval)=(yyvsp[(2) - (2)].pval);;} 02523 break; 02524 02525 case 34: 02526 02527 /* Line 1455 of yacc.c */ 02528 #line 266 "ael.y" 02529 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02530 break; 02531 02532 case 35: 02533 02534 /* Line 1455 of yacc.c */ 02535 #line 267 "ael.y" 02536 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02537 break; 02538 02539 case 36: 02540 02541 /* Line 1455 of yacc.c */ 02542 #line 268 "ael.y" 02543 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02544 break; 02545 02546 case 37: 02547 02548 /* Line 1455 of yacc.c */ 02549 #line 269 "ael.y" 02550 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02551 break; 02552 02553 case 38: 02554 02555 /* Line 1455 of yacc.c */ 02556 #line 270 "ael.y" 02557 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02558 break; 02559 02560 case 39: 02561 02562 /* Line 1455 of yacc.c */ 02563 #line 271 "ael.y" 02564 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02565 break; 02566 02567 case 40: 02568 02569 /* Line 1455 of yacc.c */ 02570 #line 272 "ael.y" 02571 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 02572 break; 02573 02574 case 41: 02575 02576 /* Line 1455 of yacc.c */ 02577 #line 273 "ael.y" 02578 {free((yyvsp[(1) - (2)].str)); (yyval.pval)=0;;} 02579 break; 02580 02581 case 42: 02582 02583 /* Line 1455 of yacc.c */ 02584 #line 274 "ael.y" 02585 {(yyval.pval)=0;/* allow older docs to be read */;} 02586 break; 02587 02588 case 43: 02589 02590 /* Line 1455 of yacc.c */ 02591 #line 277 "ael.y" 02592 { 02593 (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); 02594 (yyval.pval)->u1.str = (yyvsp[(3) - (4)].str);;} 02595 break; 02596 02597 case 44: 02598 02599 /* Line 1455 of yacc.c */ 02600 #line 282 "ael.y" 02601 { 02602 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 02603 (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); 02604 (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;} 02605 break; 02606 02607 case 45: 02608 02609 /* Line 1455 of yacc.c */ 02610 #line 286 "ael.y" 02611 { 02612 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (5)]), &(yylsp[(3) - (5)])); 02613 (yyval.pval)->u1.str = malloc(strlen((yyvsp[(1) - (5)].str))+strlen((yyvsp[(3) - (5)].str))+2); 02614 strcpy((yyval.pval)->u1.str,(yyvsp[(1) - (5)].str)); 02615 strcat((yyval.pval)->u1.str,"@"); 02616 strcat((yyval.pval)->u1.str,(yyvsp[(3) - (5)].str)); 02617 free((yyvsp[(1) - (5)].str)); 02618 (yyval.pval)->u2.statements = (yyvsp[(5) - (5)].pval); set_dads((yyval.pval),(yyvsp[(5) - (5)].pval));;} 02619 break; 02620 02621 case 46: 02622 02623 /* Line 1455 of yacc.c */ 02624 #line 294 "ael.y" 02625 { 02626 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); 02627 (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str); 02628 (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval)); 02629 (yyval.pval)->u4.regexten=1;;} 02630 break; 02631 02632 case 47: 02633 02634 /* Line 1455 of yacc.c */ 02635 #line 299 "ael.y" 02636 { 02637 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (7)]), &(yylsp[(7) - (7)])); 02638 (yyval.pval)->u1.str = (yyvsp[(5) - (7)].str); 02639 (yyval.pval)->u2.statements = (yyvsp[(7) - (7)].pval); set_dads((yyval.pval),(yyvsp[(7) - (7)].pval)); 02640 (yyval.pval)->u3.hints = (yyvsp[(3) - (7)].str);;} 02641 break; 02642 02643 case 48: 02644 02645 /* Line 1455 of yacc.c */ 02646 #line 304 "ael.y" 02647 { 02648 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)])); 02649 (yyval.pval)->u1.str = (yyvsp[(6) - (8)].str); 02650 (yyval.pval)->u2.statements = (yyvsp[(8) - (8)].pval); set_dads((yyval.pval),(yyvsp[(8) - (8)].pval)); 02651 (yyval.pval)->u4.regexten=1; 02652 (yyval.pval)->u3.hints = (yyvsp[(4) - (8)].str);;} 02653 break; 02654 02655 case 49: 02656 02657 /* Line 1455 of yacc.c */ 02658 #line 313 "ael.y" 02659 { (yyval.pval) = NULL; ;} 02660 break; 02661 02662 case 50: 02663 02664 /* Line 1455 of yacc.c */ 02665 #line 314 "ael.y" 02666 { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;} 02667 break; 02668 02669 case 51: 02670 02671 /* Line 1455 of yacc.c */ 02672 #line 315 "ael.y" 02673 {(yyval.pval)=(yyvsp[(2) - (2)].pval);;} 02674 break; 02675 02676 case 52: 02677 02678 /* Line 1455 of yacc.c */ 02679 #line 321 "ael.y" 02680 { 02681 if (asprintf(&(yyval.str), "%s:%s:%s", (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)) < 0) { 02682 ast_log(LOG_WARNING, "asprintf() failed\n"); 02683 (yyval.str) = NULL; 02684 } else { 02685 free((yyvsp[(1) - (5)].str)); 02686 free((yyvsp[(3) - (5)].str)); 02687 free((yyvsp[(5) - (5)].str)); 02688 } 02689 ;} 02690 break; 02691 02692 case 53: 02693 02694 /* Line 1455 of yacc.c */ 02695 #line 331 "ael.y" 02696 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 02697 break; 02698 02699 case 54: 02700 02701 /* Line 1455 of yacc.c */ 02702 #line 335 "ael.y" 02703 { 02704 (yyval.pval) = nword((yyvsp[(1) - (7)].str), &(yylsp[(1) - (7)])); 02705 (yyval.pval)->next = nword((yyvsp[(3) - (7)].str), &(yylsp[(3) - (7)])); 02706 (yyval.pval)->next->next = nword((yyvsp[(5) - (7)].str), &(yylsp[(5) - (7)])); 02707 (yyval.pval)->next->next->next = nword((yyvsp[(7) - (7)].str), &(yylsp[(7) - (7)])); ;} 02708 break; 02709 02710 case 55: 02711 02712 /* Line 1455 of yacc.c */ 02713 #line 343 "ael.y" 02714 { reset_parencount(parseio->scanner); ;} 02715 break; 02716 02717 case 56: 02718 02719 /* Line 1455 of yacc.c */ 02720 #line 343 "ael.y" 02721 { (yyval.str) = (yyvsp[(3) - (4)].str); ;} 02722 break; 02723 02724 case 57: 02725 02726 /* Line 1455 of yacc.c */ 02727 #line 347 "ael.y" 02728 { 02729 (yyval.pval)= npval2(PV_IF, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); 02730 (yyval.pval)->u1.str = (yyvsp[(2) - (2)].str); ;} 02731 break; 02732 02733 case 58: 02734 02735 /* Line 1455 of yacc.c */ 02736 #line 350 "ael.y" 02737 { 02738 (yyval.pval) = npval2(PV_RANDOM, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); 02739 (yyval.pval)->u1.str=(yyvsp[(2) - (2)].str);;} 02740 break; 02741 02742 case 59: 02743 02744 /* Line 1455 of yacc.c */ 02745 #line 353 "ael.y" 02746 { 02747 (yyval.pval) = npval2(PV_IFTIME, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); 02748 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); 02749 prev_word = 0; ;} 02750 break; 02751 02752 case 60: 02753 02754 /* Line 1455 of yacc.c */ 02755 #line 364 "ael.y" 02756 { (yyval.str) = (yyvsp[(1) - (1)].str);;} 02757 break; 02758 02759 case 61: 02760 02761 /* Line 1455 of yacc.c */ 02762 #line 365 "ael.y" 02763 { 02764 if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) { 02765 ast_log(LOG_WARNING, "asprintf() failed\n"); 02766 (yyval.str) = NULL; 02767 } else { 02768 free((yyvsp[(1) - (2)].str)); 02769 free((yyvsp[(2) - (2)].str)); 02770 prev_word = (yyval.str); 02771 } 02772 ;} 02773 break; 02774 02775 case 62: 02776 02777 /* Line 1455 of yacc.c */ 02778 #line 377 "ael.y" 02779 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 02780 break; 02781 02782 case 63: 02783 02784 /* Line 1455 of yacc.c */ 02785 #line 378 "ael.y" 02786 { 02787 if (asprintf(&((yyval.str)), "%s %s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) { 02788 ast_log(LOG_WARNING, "asprintf() failed\n"); 02789 (yyval.str) = NULL; 02790 } else { 02791 free((yyvsp[(1) - (2)].str)); 02792 free((yyvsp[(2) - (2)].str)); 02793 } 02794 ;} 02795 break; 02796 02797 case 64: 02798 02799 /* Line 1455 of yacc.c */ 02800 #line 387 "ael.y" 02801 { 02802 if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) { 02803 ast_log(LOG_WARNING, "asprintf() failed\n"); 02804 (yyval.str) = NULL; 02805 } else { 02806 free((yyvsp[(1) - (3)].str)); 02807 free((yyvsp[(3) - (3)].str)); 02808 } 02809 ;} 02810 break; 02811 02812 case 65: 02813 02814 /* Line 1455 of yacc.c */ 02815 #line 396 "ael.y" 02816 { /* there are often '&' in hints */ 02817 if (asprintf(&((yyval.str)), "%s&%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) { 02818 ast_log(LOG_WARNING, "asprintf() failed\n"); 02819 (yyval.str) = NULL; 02820 } else { 02821 free((yyvsp[(1) - (3)].str)); 02822 free((yyvsp[(3) - (3)].str)); 02823 } 02824 ;} 02825 break; 02826 02827 case 66: 02828 02829 /* Line 1455 of yacc.c */ 02830 #line 405 "ael.y" 02831 { 02832 if (asprintf(&((yyval.str)), "%s@%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) { 02833 ast_log(LOG_WARNING, "asprintf() failed\n"); 02834 (yyval.str) = NULL; 02835 } else { 02836 free((yyvsp[(1) - (3)].str)); 02837 free((yyvsp[(3) - (3)].str)); 02838 } 02839 ;} 02840 break; 02841 02842 case 67: 02843 02844 /* Line 1455 of yacc.c */ 02845 #line 416 "ael.y" 02846 { (yyval.str) = (yyvsp[(1) - (1)].str);;} 02847 break; 02848 02849 case 68: 02850 02851 /* Line 1455 of yacc.c */ 02852 #line 417 "ael.y" 02853 { 02854 if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) { 02855 ast_log(LOG_WARNING, "asprintf() failed\n"); 02856 (yyval.str) = NULL; 02857 } else { 02858 free((yyvsp[(1) - (2)].str)); 02859 free((yyvsp[(2) - (2)].str)); 02860 prev_word = (yyval.str); 02861 } 02862 ;} 02863 break; 02864 02865 case 69: 02866 02867 /* Line 1455 of yacc.c */ 02868 #line 427 "ael.y" 02869 { 02870 if (asprintf(&((yyval.str)), "%s%s%s", (yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) { 02871 ast_log(LOG_WARNING, "asprintf() failed\n"); 02872 (yyval.str) = NULL; 02873 } else { 02874 free((yyvsp[(1) - (3)].str)); 02875 free((yyvsp[(2) - (3)].str)); 02876 free((yyvsp[(3) - (3)].str)); 02877 prev_word=(yyval.str); 02878 } 02879 ;} 02880 break; 02881 02882 case 70: 02883 02884 /* Line 1455 of yacc.c */ 02885 #line 440 "ael.y" 02886 { (yyval.str) = (yyvsp[(1) - (1)].str);;} 02887 break; 02888 02889 case 71: 02890 02891 /* Line 1455 of yacc.c */ 02892 #line 441 "ael.y" 02893 { 02894 if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) { 02895 ast_log(LOG_WARNING, "asprintf() failed\n"); 02896 (yyval.str) = NULL; 02897 } else { 02898 free((yyvsp[(1) - (2)].str)); 02899 free((yyvsp[(2) - (2)].str)); 02900 } 02901 ;} 02902 break; 02903 02904 case 72: 02905 02906 /* Line 1455 of yacc.c */ 02907 #line 450 "ael.y" 02908 { 02909 if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) { 02910 ast_log(LOG_WARNING, "asprintf() failed\n"); 02911 (yyval.str) = NULL; 02912 } else { 02913 free((yyvsp[(1) - (3)].str)); 02914 free((yyvsp[(3) - (3)].str)); 02915 } 02916 ;} 02917 break; 02918 02919 case 73: 02920 02921 /* Line 1455 of yacc.c */ 02922 #line 461 "ael.y" 02923 { 02924 (yyval.pval) = npval2(PV_SWITCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)])); 02925 (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str); 02926 (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));;} 02927 break; 02928 02929 case 74: 02930 02931 /* Line 1455 of yacc.c */ 02932 #line 470 "ael.y" 02933 { 02934 (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 02935 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));;} 02936 break; 02937 02938 case 75: 02939 02940 /* Line 1455 of yacc.c */ 02941 #line 473 "ael.y" 02942 { (yyval.pval) = (yyvsp[(1) - (1)].pval); ;} 02943 break; 02944 02945 case 76: 02946 02947 /* Line 1455 of yacc.c */ 02948 #line 474 "ael.y" 02949 { (yyval.pval) = (yyvsp[(1) - (1)].pval); ;} 02950 break; 02951 02952 case 77: 02953 02954 /* Line 1455 of yacc.c */ 02955 #line 475 "ael.y" 02956 { 02957 (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 02958 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);;} 02959 break; 02960 02961 case 78: 02962 02963 /* Line 1455 of yacc.c */ 02964 #line 478 "ael.y" 02965 { 02966 (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 02967 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);;} 02968 break; 02969 02970 case 79: 02971 02972 /* Line 1455 of yacc.c */ 02973 #line 481 "ael.y" 02974 { 02975 (yyval.pval) = npval2(PV_LABEL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); 02976 (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str); ;} 02977 break; 02978 02979 case 80: 02980 02981 /* Line 1455 of yacc.c */ 02982 #line 484 "ael.y" 02983 {reset_semicount(parseio->scanner);;} 02984 break; 02985 02986 case 81: 02987 02988 /* Line 1455 of yacc.c */ 02989 #line 485 "ael.y" 02990 {reset_semicount(parseio->scanner);;} 02991 break; 02992 02993 case 82: 02994 02995 /* Line 1455 of yacc.c */ 02996 #line 486 "ael.y" 02997 {reset_parencount(parseio->scanner);;} 02998 break; 02999 03000 case 83: 03001 03002 /* Line 1455 of yacc.c */ 03003 #line 486 "ael.y" 03004 { /* XXX word_list maybe ? */ 03005 (yyval.pval) = npval2(PV_FOR, &(yylsp[(1) - (12)]), &(yylsp[(12) - (12)])); 03006 (yyval.pval)->u1.for_init = (yyvsp[(4) - (12)].str); 03007 (yyval.pval)->u2.for_test=(yyvsp[(7) - (12)].str); 03008 (yyval.pval)->u3.for_inc = (yyvsp[(10) - (12)].str); 03009 (yyval.pval)->u4.for_statements = (yyvsp[(12) - (12)].pval); set_dads((yyval.pval),(yyvsp[(12) - (12)].pval));;} 03010 break; 03011 03012 case 84: 03013 03014 /* Line 1455 of yacc.c */ 03015 #line 492 "ael.y" 03016 { 03017 (yyval.pval) = npval2(PV_WHILE, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 03018 (yyval.pval)->u1.str = (yyvsp[(2) - (3)].str); 03019 (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;} 03020 break; 03021 03022 case 85: 03023 03024 /* Line 1455 of yacc.c */ 03025 #line 496 "ael.y" 03026 { (yyval.pval) = (yyvsp[(1) - (1)].pval); ;} 03027 break; 03028 03029 case 86: 03030 03031 /* Line 1455 of yacc.c */ 03032 #line 497 "ael.y" 03033 { (yyval.pval) = update_last((yyvsp[(2) - (3)].pval), &(yylsp[(2) - (3)])); ;} 03034 break; 03035 03036 case 87: 03037 03038 /* Line 1455 of yacc.c */ 03039 #line 498 "ael.y" 03040 { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); ;} 03041 break; 03042 03043 case 88: 03044 03045 /* Line 1455 of yacc.c */ 03046 #line 499 "ael.y" 03047 { 03048 (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); 03049 (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str);;} 03050 break; 03051 03052 case 89: 03053 03054 /* Line 1455 of yacc.c */ 03055 #line 502 "ael.y" 03056 {reset_semicount(parseio->scanner);;} 03057 break; 03058 03059 case 90: 03060 03061 /* Line 1455 of yacc.c */ 03062 #line 502 "ael.y" 03063 { 03064 char *bufx; 03065 int tot=0; 03066 pval *pptr; 03067 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)])); 03068 (yyval.pval)->u2.val=(yyvsp[(4) - (5)].str); 03069 /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */ 03070 /* string to big to fit in the buffer? */ 03071 tot+=strlen((yyvsp[(1) - (5)].pval)->u1.str); 03072 for(pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) { 03073 tot+=strlen(pptr->u1.str); 03074 tot++; /* for a sep like a comma */ 03075 } 03076 tot+=4; /* for safety */ 03077 bufx = calloc(1, tot); 03078 strcpy(bufx,(yyvsp[(1) - (5)].pval)->u1.str); 03079 strcat(bufx,"("); 03080 /* XXX need to advance the pointer or the loop is very inefficient */ 03081 for (pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) { 03082 if ( pptr != (yyvsp[(1) - (5)].pval)->u2.arglist ) 03083 strcat(bufx,","); 03084 strcat(bufx,pptr->u1.str); 03085 } 03086 strcat(bufx,")"); 03087 #ifdef AAL_ARGCHECK 03088 if ( !ael_is_funcname((yyvsp[(1) - (5)].pval)->u1.str) ) 03089 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", 03090 my_file, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column, (yylsp[(1) - (5)]).last_column, (yyvsp[(1) - (5)].pval)->u1.str); 03091 #endif 03092 (yyval.pval)->u1.str = bufx; 03093 destroy_pval((yyvsp[(1) - (5)].pval)); /* the app call it is not, get rid of that chain */ 03094 prev_word = 0; 03095 ;} 03096 break; 03097 03098 case 91: 03099 03100 /* Line 1455 of yacc.c */ 03101 #line 535 "ael.y" 03102 { (yyval.pval) = npval2(PV_BREAK, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); ;} 03103 break; 03104 03105 case 92: 03106 03107 /* Line 1455 of yacc.c */ 03108 #line 536 "ael.y" 03109 { (yyval.pval) = npval2(PV_RETURN, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); ;} 03110 break; 03111 03112 case 93: 03113 03114 /* Line 1455 of yacc.c */ 03115 #line 537 "ael.y" 03116 { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); ;} 03117 break; 03118 03119 case 94: 03120 03121 /* Line 1455 of yacc.c */ 03122 #line 538 "ael.y" 03123 { 03124 (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(2) - (3)])); 03125 (yyval.pval)->u2.statements = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval)); 03126 (yyval.pval)->u3.else_statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;} 03127 break; 03128 03129 case 95: 03130 03131 /* Line 1455 of yacc.c */ 03132 #line 542 "ael.y" 03133 { (yyval.pval)=0; ;} 03134 break; 03135 03136 case 96: 03137 03138 /* Line 1455 of yacc.c */ 03139 #line 545 "ael.y" 03140 { (yyval.pval) = (yyvsp[(2) - (2)].pval); ;} 03141 break; 03142 03143 case 97: 03144 03145 /* Line 1455 of yacc.c */ 03146 #line 546 "ael.y" 03147 { (yyval.pval) = NULL ; ;} 03148 break; 03149 03150 case 98: 03151 03152 /* Line 1455 of yacc.c */ 03153 #line 549 "ael.y" 03154 { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;} 03155 break; 03156 03157 case 99: 03158 03159 /* Line 1455 of yacc.c */ 03160 #line 550 "ael.y" 03161 { 03162 (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)])); 03163 (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); ;} 03164 break; 03165 03166 case 100: 03167 03168 /* Line 1455 of yacc.c */ 03169 #line 553 "ael.y" 03170 { 03171 (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)])); 03172 (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); ;} 03173 break; 03174 03175 case 101: 03176 03177 /* Line 1455 of yacc.c */ 03178 #line 556 "ael.y" 03179 { 03180 (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)])); 03181 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)])); 03182 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;} 03183 break; 03184 03185 case 102: 03186 03187 /* Line 1455 of yacc.c */ 03188 #line 560 "ael.y" 03189 { 03190 (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)])); 03191 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)])); 03192 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;} 03193 break; 03194 03195 case 103: 03196 03197 /* Line 1455 of yacc.c */ 03198 #line 564 "ael.y" 03199 { 03200 (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)])); 03201 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)])); 03202 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;} 03203 break; 03204 03205 case 104: 03206 03207 /* Line 1455 of yacc.c */ 03208 #line 568 "ael.y" 03209 { 03210 (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)])); 03211 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)])); 03212 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;} 03213 break; 03214 03215 case 105: 03216 03217 /* Line 1455 of yacc.c */ 03218 #line 574 "ael.y" 03219 { (yyval.str) = strdup("1"); ;} 03220 break; 03221 03222 case 106: 03223 03224 /* Line 1455 of yacc.c */ 03225 #line 575 "ael.y" 03226 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 03227 break; 03228 03229 case 107: 03230 03231 /* Line 1455 of yacc.c */ 03232 #line 579 "ael.y" 03233 { /* ext[, pri] default 1 */ 03234 (yyval.pval) = nword((yyvsp[(1) - (2)].str), &(yylsp[(1) - (2)])); 03235 (yyval.pval)->next = nword((yyvsp[(2) - (2)].str), &(yylsp[(2) - (2)])); ;} 03236 break; 03237 03238 case 108: 03239 03240 /* Line 1455 of yacc.c */ 03241 #line 582 "ael.y" 03242 { /* context, ext, pri */ 03243 (yyval.pval) = nword((yyvsp[(4) - (4)].str), &(yylsp[(4) - (4)])); 03244 (yyval.pval)->next = nword((yyvsp[(1) - (4)].str), &(yylsp[(1) - (4)])); 03245 (yyval.pval)->next->next = nword((yyvsp[(2) - (4)].str), &(yylsp[(2) - (4)])); ;} 03246 break; 03247 03248 case 109: 03249 03250 /* Line 1455 of yacc.c */ 03251 #line 588 "ael.y" 03252 {reset_argcount(parseio->scanner);;} 03253 break; 03254 03255 case 110: 03256 03257 /* Line 1455 of yacc.c */ 03258 #line 588 "ael.y" 03259 { 03260 /* XXX original code had @2 but i think we need @5 */ 03261 (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)])); 03262 (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str); 03263 (yyval.pval)->u2.arglist = (yyvsp[(4) - (5)].pval);;} 03264 break; 03265 03266 case 111: 03267 03268 /* Line 1455 of yacc.c */ 03269 #line 593 "ael.y" 03270 { 03271 (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 03272 (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); ;} 03273 break; 03274 03275 case 112: 03276 03277 /* Line 1455 of yacc.c */ 03278 #line 601 "ael.y" 03279 {reset_argcount(parseio->scanner);;} 03280 break; 03281 03282 case 113: 03283 03284 /* Line 1455 of yacc.c */ 03285 #line 601 "ael.y" 03286 { 03287 if (strcasecmp((yyvsp[(1) - (3)].str),"goto") == 0) { 03288 (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)])); 03289 free((yyvsp[(1) - (3)].str)); /* won't be using this */ 03290 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, (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column, (yylsp[(1) - (3)]).last_column ); 03291 } else { 03292 (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)])); 03293 (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); 03294 } ;} 03295 break; 03296 03297 case 114: 03298 03299 /* Line 1455 of yacc.c */ 03300 #line 612 "ael.y" 03301 { 03302 (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(3) - (3)])); 03303 if( (yyval.pval)->type == PV_GOTO ) 03304 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); 03305 else 03306 (yyval.pval)->u2.arglist = (yyvsp[(2) - (3)].pval); 03307 ;} 03308 break; 03309 03310 case 115: 03311 03312 /* Line 1455 of yacc.c */ 03313 #line 619 "ael.y" 03314 { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); ;} 03315 break; 03316 03317 case 116: 03318 03319 /* Line 1455 of yacc.c */ 03320 #line 622 "ael.y" 03321 { (yyval.str) = (yyvsp[(1) - (1)].str) ;} 03322 break; 03323 03324 case 117: 03325 03326 /* Line 1455 of yacc.c */ 03327 #line 623 "ael.y" 03328 { (yyval.str) = strdup(""); ;} 03329 break; 03330 03331 case 118: 03332 03333 /* Line 1455 of yacc.c */ 03334 #line 626 "ael.y" 03335 { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;} 03336 break; 03337 03338 case 119: 03339 03340 /* Line 1455 of yacc.c */ 03341 #line 627 "ael.y" 03342 { 03343 (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/); 03344 (yyval.pval)->u1.str = strdup(""); ;} 03345 break; 03346 03347 case 120: 03348 03349 /* Line 1455 of yacc.c */ 03350 #line 630 "ael.y" 03351 { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); ;} 03352 break; 03353 03354 case 121: 03355 03356 /* Line 1455 of yacc.c */ 03357 #line 633 "ael.y" 03358 { (yyval.pval) = NULL; ;} 03359 break; 03360 03361 case 122: 03362 03363 /* Line 1455 of yacc.c */ 03364 #line 634 "ael.y" 03365 { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;} 03366 break; 03367 03368 case 123: 03369 03370 /* Line 1455 of yacc.c */ 03371 #line 637 "ael.y" 03372 { 03373 (yyval.pval) = npval2(PV_CASE, &(yylsp[(1) - (4)]), &(yylsp[(3) - (4)])); /* XXX 3 or 4 ? */ 03374 (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str); 03375 (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));;} 03376 break; 03377 03378 case 124: 03379 03380 /* Line 1455 of yacc.c */ 03381 #line 641 "ael.y" 03382 { 03383 (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)])); 03384 (yyval.pval)->u1.str = NULL; 03385 (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;} 03386 break; 03387 03388 case 125: 03389 03390 /* Line 1455 of yacc.c */ 03391 #line 645 "ael.y" 03392 { 03393 (yyval.pval) = npval2(PV_PATTERN, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); /* XXX@3 or @4 ? */ 03394 (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str); 03395 (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval);set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));;} 03396 break; 03397 03398 case 126: 03399 03400 /* Line 1455 of yacc.c */ 03401 #line 651 "ael.y" 03402 { (yyval.pval) = NULL; ;} 03403 break; 03404 03405 case 127: 03406 03407 /* Line 1455 of yacc.c */ 03408 #line 652 "ael.y" 03409 { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;} 03410 break; 03411 03412 case 128: 03413 03414 /* Line 1455 of yacc.c */ 03415 #line 655 "ael.y" 03416 {(yyval.pval)=(yyvsp[(1) - (1)].pval);;} 03417 break; 03418 03419 case 129: 03420 03421 /* Line 1455 of yacc.c */ 03422 #line 656 "ael.y" 03423 { (yyval.pval)=(yyvsp[(1) - (1)].pval);;} 03424 break; 03425 03426 case 130: 03427 03428 /* Line 1455 of yacc.c */ 03429 #line 657 "ael.y" 03430 { 03431 (yyval.pval) = npval2(PV_CATCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)])); 03432 (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str); 03433 (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));;} 03434 break; 03435 03436 case 131: 03437 03438 /* Line 1455 of yacc.c */ 03439 #line 663 "ael.y" 03440 { 03441 (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)])); 03442 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;} 03443 break; 03444 03445 case 132: 03446 03447 /* Line 1455 of yacc.c */ 03448 #line 668 "ael.y" 03449 { 03450 (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)])); 03451 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;} 03452 break; 03453 03454 case 133: 03455 03456 /* Line 1455 of yacc.c */ 03457 #line 673 "ael.y" 03458 { (yyval.pval) = NULL; ;} 03459 break; 03460 03461 case 134: 03462 03463 /* Line 1455 of yacc.c */ 03464 #line 674 "ael.y" 03465 { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval),nword((yyvsp[(2) - (3)].str), &(yylsp[(2) - (3)]))); ;} 03466 break; 03467 03468 case 135: 03469 03470 /* Line 1455 of yacc.c */ 03471 #line 675 "ael.y" 03472 { 03473 char *x; 03474 if (asprintf(&x,"%s@%s", (yyvsp[(2) - (5)].str), (yyvsp[(4) - (5)].str)) < 0) { 03475 ast_log(LOG_WARNING, "asprintf() failed\n"); 03476 (yyval.pval) = NULL; 03477 } else { 03478 free((yyvsp[(2) - (5)].str)); 03479 free((yyvsp[(4) - (5)].str)); 03480 (yyval.pval) = linku1((yyvsp[(1) - (5)].pval),nword(x, &(yylsp[(2) - (5)]))); 03481 } 03482 ;} 03483 break; 03484 03485 case 136: 03486 03487 /* Line 1455 of yacc.c */ 03488 #line 686 "ael.y" 03489 {(yyval.pval)=(yyvsp[(2) - (2)].pval);;} 03490 break; 03491 03492 case 137: 03493 03494 /* Line 1455 of yacc.c */ 03495 #line 689 "ael.y" 03496 { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;} 03497 break; 03498 03499 case 138: 03500 03501 /* Line 1455 of yacc.c */ 03502 #line 690 "ael.y" 03503 { 03504 (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)])); 03505 (yyval.pval)->u2.arglist = (yyvsp[(3) - (3)].pval); 03506 prev_word=0; /* XXX sure ? */ ;} 03507 break; 03508 03509 case 139: 03510 03511 /* Line 1455 of yacc.c */ 03512 #line 697 "ael.y" 03513 { (yyval.pval) = (yyvsp[(1) - (2)].pval); ;} 03514 break; 03515 03516 case 140: 03517 03518 /* Line 1455 of yacc.c */ 03519 #line 698 "ael.y" 03520 { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), (yyvsp[(2) - (3)].pval)); ;} 03521 break; 03522 03523 case 141: 03524 03525 /* Line 1455 of yacc.c */ 03526 #line 699 "ael.y" 03527 {(yyval.pval)=(yyvsp[(1) - (2)].pval);;} 03528 break; 03529 03530 case 142: 03531 03532 /* Line 1455 of yacc.c */ 03533 #line 702 "ael.y" 03534 { 03535 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); 03536 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;} 03537 break; 03538 03539 case 143: 03540 03541 /* Line 1455 of yacc.c */ 03542 #line 705 "ael.y" 03543 { 03544 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));;} 03545 break; 03546 03547 03548 03549 /* Line 1455 of yacc.c */ 03550 #line 3551 "ael.tab.c" 03551 default: break; 03552 } 03553 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 03554 03555 YYPOPSTACK (yylen); 03556 yylen = 0; 03557 YY_STACK_PRINT (yyss, yyssp); 03558 03559 *++yyvsp = yyval; 03560 *++yylsp = yyloc; 03561 03562 /* Now `shift' the result of the reduction. Determine what state 03563 that goes to, based on the state we popped back to and the rule 03564 number reduced by. */ 03565 03566 yyn = yyr1[yyn]; 03567 03568 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 03569 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 03570 yystate = yytable[yystate]; 03571 else 03572 yystate = yydefgoto[yyn - YYNTOKENS]; 03573 03574 goto yynewstate; 03575 03576 03577 /*------------------------------------. 03578 | yyerrlab -- here on detecting error | 03579 `------------------------------------*/ 03580 yyerrlab: 03581 /* If not already recovering from an error, report this error. */ 03582 if (!yyerrstatus) 03583 { 03584 ++yynerrs; 03585 #if ! YYERROR_VERBOSE 03586 yyerror (&yylloc, parseio, YY_("syntax error")); 03587 #else 03588 { 03589 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 03590 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 03591 { 03592 YYSIZE_T yyalloc = 2 * yysize; 03593 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 03594 yyalloc = YYSTACK_ALLOC_MAXIMUM; 03595 if (yymsg != yymsgbuf) 03596 YYSTACK_FREE (yymsg); 03597 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 03598 if (yymsg) 03599 yymsg_alloc = yyalloc; 03600 else 03601 { 03602 yymsg = yymsgbuf; 03603 yymsg_alloc = sizeof yymsgbuf; 03604 } 03605 } 03606 03607 if (0 < yysize && yysize <= yymsg_alloc) 03608 { 03609 (void) yysyntax_error (yymsg, yystate, yychar); 03610 yyerror (&yylloc, parseio, yymsg); 03611 } 03612 else 03613 { 03614 yyerror (&yylloc, parseio, YY_("syntax error")); 03615 if (yysize != 0) 03616 goto yyexhaustedlab; 03617 } 03618 } 03619 #endif 03620 } 03621 03622 yyerror_range[0] = yylloc; 03623 03624 if (yyerrstatus == 3) 03625 { 03626 /* If just tried and failed to reuse lookahead token after an 03627 error, discard it. */ 03628 03629 if (yychar <= YYEOF) 03630 { 03631 /* Return failure if at end of input. */ 03632 if (yychar == YYEOF) 03633 YYABORT; 03634 } 03635 else 03636 { 03637 yydestruct ("Error: discarding", 03638 yytoken, &yylval, &yylloc, parseio); 03639 yychar = YYEMPTY; 03640 } 03641 } 03642 03643 /* Else will try to reuse lookahead token after shifting the error 03644 token. */ 03645 goto yyerrlab1; 03646 03647 03648 /*---------------------------------------------------. 03649 | yyerrorlab -- error raised explicitly by YYERROR. | 03650 `---------------------------------------------------*/ 03651 yyerrorlab: 03652 03653 /* Pacify compilers like GCC when the user code never invokes 03654 YYERROR and the label yyerrorlab therefore never appears in user 03655 code. */ 03656 if (/*CONSTCOND*/ 0) 03657 goto yyerrorlab; 03658 03659 yyerror_range[0] = yylsp[1-yylen]; 03660 /* Do not reclaim the symbols of the rule which action triggered 03661 this YYERROR. */ 03662 YYPOPSTACK (yylen); 03663 yylen = 0; 03664 YY_STACK_PRINT (yyss, yyssp); 03665 yystate = *yyssp; 03666 goto yyerrlab1; 03667 03668 03669 /*-------------------------------------------------------------. 03670 | yyerrlab1 -- common code for both syntax error and YYERROR. | 03671 `-------------------------------------------------------------*/ 03672 yyerrlab1: 03673 yyerrstatus = 3; /* Each real token shifted decrements this. */ 03674 03675 for (;;) 03676 { 03677 yyn = yypact[yystate]; 03678 if (yyn != YYPACT_NINF) 03679 { 03680 yyn += YYTERROR; 03681 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 03682 { 03683 yyn = yytable[yyn]; 03684 if (0 < yyn) 03685 break; 03686 } 03687 } 03688 03689 /* Pop the current state because it cannot handle the error token. */ 03690 if (yyssp == yyss) 03691 YYABORT; 03692 03693 yyerror_range[0] = *yylsp; 03694 yydestruct ("Error: popping", 03695 yystos[yystate], yyvsp, yylsp, parseio); 03696 YYPOPSTACK (1); 03697 yystate = *yyssp; 03698 YY_STACK_PRINT (yyss, yyssp); 03699 } 03700 03701 *++yyvsp = yylval; 03702 03703 yyerror_range[1] = yylloc; 03704 /* Using YYLLOC is tempting, but would change the location of 03705 the lookahead. YYLOC is available though. */ 03706 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); 03707 *++yylsp = yyloc; 03708 03709 /* Shift the error token. */ 03710 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 03711 03712 yystate = yyn; 03713 goto yynewstate; 03714 03715 03716 /*-------------------------------------. 03717 | yyacceptlab -- YYACCEPT comes here. | 03718 `-------------------------------------*/ 03719 yyacceptlab: 03720 yyresult = 0; 03721 goto yyreturn; 03722 03723 /*-----------------------------------. 03724 | yyabortlab -- YYABORT comes here. | 03725 `-----------------------------------*/ 03726 yyabortlab: 03727 yyresult = 1; 03728 goto yyreturn; 03729 03730 #if !defined(yyoverflow) || YYERROR_VERBOSE 03731 /*-------------------------------------------------. 03732 | yyexhaustedlab -- memory exhaustion comes here. | 03733 `-------------------------------------------------*/ 03734 yyexhaustedlab: 03735 yyerror (&yylloc, parseio, YY_("memory exhausted")); 03736 yyresult = 2; 03737 /* Fall through. */ 03738 #endif 03739 03740 yyreturn: 03741 if (yychar != YYEMPTY) 03742 yydestruct ("Cleanup: discarding lookahead", 03743 yytoken, &yylval, &yylloc, parseio); 03744 /* Do not reclaim the symbols of the rule which action triggered 03745 this YYABORT or YYACCEPT. */ 03746 YYPOPSTACK (yylen); 03747 YY_STACK_PRINT (yyss, yyssp); 03748 while (yyssp != yyss) 03749 { 03750 yydestruct ("Cleanup: popping", 03751 yystos[*yyssp], yyvsp, yylsp, parseio); 03752 YYPOPSTACK (1); 03753 } 03754 #ifndef yyoverflow 03755 if (yyss != yyssa) 03756 YYSTACK_FREE (yyss); 03757 #endif 03758 #if YYERROR_VERBOSE 03759 if (yymsg != yymsgbuf) 03760 YYSTACK_FREE (yymsg); 03761 #endif 03762 /* Make sure YYID is used. */ 03763 return YYID (yyresult); 03764 }
int yyparse | ( | ) |
static char* yystpcpy | ( | char * | yydest, | |
const char * | yysrc | |||
) | [static] |
static YYSIZE_T yystrlen | ( | char * | yystr | ) | const [static] |
static YYSIZE_T yysyntax_error | ( | char * | yyresult, | |
int | yystate, | |||
int | yychar | |||
) | [static] |
Definition at line 1326 of file ael.tab.c.
References YY_, YYLAST, YYNTOKENS, YYPACT_NINF, YYSIZE_MAXIMUM, YYSIZE_T, yystpcpy(), yystrlen(), YYTERROR, yytnamerr(), and YYTRANSLATE.
01327 { 01328 int yyn = yypact[yystate]; 01329 01330 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 01331 return 0; 01332 else 01333 { 01334 int yytype = YYTRANSLATE (yychar); 01335 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 01336 YYSIZE_T yysize = yysize0; 01337 YYSIZE_T yysize1; 01338 int yysize_overflow = 0; 01339 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 01340 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 01341 int yyx; 01342 01343 # if 0 01344 /* This is so xgettext sees the translatable formats that are 01345 constructed on the fly. */ 01346 YY_("syntax error, unexpected %s"); 01347 YY_("syntax error, unexpected %s, expecting %s"); 01348 YY_("syntax error, unexpected %s, expecting %s or %s"); 01349 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 01350 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 01351 # endif 01352 char *yyfmt; 01353 char const *yyf; 01354 static char const yyunexpected[] = "syntax error, unexpected %s"; 01355 static char const yyexpecting[] = ", expecting %s"; 01356 static char const yyor[] = " or %s"; 01357 char yyformat[sizeof yyunexpected 01358 + sizeof yyexpecting - 1 01359 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 01360 * (sizeof yyor - 1))]; 01361 char const *yyprefix = yyexpecting; 01362 01363 /* Start YYX at -YYN if negative to avoid negative indexes in 01364 YYCHECK. */ 01365 int yyxbegin = yyn < 0 ? -yyn : 0; 01366 01367 /* Stay within bounds of both yycheck and yytname. */ 01368 int yychecklim = YYLAST - yyn + 1; 01369 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 01370 int yycount = 1; 01371 01372 yyarg[0] = yytname[yytype]; 01373 yyfmt = yystpcpy (yyformat, yyunexpected); 01374 01375 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 01376 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 01377 { 01378 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 01379 { 01380 yycount = 1; 01381 yysize = yysize0; 01382 yyformat[sizeof yyunexpected - 1] = '\0'; 01383 break; 01384 } 01385 yyarg[yycount++] = yytname[yyx]; 01386 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 01387 yysize_overflow |= (yysize1 < yysize); 01388 yysize = yysize1; 01389 yyfmt = yystpcpy (yyfmt, yyprefix); 01390 yyprefix = yyor; 01391 } 01392 01393 yyf = YY_(yyformat); 01394 yysize1 = yysize + yystrlen (yyf); 01395 yysize_overflow |= (yysize1 < yysize); 01396 yysize = yysize1; 01397 01398 if (yysize_overflow) 01399 return YYSIZE_MAXIMUM; 01400 01401 if (yyresult) 01402 { 01403 /* Avoid sprintf, as that infringes on the user's name space. 01404 Don't have undefined behavior even if the translation 01405 produced a string with the wrong number of "%s"s. */ 01406 char *yyp = yyresult; 01407 int yyi = 0; 01408 while ((*yyp = *yyf) != '\0') 01409 { 01410 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 01411 { 01412 yyp += yytnamerr (yyp, yyarg[yyi++]); 01413 yyf += 2; 01414 } 01415 else 01416 { 01417 yyp++; 01418 yyf++; 01419 } 01420 } 01421 } 01422 return yysize; 01423 } 01424 }
static YYSIZE_T yytnamerr | ( | char * | yyres, | |
const char * | yystr | |||
) | [static] |
Definition at line 1279 of file ael.tab.c.
References YYSIZE_T, yystpcpy(), and yystrlen().
01280 { 01281 if (*yystr == '"') 01282 { 01283 YYSIZE_T yyn = 0; 01284 char const *yyp = yystr; 01285 01286 for (;;) 01287 switch (*++yyp) 01288 { 01289 case '\'': 01290 case ',': 01291 goto do_not_strip_quotes; 01292 01293 case '\\': 01294 if (*++yyp != '\\') 01295 goto do_not_strip_quotes; 01296 /* Fall through. */ 01297 default: 01298 if (yyres) 01299 yyres[yyn] = *yyp; 01300 yyn++; 01301 break; 01302 01303 case '"': 01304 if (yyres) 01305 yyres[yyn] = '\0'; 01306 return yyn; 01307 } 01308 do_not_strip_quotes: ; 01309 } 01310 01311 if (! yyres) 01312 return yystrlen (yystr); 01313 01314 return yystpcpy (yyres, yystr) - yyres; 01315 }
char* token_equivs1[] [static] |
char* token_equivs2[] [static] |
const yytype_uint16 yycheck[] [static] |
const yytype_uint8 yydefact[] [static] |
const yytype_int16 yydefgoto[] [static] |
const yytype_int16 yypact[] [static] |
const yytype_int16 yypgoto[] [static] |
const yytype_uint8 yyr1[] [static] |
const yytype_uint8 yyr2[] [static] |
const yytype_uint8 yystos[] [static] |
const yytype_int16 yytable[] [static] |
const yytype_uint8 yytranslate[] [static] |