Mon Mar 19 11:30:31 2012

Asterisk developer's documentation


ael.tab.c File Reference

Bison Grammar description of AEL2. More...

#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)
pvallinku1 (pval *head, pval *tail)
pvalnpval (pvaltype type, int first_line, int last_line, int first_column, int last_column)
static pvalnpval2 (pvaltype type, YYLTYPE *first, YYLTYPE *last)
static pvalnword (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 pvalupdate_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 []


Detailed Description

Bison Grammar description of AEL2.

Definition in file ael.tab.c.


Define Documentation

#define YY_ ( msgid   )     msgid

Definition at line 329 of file ael.tab.c.

#define YY_LOCATION_PRINT ( File,
Loc   ) 

Value:

fprintf (File, "%d.%d-%d.%d",       \
         (Loc).first_line, (Loc).first_column,  \
         (Loc).last_line,  (Loc).last_column)

Definition at line 1007 of file ael.tab.c.

#define YY_REDUCE_PRINT ( Rule   ) 

Definition at line 1195 of file ael.tab.c.

#define YY_STACK_PRINT ( Bottom,
Top   ) 

Definition at line 1194 of file ael.tab.c.

#define YY_SYMBOL_PRINT ( Title,
Type,
Value,
Location   ) 

Definition at line 1193 of file ael.tab.c.

#define YYABORT   goto yyabortlab

Definition at line 941 of file ael.tab.c.

#define YYACCEPT   goto yyacceptlab

Definition at line 940 of file ael.tab.c.

#define YYBACKUP ( Token,
Value   ) 

Definition at line 953 of file ael.tab.c.

#define YYBISON   1

Definition at line 46 of file ael.tab.c.

#define YYBISON_VERSION   "2.4.1"

Definition at line 49 of file ael.tab.c.

#define yychar   ael_yychar

Definition at line 71 of file ael.tab.c.

#define yyclearin   (yychar = YYEMPTY)

Definition at line 936 of file ael.tab.c.

#define YYCOPY ( To,
From,
Count   ) 

Definition at line 457 of file ael.tab.c.

#define YYDEBUG   0

Definition at line 142 of file ael.tab.c.

#define yydebug   ael_yydebug

Definition at line 72 of file ael.tab.c.

#define YYDPRINTF ( Args   ) 

Definition at line 1192 of file ael.tab.c.

#define YYEMPTY   (-2)

Definition at line 937 of file ael.tab.c.

#define YYEOF   0

Definition at line 938 of file ael.tab.c.

#define YYERRCODE   256

Definition at line 972 of file ael.tab.c.

#define yyerrok   (yyerrstatus = 0)

Definition at line 935 of file ael.tab.c.

#define YYERROR   goto yyerrorlab

Definition at line 942 of file ael.tab.c.

#define yyerror   ael_yyerror

Definition at line 69 of file ael.tab.c.

#define YYERROR_VERBOSE   1

Definition at line 148 of file ael.tab.c.

#define YYERROR_VERBOSE   1

Definition at line 148 of file ael.tab.c.

#define YYFAIL   goto yyerrlab

Definition at line 949 of file ael.tab.c.

#define YYFINAL   17

Definition at line 487 of file ael.tab.c.

#define YYFREE   free

Definition at line 418 of file ael.tab.c.

#define YYID (  )     (n)

Definition at line 342 of file ael.tab.c.

#define YYINITDEPTH   200

Definition at line 1201 of file ael.tab.c.

#define YYLAST   371

Definition at line 489 of file ael.tab.c.

#define YYLEX   yylex (&yylval, &yylloc, YYLEX_PARAM)

Definition at line 1020 of file ael.tab.c.

#define yylex   ael_yylex

Definition at line 68 of file ael.tab.c.

#define YYLEX_PARAM   ((struct parse_io *)parseio)->scanner

Definition at line 126 of file ael.tab.c.

#define yylloc   ael_yylloc

Definition at line 74 of file ael.tab.c.

#define YYLLOC_DEFAULT ( Current,
Rhs,
 ) 

Definition at line 981 of file ael.tab.c.

#define YYLSP_NEEDED   1

Definition at line 64 of file ael.tab.c.

#define yyltype   YYLTYPE

