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"

Include dependency graph for ael.tab.c:

Go to the source code of this file.

Data Structures

union  yyalloc
struct  YYLTYPE
union  YYSTYPE

Defines

#define WRAP_LIBC_MALLOC
#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.5"
#define YYCASE_(N, S)
#define yychar   ael_yychar
#define yyclearin   (yychar = YYEMPTY)
#define YYCOPY(To, From, Count)
#define YYCOPY_NEEDED   1
#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 yypact_value_is_default(yystate)   ((yystate) == (-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 YYSYNTAX_ERROR
#define YYTABLE_NINF   -134
#define yytable_value_is_error(yytable_value)   YYID (0)
#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 {
  TOK_COMMA = 258, TOK_COLONCOLON = 259, TOK_COND = 260, TOK_OR = 261,
  TOK_AND = 262, TOK_NE = 263, TOK_LE = 264, TOK_GE = 265,
  TOK_LT = 266, TOK_GT = 267, TOK_EQ = 268, TOK_MINUS = 269,
  TOK_PLUS = 270, TOK_MOD = 271, TOK_DIV = 272, TOK_MULT = 273,
  TOK_COMPL = 274, TOK_TILDETILDE = 275, TOK_EQTILDE = 276, TOK_COLON = 277,
  TOK_LP = 278, TOK_RP = 279, TOKEN = 280, TOK_COMMA = 258,
  TOK_COLONCOLON = 259, TOK_COND = 260, TOK_OR = 261, TOK_AND = 262,
  TOK_NE = 263, TOK_LE = 264, TOK_GE = 265, TOK_LT = 266,
  TOK_GT = 267, TOK_EQ = 268, TOK_MINUS = 269, TOK_PLUS = 270,
  TOK_MOD = 271, TOK_DIV = 272, TOK_MULT = 273, TOK_COMPL = 274,
  TOK_TILDETILDE = 275, TOK_EQTILDE = 276, TOK_COLON = 277, TOK_LP = 278,
  TOK_RP = 279, TOKEN = 280, 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, 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 int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
static YYSIZE_T yytnamerr (char *yyres, const char *yystr)

Variables

struct 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 WRAP_LIBC_MALLOC

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

#define YY_ ( msgid   )     msgid

Definition at line 328 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 1023 of file ael.tab.c.

#define YY_REDUCE_PRINT ( Rule   ) 

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

#define YY_STACK_PRINT ( Bottom,
Top   ) 

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

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

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

#define YYABORT   goto yyabortlab

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

#define YYACCEPT   goto yyacceptlab

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

#define YYBACKUP ( Token,
Value   ) 

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

#define YYBISON   1

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

#define YYBISON_VERSION   "2.5"

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

#define YYCASE_ ( N,
 ) 

Value:

case N:                               \
        yyformat = S;                       \
      break

Referenced by yysyntax_error().

#define yychar   ael_yychar

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

#define yyclearin   (yychar = YYEMPTY)

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

#define YYCOPY ( To,
From,
Count   ) 

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

#define YYCOPY_NEEDED   1

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

#define YYDEBUG   0

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

#define yydebug   ael_yydebug

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

#define YYDPRINTF ( Args   ) 

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

#define YYEMPTY   (-2)

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

#define YYEOF   0

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

#define YYERRCODE   256

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

#define yyerrok   (yyerrstatus = 0)

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

#define YYERROR   goto yyerrorlab

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

#define yyerror   ael_yyerror

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

#define YYERROR_VERBOSE   1

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

#define YYERROR_VERBOSE   1

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

#define YYFAIL   goto yyerrlab

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

#define YYFINAL   17

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

#define YYFREE   free

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

#define YYID (  )     (n)

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

#define YYINITDEPTH   200

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

#define YYLAST   371

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

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

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

#define yylex   ael_yylex

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

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

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

#define yylloc   ael_yylloc

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

#define YYLLOC_DEFAULT ( Current,
Rhs,
 ) 

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

#define YYLSP_NEEDED   1

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

#define yyltype   YYLTYPE

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

#define YYLTYPE_IS_DECLARED   1

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

#define YYLTYPE_IS_TRIVIAL   1

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

#define yylval   ael_yylval

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

#define YYMALLOC   malloc

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

#define YYMAXDEPTH   10000

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

#define YYMAXUTOK   298

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

#define yynerrs   ael_yynerrs

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

#define YYNNTS   56

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

#define YYNRULES   143

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

#define YYNSTATES   283

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

#define YYNTOKENS   44

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

#define YYPACT_NINF   -211

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

#define yypact_value_is_default ( yystate   )     ((yystate) == (-211))

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

Referenced by yyparse(), and yysyntax_error().

#define yyparse   ael_yyparse

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

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

#define YYPULL   1

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

#define YYPURE   1

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

#define YYPUSH   0

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

 
#define YYRECOVERING (  )     (!!yyerrstatus)

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

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

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

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

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

#define YYSIZE_T   unsigned int

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

#define YYSKELETON_NAME   "yacc.c"

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

#define YYSTACK_ALLOC   YYMALLOC

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

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

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

#define YYSTACK_BYTES (  ) 

Value:

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

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

#define YYSTACK_FREE   YYFREE

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

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

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

#define YYSTACK_RELOCATE ( Stack_alloc,
Stack   ) 

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

#define yystype   YYSTYPE

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

#define YYSTYPE_IS_DECLARED   1

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

#define YYSTYPE_IS_TRIVIAL   1

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

#define YYSYNTAX_ERROR

Value:

yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)

Referenced by yyparse().

#define YYTABLE_NINF   -134

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

#define yytable_value_is_error ( yytable_value   )     YYID (0)

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

Referenced by yyparse(), and yysyntax_error().

#define YYTERROR   1

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

#define YYTOKEN_TABLE   0

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

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

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

#define YYUNDEFTOK   2

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

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

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


Typedef Documentation

typedef short int yytype_int16

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

typedef short int yytype_int8

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

typedef unsigned short int yytype_uint16

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

typedef unsigned char yytype_uint8

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


Enumeration Type Documentation

Enumerator:
TOK_COMMA 
TOK_COLONCOLON 
TOK_COND 
TOK_OR 
TOK_AND 
TOK_NE 
TOK_LE 
TOK_GE 
TOK_LT 
TOK_GT 
TOK_EQ 
TOK_MINUS 
TOK_PLUS 
TOK_MOD 
TOK_DIV 
TOK_MULT 
TOK_COMPL 
TOK_TILDETILDE 
TOK_EQTILDE 
TOK_COLON 
TOK_LP 
TOK_RP 
TOKEN 
TOK_COMMA 
TOK_COLONCOLON 
TOK_COND 
TOK_OR 
TOK_AND 
TOK_NE 
TOK_LE 
TOK_GE 
TOK_LT 
TOK_GT 
TOK_EQ 
TOK_MINUS 
TOK_PLUS 
TOK_MOD 
TOK_DIV 
TOK_MULT 
TOK_COMPL 
TOK_TILDETILDE 
TOK_EQTILDE 
TOK_COLON 
TOK_LP 
TOK_RP 
TOKEN 
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 
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 163 of file ael.tab.c.

00163                     {
00164      KW_CONTEXT = 258,
00165      LC = 259,
00166      RC = 260,
00167      LP = 261,
00168      RP = 262,
00169      SEMI = 263,
00170      EQ = 264,
00171      COMMA = 265,
00172      COLON = 266,
00173      AMPER = 267,
00174      BAR = 268,
00175      AT = 269,
00176      KW_MACRO = 270,
00177      KW_GLOBALS = 271,
00178      KW_IGNOREPAT = 272,
00179      KW_SWITCH = 273,
00180      KW_IF = 274,
00181      KW_IFTIME = 275,
00182      KW_ELSE = 276,
00183      KW_RANDOM = 277,
00184      KW_ABSTRACT = 278,
00185      KW_EXTEND = 279,
00186      EXTENMARK = 280,
00187      KW_GOTO = 281,
00188      KW_JUMP = 282,
00189      KW_RETURN = 283,
00190      KW_BREAK = 284,
00191      KW_CONTINUE = 285,
00192      KW_REGEXTEN = 286,
00193      KW_HINT = 287,
00194      KW_FOR = 288,
00195      KW_WHILE = 289,
00196      KW_CASE = 290,
00197      KW_PATTERN = 291,
00198      KW_DEFAULT = 292,
00199      KW_CATCH = 293,
00200      KW_SWITCHES = 294,
00201      KW_ESWITCHES = 295,
00202      KW_INCLUDES = 296,
00203      KW_LOCAL = 297,
00204      word = 298
00205    };


Function Documentation

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

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

References calloc, and len().

Referenced by yyerror().

03913 {
03914    /* calc a length, malloc, fill, and return; yyerror had better free it! */
03915    int len=0,i;
03916    const char *p;
03917    char *res, *s,*t;
03918    int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
03919 
03920    for (p=mess; *p; p++) {
03921       for (i=0; i<token_equivs_entries; i++) {
03922          if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
03923          {
03924             len+=strlen(token_equivs2[i])+2;
03925             p += strlen(token_equivs1[i])-1;
03926             break;
03927          }
03928       }
03929       len++;
03930    }
03931    res = calloc(1, len+1);
03932    res[0] = 0;
03933    s = res;
03934    for (p=mess; *p;) {
03935       int found = 0;
03936       for (i=0; i<token_equivs_entries; i++) {
03937          if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
03938             *s++ = '\'';
03939             for (t=token_equivs2[i]; *t;) {
03940                *s++ = *t++;
03941             }
03942             *s++ = '\'';
03943             p += strlen(token_equivs1[i]);
03944             found = 1;
03945             break;
03946          }
03947       }
03948       if( !found )
03949          *s++ = *p++;
03950    }
03951    *s++ = 0;
03952    return res;
03953 }

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

pval* linku1 ( pval head,
pval tail 
)

Definition at line 5898 of file pval.c.

References pval::next, pval::prev, and pval::u1_last.

05899 {
05900    if (!head)
05901       return tail;
05902    if (tail) {
05903       if (!head->next) {
05904          head->next = tail;
05905       } else {
05906          head->u1_last->next = tail;
05907       }
05908       head->u1_last = tail;
05909       tail->prev = head; /* the dad link only points to containers */
05910    }
05911    return head;
05912 }

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, read]

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

References YYLTYPE::first_column, YYLTYPE::first_line, YYLTYPE::last_column, YYLTYPE::last_line, and npval().

Referenced by nword(), and yyparse().

03981 {
03982    return npval(type, first->first_line, last->last_line,
03983          first->first_column, last->last_column);
03984 }

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

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

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

Referenced by yyparse().

03995 {
03996    pval *p = npval2(PV_WORD, pos, pos);
03997    if (p)
03998       p->u1.str = string;
03999    return p;
04000 }

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 4003 of file ael.tab.c.

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

Referenced by yyparse().

04004 {
04005    struct pval *t;
04006    
04007    for(t=child_list;t;t=t->next)  /* simple stuff */
04008       t->dad = dad;
04009 }

static struct pval * update_last ( pval obj,
YYLTYPE last 
) [static, read]

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