Definition at line 240 of file ael.tab.c.

#define YYLTYPE_IS_DECLARED   1

Definition at line 241 of file ael.tab.c.

#define YYLTYPE_IS_TRIVIAL   1

Definition at line 242 of file ael.tab.c.

#define yylval   ael_yylval

Definition at line 70 of file ael.tab.c.

#define YYMALLOC   malloc

Definition at line 411 of file ael.tab.c.

#define YYMAXDEPTH   10000

Definition at line 1212 of file ael.tab.c.

#define YYMAXUTOK   298

Definition at line 502 of file ael.tab.c.

#define yynerrs   ael_yynerrs

Definition at line 73 of file ael.tab.c.

#define YYNNTS   56

Definition at line 494 of file ael.tab.c.

#define YYNRULES   143

Definition at line 496 of file ael.tab.c.

#define YYNSTATES   283

Definition at line 498 of file ael.tab.c.

#define YYNTOKENS   44

Definition at line 492 of file ael.tab.c.

#define YYPACT_NINF   -211

Definition at line 766 of file ael.tab.c.

#define yyparse   ael_yyparse

Definition at line 67 of file ael.tab.c.

#define YYPOPSTACK (  )     (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

#define YYPULL   1

Definition at line 61 of file ael.tab.c.

#define YYPURE   1

Definition at line 55 of file ael.tab.c.

#define YYPUSH   0

Definition at line 58 of file ael.tab.c.

 
#define YYRECOVERING (  )     (!!yyerrstatus)

Definition at line 951 of file ael.tab.c.

#define YYRHSLOC ( Rhs,
 )     ((Rhs)[K])

Definition at line 979 of file ael.tab.c.

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 319 of file ael.tab.c.

#define YYSIZE_T   unsigned int

Definition at line 315 of file ael.tab.c.

#define YYSKELETON_NAME   "yacc.c"

Definition at line 52 of file ael.tab.c.

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 397 of file ael.tab.c.

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 400 of file ael.tab.c.

#define YYSTACK_BYTES (  ) 

Value:

((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

Definition at line 446 of file ael.tab.c.

#define YYSTACK_FREE   YYFREE

Definition at line 398 of file ael.tab.c.

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)

Definition at line 442 of file ael.tab.c.

#define YYSTACK_RELOCATE ( Stack_alloc,
Stack   ) 

Definition at line 473 of file ael.tab.c.

#define yystype   YYSTYPE

Definition at line 228 of file ael.tab.c.

#define YYSTYPE_IS_DECLARED   1

Definition at line 229 of file ael.tab.c.

#define YYSTYPE_IS_TRIVIAL   1

Definition at line 227 of file ael.tab.c.

#define YYTABLE_NINF   -134

Definition at line 815 of file ael.tab.c.

#define YYTERROR   1

Definition at line 971 of file ael.tab.c.

#define YYTOKEN_TABLE   0

Definition at line 155 of file ael.tab.c.

#define YYTRANSLATE ( YYX   )     ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

Definition at line 504 of file ael.tab.c.

#define YYUNDEFTOK   2

Definition at line 501 of file ael.tab.c.

#define YYUSE (  )     ((void) (e))

Definition at line 335 of file ael.tab.c.


Typedef Documentation

typedef short int yytype_int16

Definition at line 302 of file ael.tab.c.

typedef short int yytype_int8

Definition at line 290 of file ael.tab.c.

typedef unsigned short int yytype_uint16

Definition at line 296 of file ael.tab.c.

typedef unsigned char yytype_uint8

Definition at line 281 of file ael.tab.c.


Enumeration Type Documentation

enum yytokentype

Enumerator:
KW_CONTEXT 
LC 
RC 
LP 
RP 
SEMI 
EQ 
COMMA 
COLON 
AMPER 
BAR 
AT 
KW_MACRO 
KW_GLOBALS 
KW_IGNOREPAT 
KW_SWITCH 
KW_IF 
KW_IFTIME 
KW_ELSE 
KW_RANDOM 
KW_ABSTRACT 
KW_EXTEND 
EXTENMARK 
KW_GOTO 
KW_JUMP 
KW_RETURN 
KW_BREAK 
KW_CONTINUE 
KW_REGEXTEN 
KW_HINT 
KW_FOR 
KW_WHILE 
KW_CASE 
KW_PATTERN 
KW_DEFAULT 
KW_CATCH 
KW_SWITCHES 
KW_ESWITCHES 
KW_INCLUDES 
KW_LOCAL 
word 

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    };