References pval::endcol, pval::endline, YYLTYPE::last_column, and YYLTYPE::last_line.

Referenced by yyparse().

03987 {
03988    obj->endline = last->last_line;
03989    obj->endcol = last->last_column;
03990    return obj;
03991 }

static void yydestruct ( char *  yymsg,
int  yytype,
YYSTYPE yyvaluep,
YYLTYPE yylocationp,
struct parse_io parseio 
) const [static]

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

References destroy_pval(), free, prev_word, YYSTYPE::pval, YYSTYPE::str, YY_SYMBOL_PRINT, and YYUSE.

01488 {
01489   YYUSE (yyvaluep);
01490   YYUSE (yylocationp);
01491   YYUSE (parseio);
01492 
01493   if (!yymsg)
01494     yymsg = "Deleting";
01495   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01496 
01497   switch (yytype)
01498     {
01499       case 43: /* "word" */
01500 
01501 /* Line 1391 of yacc.c  */
01502 #line 183 "ael.y"
01503    { free((yyvaluep->str));};
01504 
01505 /* Line 1391 of yacc.c  */
01506 #line 1506 "ael.tab.c"
01507    break;
01508       case 46: /* "objects" */
01509 
01510 /* Line 1391 of yacc.c  */
01511 #line 170 "ael.y"
01512    {
01513       destroy_pval((yyvaluep->pval));
01514       prev_word=0;
01515    };
01516 
01517 /* Line 1391 of yacc.c  */
01518 #line 1518 "ael.tab.c"
01519    break;
01520       case 47: /* "object" */
01521 
01522 /* Line 1391 of yacc.c  */
01523 #line 170 "ael.y"
01524    {
01525       destroy_pval((yyvaluep->pval));
01526       prev_word=0;
01527    };
01528 
01529 /* Line 1391 of yacc.c  */
01530 #line 1530 "ael.tab.c"
01531    break;
01532       case 48: /* "context_name" */
01533 
01534 /* Line 1391 of yacc.c  */
01535 #line 183 "ael.y"
01536    { free((yyvaluep->str));};
01537 
01538 /* Line 1391 of yacc.c  */
01539 #line 1539 "ael.tab.c"
01540    break;
01541       case 49: /* "context" */
01542 
01543 /* Line 1391 of yacc.c  */
01544 #line 170 "ael.y"
01545    {
01546       destroy_pval((yyvaluep->pval));
01547       prev_word=0;
01548    };
01549 
01550 /* Line 1391 of yacc.c  */
01551 #line 1551 "ael.tab.c"
01552    break;
01553       case 51: /* "macro" */
01554 
01555 /* Line 1391 of yacc.c  */
01556 #line 170 "ael.y"
01557    {
01558       destroy_pval((yyvaluep->pval));
01559       prev_word=0;
01560    };
01561 
01562 /* Line 1391 of yacc.c  */
01563 #line 1563 "ael.tab.c"
01564    break;
01565       case 52: /* "globals" */
01566 
01567 /* Line 1391 of yacc.c  */
01568 #line 170 "ael.y"
01569    {
01570       destroy_pval((yyvaluep->pval));
01571       prev_word=0;
01572    };
01573 
01574 /* Line 1391 of yacc.c  */
01575 #line 1575 "ael.tab.c"
01576    break;
01577       case 53: /* "global_statements" */
01578 
01579 /* Line 1391 of yacc.c  */
01580 #line 170 "ael.y"
01581    {
01582       destroy_pval((yyvaluep->pval));
01583       prev_word=0;
01584    };
01585 
01586 /* Line 1391 of yacc.c  */
01587 #line 1587 "ael.tab.c"
01588    break;
01589       case 54: /* "assignment" */
01590 
01591 /* Line 1391 of yacc.c  */
01592 #line 170 "ael.y"
01593    {
01594       destroy_pval((yyvaluep->pval));
01595       prev_word=0;
01596    };
01597 
01598 /* Line 1391 of yacc.c  */
01599 #line 1599 "ael.tab.c"
01600    break;
01601       case 56: /* "local_assignment" */
01602 
01603 /* Line 1391 of yacc.c  */
01604 #line 170 "ael.y"
01605    {
01606       destroy_pval((yyvaluep->pval));
01607       prev_word=0;
01608    };
01609 
01610 /* Line 1391 of yacc.c  */
01611 #line 1611 "ael.tab.c"
01612    break;
01613       case 58: /* "arglist" */
01614 
01615 /* Line 1391 of yacc.c  */
01616 #line 170 "ael.y"
01617    {
01618       destroy_pval((yyvaluep->pval));
01619       prev_word=0;
01620    };
01621 
01622 /* Line 1391 of yacc.c  */
01623 #line 1623 "ael.tab.c"
01624    break;
01625       case 59: /* "elements" */
01626 
01627 /* Line 1391 of yacc.c  */
01628 #line 170 "ael.y"
01629    {
01630       destroy_pval((yyvaluep->pval));
01631       prev_word=0;
01632    };
01633 
01634 /* Line 1391 of yacc.c  */
01635 #line 1635 "ael.tab.c"
01636    break;
01637       case 60: /* "element" */
01638 
01639 /* Line 1391 of yacc.c  */
01640 #line 170 "ael.y"
01641    {
01642       destroy_pval((yyvaluep->pval));
01643       prev_word=0;
01644    };
01645 
01646 /* Line 1391 of yacc.c  */
01647 #line 1647 "ael.tab.c"
01648    break;
01649       case 61: /* "ignorepat" */
01650 
01651 /* Line 1391 of yacc.c  */
01652 #line 170 "ael.y"
01653    {
01654       destroy_pval((yyvaluep->pval));
01655       prev_word=0;
01656    };
01657 
01658 /* Line 1391 of yacc.c  */
01659 #line 1659 "ael.tab.c"
01660    break;
01661       case 62: /* "extension" */
01662 
01663 /* Line 1391 of yacc.c  */
01664 #line 170 "ael.y"
01665    {
01666       destroy_pval((yyvaluep->pval));
01667       prev_word=0;
01668    };
01669 
01670 /* Line 1391 of yacc.c  */
01671 #line 1671 "ael.tab.c"
01672    break;
01673       case 63: /* "statements" */
01674 
01675 /* Line 1391 of yacc.c  */
01676 #line 170 "ael.y"
01677    {
01678       destroy_pval((yyvaluep->pval));
01679       prev_word=0;
01680    };
01681 
01682 /* Line 1391 of yacc.c  */
01683 #line 1683 "ael.tab.c"
01684    break;
01685       case 64: /* "timerange" */
01686 
01687 /* Line 1391 of yacc.c  */
01688 #line 183 "ael.y"
01689    { free((yyvaluep->str));};
01690 
01691 /* Line 1391 of yacc.c  */
01692 #line 1692 "ael.tab.c"
01693    break;
01694       case 65: /* "timespec" */
01695 
01696 /* Line 1391 of yacc.c  */
01697 #line 170 "ael.y"
01698    {
01699       destroy_pval((yyvaluep->pval));
01700       prev_word=0;
01701    };
01702 
01703 /* Line 1391 of yacc.c  */
01704 #line 1704 "ael.tab.c"
01705    break;
01706       case 66: /* "test_expr" */
01707 
01708 /* Line 1391 of yacc.c  */
01709 #line 183 "ael.y"
01710    { free((yyvaluep->str));};
01711 
01712 /* Line 1391 of yacc.c  */
01713 #line 1713 "ael.tab.c"
01714    break;
01715       case 68: /* "if_like_head" */
01716 
01717 /* Line 1391 of yacc.c  */
01718 #line 170 "ael.y"
01719    {
01720       destroy_pval((yyvaluep->pval));
01721       prev_word=0;
01722    };
01723 
01724 /* Line 1391 of yacc.c  */
01725 #line 1725 "ael.tab.c"
01726    break;
01727       case 69: /* "word_list" */
01728 
01729 /* Line 1391 of yacc.c  */
01730 #line 183 "ael.y"
01731    { free((yyvaluep->str));};
01732 
01733 /* Line 1391 of yacc.c  */
01734 #line 1734 "ael.tab.c"
01735    break;
01736       case 71: /* "word3_list" */
01737 
01738 /* Line 1391 of yacc.c  */
01739 #line 183 "ael.y"
01740    { free((yyvaluep->str));};
01741 
01742 /* Line 1391 of yacc.c  */
01743 #line 1743 "ael.tab.c"
01744    break;
01745       case 72: /* "goto_word" */
01746 
01747 /* Line 1391 of yacc.c  */
01748 #line 183 "ael.y"
01749    { free((yyvaluep->str));};
01750 
01751 /* Line 1391 of yacc.c  */
01752 #line 1752 "ael.tab.c"
01753    break;
01754       case 73: /* "switch_statement" */
01755 
01756 /* Line 1391 of yacc.c  */
01757 #line 170 "ael.y"
01758    {
01759       destroy_pval((yyvaluep->pval));
01760       prev_word=0;
01761    };
01762 
01763 /* Line 1391 of yacc.c  */
01764 #line 1764 "ael.tab.c"
01765    break;
01766       case 74: /* "statement" */
01767 
01768 /* Line 1391 of yacc.c  */
01769 #line 170 "ael.y"
01770    {
01771       destroy_pval((yyvaluep->pval));
01772       prev_word=0;
01773    };
01774 
01775 /* Line 1391 of yacc.c  */
01776 #line 1776 "ael.tab.c"
01777    break;
01778       case 79: /* "opt_else" */
01779 
01780 /* Line 1391 of yacc.c  */
01781 #line 170 "ael.y"
01782    {
01783       destroy_pval((yyvaluep->pval));
01784       prev_word=0;
01785    };
01786 
01787 /* Line 1391 of yacc.c  */
01788 #line 1788 "ael.tab.c"
01789    break;
01790       case 80: /* "target" */
01791 
01792 /* Line 1391 of yacc.c  */
01793 #line 170 "ael.y"
01794    {
01795       destroy_pval((yyvaluep->pval));
01796       prev_word=0;
01797    };
01798 
01799 /* Line 1391 of yacc.c  */
01800 #line 1800 "ael.tab.c"
01801    break;
01802       case 81: /* "opt_pri" */
01803 
01804 /* Line 1391 of yacc.c  */
01805 #line 183 "ael.y"
01806    { free((yyvaluep->str));};
01807 
01808 /* Line 1391 of yacc.c  */
01809 #line 1809 "ael.tab.c"
01810    break;
01811       case 82: /* "jumptarget" */
01812 
01813 /* Line 1391 of yacc.c  */
01814 #line 170 "ael.y"
01815    {
01816       destroy_pval((yyvaluep->pval));
01817       prev_word=0;
01818    };
01819 
01820 /* Line 1391 of yacc.c  */
01821 #line 1821 "ael.tab.c"
01822    break;
01823       case 83: /* "macro_call" */
01824 
01825 /* Line 1391 of yacc.c  */
01826 #line 170 "ael.y"
01827    {
01828       destroy_pval((yyvaluep->pval));
01829       prev_word=0;
01830    };
01831 
01832 /* Line 1391 of yacc.c  */
01833 #line 1833 "ael.tab.c"
01834    break;
01835       case 85: /* "application_call_head" */
01836 
01837 /* Line 1391 of yacc.c  */
01838 #line 170 "ael.y"
01839    {
01840       destroy_pval((yyvaluep->pval));
01841       prev_word=0;
01842    };
01843 
01844 /* Line 1391 of yacc.c  */
01845 #line 1845 "ael.tab.c"
01846    break;
01847       case 87: /* "application_call" */
01848 
01849 /* Line 1391 of yacc.c  */
01850 #line 170 "ael.y"
01851    {
01852       destroy_pval((yyvaluep->pval));
01853       prev_word=0;
01854    };
01855 
01856 /* Line 1391 of yacc.c  */
01857 #line 1857 "ael.tab.c"
01858    break;
01859       case 88: /* "opt_word" */
01860 
01861 /* Line 1391 of yacc.c  */
01862 #line 183 "ael.y"
01863    { free((yyvaluep->str));};
01864 
01865 /* Line 1391 of yacc.c  */
01866 #line 1866 "ael.tab.c"
01867    break;
01868       case 89: /* "eval_arglist" */
01869 
01870 /* Line 1391 of yacc.c  */
01871 #line 170 "ael.y"
01872    {
01873       destroy_pval((yyvaluep->pval));
01874       prev_word=0;
01875    };
01876 
01877 /* Line 1391 of yacc.c  */
01878 #line 1878 "ael.tab.c"
01879    break;
01880       case 90: /* "case_statements" */
01881 
01882 /* Line 1391 of yacc.c  */
01883 #line 170 "ael.y"
01884    {
01885       destroy_pval((yyvaluep->pval));
01886       prev_word=0;
01887    };
01888 
01889 /* Line 1391 of yacc.c  */
01890 #line 1890 "ael.tab.c"
01891    break;
01892       case 91: /* "case_statement" */
01893 
01894 /* Line 1391 of yacc.c  */
01895 #line 170 "ael.y"
01896    {
01897       destroy_pval((yyvaluep->pval));
01898       prev_word=0;
01899    };
01900 
01901 /* Line 1391 of yacc.c  */
01902 #line 1902 "ael.tab.c"
01903    break;
01904       case 92: /* "macro_statements" */
01905 
01906 /* Line 1391 of yacc.c  */
01907 #line 170 "ael.y"
01908    {
01909       destroy_pval((yyvaluep->pval));
01910       prev_word=0;
01911    };
01912 
01913 /* Line 1391 of yacc.c  */
01914 #line 1914 "ael.tab.c"
01915    break;
01916       case 93: /* "macro_statement" */
01917 
01918 /* Line 1391 of yacc.c  */
01919 #line 170 "ael.y"
01920    {
01921       destroy_pval((yyvaluep->pval));
01922       prev_word=0;
01923    };
01924 
01925 /* Line 1391 of yacc.c  */
01926 #line 1926 "ael.tab.c"
01927    break;
01928       case 94: /* "switches" */
01929 
01930 /* Line 1391 of yacc.c  */
01931 #line 170 "ael.y"
01932    {
01933       destroy_pval((yyvaluep->pval));
01934       prev_word=0;
01935    };
01936 
01937 /* Line 1391 of yacc.c  */
01938 #line 1938 "ael.tab.c"
01939    break;
01940       case 95: /* "eswitches" */
01941 
01942 /* Line 1391 of yacc.c  */
01943 #line 170 "ael.y"
01944    {
01945       destroy_pval((yyvaluep->pval));
01946       prev_word=0;
01947    };
01948 
01949 /* Line 1391 of yacc.c  */
01950 #line 1950 "ael.tab.c"
01951    break;
01952       case 96: /* "switchlist" */
01953 
01954 /* Line 1391 of yacc.c  */
01955 #line 170 "ael.y"
01956    {
01957       destroy_pval((yyvaluep->pval));
01958       prev_word=0;
01959    };
01960 
01961 /* Line 1391 of yacc.c  */
01962 #line 1962 "ael.tab.c"
01963    break;
01964       case 97: /* "included_entry" */
01965 
01966 /* Line 1391 of yacc.c  */
01967 #line 170 "ael.y"
01968    {
01969       destroy_pval((yyvaluep->pval));
01970       prev_word=0;
01971    };
01972 
01973 /* Line 1391 of yacc.c  */
01974 #line 1974 "ael.tab.c"
01975    break;
01976       case 98: /* "includeslist" */
01977 
01978 /* Line 1391 of yacc.c  */
01979 #line 170 "ael.y"
01980    {
01981       destroy_pval((yyvaluep->pval));
01982       prev_word=0;
01983    };
01984 
01985 /* Line 1391 of yacc.c  */
01986 #line 1986 "ael.tab.c"
01987    break;
01988       case 99: /* "includes" */
01989 
01990 /* Line 1391 of yacc.c  */
01991 #line 170 "ael.y"
01992    {
01993       destroy_pval((yyvaluep->pval));
01994       prev_word=0;
01995    };
01996 
01997 /* Line 1391 of yacc.c  */
01998 #line 1998 "ael.tab.c"
01999    break;
02000 
02001       default:
02002    break;
02003     }
02004 }

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

Definition at line 3955 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.

03956 {
03957    char *s2 = ael_token_subst((char *)s);
03958    if (locp->first_line == locp->last_line) {
03959       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);
03960    } else {
03961       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);
03962    }
03963    free(s2);
03964    parseio->syntax_error_count++;
03965 }

int yyparse ( struct parse_io parseio  ) 

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

References pval::arglist, asprintf, ast_log, calloc, destroy_pval(), YYLTYPE::first_column, YYLTYPE::first_line, pval::for_init, free, YYSTYPE::intval, YYLTYPE::last_column, YYLTYPE::last_line, linku1(), pval::list, LOG_WARNING, malloc, pval::next, npval(), npval2(), NULL, 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_value_is_default, YYPOPSTACK, YYSIZE_T, yyalloc::yyss_alloc, YYSTACK_ALLOC, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, YYSYNTAX_ERROR, yytable_value_is_error, YYTERROR, YYTRANSLATE, and yyalloc::yyvs_alloc.

02048 {
02049 /* The lookahead symbol.  */
02050 int yychar;
02051 
02052 /* The semantic value of the lookahead symbol.  */
02053 YYSTYPE yylval;
02054 
02055 /* Location data for the lookahead symbol.  */
02056 YYLTYPE yylloc;
02057 
02058     /* Number of syntax errors so far.  */
02059     int yynerrs;
02060 
02061     int yystate;
02062     /* Number of tokens to shift before error messages enabled.  */
02063     int yyerrstatus;
02064 
02065     /* The stacks and their tools:
02066        `yyss': related to states.
02067        `yyvs': related to semantic values.
02068        `yyls': related to locations.
02069 
02070        Refer to the stacks thru separate pointers, to allow yyoverflow
02071        to reallocate them elsewhere.  */
02072 
02073     /* The state stack.  */
02074     yytype_int16 yyssa[YYINITDEPTH];
02075     yytype_int16 *yyss;
02076     yytype_int16 *yyssp;
02077 
02078     /* The semantic value stack.  */
02079     YYSTYPE yyvsa[YYINITDEPTH];
02080     YYSTYPE *yyvs;
02081     YYSTYPE *yyvsp;
02082 
02083     /* The location stack.  */
02084     YYLTYPE yylsa[YYINITDEPTH];
02085     YYLTYPE *yyls;
02086     YYLTYPE *yylsp;
02087 
02088     /* The locations where the error started and ended.  */
02089     YYLTYPE yyerror_range[3];
02090 
02091     YYSIZE_T yystacksize;
02092 
02093   int yyn;
02094   int yyresult;
02095   /* Lookahead token as an internal (translated) token number.  */
02096   int yytoken;
02097   /* The variables used to return semantic value and location from the
02098      action routines.  */
02099   YYSTYPE yyval;
02100   YYLTYPE yyloc;
02101 
02102 #if YYERROR_VERBOSE
02103   /* Buffer for error messages, and its allocated size.  */
02104   char yymsgbuf[128];
02105   char *yymsg = yymsgbuf;
02106   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
02107 #endif
02108 
02109 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
02110 
02111   /* The number of symbols on the RHS of the reduced rule.
02112      Keep to zero when no symbol should be popped.  */
02113   int yylen = 0;
02114 
02115   yytoken = 0;
02116   yyss = yyssa;
02117   yyvs = yyvsa;
02118   yyls = yylsa;
02119   yystacksize = YYINITDEPTH;
02120 
02121   YYDPRINTF ((stderr, "Starting parse\n"));
02122 
02123   yystate = 0;
02124   yyerrstatus = 0;
02125   yynerrs = 0;
02126   yychar = YYEMPTY; /* Cause a token to be read.  */
02127 
02128   /* Initialize stack pointers.
02129      Waste one element of value and location stack
02130      so that they stay on the same level as the state stack.
02131      The wasted elements are never initialized.  */
02132   yyssp = yyss;
02133   yyvsp = yyvs;
02134   yylsp = yyls;
02135 
02136 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
02137   /* Initialize the default location before parsing starts.  */
02138   yylloc.first_line   = yylloc.last_line   = 1;
02139   yylloc.first_column = yylloc.last_column = 1;
02140 #endif
02141 
02142   goto yysetstate;
02143 
02144 /*------------------------------------------------------------.
02145 | yynewstate -- Push a new state, which is found in yystate.  |
02146 `------------------------------------------------------------*/
02147  yynewstate:
02148   /* In all cases, when you get here, the value and location stacks
02149      have just been pushed.  So pushing a state here evens the stacks.  */
02150   yyssp++;
02151 
02152  yysetstate:
02153   *yyssp = yystate;
02154 
02155   if (yyss + yystacksize - 1 <= yyssp)
02156     {
02157       /* Get the current used size of the three stacks, in elements.  */
02158       YYSIZE_T yysize = yyssp - yyss + 1;
02159 
02160 #ifdef yyoverflow
02161       {
02162    /* Give user a chance to reallocate the stack.  Use copies of
02163       these so that the &'s don't force the real ones into
02164       memory.  */
02165    YYSTYPE *yyvs1 = yyvs;
02166    yytype_int16 *yyss1 = yyss;
02167    YYLTYPE *yyls1 = yyls;
02168 
02169    /* Each stack pointer address is followed by the size of the
02170       data in use in that stack, in bytes.  This used to be a
02171       conditional around just the two extra args, but that might
02172       be undefined if yyoverflow is a macro.  */
02173    yyoverflow (YY_("memory exhausted"),
02174           &yyss1, yysize * sizeof (*yyssp),
02175           &yyvs1, yysize * sizeof (*yyvsp),
02176           &yyls1, yysize * sizeof (*yylsp),
02177           &yystacksize);
02178 
02179    yyls = yyls1;
02180    yyss = yyss1;
02181    yyvs = yyvs1;
02182       }
02183 #else /* no yyoverflow */
02184 # ifndef YYSTACK_RELOCATE
02185       goto yyexhaustedlab;
02186 # else
02187       /* Extend the stack our own way.  */
02188       if (YYMAXDEPTH <= yystacksize)
02189    goto yyexhaustedlab;
02190       yystacksize *= 2;
02191       if (YYMAXDEPTH < yystacksize)
02192    yystacksize = YYMAXDEPTH;
02193 
02194       {
02195    yytype_int16 *yyss1 = yyss;
02196    union yyalloc *yyptr =
02197      (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
02198    if (! yyptr)
02199      goto yyexhaustedlab;
02200    YYSTACK_RELOCATE (yyss_alloc, yyss);
02201    YYSTACK_RELOCATE (yyvs_alloc, yyvs);
02202    YYSTACK_RELOCATE (yyls_alloc, yyls);
02203 #  undef YYSTACK_RELOCATE
02204    if (yyss1 != yyssa)
02205      YYSTACK_FREE (yyss1);
02206       }
02207 # endif
02208 #endif /* no yyoverflow */
02209 
02210       yyssp = yyss + yysize - 1;
02211       yyvsp = yyvs + yysize - 1;
02212       yylsp = yyls + yysize - 1;
02213 
02214       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
02215         (unsigned long int) yystacksize));
02216 
02217       if (yyss + yystacksize - 1 <= yyssp)
02218    YYABORT;
02219     }
02220 
02221   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
02222 
02223   if (yystate == YYFINAL)
02224     YYACCEPT;
02225 
02226   goto yybackup;
02227 
02228 /*-----------.
02229 | yybackup.  |
02230 `-----------*/
02231 yybackup:
02232 
02233   /* Do appropriate processing given the current state.  Read a
02234      lookahead token if we need one and don't already have one.  */
02235 
02236   /* First try to decide what to do without reference to lookahead token.  */
02237   yyn = yypact[yystate];
02238   if (yypact_value_is_default (yyn))
02239     goto yydefault;
02240 
02241   /* Not known => get a lookahead token if don't already have one.  */
02242 
02243   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
02244   if (yychar == YYEMPTY)
02245     {
02246       YYDPRINTF ((stderr, "Reading a token: "));
02247       yychar = YYLEX;
02248     }
02249 
02250   if (yychar <= YYEOF)
02251     {
02252       yychar = yytoken = YYEOF;
02253       YYDPRINTF ((stderr, "Now at end of input.\n"));
02254     }
02255   else
02256     {
02257       yytoken = YYTRANSLATE (yychar);
02258       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
02259     }
02260 
02261   /* If the proper action on seeing token YYTOKEN is to reduce or to
02262      detect an error, take that action.  */
02263   yyn += yytoken;
02264   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
02265     goto yydefault;
02266   yyn = yytable[yyn];
02267   if (yyn <= 0)
02268     {
02269       if (yytable_value_is_error (yyn))
02270         goto yyerrlab;
02271       yyn = -yyn;
02272       goto yyreduce;
02273     }
02274 
02275   /* Count tokens shifted since error; after three, turn off error
02276      status.  */
02277   if (yyerrstatus)
02278     yyerrstatus--;
02279 
02280   /* Shift the lookahead token.  */
02281   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
02282 
02283   /* Discard the shifted token.  */
02284   yychar = YYEMPTY;
02285 
02286   yystate = yyn;
02287   *++yyvsp = yylval;
02288   *++yylsp = yylloc;
02289   goto yynewstate;
02290 
02291 
02292 /*-----------------------------------------------------------.
02293 | yydefault -- do the default action for the current state.  |
02294 `-----------------------------------------------------------*/
02295 yydefault:
02296   yyn = yydefact[yystate];
02297   if (yyn == 0)
02298     goto yyerrlab;
02299   goto yyreduce;
02300 
02301 
02302 /*-----------------------------.
02303 | yyreduce -- Do a reduction.  |
02304 `-----------------------------*/
02305 yyreduce:
02306   /* yyn is the number of a rule to reduce with.  */
02307   yylen = yyr2[yyn];
02308 
02309   /* If YYLEN is nonzero, implement the default value of the action:
02310      `$$ = $1'.
02311 
02312      Otherwise, the following line sets YYVAL to garbage.
02313      This behavior is undocumented and Bison
02314      users should not rely upon it.  Assigning to YYVAL
02315      unconditionally makes the parser a bit smaller, and it avoids a
02316      GCC warning that YYVAL may be used uninitialized.  */
02317   yyval = yyvsp[1-yylen];
02318 
02319   /* Default location.  */
02320   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
02321   YY_REDUCE_PRINT (yyn);
02322   switch (yyn)
02323     {
02324         case 2:
02325 
02326 /* Line 1806 of yacc.c  */
02327 #line 191 "ael.y"
02328     { (yyval.pval) = parseio->pval = (yyvsp[(1) - (1)].pval); }
02329     break;
02330 
02331   case 3:
02332 
02333 /* Line 1806 of yacc.c  */
02334 #line 194 "ael.y"
02335     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02336     break;
02337 
02338   case 4:
02339 
02340 /* Line 1806 of yacc.c  */
02341 #line 195 "ael.y"
02342     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02343     break;
02344 
02345   case 5:
02346 
02347 /* Line 1806 of yacc.c  */
02348 #line 196 "ael.y"
02349     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
02350     break;
02351 
02352   case 6:
02353 
02354 /* Line 1806 of yacc.c  */
02355 #line 199 "ael.y"
02356     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02357     break;
02358 
02359   case 7:
02360 
02361 /* Line 1806 of yacc.c  */
02362 #line 200 "ael.y"
02363     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02364     break;
02365 
02366   case 8:
02367 
02368 /* Line 1806 of yacc.c  */
02369 #line 201 "ael.y"
02370     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02371     break;
02372 
02373   case 9:
02374 
02375 /* Line 1806 of yacc.c  */
02376 #line 202 "ael.y"
02377     {(yyval.pval)=0;/* allow older docs to be read */}
02378     break;
02379 
02380   case 10:
02381 
02382 /* Line 1806 of yacc.c  */
02383 #line 205 "ael.y"
02384     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02385     break;
02386 
02387   case 11:
02388 
02389 /* Line 1806 of yacc.c  */
02390 #line 206 "ael.y"
02391     { (yyval.str) = strdup("default"); }
02392     break;
02393 
02394   case 12:
02395 
02396 /* Line 1806 of yacc.c  */
02397 #line 209 "ael.y"
02398     {
02399       (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
02400       (yyval.pval)->u1.str = (yyvsp[(3) - (6)].str);
02401       (yyval.pval)->u2.statements = (yyvsp[(5) - (6)].pval);
02402       set_dads((yyval.pval),(yyvsp[(5) - (6)].pval));
02403       (yyval.pval)->u3.abstract = (yyvsp[(1) - (6)].intval);}
02404     break;
02405 
02406   case 13:
02407 
02408 /* Line 1806 of yacc.c  */
02409 #line 218 "ael.y"
02410     { (yyval.intval) = 1; }
02411     break;
02412 
02413   case 14:
02414 
02415 /* Line 1806 of yacc.c  */
02416 #line 219 "ael.y"
02417     { (yyval.intval) = 0; }
02418     break;
02419 
02420   case 15:
02421 
02422 /* Line 1806 of yacc.c  */
02423 #line 220 "ael.y"
02424     { (yyval.intval) = 2; }
02425     break;
02426 
02427   case 16:
02428 
02429 /* Line 1806 of yacc.c  */
02430 #line 221 "ael.y"
02431     { (yyval.intval)=3; }
02432     break;
02433 
02434   case 17:
02435 
02436 /* Line 1806 of yacc.c  */
02437 #line 222 "ael.y"
02438     { (yyval.intval)=3; }
02439     break;
02440 
02441   case 18:
02442 
02443 /* Line 1806 of yacc.c  */
02444 #line 225 "ael.y"
02445     {
02446       (yyval.pval) = npval2(PV_MACRO, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
02447       (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);
02448         set_dads((yyval.pval),(yyvsp[(7) - (8)].pval));}
02449     break;
02450 
02451   case 19:
02452 
02453 /* Line 1806 of yacc.c  */
02454 #line 231 "ael.y"
02455     {
02456       (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02457       (yyval.pval)->u1.statements = (yyvsp[(3) - (4)].pval);
02458         set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
02459     break;
02460 
02461   case 20:
02462 
02463 /* Line 1806 of yacc.c  */
02464 #line 237 "ael.y"
02465     { (yyval.pval) = NULL; }
02466     break;
02467 
02468   case 21:
02469 
02470 /* Line 1806 of yacc.c  */
02471 #line 238 "ael.y"
02472     {(yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02473     break;
02474 
02475   case 22:
02476 
02477 /* Line 1806 of yacc.c  */
02478 #line 239 "ael.y"
02479     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
02480     break;
02481 
02482   case 23:
02483 
02484 /* Line 1806 of yacc.c  */
02485 #line 242 "ael.y"
02486     { reset_semicount(parseio->scanner); }
02487     break;
02488 
02489   case 24:
02490 
02491 /* Line 1806 of yacc.c  */
02492 #line 242 "ael.y"
02493     {
02494       (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
02495       (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
02496       (yyval.pval)->u2.val = (yyvsp[(4) - (5)].str); }
02497     break;
02498 
02499   case 25:
02500 
02501 /* Line 1806 of yacc.c  */
02502 #line 248 "ael.y"
02503     { reset_semicount(parseio->scanner); }
02504     break;
02505 
02506   case 26:
02507 
02508 /* Line 1806 of yacc.c  */
02509 #line 248 "ael.y"
02510     {
02511       (yyval.pval) = npval2(PV_LOCALVARDEC, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
02512       (yyval.pval)->u1.str = (yyvsp[(2) - (6)].str);
02513       (yyval.pval)->u2.val = (yyvsp[(5) - (6)].str); }
02514     break;
02515 
02516   case 27:
02517 
02518 /* Line 1806 of yacc.c  */
02519 #line 255 "ael.y"
02520     { (yyval.pval) = NULL; }
02521     break;
02522 
02523   case 28:
02524 
02525 /* Line 1806 of yacc.c  */
02526 #line 256 "ael.y"
02527     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
02528     break;
02529 
02530   case 29:
02531 
02532 /* Line 1806 of yacc.c  */
02533 #line 257 "ael.y"
02534     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
02535     break;
02536 
02537   case 30:
02538 
02539 /* Line 1806 of yacc.c  */
02540 #line 258 "ael.y"
02541     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
02542     break;
02543 
02544   case 31:
02545 
02546 /* Line 1806 of yacc.c  */
02547 #line 261 "ael.y"
02548     {(yyval.pval)=0;}
02549     break;
02550 
02551   case 32:
02552 
02553 /* Line 1806 of yacc.c  */
02554 #line 262 "ael.y"
02555     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02556     break;
02557 
02558   case 33:
02559 
02560 /* Line 1806 of yacc.c  */
02561 #line 263 "ael.y"
02562     { (yyval.pval)=(yyvsp[(2) - (2)].pval);}
02563     break;
02564 
02565   case 34:
02566 
02567 /* Line 1806 of yacc.c  */
02568 #line 266 "ael.y"
02569     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02570     break;
02571 
02572   case 35:
02573 
02574 /* Line 1806 of yacc.c  */
02575 #line 267 "ael.y"
02576     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02577     break;
02578 
02579   case 36:
02580 
02581 /* Line 1806 of yacc.c  */
02582 #line 268 "ael.y"
02583     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02584     break;
02585 
02586   case 37:
02587 
02588 /* Line 1806 of yacc.c  */
02589 #line 269 "ael.y"
02590     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02591     break;
02592 
02593   case 38:
02594 
02595 /* Line 1806 of yacc.c  */
02596 #line 270 "ael.y"
02597     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02598     break;
02599 
02600   case 39:
02601 
02602 /* Line 1806 of yacc.c  */
02603 #line 271 "ael.y"
02604     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02605     break;
02606 
02607   case 40:
02608 
02609 /* Line 1806 of yacc.c  */
02610 #line 272 "ael.y"
02611     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02612     break;
02613 
02614   case 41:
02615 
02616 /* Line 1806 of yacc.c  */
02617 #line 273 "ael.y"
02618     {free((yyvsp[(1) - (2)].str)); (yyval.pval)=0;}
02619     break;
02620 
02621   case 42:
02622 
02623 /* Line 1806 of yacc.c  */
02624 #line 274 "ael.y"
02625     {(yyval.pval)=0;/* allow older docs to be read */}
02626     break;
02627 
02628   case 43:
02629 
02630 /* Line 1806 of yacc.c  */
02631 #line 277 "ael.y"
02632     {
02633       (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02634       (yyval.pval)->u1.str = (yyvsp[(3) - (4)].str);}
02635     break;
02636 
02637   case 44:
02638 
02639 /* Line 1806 of yacc.c  */
02640 #line 282 "ael.y"
02641     {
02642       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02643       (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
02644       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
02645     break;
02646 
02647   case 45:
02648 
02649 /* Line 1806 of yacc.c  */
02650 #line 286 "ael.y"
02651     {
02652       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (5)]), &(yylsp[(3) - (5)]));
02653       (yyval.pval)->u1.str = malloc(strlen((yyvsp[(1) - (5)].str))+strlen((yyvsp[(3) - (5)].str))+2);
02654       strcpy((yyval.pval)->u1.str,(yyvsp[(1) - (5)].str));
02655       strcat((yyval.pval)->u1.str,"@");
02656       strcat((yyval.pval)->u1.str,(yyvsp[(3) - (5)].str));
02657       free((yyvsp[(1) - (5)].str));
02658       (yyval.pval)->u2.statements = (yyvsp[(5) - (5)].pval); set_dads((yyval.pval),(yyvsp[(5) - (5)].pval));}
02659     break;
02660 
02661   case 46:
02662 
02663 /* Line 1806 of yacc.c  */
02664 #line 294 "ael.y"
02665     {
02666       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02667       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
02668       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));
02669       (yyval.pval)->u4.regexten=1;}
02670     break;
02671 
02672   case 47:
02673 
02674 /* Line 1806 of yacc.c  */
02675 #line 299 "ael.y"
02676     {
02677       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (7)]), &(yylsp[(7) - (7)]));
02678       (yyval.pval)->u1.str = (yyvsp[(5) - (7)].str);
02679       (yyval.pval)->u2.statements = (yyvsp[(7) - (7)].pval); set_dads((yyval.pval),(yyvsp[(7) - (7)].pval));
02680       (yyval.pval)->u3.hints = (yyvsp[(3) - (7)].str);}
02681     break;
02682 
02683   case 48:
02684 
02685 /* Line 1806 of yacc.c  */
02686 #line 304 "ael.y"
02687     {
02688       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
02689       (yyval.pval)->u1.str = (yyvsp[(6) - (8)].str);
02690       (yyval.pval)->u2.statements = (yyvsp[(8) - (8)].pval); set_dads((yyval.pval),(yyvsp[(8) - (8)].pval));
02691       (yyval.pval)->u4.regexten=1;
02692       (yyval.pval)->u3.hints = (yyvsp[(4) - (8)].str);}
02693     break;
02694 
02695   case 49:
02696 
02697 /* Line 1806 of yacc.c  */
02698 #line 313 "ael.y"
02699     { (yyval.pval) = NULL; }
02700     break;
02701 
02702   case 50:
02703 
02704 /* Line 1806 of yacc.c  */
02705 #line 314 "ael.y"
02706     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02707     break;
02708 
02709   case 51:
02710 
02711 /* Line 1806 of yacc.c  */
02712 #line 315 "ael.y"
02713     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
02714     break;
02715 
02716   case 52:
02717 
02718 /* Line 1806 of yacc.c  */
02719 #line 321 "ael.y"
02720     {
02721       if (asprintf(&(yyval.str), "%s:%s:%s", (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)) < 0) {
02722          ast_log(LOG_WARNING, "asprintf() failed\n");
02723          (yyval.str) = NULL;
02724       } else {
02725          free((yyvsp[(1) - (5)].str));
02726          free((yyvsp[(3) - (5)].str));
02727          free((yyvsp[(5) - (5)].str));
02728       }
02729    }
02730     break;
02731 
02732   case 53:
02733 
02734 /* Line 1806 of yacc.c  */
02735 #line 331 "ael.y"
02736     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02737     break;
02738 
02739   case 54:
02740 
02741 /* Line 1806 of yacc.c  */
02742 #line 335 "ael.y"
02743     {
02744       (yyval.pval) = nword((yyvsp[(1) - (7)].str), &(yylsp[(1) - (7)]));
02745       (yyval.pval)->next = nword((yyvsp[(3) - (7)].str), &(yylsp[(3) - (7)]));
02746       (yyval.pval)->next->next = nword((yyvsp[(5) - (7)].str), &(yylsp[(5) - (7)]));
02747       (yyval.pval)->next->next->next = nword((yyvsp[(7) - (7)].str), &(yylsp[(7) - (7)])); }
02748     break;
02749 
02750   case 55:
02751 
02752 /* Line 1806 of yacc.c  */
02753 #line 343 "ael.y"
02754     { reset_parencount(parseio->scanner); }
02755     break;
02756 
02757   case 56:
02758 
02759 /* Line 1806 of yacc.c  */
02760 #line 343 "ael.y"
02761     { (yyval.str) = (yyvsp[(3) - (4)].str); }
02762     break;
02763 
02764   case 57:
02765 
02766 /* Line 1806 of yacc.c  */
02767 #line 347 "ael.y"
02768     {
02769       (yyval.pval)= npval2(PV_IF, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
02770       (yyval.pval)->u1.str = (yyvsp[(2) - (2)].str); }
02771     break;
02772 
02773   case 58:
02774 
02775 /* Line 1806 of yacc.c  */
02776 #line 350 "ael.y"
02777     {
02778       (yyval.pval) = npval2(PV_RANDOM, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
02779       (yyval.pval)->u1.str=(yyvsp[(2) - (2)].str);}
02780     break;
02781 
02782   case 59:
02783 
02784 /* Line 1806 of yacc.c  */
02785 #line 353 "ael.y"
02786     {
02787       (yyval.pval) = npval2(PV_IFTIME, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02788       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);
02789       prev_word = 0; }
02790     break;
02791 
02792   case 60:
02793 
02794 /* Line 1806 of yacc.c  */
02795 #line 364 "ael.y"
02796     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02797     break;
02798 
02799   case 61:
02800 
02801 /* Line 1806 of yacc.c  */
02802 #line 365 "ael.y"
02803     {
02804       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02805          ast_log(LOG_WARNING, "asprintf() failed\n");
02806          (yyval.str) = NULL;
02807       } else {
02808          free((yyvsp[(1) - (2)].str));
02809          free((yyvsp[(2) - (2)].str));
02810          prev_word = (yyval.str);
02811       }
02812    }
02813     break;
02814 
02815   case 62:
02816 
02817 /* Line 1806 of yacc.c  */
02818 #line 377 "ael.y"
02819     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02820     break;
02821 
02822   case 63:
02823 
02824 /* Line 1806 of yacc.c  */
02825 #line 378 "ael.y"
02826     {
02827       if (asprintf(&((yyval.str)), "%s %s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02828          ast_log(LOG_WARNING, "asprintf() failed\n");
02829          (yyval.str) = NULL;
02830       } else {
02831          free((yyvsp[(1) - (2)].str));
02832          free((yyvsp[(2) - (2)].str));
02833       }
02834    }
02835     break;
02836 
02837   case 64:
02838 
02839 /* Line 1806 of yacc.c  */
02840 #line 387 "ael.y"
02841     {
02842       if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02843          ast_log(LOG_WARNING, "asprintf() failed\n");
02844          (yyval.str) = NULL;
02845       } else {
02846          free((yyvsp[(1) - (3)].str));
02847          free((yyvsp[(3) - (3)].str));
02848       }
02849    }
02850     break;
02851 
02852   case 65:
02853 
02854 /* Line 1806 of yacc.c  */
02855 #line 396 "ael.y"
02856     {  /* there are often '&' in hints */
02857       if (asprintf(&((yyval.str)), "%s&%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02858          ast_log(LOG_WARNING, "asprintf() failed\n");
02859          (yyval.str) = NULL;
02860       } else {
02861          free((yyvsp[(1) - (3)].str));
02862          free((yyvsp[(3) - (3)].str));
02863       }
02864    }
02865     break;
02866 
02867   case 66:
02868 
02869 /* Line 1806 of yacc.c  */
02870 #line 405 "ael.y"
02871     {
02872       if (asprintf(&((yyval.str)), "%s@%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02873          ast_log(LOG_WARNING, "asprintf() failed\n");
02874          (yyval.str) = NULL;
02875       } else {
02876          free((yyvsp[(1) - (3)].str));
02877          free((yyvsp[(3) - (3)].str));
02878       }
02879    }
02880     break;
02881 
02882   case 67:
02883 
02884 /* Line 1806 of yacc.c  */
02885 #line 416 "ael.y"
02886     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02887     break;
02888 
02889   case 68:
02890 
02891 /* Line 1806 of yacc.c  */
02892 #line 417 "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          prev_word = (yyval.str);
02901       }        
02902    }
02903     break;
02904 
02905   case 69:
02906 
02907 /* Line 1806 of yacc.c  */
02908 #line 427 "ael.y"
02909     {
02910       if (asprintf(&((yyval.str)), "%s%s%s", (yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02911          ast_log(LOG_WARNING, "asprintf() failed\n");
02912          (yyval.str) = NULL;
02913       } else {
02914          free((yyvsp[(1) - (3)].str));
02915          free((yyvsp[(2) - (3)].str));
02916          free((yyvsp[(3) - (3)].str));
02917          prev_word=(yyval.str);
02918       }
02919    }
02920     break;
02921 
02922   case 70:
02923 
02924 /* Line 1806 of yacc.c  */
02925 #line 440 "ael.y"
02926     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02927     break;
02928 
02929   case 71:
02930 
02931 /* Line 1806 of yacc.c  */
02932 #line 441 "ael.y"
02933     {
02934       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02935          ast_log(LOG_WARNING, "asprintf() failed\n");
02936          (yyval.str) = NULL;
02937       } else {
02938          free((yyvsp[(1) - (2)].str));
02939          free((yyvsp[(2) - (2)].str));
02940       }
02941    }
02942     break;
02943 
02944   case 72:
02945 
02946 /* Line 1806 of yacc.c  */
02947 #line 450 "ael.y"
02948     {
02949       if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02950          ast_log(LOG_WARNING, "asprintf() failed\n");
02951          (yyval.str) = NULL;
02952       } else {
02953          free((yyvsp[(1) - (3)].str));
02954          free((yyvsp[(3) - (3)].str));
02955       }
02956    }
02957     break;
02958 
02959   case 73:
02960 
02961 /* Line 1806 of yacc.c  */
02962 #line 461 "ael.y"
02963     {
02964       (yyval.pval) = npval2(PV_SWITCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
02965       (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
02966       (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
02967     break;
02968 
02969   case 74:
02970 
02971 /* Line 1806 of yacc.c  */
02972 #line 470 "ael.y"
02973     {
02974       (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02975       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));}
02976     break;
02977 
02978   case 75:
02979 
02980 /* Line 1806 of yacc.c  */
02981 #line 473 "ael.y"
02982     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
02983     break;
02984 
02985   case 76:
02986 
02987 /* Line 1806 of yacc.c  */
02988 #line 474 "ael.y"
02989     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
02990     break;
02991 
02992   case 77:
02993 
02994 /* Line 1806 of yacc.c  */
02995 #line 475 "ael.y"
02996     {
02997       (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02998       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
02999     break;
03000 
03001   case 78:
03002 
03003 /* Line 1806 of yacc.c  */
03004 #line 478 "ael.y"
03005     {
03006       (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03007       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
03008     break;
03009 
03010   case 79:
03011 
03012 /* Line 1806 of yacc.c  */
03013 #line 481 "ael.y"
03014     {
03015       (yyval.pval) = npval2(PV_LABEL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
03016       (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str); }
03017     break;
03018 
03019   case 80:
03020 
03021 /* Line 1806 of yacc.c  */
03022 #line 484 "ael.y"
03023     {reset_semicount(parseio->scanner);}
03024     break;
03025 
03026   case 81:
03027 
03028 /* Line 1806 of yacc.c  */
03029 #line 485 "ael.y"
03030     {reset_semicount(parseio->scanner);}
03031     break;
03032 
03033   case 82:
03034 
03035 /* Line 1806 of yacc.c  */
03036 #line 486 "ael.y"
03037     {reset_parencount(parseio->scanner);}
03038     break;
03039 
03040   case 83:
03041 
03042 /* Line 1806 of yacc.c  */
03043 #line 486 "ael.y"
03044     { /* XXX word_list maybe ? */
03045       (yyval.pval) = npval2(PV_FOR, &(yylsp[(1) - (12)]), &(yylsp[(12) - (12)]));
03046       (yyval.pval)->u1.for_init = (yyvsp[(4) - (12)].str);
03047       (yyval.pval)->u2.for_test=(yyvsp[(7) - (12)].str);
03048       (yyval.pval)->u3.for_inc = (yyvsp[(10) - (12)].str);
03049       (yyval.pval)->u4.for_statements = (yyvsp[(12) - (12)].pval); set_dads((yyval.pval),(yyvsp[(12) - (12)].pval));}
03050     break;
03051 
03052   case 84:
03053 
03054 /* Line 1806 of yacc.c  */
03055 #line 492 "ael.y"
03056     {
03057       (yyval.pval) = npval2(PV_WHILE, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03058       (yyval.pval)->u1.str = (yyvsp[(2) - (3)].str);
03059       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03060     break;
03061 
03062   case 85:
03063 
03064 /* Line 1806 of yacc.c  */
03065 #line 496 "ael.y"
03066     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
03067     break;
03068 
03069   case 86:
03070 
03071 /* Line 1806 of yacc.c  */
03072 #line 497 "ael.y"
03073     { (yyval.pval) = update_last((yyvsp[(2) - (3)].pval), &(yylsp[(2) - (3)])); }
03074     break;
03075 
03076   case 87:
03077 
03078 /* Line 1806 of yacc.c  */
03079 #line 498 "ael.y"
03080     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
03081     break;
03082 
03083   case 88:
03084 
03085 /* Line 1806 of yacc.c  */
03086 #line 499 "ael.y"
03087     {
03088       (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
03089       (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str);}
03090     break;
03091 
03092   case 89:
03093 
03094 /* Line 1806 of yacc.c  */
03095 #line 502 "ael.y"
03096     {reset_semicount(parseio->scanner);}
03097     break;
03098 
03099   case 90:
03100 
03101 /* Line 1806 of yacc.c  */
03102 #line 502 "ael.y"
03103     {
03104       char *bufx;
03105       int tot=0;
03106       pval *pptr;
03107       (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03108       (yyval.pval)->u2.val=(yyvsp[(4) - (5)].str);
03109       /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
03110       /* string to big to fit in the buffer? */
03111       tot+=strlen((yyvsp[(1) - (5)].pval)->u1.str);
03112       for(pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
03113          tot+=strlen(pptr->u1.str);
03114          tot++; /* for a sep like a comma */
03115       }
03116       tot+=4; /* for safety */
03117       bufx = calloc(1, tot);
03118       strcpy(bufx,(yyvsp[(1) - (5)].pval)->u1.str);
03119       strcat(bufx,"(");
03120       /* XXX need to advance the pointer or the loop is very inefficient */
03121       for (pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
03122          if ( pptr != (yyvsp[(1) - (5)].pval)->u2.arglist )
03123             strcat(bufx,",");
03124          strcat(bufx,pptr->u1.str);
03125       }
03126       strcat(bufx,")");
03127 #ifdef AAL_ARGCHECK
03128       if ( !ael_is_funcname((yyvsp[(1) - (5)].pval)->u1.str) )
03129          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",
03130             my_file, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column, (yylsp[(1) - (5)]).last_column, (yyvsp[(1) - (5)].pval)->u1.str);
03131 #endif
03132       (yyval.pval)->u1.str = bufx;
03133       destroy_pval((yyvsp[(1) - (5)].pval)); /* the app call it is not, get rid of that chain */
03134       prev_word = 0;
03135    }
03136     break;
03137 
03138   case 91:
03139 
03140 /* Line 1806 of yacc.c  */
03141 #line 535 "ael.y"
03142     { (yyval.pval) = npval2(PV_BREAK, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03143     break;
03144 
03145   case 92:
03146 
03147 /* Line 1806 of yacc.c  */
03148 #line 536 "ael.y"
03149     { (yyval.pval) = npval2(PV_RETURN, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03150     break;
03151 
03152   case 93:
03153 
03154 /* Line 1806 of yacc.c  */
03155 #line 537 "ael.y"
03156     { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03157     break;
03158 
03159   case 94:
03160 
03161 /* Line 1806 of yacc.c  */
03162 #line 538 "ael.y"
03163     {
03164       (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(2) - (3)]));
03165       (yyval.pval)->u2.statements = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));
03166       (yyval.pval)->u3.else_statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03167     break;
03168 
03169   case 95:
03170 
03171 /* Line 1806 of yacc.c  */
03172 #line 542 "ael.y"
03173     { (yyval.pval)=0; }
03174     break;
03175 
03176   case 96:
03177 
03178 /* Line 1806 of yacc.c  */
03179 #line 545 "ael.y"
03180     { (yyval.pval) = (yyvsp[(2) - (2)].pval); }
03181     break;
03182 
03183   case 97:
03184 
03185 /* Line 1806 of yacc.c  */
03186 #line 546 "ael.y"
03187     { (yyval.pval) = NULL ; }
03188     break;
03189 
03190   case 98:
03191 
03192 /* Line 1806 of yacc.c  */
03193 #line 549 "ael.y"
03194     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03195     break;
03196 
03197   case 99:
03198 
03199 /* Line 1806 of yacc.c  */
03200 #line 550 "ael.y"
03201     {
03202       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03203       (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
03204     break;
03205 
03206   case 100:
03207 
03208 /* Line 1806 of yacc.c  */
03209 #line 553 "ael.y"
03210     {
03211       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03212       (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
03213     break;
03214 
03215   case 101:
03216 
03217 /* Line 1806 of yacc.c  */
03218 #line 556 "ael.y"
03219     {
03220       (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
03221       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03222       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03223     break;
03224 
03225   case 102:
03226 
03227 /* Line 1806 of yacc.c  */
03228 #line 560 "ael.y"
03229     {
03230       (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
03231       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03232       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03233     break;
03234 
03235   case 103:
03236 
03237 /* Line 1806 of yacc.c  */
03238 #line 564 "ael.y"
03239     {
03240       (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
03241       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03242       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03243     break;
03244 
03245   case 104:
03246 
03247 /* Line 1806 of yacc.c  */
03248 #line 568 "ael.y"
03249     {
03250       (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
03251       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03252       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03253     break;
03254 
03255   case 105:
03256 
03257 /* Line 1806 of yacc.c  */
03258 #line 574 "ael.y"
03259     { (yyval.str) = strdup("1"); }
03260     break;
03261 
03262   case 106:
03263 
03264 /* Line 1806 of yacc.c  */
03265 #line 575 "ael.y"
03266     { (yyval.str) = (yyvsp[(2) - (2)].str); }
03267     break;
03268 
03269   case 107:
03270 
03271 /* Line 1806 of yacc.c  */
03272 #line 579 "ael.y"
03273     {       /* ext[, pri] default 1 */
03274       (yyval.pval) = nword((yyvsp[(1) - (2)].str), &(yylsp[(1) - (2)]));
03275       (yyval.pval)->next = nword((yyvsp[(2) - (2)].str), &(yylsp[(2) - (2)])); }
03276     break;
03277 
03278   case 108:
03279 
03280 /* Line 1806 of yacc.c  */
03281 #line 582 "ael.y"
03282     { /* context, ext, pri */
03283       (yyval.pval) = nword((yyvsp[(4) - (4)].str), &(yylsp[(4) - (4)]));
03284       (yyval.pval)->next = nword((yyvsp[(1) - (4)].str), &(yylsp[(1) - (4)]));
03285       (yyval.pval)->next->next = nword((yyvsp[(2) - (4)].str), &(yylsp[(2) - (4)])); }
03286     break;
03287 
03288   case 109:
03289 
03290 /* Line 1806 of yacc.c  */
03291 #line 588 "ael.y"
03292     {reset_argcount(parseio->scanner);}
03293     break;
03294 
03295   case 110:
03296 
03297 /* Line 1806 of yacc.c  */
03298 #line 588 "ael.y"
03299     {
03300       /* XXX original code had @2 but i think we need @5 */
03301       (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03302       (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
03303       (yyval.pval)->u2.arglist = (yyvsp[(4) - (5)].pval);}
03304     break;
03305 
03306   case 111:
03307 
03308 /* Line 1806 of yacc.c  */
03309 #line 593 "ael.y"
03310     {
03311       (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03312       (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); }
03313     break;
03314 
03315   case 112:
03316 
03317 /* Line 1806 of yacc.c  */
03318 #line 601 "ael.y"
03319     {reset_argcount(parseio->scanner);}
03320     break;
03321 
03322   case 113:
03323 
03324 /* Line 1806 of yacc.c  */
03325 #line 601 "ael.y"
03326     {
03327       if (strcasecmp((yyvsp[(1) - (3)].str),"goto") == 0) {
03328          (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
03329          free((yyvsp[(1) - (3)].str)); /* won't be using this */
03330          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 );
03331       } else {
03332          (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
03333          (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
03334       } }
03335     break;
03336 
03337   case 114:
03338 
03339 /* Line 1806 of yacc.c  */
03340 #line 612 "ael.y"
03341     {
03342       (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(3) - (3)]));
03343       if( (yyval.pval)->type == PV_GOTO )
03344          (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);
03345       else
03346          (yyval.pval)->u2.arglist = (yyvsp[(2) - (3)].pval);
03347    }
03348     break;
03349 
03350   case 115:
03351 
03352 /* Line 1806 of yacc.c  */
03353 #line 619 "ael.y"
03354     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
03355     break;
03356 
03357   case 116:
03358 
03359 /* Line 1806 of yacc.c  */
03360 #line 622 "ael.y"
03361     { (yyval.str) = (yyvsp[(1) - (1)].str) ;}
03362     break;
03363 
03364   case 117:
03365 
03366 /* Line 1806 of yacc.c  */
03367 #line 623 "ael.y"
03368     { (yyval.str) = strdup(""); }
03369     break;
03370 
03371   case 118:
03372 
03373 /* Line 1806 of yacc.c  */
03374 #line 626 "ael.y"
03375     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03376     break;
03377 
03378   case 119:
03379 
03380 /* Line 1806 of yacc.c  */
03381 #line 627 "ael.y"
03382     {
03383       (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
03384       (yyval.pval)->u1.str = strdup(""); }
03385     break;
03386 
03387   case 120:
03388 
03389 /* Line 1806 of yacc.c  */
03390 #line 630 "ael.y"
03391     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
03392     break;
03393 
03394   case 121:
03395 
03396 /* Line 1806 of yacc.c  */
03397 #line 633 "ael.y"
03398     { (yyval.pval) = NULL; }
03399     break;
03400 
03401   case 122:
03402 
03403 /* Line 1806 of yacc.c  */
03404 #line 634 "ael.y"
03405     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
03406     break;
03407 
03408   case 123:
03409 
03410 /* Line 1806 of yacc.c  */
03411 #line 637 "ael.y"
03412     {
03413       (yyval.pval) = npval2(PV_CASE, &(yylsp[(1) - (4)]), &(yylsp[(3) - (4)])); /* XXX 3 or 4 ? */
03414       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
03415       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
03416     break;
03417 
03418   case 124:
03419 
03420 /* Line 1806 of yacc.c  */
03421 #line 641 "ael.y"
03422     {
03423       (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03424       (yyval.pval)->u1.str = NULL;
03425       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03426     break;
03427 
03428   case 125:
03429 
03430 /* Line 1806 of yacc.c  */
03431 #line 645 "ael.y"
03432     {
03433       (yyval.pval) = npval2(PV_PATTERN, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); /* XXX@3 or @4 ? */
03434       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
03435       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval);set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
03436     break;
03437 
03438   case 126:
03439 
03440 /* Line 1806 of yacc.c  */
03441 #line 651 "ael.y"
03442     { (yyval.pval) = NULL; }
03443     break;
03444 
03445   case 127:
03446 
03447 /* Line 1806 of yacc.c  */
03448 #line 652 "ael.y"
03449     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
03450     break;
03451 
03452   case 128:
03453 
03454 /* Line 1806 of yacc.c  */
03455 #line 655 "ael.y"
03456     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
03457     break;
03458 
03459   case 129:
03460 
03461 /* Line 1806 of yacc.c  */
03462 #line 656 "ael.y"
03463     { (yyval.pval)=(yyvsp[(1) - (1)].pval);}
03464     break;
03465 
03466   case 130:
03467 
03468 /* Line 1806 of yacc.c  */
03469 #line 657 "ael.y"
03470     {
03471       (yyval.pval) = npval2(PV_CATCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03472       (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
03473       (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
03474     break;
03475 
03476   case 131:
03477 
03478 /* Line 1806 of yacc.c  */
03479 #line 663 "ael.y"
03480     {
03481       (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
03482       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03483     break;
03484 
03485   case 132:
03486 
03487 /* Line 1806 of yacc.c  */
03488 #line 668 "ael.y"
03489     {
03490       (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
03491       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03492     break;
03493 
03494   case 133:
03495 
03496 /* Line 1806 of yacc.c  */
03497 #line 673 "ael.y"
03498     { (yyval.pval) = NULL; }
03499     break;
03500 
03501   case 134:
03502 
03503 /* Line 1806 of yacc.c  */
03504 #line 674 "ael.y"
03505     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval),nword((yyvsp[(2) - (3)].str), &(yylsp[(2) - (3)]))); }
03506     break;
03507 
03508   case 135:
03509 
03510 /* Line 1806 of yacc.c  */
03511 #line 675 "ael.y"
03512     {
03513      char *x;
03514      if (asprintf(&x,"%s@%s", (yyvsp[(2) - (5)].str), (yyvsp[(4) - (5)].str)) < 0) {
03515       ast_log(LOG_WARNING, "asprintf() failed\n");
03516       (yyval.pval) = NULL;
03517      } else {
03518       free((yyvsp[(2) - (5)].str));
03519       free((yyvsp[(4) - (5)].str));
03520       (yyval.pval) = linku1((yyvsp[(1) - (5)].pval),nword(x, &(yylsp[(2) - (5)])));
03521      }
03522    }
03523     break;
03524 
03525   case 136:
03526 
03527 /* Line 1806 of yacc.c  */
03528 #line 686 "ael.y"
03529     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
03530     break;
03531 
03532   case 137:
03533 
03534 /* Line 1806 of yacc.c  */
03535 #line 689 "ael.y"
03536     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03537     break;
03538 
03539   case 138:
03540 
03541 /* Line 1806 of yacc.c  */
03542 #line 690 "ael.y"
03543     {
03544       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03545       (yyval.pval)->u2.arglist = (yyvsp[(3) - (3)].pval);
03546       prev_word=0; /* XXX sure ? */ }
03547     break;
03548 
03549   case 139:
03550 
03551 /* Line 1806 of yacc.c  */
03552 #line 697 "ael.y"
03553     { (yyval.pval) = (yyvsp[(1) - (2)].pval); }
03554     break;
03555 
03556   case 140:
03557 
03558 /* Line 1806 of yacc.c  */
03559 #line 698 "ael.y"
03560     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), (yyvsp[(2) - (3)].pval)); }
03561     break;
03562 
03563   case 141:
03564 
03565 /* Line 1806 of yacc.c  */
03566 #line 699 "ael.y"
03567     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
03568     break;
03569 
03570   case 142:
03571 
03572 /* Line 1806 of yacc.c  */
03573 #line 702 "ael.y"
03574     {
03575       (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
03576       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03577     break;
03578 
03579   case 143:
03580 
03581 /* Line 1806 of yacc.c  */
03582 #line 705 "ael.y"
03583     {
03584       (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));}
03585     break;
03586 
03587 
03588 
03589 /* Line 1806 of yacc.c  */
03590 #line 3590 "ael.tab.c"
03591       default: break;
03592     }
03593   /* User semantic actions sometimes alter yychar, and that requires
03594      that yytoken be updated with the new translation.  We take the
03595      approach of translating immediately before every use of yytoken.
03596      One alternative is translating here after every semantic action,
03597      but that translation would be missed if the semantic action invokes
03598      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
03599      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
03600      incorrect destructor might then be invoked immediately.  In the
03601      case of YYERROR or YYBACKUP, subsequent parser actions might lead
03602      to an incorrect destructor call or verbose syntax error message
03603      before the lookahead is translated.  */
03604   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
03605 
03606   YYPOPSTACK (yylen);
03607   yylen = 0;
03608   YY_STACK_PRINT (yyss, yyssp);
03609 
03610   *++yyvsp = yyval;
03611   *++yylsp = yyloc;
03612 
03613   /* Now `shift' the result of the reduction.  Determine what state
03614      that goes to, based on the state we popped back to and the rule
03615      number reduced by.  */
03616 
03617   yyn = yyr1[yyn];
03618 
03619   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
03620   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
03621     yystate = yytable[yystate];
03622   else
03623     yystate = yydefgoto[yyn - YYNTOKENS];
03624 
03625   goto yynewstate;
03626 
03627 
03628 /*------------------------------------.
03629 | yyerrlab -- here on detecting error |
03630 `------------------------------------*/
03631 yyerrlab:
03632   /* Make sure we have latest lookahead translation.  See comments at
03633      user semantic actions for why this is necessary.  */
03634   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
03635 
03636   /* If not already recovering from an error, report this error.  */
03637   if (!yyerrstatus)
03638     {
03639       ++yynerrs;
03640 #if ! YYERROR_VERBOSE
03641       yyerror (&yylloc, parseio, YY_("syntax error"));
03642 #else
03643 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
03644                                         yyssp, yytoken)
03645       {
03646         char const *yymsgp = YY_("syntax error");
03647         int yysyntax_error_status;
03648         yysyntax_error_status = YYSYNTAX_ERROR;
03649         if (yysyntax_error_status == 0)
03650           yymsgp = yymsg;
03651         else if (yysyntax_error_status == 1)
03652           {
03653             if (yymsg != yymsgbuf)
03654               YYSTACK_FREE (yymsg);
03655             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
03656             if (!yymsg)
03657               {
03658                 yymsg = yymsgbuf;
03659                 yymsg_alloc = sizeof yymsgbuf;
03660                 yysyntax_error_status = 2;
03661               }
03662             else
03663               {
03664                 yysyntax_error_status = YYSYNTAX_ERROR;
03665                 yymsgp = yymsg;
03666               }
03667           }
03668         yyerror (&yylloc, parseio, yymsgp);
03669         if (yysyntax_error_status == 2)
03670           goto yyexhaustedlab;
03671       }
03672 # undef YYSYNTAX_ERROR
03673 #endif
03674     }
03675 
03676   yyerror_range[1] = yylloc;
03677 
03678   if (yyerrstatus == 3)
03679     {
03680       /* If just tried and failed to reuse lookahead token after an
03681     error, discard it.  */
03682 
03683       if (yychar <= YYEOF)
03684    {
03685      /* Return failure if at end of input.  */
03686      if (yychar == YYEOF)
03687        YYABORT;
03688    }
03689       else
03690    {
03691      yydestruct ("Error: discarding",
03692             yytoken, &yylval, &yylloc, parseio);
03693      yychar = YYEMPTY;
03694    }
03695     }
03696 
03697   /* Else will try to reuse lookahead token after shifting the error
03698      token.  */
03699   goto yyerrlab1;
03700 
03701 
03702 /*---------------------------------------------------.
03703 | yyerrorlab -- error raised explicitly by YYERROR.  |
03704 `---------------------------------------------------*/
03705 yyerrorlab:
03706 
03707   /* Pacify compilers like GCC when the user code never invokes
03708      YYERROR and the label yyerrorlab therefore never appears in user
03709      code.  */
03710   if (/*CONSTCOND*/ 0)
03711      goto yyerrorlab;
03712 
03713   yyerror_range[1] = yylsp[1-yylen];
03714   /* Do not reclaim the symbols of the rule which action triggered
03715      this YYERROR.  */
03716   YYPOPSTACK (yylen);
03717   yylen = 0;
03718   YY_STACK_PRINT (yyss, yyssp);
03719   yystate = *yyssp;
03720   goto yyerrlab1;
03721 
03722 
03723 /*-------------------------------------------------------------.
03724 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
03725 `-------------------------------------------------------------*/
03726 yyerrlab1:
03727   yyerrstatus = 3;   /* Each real token shifted decrements this.  */
03728 
03729   for (;;)
03730     {
03731       yyn = yypact[yystate];
03732       if (!yypact_value_is_default (yyn))
03733    {
03734      yyn += YYTERROR;
03735      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
03736        {
03737          yyn = yytable[yyn];
03738          if (0 < yyn)
03739       break;
03740        }
03741    }
03742 
03743       /* Pop the current state because it cannot handle the error token.  */
03744       if (yyssp == yyss)
03745    YYABORT;
03746 
03747       yyerror_range[1] = *yylsp;
03748       yydestruct ("Error: popping",
03749         yystos[yystate], yyvsp, yylsp, parseio);
03750       YYPOPSTACK (1);
03751       yystate = *yyssp;
03752       YY_STACK_PRINT (yyss, yyssp);
03753     }
03754 
03755   *++yyvsp = yylval;
03756 
03757   yyerror_range[2] = yylloc;
03758   /* Using YYLLOC is tempting, but would change the location of
03759      the lookahead.  YYLOC is available though.  */
03760   YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
03761   *++yylsp = yyloc;
03762 
03763   /* Shift the error token.  */
03764   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
03765 
03766   yystate = yyn;
03767   goto yynewstate;
03768 
03769 
03770 /*-------------------------------------.
03771 | yyacceptlab -- YYACCEPT comes here.  |
03772 `-------------------------------------*/
03773 yyacceptlab:
03774   yyresult = 0;
03775   goto yyreturn;
03776 
03777 /*-----------------------------------.
03778 | yyabortlab -- YYABORT comes here.  |
03779 `-----------------------------------*/
03780 yyabortlab:
03781   yyresult = 1;
03782   goto yyreturn;
03783 
03784 #if !defined(yyoverflow) || YYERROR_VERBOSE
03785 /*-------------------------------------------------.
03786 | yyexhaustedlab -- memory exhaustion comes here.  |
03787 `-------------------------------------------------*/
03788 yyexhaustedlab:
03789   yyerror (&yylloc, parseio, YY_("memory exhausted"));
03790   yyresult = 2;
03791   /* Fall through.  */
03792 #endif
03793 
03794 yyreturn:
03795   if (yychar != YYEMPTY)
03796     {
03797       /* Make sure we have latest lookahead translation.  See comments at
03798          user semantic actions for why this is necessary.  */
03799       yytoken = YYTRANSLATE (yychar);
03800       yydestruct ("Cleanup: discarding lookahead",
03801                   yytoken, &yylval, &yylloc, parseio);
03802     }
03803   /* Do not reclaim the symbols of the rule which action triggered
03804      this YYABORT or YYACCEPT.  */
03805   YYPOPSTACK (yylen);
03806   YY_STACK_PRINT (yyss, yyssp);
03807   while (yyssp != yyss)
03808     {
03809       yydestruct ("Cleanup: popping",
03810         yystos[*yyssp], yyvsp, yylsp, parseio);
03811       YYPOPSTACK (1);
03812     }
03813 #ifndef yyoverflow
03814   if (yyss != yyssa)
03815     YYSTACK_FREE (yyss);
03816 #endif
03817 #if YYERROR_VERBOSE
03818   if (yymsg != yymsgbuf)
03819     YYSTACK_FREE (yymsg);
03820 #endif
03821   /* Make sure YYID is used.  */
03822   return YYID (yyresult);
03823 }

int yyparse (  ) 

static char* yystpcpy ( char *  yydest,
const char *  yysrc 
) [static]

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

01273 {
01274   char *yyd = yydest;
01275   const char *yys = yysrc;
01276 
01277   while ((*yyd++ = *yys++) != '\0')
01278     continue;
01279 
01280   return yyd - 1;
01281 }

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

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

References YYSIZE_T.

01248 {
01249   YYSIZE_T yylen;
01250   for (yylen = 0; yystr[yylen]; yylen++)
01251     continue;
01252   return yylen;
01253 }

static int yysyntax_error ( YYSIZE_T *  yymsg_alloc,
char **  yymsg,
yytype_int16 yyssp,
int  yytoken 
) [static]

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

References YY_, YYCASE_, YYEMPTY, YYLAST, YYNTOKENS, yypact_value_is_default, YYSIZE_T, YYSTACK_ALLOC_MAXIMUM, yystrlen(), yytable_value_is_error, YYTERROR, and yytnamerr().

01344 {
01345   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
01346   YYSIZE_T yysize = yysize0;
01347   YYSIZE_T yysize1;
01348   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01349   /* Internationalized format string. */
01350   const char *yyformat = 0;
01351   /* Arguments of yyformat. */
01352   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01353   /* Number of reported tokens (one for the "unexpected", one per
01354      "expected"). */
01355   int yycount = 0;
01356 
01357   /* There are many possibilities here to consider:
01358      - Assume YYFAIL is not used.  It's too flawed to consider.  See
01359        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
01360        for details.  YYERROR is fine as it does not invoke this
01361        function.
01362      - If this state is a consistent state with a default action, then
01363        the only way this function was invoked is if the default action
01364        is an error action.  In that case, don't check for expected
01365        tokens because there are none.
01366      - The only way there can be no lookahead present (in yychar) is if
01367        this state is a consistent state with a default action.  Thus,
01368        detecting the absence of a lookahead is sufficient to determine
01369        that there is no unexpected or expected token to report.  In that
01370        case, just report a simple "syntax error".
01371      - Don't assume there isn't a lookahead just because this state is a
01372        consistent state with a default action.  There might have been a
01373        previous inconsistent state, consistent state with a non-default
01374        action, or user semantic action that manipulated yychar.
01375      - Of course, the expected token list depends on states to have
01376        correct lookahead information, and it depends on the parser not
01377        to perform extra reductions after fetching a lookahead from the
01378        scanner and before detecting a syntax error.  Thus, state merging
01379        (from LALR or IELR) and default reductions corrupt the expected
01380        token list.  However, the list is correct for canonical LR with
01381        one exception: it will still contain any token that will not be
01382        accepted due to an error action in a later state.
01383   */
01384   if (yytoken != YYEMPTY)
01385     {
01386       int yyn = yypact[*yyssp];
01387       yyarg[yycount++] = yytname[yytoken];
01388       if (!yypact_value_is_default (yyn))
01389         {
01390           /* Start YYX at -YYN if negative to avoid negative indexes in
01391              YYCHECK.  In other words, skip the first -YYN actions for
01392              this state because they are default actions.  */
01393           int yyxbegin = yyn < 0 ? -yyn : 0;
01394           /* Stay within bounds of both yycheck and yytname.  */
01395           int yychecklim = YYLAST - yyn + 1;
01396           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01397           int yyx;
01398 
01399           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01400             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
01401                 && !yytable_value_is_error (yytable[yyx + yyn]))
01402               {
01403                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01404                   {
01405                     yycount = 1;
01406                     yysize = yysize0;
01407                     break;
01408                   }
01409                 yyarg[yycount++] = yytname[yyx];
01410                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01411                 if (! (yysize <= yysize1
01412                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
01413                   return 2;
01414                 yysize = yysize1;
01415               }
01416         }
01417     }
01418 
01419   switch (yycount)
01420     {
01421 # define YYCASE_(N, S)                      \
01422       case N:                               \
01423         yyformat = S;                       \
01424       break
01425       YYCASE_(0, YY_("syntax error"));
01426       YYCASE_(1, YY_("syntax error, unexpected %s"));
01427       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
01428       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
01429       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
01430       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
01431 # undef YYCASE_
01432     }
01433 
01434   yysize1 = yysize + yystrlen (yyformat);
01435   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
01436     return 2;
01437   yysize = yysize1;
01438 
01439   if (*yymsg_alloc < yysize)
01440     {
01441       *yymsg_alloc = 2 * yysize;
01442       if (! (yysize <= *yymsg_alloc
01443              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
01444         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
01445       return 1;
01446     }
01447 
01448   /* Avoid sprintf, as that infringes on the user's name space.
01449      Don't have undefined behavior even if the translation
01450      produced a string with the wrong number of "%s"s.  */
01451   {
01452     char *yyp = *yymsg;
01453     int yyi = 0;
01454     while ((*yyp = *yyformat) != '\0')
01455       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
01456         {
01457           yyp += yytnamerr (yyp, yyarg[yyi++]);
01458           yyformat += 2;
01459         }
01460       else
01461         {
01462           yyp++;
01463           yyformat++;
01464         }
01465   }
01466   return 0;
01467 }

static YYSIZE_T yytnamerr ( char *  yyres,
const char *  yystr 
) [static]

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

References YYSIZE_T, yystpcpy(), and yystrlen().

01295 {
01296   if (*yystr == '"')
01297     {
01298       YYSIZE_T yyn = 0;
01299       char const *yyp = yystr;
01300 
01301       for (;;)
01302    switch (*++yyp)
01303      {
01304      case '\'':
01305      case ',':
01306        goto do_not_strip_quotes;
01307 
01308      case '\\':
01309        if (*++yyp != '\\')
01310          goto do_not_strip_quotes;
01311        /* Fall through.  */
01312      default:
01313        if (yyres)
01314          yyres[yyn] = *yyp;
01315        yyn++;
01316        break;
01317 
01318      case '"':
01319        if (yyres)
01320          yyres[yyn] = '\0';
01321        return yyn;
01322      }
01323     do_not_strip_quotes: ;
01324     }
01325 
01326   if (! yyres)
01327     return yystrlen (yystr);
01328 
01329   return yystpcpy (yyres, yystr) - yyres;
01330 }


Variable Documentation

char* my_file

Definition at line 883 of file ael_lex.c.

char* token_equivs1[] [static]

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

char* token_equivs2[] [static]

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

const yytype_uint16 yycheck[] [static]

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

const yytype_uint8 yydefact[] [static]

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

const yytype_int16 yydefgoto[] [static]

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

const yytype_int16 yypact[] [static]

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

const yytype_int16 yypgoto[] [static]

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

const yytype_uint8 yyr1[] [static]

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

const yytype_uint8 yyr2[] [static]

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

const yytype_uint8 yystos[] [static]

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

const yytype_int16 yytable[] [static]

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

const char* const yytname[] [static]

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

const yytype_uint8 yytranslate[] [static]

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


Generated on Thu Apr 16 06:28:10 2015 for Asterisk - The Open Source Telephony Project by  doxygen 1.5.6