Function Documentation

static char * ael_token_subst ( const char *  mess  )  [static]

Definition at line 3853 of file ael.tab.c.

References calloc, and len().

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 }

int ael_yylex ( YYSTYPE yylval_param,
YYLTYPE yylloc_param,
void *  yyscanner 
)

pval* linku1 ( pval head,
pval tail 
)

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 }

pval* npval ( pvaltype  type,
int  first_line,
int  last_line,
int  first_column,
int  last_column 
)

static struct pval * npval2 ( pvaltype  type,
YYLTYPE first,
YYLTYPE last 
) [static]

Definition at line 3921 of file ael.tab.c.

References first, last, and npval().

Referenced by nword(), and yyparse().

03922 {
03923    return npval(type, first->first_line, last->last_line,
03924          first->first_column, last->last_column);
03925 }

static pval * nword ( char *  string,
YYLTYPE pos 
) [static]

Definition at line 3935 of file ael.tab.c.

References npval2(), PV_WORD, pval::str, and pval::u1.

Referenced by yyparse().

03936 {
03937    pval *p = npval2(PV_WORD, pos, pos);
03938    if (p)
03939       p->u1.str = string;
03940    return p;
03941 }

void reset_argcount ( yyscan_t  yyscanner  ) 

Referenced by yyparse().

void reset_parencount ( yyscan_t  yyscanner  ) 

Referenced by yyparse().

void reset_semicount ( yyscan_t  yyscanner  ) 

Referenced by yyparse().

static void set_dads ( pval dad,
pval child_list 
) [static]

Definition at line 3944 of file ael.tab.c.

References pval::dad, and pval::next.

Referenced by yyparse().

03945 {
03946    struct pval *t;
03947    
03948    for(t=child_list;t;t=t->next)  /* simple stuff */
03949       t->dad = dad;
03950 }

static struct pval * update_last ( pval ,
YYLTYPE  
) [static]

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 }

void yyerror ( YYLTYPE locp,
struct parse_io parseio,
char const *  s 
)

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]

Definition at line 1254 of file ael.tab.c.

01258 {
01259   char *yyd = yydest;
01260   const char *yys = yysrc;
01261 
01262   while ((*yyd++ = *yys++) != '\0')
01263     continue;
01264 
01265   return yyd - 1;
01266 }

static YYSIZE_T yystrlen ( char *  yystr  )  const [static]

Definition at line 1230 of file ael.tab.c.

References YYSIZE_T.

01233 {
01234   YYSIZE_T yylen;
01235   for (yylen = 0; yystr[yylen]; yylen++)
01236     continue;
01237   return yylen;
01238 }

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 }


Variable Documentation

char* my_file

Definition at line 882 of file ael_lex.c.

char* token_equivs1[] [static]

Definition at line 3772 of file ael.tab.c.

char* token_equivs2[] [static]

Definition at line 3812 of file ael.tab.c.

const yytype_uint16 yycheck[] [static]

Definition at line 858 of file ael.tab.c.

const yytype_uint8 yydefact[] [static]

Definition at line 720 of file ael.tab.c.

const yytype_int16 yydefgoto[] [static]

Definition at line 754 of file ael.tab.c.

const yytype_int16 yypact[] [static]

Definition at line 767 of file ael.tab.c.

const yytype_int16 yypgoto[] [static]

Definition at line 801 of file ael.tab.c.

const yytype_uint8 yyr1[] [static]

Definition at line 678 of file ael.tab.c.

const yytype_uint8 yyr2[] [static]

Definition at line 698 of file ael.tab.c.

const yytype_uint8 yystos[] [static]

Definition at line 902 of file ael.tab.c.

const yytype_int16 yytable[] [static]

Definition at line 816 of file ael.tab.c.

const char* const yytname[] [static]

Definition at line 641 of file ael.tab.c.

const yytype_uint8 yytranslate[] [static]

Definition at line 508 of file ael.tab.c.


Generated on Mon Mar 19 11:30:31 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7