Wed Jan 8 2020 09:49:52

Asterisk developer's documentation


ael.tab.c File Reference

Bison Grammar description of AEL2. More...

#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "asterisk/logger.h"
#include "asterisk/lock.h"
#include "asterisk/hashtab.h"
#include "asterisk/ael_structs.h"
#include "asterisk/utils.h"

Go to the source code of this file.

Data Structures

union  yyalloc
 
struct  YYLTYPE
 
union  YYSTYPE
 

Macros

#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   ael_yydebug
 
#define YYDEBUG   0
 
#define YYDPRINTF(Args)
 
#define YYEMPTY   (-2)
 
#define YYEOF   0
 
#define YYERRCODE   256
 
#define yyerrok   (yyerrstatus = 0)
 
#define yyerror   ael_yyerror
 
#define YYERROR   goto yyerrorlab
 
#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   ael_yylex
 
#define YYLEX   yylex (&yylval, &yylloc, YYLEX_PARAM)
 
#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 /* obsolescent; will be withdrawn */
 
#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 /* obsolescent; will be withdrawn */
 
#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 YYTOKENTYPE
 
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYUNDEFTOK   2
 
#define YYUSE(e)   ((void) (e))
 

Typedefs

typedef struct YYLTYPE YYLTYPE
 
typedef union YYSTYPE YYSTYPE
 
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)
 
 for (;;)
 
 if (yyss+yystacksize-1<=yyssp)
 
 if (yychar==YYEMPTY)
 
 if (yychar<=YYEOF)
 
 if (yyn<=0)
 
 if (!yyerrstatus)
 
 if (yyerrstatus==3)
 
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)
 
 switch (yytype)
 
 switch (yyn)
 
static pvalupdate_last (pval *, YYLTYPE *)
 
 while (yyssp!=yyss)
 
yyexhaustedlab YY_ ("memory exhausted"))
 
 YY_REDUCE_PRINT (yyn)
 
 YY_STACK_PRINT (yyss, yyssp)
 
 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp)
 
 YY_SYMBOL_PRINT ("Next token is", yytoken,&yylval,&yylloc)
 
 YY_SYMBOL_PRINT ("Shifting", yytoken,&yylval,&yylloc)
 
 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn],&yyval,&yyloc)
 
 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp)
 
 yydestruct ("Cleanup: discarding lookahead", yytoken,&yylval,&yylloc, parseio)
 
 YYDPRINTF ((stderr,"Starting parse\n"))
 
 YYDPRINTF ((stderr,"Entering state %d\n", yystate))
 
void yyerror (YYLTYPE *locp, struct parse_io *parseio, char const *s)
 
return YYID (yyresult)
 
 YYLLOC_DEFAULT (yyloc,(yylsp-yylen), yylen)
 
 YYLLOC_DEFAULT (yyloc, yyerror_range, 2)
 
int yyparse ()
 
 YYPOPSTACK (yylen)
 
 YYSTACK_FREE (yyss)
 
 YYSTACK_FREE (yymsg)
 
static int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
 
static YYSIZE_T yytnamerr (char *yyres, const char *yystr)
 
 YYUSE (yylocationp)
 
 YYUSE (parseio)
 

Variables

yynewstate __pad0__
 
yyexhaustedlab __pad10__
 
yyreturn __pad11__
 
yysetstate __pad1__
 
yybackup __pad2__
 
yydefault __pad3__
 
yyreduce __pad4__
 
yyerrlab __pad5__
 
yyerrorlab __pad6__
 
yyerrlab1 __pad7__
 
yyacceptlab __pad8__
 
yyabortlab __pad9__
 
struct ast_flags ast_compat
 
 continue
 
 else
 
yylloc first_column = yylloc.last_column = 1
 
yylloc first_line = yylloc.last_line = 1
 
char * my_file
 
struct parse_ioparseio
 
static char * token_equivs1 []
 
static char * token_equivs2 []
 
 YYACCEPT
 
goto yybackup
 
 yychar = YYEMPTY
 
static const yytype_uint16 yycheck []
 
return yyd
 
static const yytype_uint8 yydefact []
 
goto yydefault
 
static const yytype_int16 yydefgoto []
 
static char *char * yydest
 
goto yyerrlab
 
goto yyerrlab1
 
YYLTYPE yyerror_range [3] = yylloc
 
int yyerrstatus = 0
 
return yylen = 0
 
YYLTYPE yylloc
 
YYLTYPE yyloc
 
YYLTYPEyylocationp
 
YYLTYPEyyls = yylsa
 
YYLTYPE yylsa [YYINITDEPTH]
 
YYLTYPEyylsp = yyls
 
YYSTYPE yylval
 
static void const char * yymsg = "Deleting"
 
YYSIZE_T yymsg_alloc = sizeof yymsgbuf
 
char yymsgbuf [128]
 
int yyn = yytoken
 
int yynerrs = 0
 
goto yynewstate
 
static const yytype_int16 yypact []
 
static const yytype_int16 yypgoto []
 
static const yytype_uint8 yyr1 []
 
static const yytype_uint8 yyr2 []
 
goto yyreduce
 
int yyresult = 2
 
goto yyreturn
 
const char * yys = yysrc
 
goto yysetstate
 
const char * yysrc
 
yytype_int16yyss = yyssa
 
yytype_int16 yyssa [YYINITDEPTH]
 
yytype_int16yyssp = yyss
 
YYSIZE_T yystacksize = YYINITDEPTH
 
int yystate = 0
 
static const yytype_uint8 yystos []
 
static YYSIZE_T const char * yystr
 
static const yytype_int16 yytable []
 
static const char *const yytname []
 
int yytoken = 0
 
static const yytype_uint8 yytranslate []
 
int yytype
 
YYSTYPE yyval = yyvsp[1-yylen]
 
YYSTYPEyyvaluep
 
YYSTYPEyyvs = yyvsa
 
YYSTYPE yyvsa [YYINITDEPTH]
 
YYSTYPEyyvsp = yyvs
 

Detailed Description

Bison Grammar description of AEL2.

Definition in file ael.tab.c.

Macro Definition Documentation

#define YY_ (   msgid)    msgid

Definition at line 327 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)
yylloc first_column
Definition: ast_expr2.c:1858
yylloc first_line
Definition: ast_expr2.c:1857

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

#define YY_REDUCE_PRINT (   Rule)

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

#define YY_STACK_PRINT (   Bottom,
  Top 
)

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

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

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

#define YYABORT   goto yyabortlab

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

Referenced by for(), and if().

#define YYACCEPT   goto yyacceptlab

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

#define YYBACKUP (   Token,
  Value 
)

Definition at line 969 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,
  S 
)
Value:
case N: \
yyformat = S; \
break
#define S(e)

Referenced by yysyntax_error().

#define yychar   ael_yychar

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

#define yyclearin   (yychar = YYEMPTY)

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

#define YYCOPY (   To,
  From,
  Count 
)

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

#define YYCOPY_NEEDED   1

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

#define yydebug   ael_yydebug

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

#define YYDEBUG   0

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

#define YYDPRINTF (   Args)

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

#define YYEMPTY   (-2)

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

Referenced by if(), and yysyntax_error().

#define YYEOF   0

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

Referenced by if().

#define YYERRCODE   256

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

#define yyerrok   (yyerrstatus = 0)

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

#define yyerror   ael_yyerror

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

#define YYERROR   goto yyerrorlab

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

#define YYERROR_VERBOSE   1

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

#define YYERROR_VERBOSE   1

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

#define YYFAIL   goto yyerrlab

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

#define YYFINAL   17

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

#define YYFREE   free

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

#define YYID (   n)    (n)

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

#define YYINITDEPTH   200

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

#define YYLAST   371

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

Referenced by for(), and yysyntax_error().

#define yylex   ael_yylex

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

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

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

Referenced by if().

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

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

#define YYLSP_NEEDED   1

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

#define yyltype   YYLTYPE /* obsolescent; will be withdrawn */

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

#define YYLTYPE_IS_DECLARED   1

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

#define YYLTYPE_IS_TRIVIAL   1

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

#define yylval   ael_yylval

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

#define YYMALLOC   malloc

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

#define YYMAXDEPTH   10000

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

Referenced by if().

#define YYMAXUTOK   298

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

#define yynerrs   ael_yynerrs

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

#define YYNNTS   56

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

#define YYNRULES   143

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

#define YYNSTATES   283

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

#define YYNTOKENS   44

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

Referenced by yysyntax_error().

#define YYPACT_NINF   -211

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

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

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

Referenced by for(), and yysyntax_error().

#define yyparse   ael_yyparse

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

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

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

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

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

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

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

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

#define YYSIZE_T   unsigned int

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

Referenced by if(), yysyntax_error(), and yytnamerr().

#define YYSKELETON_NAME   "yacc.c"

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

#define YYSTACK_ALLOC   YYMALLOC

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

Referenced by if().

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

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

Referenced by yysyntax_error().

#define YYSTACK_BYTES (   N)
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
#define YYSTACK_GAP_MAXIMUM
Definition: ael.tab.c:440
short int yytype_int16
Definition: ast_expr2.c:544
union YYSTYPE YYSTYPE

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

Referenced by if().

#define YYSTACK_FREE   YYFREE

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

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

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

#define YYSTACK_RELOCATE (   Stack_alloc,
  Stack 
)

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

Referenced by if().

#define yystype   YYSTYPE /* obsolescent; will be withdrawn */

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

#define YYSTYPE_IS_DECLARED   1

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

#define YYSTYPE_IS_TRIVIAL   1

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

#define YYSYNTAX_ERROR
Value:
YYSIZE_T yymsg_alloc
Definition: ast_expr2.c:1825
yytype_int16 * yyssp
Definition: ast_expr2.c:1795
static void const char * yymsg
Definition: ael.tab.c:1481
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: ael.tab.c:1341
int yytoken
Definition: ast_expr2.c:1815

Referenced by if().

#define YYTABLE_NINF   -134

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

#define yytable_value_is_error (   yytable_value)    YYID (0)

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

Referenced by if(), and yysyntax_error().

#define YYTERROR   1

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

Referenced by for(), and yysyntax_error().

#define YYTOKEN_TABLE   0

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

#define YYTOKENTYPE

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

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

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

#define YYUNDEFTOK   2

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

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

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

Typedef Documentation

typedef struct YYLTYPE YYLTYPE
typedef union YYSTYPE YYSTYPE
typedef short int yytype_int16

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

typedef short int yytype_int8

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

typedef unsigned short int yytype_uint16

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

typedef unsigned char yytype_uint8

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

162  {
163  KW_CONTEXT = 258,
164  LC = 259,
165  RC = 260,
166  LP = 261,
167  RP = 262,
168  SEMI = 263,
169  EQ = 264,
170  COMMA = 265,
171  COLON = 266,
172  AMPER = 267,
173  BAR = 268,
174  AT = 269,
175  KW_MACRO = 270,
176  KW_GLOBALS = 271,
177  KW_IGNOREPAT = 272,
178  KW_SWITCH = 273,
179  KW_IF = 274,
180  KW_IFTIME = 275,
181  KW_ELSE = 276,
182  KW_RANDOM = 277,
183  KW_ABSTRACT = 278,
184  KW_EXTEND = 279,
185  EXTENMARK = 280,
186  KW_GOTO = 281,
187  KW_JUMP = 282,
188  KW_RETURN = 283,
189  KW_BREAK = 284,
190  KW_CONTINUE = 285,
191  KW_REGEXTEN = 286,
192  KW_HINT = 287,
193  KW_FOR = 288,
194  KW_WHILE = 289,
195  KW_CASE = 290,
196  KW_PATTERN = 291,
197  KW_DEFAULT = 292,
198  KW_CATCH = 293,
199  KW_SWITCHES = 294,
200  KW_ESWITCHES = 295,
201  KW_INCLUDES = 296,
202  KW_LOCAL = 297,
203  word = 298
204  };
Definition: ael.tab.c:168
Definition: ael.tab.c:166
Definition: ael.tab.c:169
Definition: ael.tab.c:171
Definition: ael.tab.c:167
Definition: ael.tab.c:174
Definition: ael.tab.c:172
Definition: ael.tab.c:203
Definition: ael.tab.c:173
Definition: ael.tab.c:170
Definition: ael.tab.c:165
Definition: ael.tab.c:179
Definition: ael.tab.c:164

Function Documentation

static char * ael_token_subst ( const char *  mess)
static

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

References calloc, len(), and token_equivs1.

Referenced by yyerror().

3912 {
3913  /* calc a length, malloc, fill, and return; yyerror had better free it! */
3914  int len=0,i;
3915  const char *p;
3916  char *res, *s,*t;
3917  int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
3918 
3919  for (p=mess; *p; p++) {
3920  for (i=0; i<token_equivs_entries; i++) {
3921  if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
3922  {
3923  len+=strlen(token_equivs2[i])+2;
3924  p += strlen(token_equivs1[i])-1;
3925  break;
3926  }
3927  }
3928  len++;
3929  }
3930  res = calloc(1, len+1);
3931  res[0] = 0;
3932  s = res;
3933  for (p=mess; *p;) {
3934  int found = 0;
3935  for (i=0; i<token_equivs_entries; i++) {
3936  if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
3937  *s++ = '\'';
3938  for (t=token_equivs2[i]; *t;) {
3939  *s++ = *t++;
3940  }
3941  *s++ = '\'';
3942  p += strlen(token_equivs1[i]);
3943  found = 1;
3944  break;
3945  }
3946  }
3947  if( !found )
3948  *s++ = *p++;
3949  }
3950  *s++ = 0;
3951  return res;
3952 }
#define calloc(a, b)
Definition: astmm.h:79
static char * token_equivs1[]
Definition: ael.tab.c:3830
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static char * token_equivs2[]
Definition: ael.tab.c:3870
int ael_yylex ( YYSTYPE yylval_param,
YYLTYPE yylloc_param,
void *  yyscanner 
)
for ( ;;  )

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

References YY_STACK_PRINT, YYABORT, yydestruct(), YYLAST, yylsp, yyn, yypact_value_is_default, YYPOPSTACK, yyssp, yystate, and YYTERROR.

3729  {
3730  yyn = yypact[yystate];
3732  {
3733  yyn += YYTERROR;
3734  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3735  {
3736  yyn = yytable[yyn];
3737  if (0 < yyn)
3738  break;
3739  }
3740  }
3741 
3742  /* Pop the current state because it cannot handle the error token. */
3743  if (yyssp == yyss)
3744  YYABORT;
3745 
3746  yyerror_range[1] = *yylsp;
3747  yydestruct ("Error: popping",
3749  YYPOPSTACK (1);
3750  yystate = *yyssp;
3752  }
yytype_int16 * yyss
Definition: ast_expr2.c:1794
struct parse_io * parseio
Definition: ael.tab.c:1485
#define YYPOPSTACK(N)
Definition: ast_expr2.c:1828
yytype_int16 * yyssp
Definition: ast_expr2.c:1795
static const yytype_int16 yypact[]
Definition: ael.tab.c:769
YYLTYPE * yylsp
Definition: ast_expr2.c:1805
static const yytype_int16 yytable[]
Definition: ael.tab.c:817
#define YYLAST
Definition: ael.tab.c:491
int yystate
Definition: ast_expr2.c:1780
#define YYTERROR
Definition: ael.tab.c:986
#define YYABORT
Definition: ael.tab.c:948
YYSTYPE * yyvsp
Definition: ast_expr2.c:1800
int yyn
Definition: ast_expr2.c:1812
yydestruct("Cleanup: discarding lookahead", yytoken,&yylval,&yylloc)
YYLTYPE yyerror_range[3]
Definition: ast_expr2.c:1808
static const yytype_uint16 yycheck[]
Definition: ael.tab.c:865
#define YY_STACK_PRINT(Bottom, Top)
Definition: ast_expr2.c:1225
#define yypact_value_is_default(yystate)
Definition: ael.tab.c:859
static const yytype_uint8 yystos[]
Definition: ael.tab.c:909
if ( yyss+yystacksize-1<=  yyssp)

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

References YY_, YYABORT, YYDPRINTF, yyls, yyalloc::yyls_alloc, YYMAXDEPTH, YYSIZE_T, yyss, yyalloc::yyss_alloc, YYSTACK_ALLOC, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, yyvs, and yyalloc::yyvs_alloc.

2155  {
2156  /* Get the current used size of the three stacks, in elements. */
2157  YYSIZE_T yysize = yyssp - yyss + 1;
2158 
2159 #ifdef yyoverflow
2160  {
2161  /* Give user a chance to reallocate the stack. Use copies of
2162  these so that the &'s don't force the real ones into
2163  memory. */
2164  YYSTYPE *yyvs1 = yyvs;
2165  yytype_int16 *yyss1 = yyss;
2166  YYLTYPE *yyls1 = yyls;
2167 
2168  /* Each stack pointer address is followed by the size of the
2169  data in use in that stack, in bytes. This used to be a
2170  conditional around just the two extra args, but that might
2171  be undefined if yyoverflow is a macro. */
2172  yyoverflow (YY_("memory exhausted"),
2173  &yyss1, yysize * sizeof (*yyssp),
2174  &yyvs1, yysize * sizeof (*yyvsp),
2175  &yyls1, yysize * sizeof (*yylsp),
2176  &yystacksize);
2177 
2178  yyls = yyls1;
2179  yyss = yyss1;
2180  yyvs = yyvs1;
2181  }
2182 #else /* no yyoverflow */
2183 # ifndef YYSTACK_RELOCATE
2184  goto yyexhaustedlab;
2185 # else
2186  /* Extend the stack our own way. */
2187  if (YYMAXDEPTH <= yystacksize)
2188  goto yyexhaustedlab;
2189  yystacksize *= 2;
2190  if (YYMAXDEPTH < yystacksize)
2192 
2193  {
2194  yytype_int16 *yyss1 = yyss;
2195  union yyalloc *yyptr =
2197  if (! yyptr)
2198  goto yyexhaustedlab;
2199  YYSTACK_RELOCATE (yyss_alloc, yyss);
2202 # undef YYSTACK_RELOCATE
2203  if (yyss1 != yyssa)
2204  YYSTACK_FREE (yyss1);
2205  }
2206 # endif
2207 #endif /* no yyoverflow */
2208 
2209  yyssp = yyss + yysize - 1;
2210  yyvsp = yyvs + yysize - 1;
2211  yylsp = yyls + yysize - 1;
2212 
2213  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2214  (unsigned long int) yystacksize));
2215 
2216  if (yyss + yystacksize - 1 <= yyssp)
2217  YYABORT;
2218  }
yytype_int16 * yyss
Definition: ast_expr2.c:1794
yytype_int16 * yyssp
Definition: ast_expr2.c:1795
yytype_int16 yyssa[YYINITDEPTH]
Definition: ast_expr2.c:1793
#define YYSIZE_T
Definition: ael.tab.c:313
YYLTYPE * yylsp
Definition: ast_expr2.c:1805
#define YYMAXDEPTH
Definition: ael.tab.c:1227
short int yytype_int16
Definition: ast_expr2.c:544
YYLTYPE * yyls
Definition: ast_expr2.c:1804
#define YYABORT
Definition: ael.tab.c:948
YYSTYPE yyvs_alloc
Definition: ast_expr2.c:679
YYSTYPE * yyvsp
Definition: ast_expr2.c:1800
#define YYSTACK_ALLOC
Definition: ael.tab.c:395
YYSTYPE * yyvs
Definition: ast_expr2.c:1799
YYLTYPE yyls_alloc
Definition: ast_expr2.c:680
#define YYSTACK_BYTES(N)
Definition: ael.tab.c:444
#define YY_(msgid)
Definition: ast_expr2.c:571
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ael.tab.c:455
#define YYSTACK_FREE
Definition: ast_expr2.c:640
YYSIZE_T yystacksize
Definition: ast_expr2.c:1810
yytype_int16 yyss_alloc
Definition: ast_expr2.c:678
#define YYDPRINTF(Args)
Definition: ast_expr2.c:1223
if ( yychar  = YYEMPTY)

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

References YYDPRINTF, and YYLEX.

2244  {
2245  YYDPRINTF ((stderr, "Reading a token: "));
2246  yychar = YYLEX;
2247  }
#define yychar
Definition: ast_expr2.c:69
#define YYDPRINTF(Args)
Definition: ast_expr2.c:1223
#define YYLEX
Definition: ael.tab.c:1035
if ( yychar<=  YYEOF)

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

References YYDPRINTF, and YYEOF.

2250  {
2251  yychar = yytoken = YYEOF;
2252  YYDPRINTF ((stderr, "Now at end of input.\n"));
2253  }
#define yychar
Definition: ast_expr2.c:69
#define YYEOF
Definition: ael.tab.c:945
#define YYDPRINTF(Args)
Definition: ast_expr2.c:1223
int yytoken
Definition: ast_expr2.c:1815
if ( yyn<=  0)

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

References yyerrlab, yyn, yyreduce, and yytable_value_is_error.

2267  {
2269  goto yyerrlab;
2270  yyn = -yyn;
2271  goto yyreduce;
2272  }
goto yyerrlab
Definition: ast_expr2.c:2017
#define yytable_value_is_error(yytable_value)
Definition: ael.tab.c:862
int yyn
Definition: ast_expr2.c:1812
goto yyreduce
Definition: ast_expr2.c:2018
if ( yyerrstatus)

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

References YY_, yyerror, yymsg, yymsgbuf, yynerrs, YYSTACK_ALLOC, YYSTACK_FREE, and YYSYNTAX_ERROR.

3637  {
3638  ++yynerrs;
3639 #if ! YYERROR_VERBOSE
3640  yyerror (&yylloc, parseio, YY_("syntax error"));
3641 #else
3642 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3643  yyssp, yytoken)
3644  {
3645  char const *yymsgp = YY_("syntax error");
3646  int yysyntax_error_status;
3647  yysyntax_error_status = YYSYNTAX_ERROR;
3648  if (yysyntax_error_status == 0)
3649  yymsgp = yymsg;
3650  else if (yysyntax_error_status == 1)
3651  {
3652  if (yymsg != yymsgbuf)
3653  YYSTACK_FREE (yymsg);
3654  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3655  if (!yymsg)
3656  {
3657  yymsg = yymsgbuf;
3658  yymsg_alloc = sizeof yymsgbuf;
3659  yysyntax_error_status = 2;
3660  }
3661  else
3662  {
3663  yysyntax_error_status = YYSYNTAX_ERROR;
3664  yymsgp = yymsg;
3665  }
3666  }
3667  yyerror (&yylloc, parseio, yymsgp);
3668  if (yysyntax_error_status == 2)
3669  goto yyexhaustedlab;
3670  }
3671 # undef YYSYNTAX_ERROR
3672 #endif
3673  }
char yymsgbuf[128]
Definition: ast_expr2.c:1823
struct parse_io * parseio
Definition: ael.tab.c:1485
#define yyerror
Definition: ast_expr2.c:67
YYSIZE_T yymsg_alloc
Definition: ast_expr2.c:1825
#define yynerrs
Definition: ast_expr2.c:71
static void const char * yymsg
Definition: ael.tab.c:1481
#define YYSTACK_ALLOC
Definition: ael.tab.c:395
#define YY_(msgid)
Definition: ast_expr2.c:571
#define YYSTACK_FREE
Definition: ast_expr2.c:640
#define YYSYNTAX_ERROR
#define yylloc
Definition: ast_expr2.c:72
if ( yyerrstatus  = = 3)

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

References YYABORT, yydestruct(), YYEMPTY, and YYEOF.

3678  {
3679  /* If just tried and failed to reuse lookahead token after an
3680  error, discard it. */
3681 
3682  if (yychar <= YYEOF)
3683  {
3684  /* Return failure if at end of input. */
3685  if (yychar == YYEOF)
3686  YYABORT;
3687  }
3688  else
3689  {
3690  yydestruct ("Error: discarding",
3691  yytoken, &yylval, &yylloc, parseio);
3692  yychar = YYEMPTY;
3693  }
3694  }
struct parse_io * parseio
Definition: ael.tab.c:1485
#define yychar
Definition: ast_expr2.c:69
#define YYABORT
Definition: ael.tab.c:948
#define YYEOF
Definition: ael.tab.c:945
yydestruct("Cleanup: discarding lookahead", yytoken,&yylval,&yylloc)
#define YYEMPTY
Definition: ael.tab.c:944
#define yylloc
Definition: ast_expr2.c:72
#define yylval
Definition: ast_expr2.c:68
int yytoken
Definition: ast_expr2.c:1815
pval* linku1 ( pval head,
pval tail 
)

Definition at line 5926 of file pval.c.

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

5927 {
5928  if (!head)
5929  return tail;
5930  if (tail) {
5931  if (!head->next) {
5932  head->next = tail;
5933  } else {
5934  head->u1_last->next = tail;
5935  }
5936  head->u1_last = tail;
5937  tail->prev = head; /* the dad link only points to containers */
5938  }
5939  return head;
5940 }
struct pval * u1_last
Definition: pval.h:64
struct pval * prev
Definition: pval.h:97
struct pval * next
Definition: pval.h:93
pval* npval ( pvaltype  type,
int  first_line,
int  last_line,
int  first_column,
int  last_column 
)

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

References calloc, pval::endcol, pval::endline, pval::filename, first_column, first_line, S_OR, pval::startcol, pval::startline, strdup, pval::type, and type.

Referenced by npval2(), and switch().

3968 {
3969  pval *z = calloc(1, sizeof(struct pval));
3970  z->type = type;
3971  z->startline = first_line;
3972  z->endline = last_line;
3973  z->startcol = first_column;
3974  z->endcol = last_column;
3975  z->filename = strdup(S_OR(my_file, "<none>"));
3976  return z;
3977 }
yylloc first_column
Definition: ast_expr2.c:1858
int startline
Definition: pval.h:51
#define calloc(a, b)
Definition: astmm.h:79
char * filename
Definition: pval.h:55
char * my_file
Definition: ael_lex.c:873
Definition: pval.h:48
int endcol
Definition: pval.h:54
pvaltype type
Definition: pval.h:50
static const char type[]
Definition: chan_nbs.c:57
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one...
Definition: strings.h:77
#define strdup(a)
Definition: astmm.h:106
int endline
Definition: pval.h:52
int startcol
Definition: pval.h:53
yylloc first_line
Definition: ast_expr2.c:1857
static struct pval * npval2 ( pvaltype  type,
YYLTYPE first,
YYLTYPE last 
)
static

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

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

Referenced by nword(), and switch().

3980 {
3981  return npval(type, first->first_line, last->last_line,
3982  first->first_column, last->last_column);
3983 }
int last_line
Definition: ast_expr2.h:95
int last_column
Definition: ast_expr2.h:96
int first_line
Definition: ast_expr2.h:93
static const char type[]
Definition: chan_nbs.c:57
int first_column
Definition: ast_expr2.h:94
pval * npval(pvaltype type, int first_line, int last_line, int first_column, int last_column)
Definition: ael.tab.c:3966
static pval * nword ( char *  string,
YYLTYPE pos 
)
static

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

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

Referenced by switch().

3994 {
3995  pval *p = npval2(PV_WORD, pos, pos);
3996  if (p)
3997  p->u1.str = string;
3998  return p;
3999 }
union pval::@198 u1
Definition: pval.h:8
char * str
Definition: pval.h:59
Definition: pval.h:48
static pval * npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last)
Definition: ael.tab.c:3979
char string[1]
Definition: utils.c:1722
void reset_argcount ( yyscan_t  yyscanner)

Definition at line 3333 of file ael_lex.c.

References argg, BEGIN, c_prevword(), and pbcpush().

Referenced by switch().

3334 {
3335  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3336  parencount = 0;
3337  pbcpos = 0;
3338  pbcpush('('); /* push '(' so the last pcbpop (parencount= -1) will succeed */
3339  c_prevword();
3340  BEGIN(argg);
3341 }
static int parencount
Definition: ael_lex.c:847
struct yyguts_t * yyg
Definition: ast_expr2f.c:848
#define BEGIN
Definition: ael_lex.c:144
#define argg
Definition: ael_lex.c:960
static void pbcpush(char x)
Definition: ael_lex.c:3221
static int pbcpos
Definition: ael_lex.c:844
static int c_prevword(void)
Definition: ael_lex.c:3275
void reset_parencount ( yyscan_t  yyscanner)

Definition at line 3314 of file ael_lex.c.

References BEGIN, c_prevword(), paren, and pbcpush().

Referenced by switch().

3315 {
3316  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3317  parencount = 0;
3318  pbcpos = 0;
3319  pbcpush('('); /* push '(' so the last pcbpop (parencount= -1) will succeed */
3320  c_prevword();
3321  BEGIN(paren);
3322 }
static int parencount
Definition: ael_lex.c:847
struct yyguts_t * yyg
Definition: ast_expr2f.c:848
#define BEGIN
Definition: ael_lex.c:144
static void pbcpush(char x)
Definition: ael_lex.c:3221
static int pbcpos
Definition: ael_lex.c:844
static int c_prevword(void)
Definition: ael_lex.c:3275
#define paren
Definition: ael_lex.c:958
void reset_semicount ( yyscan_t  yyscanner)

Definition at line 3325 of file ael_lex.c.

References BEGIN, and semic.

Referenced by switch().

3326 {
3327  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3328  pbcpos = 0;
3329  BEGIN(semic);
3330 }
struct yyguts_t * yyg
Definition: ast_expr2f.c:848
#define semic
Definition: ael_lex.c:959
#define BEGIN
Definition: ael_lex.c:144
static int pbcpos
Definition: ael_lex.c:844
static void set_dads ( pval dad,
pval child_list 
)
static

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

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

Referenced by switch().

4003 {
4004  struct pval *t;
4005 
4006  for(t=child_list;t;t=t->next) /* simple stuff */
4007  t->dad = dad;
4008 }
struct pval * dad
Definition: pval.h:96
Definition: pval.h:48
struct pval * next
Definition: pval.h:93
switch ( yytype  )

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

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

1497  {
1498  case 43: /* "word" */
1499 
1500 /* Line 1391 of yacc.c */
1501 #line 183 "ael.y"
1502  { free((yyvaluep->str));};
1503 
1504 /* Line 1391 of yacc.c */
1505 #line 1506 "ael.tab.c"
1506  break;
1507  case 46: /* "objects" */
1508 
1509 /* Line 1391 of yacc.c */
1510 #line 170 "ael.y"
1511  {
1513  prev_word=0;
1514  };
1515 
1516 /* Line 1391 of yacc.c */
1517 #line 1518 "ael.tab.c"
1518  break;
1519  case 47: /* "object" */
1520 
1521 /* Line 1391 of yacc.c */
1522 #line 170 "ael.y"
1523  {
1525  prev_word=0;
1526  };
1527 
1528 /* Line 1391 of yacc.c */
1529 #line 1530 "ael.tab.c"
1530  break;
1531  case 48: /* "context_name" */
1532 
1533 /* Line 1391 of yacc.c */
1534 #line 183 "ael.y"
1535  { free((yyvaluep->str));};
1536 
1537 /* Line 1391 of yacc.c */
1538 #line 1539 "ael.tab.c"
1539  break;
1540  case 49: /* "context" */
1541 
1542 /* Line 1391 of yacc.c */
1543 #line 170 "ael.y"
1544  {
1546  prev_word=0;
1547  };
1548 
1549 /* Line 1391 of yacc.c */
1550 #line 1551 "ael.tab.c"
1551  break;
1552  case 51: /* "macro" */
1553 
1554 /* Line 1391 of yacc.c */
1555 #line 170 "ael.y"
1556  {
1558  prev_word=0;
1559  };
1560 
1561 /* Line 1391 of yacc.c */
1562 #line 1563 "ael.tab.c"
1563  break;
1564  case 52: /* "globals" */
1565 
1566 /* Line 1391 of yacc.c */
1567 #line 170 "ael.y"
1568  {
1570  prev_word=0;
1571  };
1572 
1573 /* Line 1391 of yacc.c */
1574 #line 1575 "ael.tab.c"
1575  break;
1576  case 53: /* "global_statements" */
1577 
1578 /* Line 1391 of yacc.c */
1579 #line 170 "ael.y"
1580  {
1582  prev_word=0;
1583  };
1584 
1585 /* Line 1391 of yacc.c */
1586 #line 1587 "ael.tab.c"
1587  break;
1588  case 54: /* "assignment" */
1589 
1590 /* Line 1391 of yacc.c */
1591 #line 170 "ael.y"
1592  {
1594  prev_word=0;
1595  };
1596 
1597 /* Line 1391 of yacc.c */
1598 #line 1599 "ael.tab.c"
1599  break;
1600  case 56: /* "local_assignment" */
1601 
1602 /* Line 1391 of yacc.c */
1603 #line 170 "ael.y"
1604  {
1606  prev_word=0;
1607  };
1608 
1609 /* Line 1391 of yacc.c */
1610 #line 1611 "ael.tab.c"
1611  break;
1612  case 58: /* "arglist" */
1613 
1614 /* Line 1391 of yacc.c */
1615 #line 170 "ael.y"
1616  {
1618  prev_word=0;
1619  };
1620 
1621 /* Line 1391 of yacc.c */
1622 #line 1623 "ael.tab.c"
1623  break;
1624  case 59: /* "elements" */
1625 
1626 /* Line 1391 of yacc.c */
1627 #line 170 "ael.y"
1628  {
1630  prev_word=0;
1631  };
1632 
1633 /* Line 1391 of yacc.c */
1634 #line 1635 "ael.tab.c"
1635  break;
1636  case 60: /* "element" */
1637 
1638 /* Line 1391 of yacc.c */
1639 #line 170 "ael.y"
1640  {
1642  prev_word=0;
1643  };
1644 
1645 /* Line 1391 of yacc.c */
1646 #line 1647 "ael.tab.c"
1647  break;
1648  case 61: /* "ignorepat" */
1649 
1650 /* Line 1391 of yacc.c */
1651 #line 170 "ael.y"
1652  {
1654  prev_word=0;
1655  };
1656 
1657 /* Line 1391 of yacc.c */
1658 #line 1659 "ael.tab.c"
1659  break;
1660  case 62: /* "extension" */
1661 
1662 /* Line 1391 of yacc.c */
1663 #line 170 "ael.y"
1664  {
1666  prev_word=0;
1667  };
1668 
1669 /* Line 1391 of yacc.c */
1670 #line 1671 "ael.tab.c"
1671  break;
1672  case 63: /* "statements" */
1673 
1674 /* Line 1391 of yacc.c */
1675 #line 170 "ael.y"
1676  {
1678  prev_word=0;
1679  };
1680 
1681 /* Line 1391 of yacc.c */
1682 #line 1683 "ael.tab.c"
1683  break;
1684  case 64: /* "timerange" */
1685 
1686 /* Line 1391 of yacc.c */
1687 #line 183 "ael.y"
1688  { free((yyvaluep->str));};
1689 
1690 /* Line 1391 of yacc.c */
1691 #line 1692 "ael.tab.c"
1692  break;
1693  case 65: /* "timespec" */
1694 
1695 /* Line 1391 of yacc.c */
1696 #line 170 "ael.y"
1697  {
1699  prev_word=0;
1700  };
1701 
1702 /* Line 1391 of yacc.c */
1703 #line 1704 "ael.tab.c"
1704  break;
1705  case 66: /* "test_expr" */
1706 
1707 /* Line 1391 of yacc.c */
1708 #line 183 "ael.y"
1709  { free((yyvaluep->str));};
1710 
1711 /* Line 1391 of yacc.c */
1712 #line 1713 "ael.tab.c"
1713  break;
1714  case 68: /* "if_like_head" */
1715 
1716 /* Line 1391 of yacc.c */
1717 #line 170 "ael.y"
1718  {
1720  prev_word=0;
1721  };
1722 
1723 /* Line 1391 of yacc.c */
1724 #line 1725 "ael.tab.c"
1725  break;
1726  case 69: /* "word_list" */
1727 
1728 /* Line 1391 of yacc.c */
1729 #line 183 "ael.y"
1730  { free((yyvaluep->str));};
1731 
1732 /* Line 1391 of yacc.c */
1733 #line 1734 "ael.tab.c"
1734  break;
1735  case 71: /* "word3_list" */
1736 
1737 /* Line 1391 of yacc.c */
1738 #line 183 "ael.y"
1739  { free((yyvaluep->str));};
1740 
1741 /* Line 1391 of yacc.c */
1742 #line 1743 "ael.tab.c"
1743  break;
1744  case 72: /* "goto_word" */
1745 
1746 /* Line 1391 of yacc.c */
1747 #line 183 "ael.y"
1748  { free((yyvaluep->str));};
1749 
1750 /* Line 1391 of yacc.c */
1751 #line 1752 "ael.tab.c"
1752  break;
1753  case 73: /* "switch_statement" */
1754 
1755 /* Line 1391 of yacc.c */
1756 #line 170 "ael.y"
1757  {
1759  prev_word=0;
1760  };
1761 
1762 /* Line 1391 of yacc.c */
1763 #line 1764 "ael.tab.c"
1764  break;
1765  case 74: /* "statement" */
1766 
1767 /* Line 1391 of yacc.c */
1768 #line 170 "ael.y"
1769  {
1771  prev_word=0;
1772  };
1773 
1774 /* Line 1391 of yacc.c */
1775 #line 1776 "ael.tab.c"
1776  break;
1777  case 79: /* "opt_else" */
1778 
1779 /* Line 1391 of yacc.c */
1780 #line 170 "ael.y"
1781  {
1783  prev_word=0;
1784  };
1785 
1786 /* Line 1391 of yacc.c */
1787 #line 1788 "ael.tab.c"
1788  break;
1789  case 80: /* "target" */
1790 
1791 /* Line 1391 of yacc.c */
1792 #line 170 "ael.y"
1793  {
1795  prev_word=0;
1796  };
1797 
1798 /* Line 1391 of yacc.c */
1799 #line 1800 "ael.tab.c"
1800  break;
1801  case 81: /* "opt_pri" */
1802 
1803 /* Line 1391 of yacc.c */
1804 #line 183 "ael.y"
1805  { free((yyvaluep->str));};
1806 
1807 /* Line 1391 of yacc.c */
1808 #line 1809 "ael.tab.c"
1809  break;
1810  case 82: /* "jumptarget" */
1811 
1812 /* Line 1391 of yacc.c */
1813 #line 170 "ael.y"
1814  {
1816  prev_word=0;
1817  };
1818 
1819 /* Line 1391 of yacc.c */
1820 #line 1821 "ael.tab.c"
1821  break;
1822  case 83: /* "macro_call" */
1823 
1824 /* Line 1391 of yacc.c */
1825 #line 170 "ael.y"
1826  {
1828  prev_word=0;
1829  };
1830 
1831 /* Line 1391 of yacc.c */
1832 #line 1833 "ael.tab.c"
1833  break;
1834  case 85: /* "application_call_head" */
1835 
1836 /* Line 1391 of yacc.c */
1837 #line 170 "ael.y"
1838  {
1840  prev_word=0;
1841  };
1842 
1843 /* Line 1391 of yacc.c */
1844 #line 1845 "ael.tab.c"
1845  break;
1846  case 87: /* "application_call" */
1847 
1848 /* Line 1391 of yacc.c */
1849 #line 170 "ael.y"
1850  {
1852  prev_word=0;
1853  };
1854 
1855 /* Line 1391 of yacc.c */
1856 #line 1857 "ael.tab.c"
1857  break;
1858  case 88: /* "opt_word" */
1859 
1860 /* Line 1391 of yacc.c */
1861 #line 183 "ael.y"
1862  { free((yyvaluep->str));};
1863 
1864 /* Line 1391 of yacc.c */
1865 #line 1866 "ael.tab.c"
1866  break;
1867  case 89: /* "eval_arglist" */
1868 
1869 /* Line 1391 of yacc.c */
1870 #line 170 "ael.y"
1871  {
1873  prev_word=0;
1874  };
1875 
1876 /* Line 1391 of yacc.c */
1877 #line 1878 "ael.tab.c"
1878  break;
1879  case 90: /* "case_statements" */
1880 
1881 /* Line 1391 of yacc.c */
1882 #line 170 "ael.y"
1883  {
1885  prev_word=0;
1886  };
1887 
1888 /* Line 1391 of yacc.c */
1889 #line 1890 "ael.tab.c"
1890  break;
1891  case 91: /* "case_statement" */
1892 
1893 /* Line 1391 of yacc.c */
1894 #line 170 "ael.y"
1895  {
1897  prev_word=0;
1898  };
1899 
1900 /* Line 1391 of yacc.c */
1901 #line 1902 "ael.tab.c"
1902  break;
1903  case 92: /* "macro_statements" */
1904 
1905 /* Line 1391 of yacc.c */
1906 #line 170 "ael.y"
1907  {
1909  prev_word=0;
1910  };
1911 
1912 /* Line 1391 of yacc.c */
1913 #line 1914 "ael.tab.c"
1914  break;
1915  case 93: /* "macro_statement" */
1916 
1917 /* Line 1391 of yacc.c */
1918 #line 170 "ael.y"
1919  {
1921  prev_word=0;
1922  };
1923 
1924 /* Line 1391 of yacc.c */
1925 #line 1926 "ael.tab.c"
1926  break;
1927  case 94: /* "switches" */
1928 
1929 /* Line 1391 of yacc.c */
1930 #line 170 "ael.y"
1931  {
1933  prev_word=0;
1934  };
1935 
1936 /* Line 1391 of yacc.c */
1937 #line 1938 "ael.tab.c"
1938  break;
1939  case 95: /* "eswitches" */
1940 
1941 /* Line 1391 of yacc.c */
1942 #line 170 "ael.y"
1943  {
1945  prev_word=0;
1946  };
1947 
1948 /* Line 1391 of yacc.c */
1949 #line 1950 "ael.tab.c"
1950  break;
1951  case 96: /* "switchlist" */
1952 
1953 /* Line 1391 of yacc.c */
1954 #line 170 "ael.y"
1955  {
1957  prev_word=0;
1958  };
1959 
1960 /* Line 1391 of yacc.c */
1961 #line 1962 "ael.tab.c"
1962  break;
1963  case 97: /* "included_entry" */
1964 
1965 /* Line 1391 of yacc.c */
1966 #line 170 "ael.y"
1967  {
1969  prev_word=0;
1970  };
1971 
1972 /* Line 1391 of yacc.c */
1973 #line 1974 "ael.tab.c"
1974  break;
1975  case 98: /* "includeslist" */
1976 
1977 /* Line 1391 of yacc.c */
1978 #line 170 "ael.y"
1979  {
1981  prev_word=0;
1982  };
1983 
1984 /* Line 1391 of yacc.c */
1985 #line 1986 "ael.tab.c"
1986  break;
1987  case 99: /* "includes" */
1988 
1989 /* Line 1391 of yacc.c */
1990 #line 170 "ael.y"
1991  {
1993  prev_word=0;
1994  };
1995 
1996 /* Line 1391 of yacc.c */
1997 #line 1998 "ael.tab.c"
1998  break;
1999 
2000  default:
2001  break;
2002  }
struct pval * pval
Definition: ael.tab.c:218
void destroy_pval(pval *item)
Definition: pval.c:4979
char * str
Definition: ael.tab.c:217
#define free(a)
Definition: astmm.h:94
char * prev_word
Definition: ael_lex.c:874
YYSTYPE * yyvaluep
Definition: ast_expr2.c:1499
switch ( yyn  )

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

References pval::arglist, asprintf(), ast_log(), calloc, destroy_pval(), first_column, first_line, pval::for_init, free, YYSTYPE::intval, linku1(), pval::list, LOG_WARNING, malloc, pval::next, npval(), npval2(), nword(), prev_word, PV_APPLICATION_CALL, PV_BREAK, PV_CASE, PV_CATCH, PV_CONTEXT, PV_CONTINUE, PV_DEFAULT, PV_ESWITCHES, PV_EXTENSION, PV_FOR, PV_GLOBALS, PV_GOTO, PV_IF, PV_IFTIME, PV_IGNOREPAT, PV_INCLUDES, PV_LABEL, PV_LOCALVARDEC, PV_MACRO, PV_MACRO_CALL, PV_PATTERN, PV_RANDOM, PV_RETURN, PV_STATEMENTBLOCK, PV_SWITCH, PV_SWITCHES, PV_VARDEC, PV_WHILE, PV_WORD, YYSTYPE::pval, reset_argcount(), reset_parencount(), reset_semicount(), set_dads(), pval::statements, pval::str, str, YYSTYPE::str, strdup, pval::u1, pval::u2, update_last(), and pval::val.

2322  {
2323  case 2:
2324 
2325 /* Line 1806 of yacc.c */
2326 #line 191 "ael.y"
2327  { (yyval.pval) = parseio->pval = (yyvsp[(1) - (1)].pval); }
2328  break;
2329 
2330  case 3:
2331 
2332 /* Line 1806 of yacc.c */
2333 #line 194 "ael.y"
2334  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2335  break;
2336 
2337  case 4:
2338 
2339 /* Line 1806 of yacc.c */
2340 #line 195 "ael.y"
2341  { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
2342  break;
2343 
2344  case 5:
2345 
2346 /* Line 1806 of yacc.c */
2347 #line 196 "ael.y"
2348  {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
2349  break;
2350 
2351  case 6:
2352 
2353 /* Line 1806 of yacc.c */
2354 #line 199 "ael.y"
2355  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2356  break;
2357 
2358  case 7:
2359 
2360 /* Line 1806 of yacc.c */
2361 #line 200 "ael.y"
2362  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2363  break;
2364 
2365  case 8:
2366 
2367 /* Line 1806 of yacc.c */
2368 #line 201 "ael.y"
2369  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2370  break;
2371 
2372  case 9:
2373 
2374 /* Line 1806 of yacc.c */
2375 #line 202 "ael.y"
2376  {(yyval.pval)=0;/* allow older docs to be read */}
2377  break;
2378 
2379  case 10:
2380 
2381 /* Line 1806 of yacc.c */
2382 #line 205 "ael.y"
2383  { (yyval.str) = (yyvsp[(1) - (1)].str); }
2384  break;
2385 
2386  case 11:
2387 
2388 /* Line 1806 of yacc.c */
2389 #line 206 "ael.y"
2390  { (yyval.str) = strdup("default"); }
2391  break;
2392 
2393  case 12:
2394 
2395 /* Line 1806 of yacc.c */
2396 #line 209 "ael.y"
2397  {
2398  (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
2399  (yyval.pval)->u1.str = (yyvsp[(3) - (6)].str);
2400  (yyval.pval)->u2.statements = (yyvsp[(5) - (6)].pval);
2401  set_dads((yyval.pval),(yyvsp[(5) - (6)].pval));
2402  (yyval.pval)->u3.abstract = (yyvsp[(1) - (6)].intval);}
2403  break;
2404 
2405  case 13:
2406 
2407 /* Line 1806 of yacc.c */
2408 #line 218 "ael.y"
2409  { (yyval.intval) = 1; }
2410  break;
2411 
2412  case 14:
2413 
2414 /* Line 1806 of yacc.c */
2415 #line 219 "ael.y"
2416  { (yyval.intval) = 0; }
2417  break;
2418 
2419  case 15:
2420 
2421 /* Line 1806 of yacc.c */
2422 #line 220 "ael.y"
2423  { (yyval.intval) = 2; }
2424  break;
2425 
2426  case 16:
2427 
2428 /* Line 1806 of yacc.c */
2429 #line 221 "ael.y"
2430  { (yyval.intval)=3; }
2431  break;
2432 
2433  case 17:
2434 
2435 /* Line 1806 of yacc.c */
2436 #line 222 "ael.y"
2437  { (yyval.intval)=3; }
2438  break;
2439 
2440  case 18:
2441 
2442 /* Line 1806 of yacc.c */
2443 #line 225 "ael.y"
2444  {
2445  (yyval.pval) = npval2(PV_MACRO, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
2446  (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);
2447  set_dads((yyval.pval),(yyvsp[(7) - (8)].pval));}
2448  break;
2449 
2450  case 19:
2451 
2452 /* Line 1806 of yacc.c */
2453 #line 231 "ael.y"
2454  {
2455  (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
2456  (yyval.pval)->u1.statements = (yyvsp[(3) - (4)].pval);
2457  set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
2458  break;
2459 
2460  case 20:
2461 
2462 /* Line 1806 of yacc.c */
2463 #line 237 "ael.y"
2464  { (yyval.pval) = NULL; }
2465  break;
2466 
2467  case 21:
2468 
2469 /* Line 1806 of yacc.c */
2470 #line 238 "ael.y"
2471  {(yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
2472  break;
2473 
2474  case 22:
2475 
2476 /* Line 1806 of yacc.c */
2477 #line 239 "ael.y"
2478  {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
2479  break;
2480 
2481  case 23:
2482 
2483 /* Line 1806 of yacc.c */
2484 #line 242 "ael.y"
2486  break;
2487 
2488  case 24:
2489 
2490 /* Line 1806 of yacc.c */
2491 #line 242 "ael.y"
2492  {
2493  (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
2494  (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
2495  (yyval.pval)->u2.val = (yyvsp[(4) - (5)].str); }
2496  break;
2497 
2498  case 25:
2499 
2500 /* Line 1806 of yacc.c */
2501 #line 248 "ael.y"
2503  break;
2504 
2505  case 26:
2506 
2507 /* Line 1806 of yacc.c */
2508 #line 248 "ael.y"
2509  {
2510  (yyval.pval) = npval2(PV_LOCALVARDEC, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
2511  (yyval.pval)->u1.str = (yyvsp[(2) - (6)].str);
2512  (yyval.pval)->u2.val = (yyvsp[(5) - (6)].str); }
2513  break;
2514 
2515  case 27:
2516 
2517 /* Line 1806 of yacc.c */
2518 #line 255 "ael.y"
2519  { (yyval.pval) = NULL; }
2520  break;
2521 
2522  case 28:
2523 
2524 /* Line 1806 of yacc.c */
2525 #line 256 "ael.y"
2526  { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
2527  break;
2528 
2529  case 29:
2530 
2531 /* Line 1806 of yacc.c */
2532 #line 257 "ael.y"
2533  { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
2534  break;
2535 
2536  case 30:
2537 
2538 /* Line 1806 of yacc.c */
2539 #line 258 "ael.y"
2540  {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
2541  break;
2542 
2543  case 31:
2544 
2545 /* Line 1806 of yacc.c */
2546 #line 261 "ael.y"
2547  {(yyval.pval)=0;}
2548  break;
2549 
2550  case 32:
2551 
2552 /* Line 1806 of yacc.c */
2553 #line 262 "ael.y"
2554  { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
2555  break;
2556 
2557  case 33:
2558 
2559 /* Line 1806 of yacc.c */
2560 #line 263 "ael.y"
2561  { (yyval.pval)=(yyvsp[(2) - (2)].pval);}
2562  break;
2563 
2564  case 34:
2565 
2566 /* Line 1806 of yacc.c */
2567 #line 266 "ael.y"
2568  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2569  break;
2570 
2571  case 35:
2572 
2573 /* Line 1806 of yacc.c */
2574 #line 267 "ael.y"
2575  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2576  break;
2577 
2578  case 36:
2579 
2580 /* Line 1806 of yacc.c */
2581 #line 268 "ael.y"
2582  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2583  break;
2584 
2585  case 37:
2586 
2587 /* Line 1806 of yacc.c */
2588 #line 269 "ael.y"
2589  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2590  break;
2591 
2592  case 38:
2593 
2594 /* Line 1806 of yacc.c */
2595 #line 270 "ael.y"
2596  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2597  break;
2598 
2599  case 39:
2600 
2601 /* Line 1806 of yacc.c */
2602 #line 271 "ael.y"
2603  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2604  break;
2605 
2606  case 40:
2607 
2608 /* Line 1806 of yacc.c */
2609 #line 272 "ael.y"
2610  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
2611  break;
2612 
2613  case 41:
2614 
2615 /* Line 1806 of yacc.c */
2616 #line 273 "ael.y"
2617  {free((yyvsp[(1) - (2)].str)); (yyval.pval)=0;}
2618  break;
2619 
2620  case 42:
2621 
2622 /* Line 1806 of yacc.c */
2623 #line 274 "ael.y"
2624  {(yyval.pval)=0;/* allow older docs to be read */}
2625  break;
2626 
2627  case 43:
2628 
2629 /* Line 1806 of yacc.c */
2630 #line 277 "ael.y"
2631  {
2632  (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
2633  (yyval.pval)->u1.str = (yyvsp[(3) - (4)].str);}
2634  break;
2635 
2636  case 44:
2637 
2638 /* Line 1806 of yacc.c */
2639 #line 282 "ael.y"
2640  {
2641  (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2642  (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
2643  (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
2644  break;
2645 
2646  case 45:
2647 
2648 /* Line 1806 of yacc.c */
2649 #line 286 "ael.y"
2650  {
2651  (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (5)]), &(yylsp[(3) - (5)]));
2652  (yyval.pval)->u1.str = malloc(strlen((yyvsp[(1) - (5)].str))+strlen((yyvsp[(3) - (5)].str))+2);
2653  strcpy((yyval.pval)->u1.str,(yyvsp[(1) - (5)].str));
2654  strcat((yyval.pval)->u1.str,"@");
2655  strcat((yyval.pval)->u1.str,(yyvsp[(3) - (5)].str));
2656  free((yyvsp[(1) - (5)].str));
2657  (yyval.pval)->u2.statements = (yyvsp[(5) - (5)].pval); set_dads((yyval.pval),(yyvsp[(5) - (5)].pval));}
2658  break;
2659 
2660  case 46:
2661 
2662 /* Line 1806 of yacc.c */
2663 #line 294 "ael.y"
2664  {
2665  (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
2666  (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
2667  (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));
2668  (yyval.pval)->u4.regexten=1;}
2669  break;
2670 
2671  case 47:
2672 
2673 /* Line 1806 of yacc.c */
2674 #line 299 "ael.y"
2675  {
2676  (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (7)]), &(yylsp[(7) - (7)]));
2677  (yyval.pval)->u1.str = (yyvsp[(5) - (7)].str);
2678  (yyval.pval)->u2.statements = (yyvsp[(7) - (7)].pval); set_dads((yyval.pval),(yyvsp[(7) - (7)].pval));
2679  (yyval.pval)->u3.hints = (yyvsp[(3) - (7)].str);}
2680  break;
2681 
2682  case 48:
2683 
2684 /* Line 1806 of yacc.c */
2685 #line 304 "ael.y"
2686  {
2687  (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
2688  (yyval.pval)->u1.str = (yyvsp[(6) - (8)].str);
2689  (yyval.pval)->u2.statements = (yyvsp[(8) - (8)].pval); set_dads((yyval.pval),(yyvsp[(8) - (8)].pval));
2690  (yyval.pval)->u4.regexten=1;
2691  (yyval.pval)->u3.hints = (yyvsp[(4) - (8)].str);}
2692  break;
2693 
2694  case 49:
2695 
2696 /* Line 1806 of yacc.c */
2697 #line 313 "ael.y"
2698  { (yyval.pval) = NULL; }
2699  break;
2700 
2701  case 50:
2702 
2703 /* Line 1806 of yacc.c */
2704 #line 314 "ael.y"
2705  { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
2706  break;
2707 
2708  case 51:
2709 
2710 /* Line 1806 of yacc.c */
2711 #line 315 "ael.y"
2712  {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
2713  break;
2714 
2715  case 52:
2716 
2717 /* Line 1806 of yacc.c */
2718 #line 321 "ael.y"
2719  {
2720  if (asprintf(&(yyval.str), "%s:%s:%s", (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)) < 0) {
2721  ast_log(LOG_WARNING, "asprintf() failed\n");
2722  (yyval.str) = NULL;
2723  } else {
2724  free((yyvsp[(1) - (5)].str));
2725  free((yyvsp[(3) - (5)].str));
2726  free((yyvsp[(5) - (5)].str));
2727  }
2728  }
2729  break;
2730 
2731  case 53:
2732 
2733 /* Line 1806 of yacc.c */
2734 #line 331 "ael.y"
2735  { (yyval.str) = (yyvsp[(1) - (1)].str); }
2736  break;
2737 
2738  case 54:
2739 
2740 /* Line 1806 of yacc.c */
2741 #line 335 "ael.y"
2742  {
2743  (yyval.pval) = nword((yyvsp[(1) - (7)].str), &(yylsp[(1) - (7)]));
2744  (yyval.pval)->next = nword((yyvsp[(3) - (7)].str), &(yylsp[(3) - (7)]));
2745  (yyval.pval)->next->next = nword((yyvsp[(5) - (7)].str), &(yylsp[(5) - (7)]));
2746  (yyval.pval)->next->next->next = nword((yyvsp[(7) - (7)].str), &(yylsp[(7) - (7)])); }
2747  break;
2748 
2749  case 55:
2750 
2751 /* Line 1806 of yacc.c */
2752 #line 343 "ael.y"
2754  break;
2755 
2756  case 56:
2757 
2758 /* Line 1806 of yacc.c */
2759 #line 343 "ael.y"
2760  { (yyval.str) = (yyvsp[(3) - (4)].str); }
2761  break;
2762 
2763  case 57:
2764 
2765 /* Line 1806 of yacc.c */
2766 #line 347 "ael.y"
2767  {
2768  (yyval.pval)= npval2(PV_IF, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
2769  (yyval.pval)->u1.str = (yyvsp[(2) - (2)].str); }
2770  break;
2771 
2772  case 58:
2773 
2774 /* Line 1806 of yacc.c */
2775 #line 350 "ael.y"
2776  {
2777  (yyval.pval) = npval2(PV_RANDOM, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
2778  (yyval.pval)->u1.str=(yyvsp[(2) - (2)].str);}
2779  break;
2780 
2781  case 59:
2782 
2783 /* Line 1806 of yacc.c */
2784 #line 353 "ael.y"
2785  {
2786  (yyval.pval) = npval2(PV_IFTIME, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
2787  (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);
2788  prev_word = 0; }
2789  break;
2790 
2791  case 60:
2792 
2793 /* Line 1806 of yacc.c */
2794 #line 364 "ael.y"
2795  { (yyval.str) = (yyvsp[(1) - (1)].str);}
2796  break;
2797 
2798  case 61:
2799 
2800 /* Line 1806 of yacc.c */
2801 #line 365 "ael.y"
2802  {
2803  if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
2804  ast_log(LOG_WARNING, "asprintf() failed\n");
2805  (yyval.str) = NULL;
2806  } else {
2807  free((yyvsp[(1) - (2)].str));
2808  free((yyvsp[(2) - (2)].str));
2809  prev_word = (yyval.str);
2810  }
2811  }
2812  break;
2813 
2814  case 62:
2815 
2816 /* Line 1806 of yacc.c */
2817 #line 377 "ael.y"
2818  { (yyval.str) = (yyvsp[(1) - (1)].str); }
2819  break;
2820 
2821  case 63:
2822 
2823 /* Line 1806 of yacc.c */
2824 #line 378 "ael.y"
2825  {
2826  if (asprintf(&((yyval.str)), "%s %s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
2827  ast_log(LOG_WARNING, "asprintf() failed\n");
2828  (yyval.str) = NULL;
2829  } else {
2830  free((yyvsp[(1) - (2)].str));
2831  free((yyvsp[(2) - (2)].str));
2832  }
2833  }
2834  break;
2835 
2836  case 64:
2837 
2838 /* Line 1806 of yacc.c */
2839 #line 387 "ael.y"
2840  {
2841  if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2842  ast_log(LOG_WARNING, "asprintf() failed\n");
2843  (yyval.str) = NULL;
2844  } else {
2845  free((yyvsp[(1) - (3)].str));
2846  free((yyvsp[(3) - (3)].str));
2847  }
2848  }
2849  break;
2850 
2851  case 65:
2852 
2853 /* Line 1806 of yacc.c */
2854 #line 396 "ael.y"
2855  { /* there are often '&' in hints */
2856  if (asprintf(&((yyval.str)), "%s&%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2857  ast_log(LOG_WARNING, "asprintf() failed\n");
2858  (yyval.str) = NULL;
2859  } else {
2860  free((yyvsp[(1) - (3)].str));
2861  free((yyvsp[(3) - (3)].str));
2862  }
2863  }
2864  break;
2865 
2866  case 66:
2867 
2868 /* Line 1806 of yacc.c */
2869 #line 405 "ael.y"
2870  {
2871  if (asprintf(&((yyval.str)), "%s@%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2872  ast_log(LOG_WARNING, "asprintf() failed\n");
2873  (yyval.str) = NULL;
2874  } else {
2875  free((yyvsp[(1) - (3)].str));
2876  free((yyvsp[(3) - (3)].str));
2877  }
2878  }
2879  break;
2880 
2881  case 67:
2882 
2883 /* Line 1806 of yacc.c */
2884 #line 416 "ael.y"
2885  { (yyval.str) = (yyvsp[(1) - (1)].str);}
2886  break;
2887 
2888  case 68:
2889 
2890 /* Line 1806 of yacc.c */
2891 #line 417 "ael.y"
2892  {
2893  if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
2894  ast_log(LOG_WARNING, "asprintf() failed\n");
2895  (yyval.str) = NULL;
2896  } else {
2897  free((yyvsp[(1) - (2)].str));
2898  free((yyvsp[(2) - (2)].str));
2899  prev_word = (yyval.str);
2900  }
2901  }
2902  break;
2903 
2904  case 69:
2905 
2906 /* Line 1806 of yacc.c */
2907 #line 427 "ael.y"
2908  {
2909  if (asprintf(&((yyval.str)), "%s%s%s", (yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2910  ast_log(LOG_WARNING, "asprintf() failed\n");
2911  (yyval.str) = NULL;
2912  } else {
2913  free((yyvsp[(1) - (3)].str));
2914  free((yyvsp[(2) - (3)].str));
2915  free((yyvsp[(3) - (3)].str));
2916  prev_word=(yyval.str);
2917  }
2918  }
2919  break;
2920 
2921  case 70:
2922 
2923 /* Line 1806 of yacc.c */
2924 #line 440 "ael.y"
2925  { (yyval.str) = (yyvsp[(1) - (1)].str);}
2926  break;
2927 
2928  case 71:
2929 
2930 /* Line 1806 of yacc.c */
2931 #line 441 "ael.y"
2932  {
2933  if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
2934  ast_log(LOG_WARNING, "asprintf() failed\n");
2935  (yyval.str) = NULL;
2936  } else {
2937  free((yyvsp[(1) - (2)].str));
2938  free((yyvsp[(2) - (2)].str));
2939  }
2940  }
2941  break;
2942 
2943  case 72:
2944 
2945 /* Line 1806 of yacc.c */
2946 #line 450 "ael.y"
2947  {
2948  if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2949  ast_log(LOG_WARNING, "asprintf() failed\n");
2950  (yyval.str) = NULL;
2951  } else {
2952  free((yyvsp[(1) - (3)].str));
2953  free((yyvsp[(3) - (3)].str));
2954  }
2955  }
2956  break;
2957 
2958  case 73:
2959 
2960 /* Line 1806 of yacc.c */
2961 #line 461 "ael.y"
2962  {
2963  (yyval.pval) = npval2(PV_SWITCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
2964  (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
2965  (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
2966  break;
2967 
2968  case 74:
2969 
2970 /* Line 1806 of yacc.c */
2971 #line 470 "ael.y"
2972  {
2973  (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2974  (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));}
2975  break;
2976 
2977  case 75:
2978 
2979 /* Line 1806 of yacc.c */
2980 #line 473 "ael.y"
2981  { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
2982  break;
2983 
2984  case 76:
2985 
2986 /* Line 1806 of yacc.c */
2987 #line 474 "ael.y"
2988  { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
2989  break;
2990 
2991  case 77:
2992 
2993 /* Line 1806 of yacc.c */
2994 #line 475 "ael.y"
2995  {
2996  (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2997  (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
2998  break;
2999 
3000  case 78:
3001 
3002 /* Line 1806 of yacc.c */
3003 #line 478 "ael.y"
3004  {
3005  (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
3006  (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
3007  break;
3008 
3009  case 79:
3010 
3011 /* Line 1806 of yacc.c */
3012 #line 481 "ael.y"
3013  {
3014  (yyval.pval) = npval2(PV_LABEL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
3015  (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str); }
3016  break;
3017 
3018  case 80:
3019 
3020 /* Line 1806 of yacc.c */
3021 #line 484 "ael.y"
3023  break;
3024 
3025  case 81:
3026 
3027 /* Line 1806 of yacc.c */
3028 #line 485 "ael.y"
3030  break;
3031 
3032  case 82:
3033 
3034 /* Line 1806 of yacc.c */
3035 #line 486 "ael.y"
3037  break;
3038 
3039  case 83:
3040 
3041 /* Line 1806 of yacc.c */
3042 #line 486 "ael.y"
3043  { /* XXX word_list maybe ? */
3044  (yyval.pval) = npval2(PV_FOR, &(yylsp[(1) - (12)]), &(yylsp[(12) - (12)]));
3045  (yyval.pval)->u1.for_init = (yyvsp[(4) - (12)].str);
3046  (yyval.pval)->u2.for_test=(yyvsp[(7) - (12)].str);
3047  (yyval.pval)->u3.for_inc = (yyvsp[(10) - (12)].str);
3048  (yyval.pval)->u4.for_statements = (yyvsp[(12) - (12)].pval); set_dads((yyval.pval),(yyvsp[(12) - (12)].pval));}
3049  break;
3050 
3051  case 84:
3052 
3053 /* Line 1806 of yacc.c */
3054 #line 492 "ael.y"
3055  {
3056  (yyval.pval) = npval2(PV_WHILE, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
3057  (yyval.pval)->u1.str = (yyvsp[(2) - (3)].str);
3058  (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
3059  break;
3060 
3061  case 85:
3062 
3063 /* Line 1806 of yacc.c */
3064 #line 496 "ael.y"
3065  { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
3066  break;
3067 
3068  case 86:
3069 
3070 /* Line 1806 of yacc.c */
3071 #line 497 "ael.y"
3072  { (yyval.pval) = update_last((yyvsp[(2) - (3)].pval), &(yylsp[(2) - (3)])); }
3073  break;
3074 
3075  case 87:
3076 
3077 /* Line 1806 of yacc.c */
3078 #line 498 "ael.y"
3079  { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
3080  break;
3081 
3082  case 88:
3083 
3084 /* Line 1806 of yacc.c */
3085 #line 499 "ael.y"
3086  {
3087  (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
3088  (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str);}
3089  break;
3090 
3091  case 89:
3092 
3093 /* Line 1806 of yacc.c */
3094 #line 502 "ael.y"
3096  break;
3097 
3098  case 90:
3099 
3100 /* Line 1806 of yacc.c */
3101 #line 502 "ael.y"
3102  {
3103  char *bufx;
3104  int tot=0;
3105  pval *pptr;
3106  (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
3107  (yyval.pval)->u2.val=(yyvsp[(4) - (5)].str);
3108  /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
3109  /* string to big to fit in the buffer? */
3110  tot+=strlen((yyvsp[(1) - (5)].pval)->u1.str);
3111  for(pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
3112  tot+=strlen(pptr->u1.str);
3113  tot++; /* for a sep like a comma */
3114  }
3115  tot+=4; /* for safety */
3116  bufx = calloc(1, tot);
3117  strcpy(bufx,(yyvsp[(1) - (5)].pval)->u1.str);
3118  strcat(bufx,"(");
3119  /* XXX need to advance the pointer or the loop is very inefficient */
3120  for (pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
3121  if ( pptr != (yyvsp[(1) - (5)].pval)->u2.arglist )
3122  strcat(bufx,",");
3123  strcat(bufx,pptr->u1.str);
3124  }
3125  strcat(bufx,")");
3126 #ifdef AAL_ARGCHECK
3127  if ( !ael_is_funcname((yyvsp[(1) - (5)].pval)->u1.str) )
3128  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",
3129  my_file, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column, (yylsp[(1) - (5)]).last_column, (yyvsp[(1) - (5)].pval)->u1.str);
3130 #endif
3131  (yyval.pval)->u1.str = bufx;
3132  destroy_pval((yyvsp[(1) - (5)].pval)); /* the app call it is not, get rid of that chain */
3133  prev_word = 0;
3134  }
3135  break;
3136 
3137  case 91:
3138 
3139 /* Line 1806 of yacc.c */
3140 #line 535 "ael.y"
3141  { (yyval.pval) = npval2(PV_BREAK, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
3142  break;
3143 
3144  case 92:
3145 
3146 /* Line 1806 of yacc.c */
3147 #line 536 "ael.y"
3148  { (yyval.pval) = npval2(PV_RETURN, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
3149  break;
3150 
3151  case 93:
3152 
3153 /* Line 1806 of yacc.c */
3154 #line 537 "ael.y"
3155  { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
3156  break;
3157 
3158  case 94:
3159 
3160 /* Line 1806 of yacc.c */
3161 #line 538 "ael.y"
3162  {
3163  (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(2) - (3)]));
3164  (yyval.pval)->u2.statements = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));
3165  (yyval.pval)->u3.else_statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
3166  break;
3167 
3168  case 95:
3169 
3170 /* Line 1806 of yacc.c */
3171 #line 542 "ael.y"
3172  { (yyval.pval)=0; }
3173  break;
3174 
3175  case 96:
3176 
3177 /* Line 1806 of yacc.c */
3178 #line 545 "ael.y"
3179  { (yyval.pval) = (yyvsp[(2) - (2)].pval); }
3180  break;
3181 
3182  case 97:
3183 
3184 /* Line 1806 of yacc.c */
3185 #line 546 "ael.y"
3186  { (yyval.pval) = NULL ; }
3187  break;
3188 
3189  case 98:
3190 
3191 /* Line 1806 of yacc.c */
3192 #line 549 "ael.y"
3193  { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
3194  break;
3195 
3196  case 99:
3197 
3198 /* Line 1806 of yacc.c */
3199 #line 550 "ael.y"
3200  {
3201  (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
3202  (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
3203  break;
3204 
3205  case 100:
3206 
3207 /* Line 1806 of yacc.c */
3208 #line 553 "ael.y"
3209  {
3210  (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
3211  (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
3212  break;
3213 
3214  case 101:
3215 
3216 /* Line 1806 of yacc.c */
3217 #line 556 "ael.y"
3218  {
3219  (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
3220  (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
3221  (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
3222  break;
3223 
3224  case 102:
3225 
3226 /* Line 1806 of yacc.c */
3227 #line 560 "ael.y"
3228  {
3229  (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
3230  (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
3231  (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
3232  break;
3233 
3234  case 103:
3235 
3236 /* Line 1806 of yacc.c */
3237 #line 564 "ael.y"
3238  {
3239  (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
3240  (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
3241  (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
3242  break;
3243 
3244  case 104:
3245 
3246 /* Line 1806 of yacc.c */
3247 #line 568 "ael.y"
3248  {
3249  (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
3250  (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
3251  (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
3252  break;
3253 
3254  case 105:
3255 
3256 /* Line 1806 of yacc.c */
3257 #line 574 "ael.y"
3258  { (yyval.str) = strdup("1"); }
3259  break;
3260 
3261  case 106:
3262 
3263 /* Line 1806 of yacc.c */
3264 #line 575 "ael.y"
3265  { (yyval.str) = (yyvsp[(2) - (2)].str); }
3266  break;
3267 
3268  case 107:
3269 
3270 /* Line 1806 of yacc.c */
3271 #line 579 "ael.y"
3272  { /* ext[, pri] default 1 */
3273  (yyval.pval) = nword((yyvsp[(1) - (2)].str), &(yylsp[(1) - (2)]));
3274  (yyval.pval)->next = nword((yyvsp[(2) - (2)].str), &(yylsp[(2) - (2)])); }
3275  break;
3276 
3277  case 108:
3278 
3279 /* Line 1806 of yacc.c */
3280 #line 582 "ael.y"
3281  { /* context, ext, pri */
3282  (yyval.pval) = nword((yyvsp[(4) - (4)].str), &(yylsp[(4) - (4)]));
3283  (yyval.pval)->next = nword((yyvsp[(1) - (4)].str), &(yylsp[(1) - (4)]));
3284  (yyval.pval)->next->next = nword((yyvsp[(2) - (4)].str), &(yylsp[(2) - (4)])); }
3285  break;
3286 
3287  case 109:
3288 
3289 /* Line 1806 of yacc.c */
3290 #line 588 "ael.y"
3292  break;
3293 
3294  case 110:
3295 
3296 /* Line 1806 of yacc.c */
3297 #line 588 "ael.y"
3298  {
3299  /* XXX original code had @2 but i think we need @5 */
3300  (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
3301  (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
3302  (yyval.pval)->u2.arglist = (yyvsp[(4) - (5)].pval);}
3303  break;
3304 
3305  case 111:
3306 
3307 /* Line 1806 of yacc.c */
3308 #line 593 "ael.y"
3309  {
3310  (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
3311  (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); }
3312  break;
3313 
3314  case 112:
3315 
3316 /* Line 1806 of yacc.c */
3317 #line 601 "ael.y"
3319  break;
3320 
3321  case 113:
3322 
3323 /* Line 1806 of yacc.c */
3324 #line 601 "ael.y"
3325  {
3326  if (strcasecmp((yyvsp[(1) - (3)].str),"goto") == 0) {
3327  (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
3328  free((yyvsp[(1) - (3)].str)); /* won't be using this */
3329  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 );
3330  } else {
3331  (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
3332  (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
3333  } }
3334  break;
3335 
3336  case 114:
3337 
3338 /* Line 1806 of yacc.c */
3339 #line 612 "ael.y"
3340  {
3341  (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(3) - (3)]));
3342  if( (yyval.pval)->type == PV_GOTO )
3343  (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);
3344  else
3345  (yyval.pval)->u2.arglist = (yyvsp[(2) - (3)].pval);
3346  }
3347  break;
3348 
3349  case 115:
3350 
3351 /* Line 1806 of yacc.c */
3352 #line 619 "ael.y"
3353  { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
3354  break;
3355 
3356  case 116:
3357 
3358 /* Line 1806 of yacc.c */
3359 #line 622 "ael.y"
3360  { (yyval.str) = (yyvsp[(1) - (1)].str) ;}
3361  break;
3362 
3363  case 117:
3364 
3365 /* Line 1806 of yacc.c */
3366 #line 623 "ael.y"
3367  { (yyval.str) = strdup(""); }
3368  break;
3369 
3370  case 118:
3371 
3372 /* Line 1806 of yacc.c */
3373 #line 626 "ael.y"
3374  { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
3375  break;
3376 
3377  case 119:
3378 
3379 /* Line 1806 of yacc.c */
3380 #line 627 "ael.y"
3381  {
3382  (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
3383  (yyval.pval)->u1.str = strdup(""); }
3384  break;
3385 
3386  case 120:
3387 
3388 /* Line 1806 of yacc.c */
3389 #line 630 "ael.y"
3390  { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
3391  break;
3392 
3393  case 121:
3394 
3395 /* Line 1806 of yacc.c */
3396 #line 633 "ael.y"
3397  { (yyval.pval) = NULL; }
3398  break;
3399 
3400  case 122:
3401 
3402 /* Line 1806 of yacc.c */
3403 #line 634 "ael.y"
3404  { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
3405  break;
3406 
3407  case 123:
3408 
3409 /* Line 1806 of yacc.c */
3410 #line 637 "ael.y"
3411  {
3412  (yyval.pval) = npval2(PV_CASE, &(yylsp[(1) - (4)]), &(yylsp[(3) - (4)])); /* XXX 3 or 4 ? */
3413  (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
3414  (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
3415  break;
3416 
3417  case 124:
3418 
3419 /* Line 1806 of yacc.c */
3420 #line 641 "ael.y"
3421  {
3422  (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
3423  (yyval.pval)->u1.str = NULL;
3424  (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
3425  break;
3426 
3427  case 125:
3428 
3429 /* Line 1806 of yacc.c */
3430 #line 645 "ael.y"
3431  {
3432  (yyval.pval) = npval2(PV_PATTERN, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); /* XXX@3 or @4 ? */
3433  (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
3434  (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval);set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
3435  break;
3436 
3437  case 126:
3438 
3439 /* Line 1806 of yacc.c */
3440 #line 651 "ael.y"
3441  { (yyval.pval) = NULL; }
3442  break;
3443 
3444  case 127:
3445 
3446 /* Line 1806 of yacc.c */
3447 #line 652 "ael.y"
3448  { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
3449  break;
3450 
3451  case 128:
3452 
3453 /* Line 1806 of yacc.c */
3454 #line 655 "ael.y"
3455  {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
3456  break;
3457 
3458  case 129:
3459 
3460 /* Line 1806 of yacc.c */
3461 #line 656 "ael.y"
3462  { (yyval.pval)=(yyvsp[(1) - (1)].pval);}
3463  break;
3464 
3465  case 130:
3466 
3467 /* Line 1806 of yacc.c */
3468 #line 657 "ael.y"
3469  {
3470  (yyval.pval) = npval2(PV_CATCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
3471  (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
3472  (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
3473  break;
3474 
3475  case 131:
3476 
3477 /* Line 1806 of yacc.c */
3478 #line 663 "ael.y"
3479  {
3480  (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
3481  (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
3482  break;
3483 
3484  case 132:
3485 
3486 /* Line 1806 of yacc.c */
3487 #line 668 "ael.y"
3488  {
3489  (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
3490  (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
3491  break;
3492 
3493  case 133:
3494 
3495 /* Line 1806 of yacc.c */
3496 #line 673 "ael.y"
3497  { (yyval.pval) = NULL; }
3498  break;
3499 
3500  case 134:
3501 
3502 /* Line 1806 of yacc.c */
3503 #line 674 "ael.y"
3504  { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval),nword((yyvsp[(2) - (3)].str), &(yylsp[(2) - (3)]))); }
3505  break;
3506 
3507  case 135:
3508 
3509 /* Line 1806 of yacc.c */
3510 #line 675 "ael.y"
3511  {
3512  char *x;
3513  if (asprintf(&x,"%s@%s", (yyvsp[(2) - (5)].str), (yyvsp[(4) - (5)].str)) < 0) {
3514  ast_log(LOG_WARNING, "asprintf() failed\n");
3515  (yyval.pval) = NULL;
3516  } else {
3517  free((yyvsp[(2) - (5)].str));
3518  free((yyvsp[(4) - (5)].str));
3519  (yyval.pval) = linku1((yyvsp[(1) - (5)].pval),nword(x, &(yylsp[(2) - (5)])));
3520  }
3521  }
3522  break;
3523 
3524  case 136:
3525 
3526 /* Line 1806 of yacc.c */
3527 #line 686 "ael.y"
3528  {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
3529  break;
3530 
3531  case 137:
3532 
3533 /* Line 1806 of yacc.c */
3534 #line 689 "ael.y"
3535  { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
3536  break;
3537 
3538  case 138:
3539 
3540 /* Line 1806 of yacc.c */
3541 #line 690 "ael.y"
3542  {
3543  (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
3544  (yyval.pval)->u2.arglist = (yyvsp[(3) - (3)].pval);
3545  prev_word=0; /* XXX sure ? */ }
3546  break;
3547 
3548  case 139:
3549 
3550 /* Line 1806 of yacc.c */
3551 #line 697 "ael.y"
3552  { (yyval.pval) = (yyvsp[(1) - (2)].pval); }
3553  break;
3554 
3555  case 140:
3556 
3557 /* Line 1806 of yacc.c */
3558 #line 698 "ael.y"
3559  { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), (yyvsp[(2) - (3)].pval)); }
3560  break;
3561 
3562  case 141:
3563 
3564 /* Line 1806 of yacc.c */
3565 #line 699 "ael.y"
3566  {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
3567  break;
3568 
3569  case 142:
3570 
3571 /* Line 1806 of yacc.c */
3572 #line 702 "ael.y"
3573  {
3574  (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
3575  (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
3576  break;
3577 
3578  case 143:
3579 
3580 /* Line 1806 of yacc.c */
3581 #line 705 "ael.y"
3582  {
3583  (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));}
3584  break;
3585 
3586 
3587 
3588 /* Line 1806 of yacc.c */
3589 #line 3590 "ael.tab.c"
3590  default: break;
3591  }
union pval::@198 u1
void reset_semicount(yyscan_t yyscanner)
Definition: ael_lex.c:3325
struct parse_io * parseio
Definition: ael.tab.c:1485
struct pval * list
Definition: pval.h:60
#define malloc(a)
Definition: astmm.h:88
static void set_dads(pval *dad, pval *child_list)
Definition: ael.tab.c:4002
Definition: pval.h:32
struct pval * pval
Definition: ael_structs.h:77
Definition: pval.h:29
#define LOG_WARNING
Definition: logger.h:144
yylloc first_column
Definition: ast_expr2.c:1858
struct pval * pval
Definition: ael.tab.c:218
YYLTYPE * yylsp
Definition: ast_expr2.c:1805
Definition: pval.h:22
yyscan_t scanner
Definition: ael_structs.h:78
const char * str
Definition: app_jack.c:144
Definition: pval.h:8
#define calloc(a, b)
Definition: astmm.h:79
union pval::@200 u3
union pval::@199 u2
Definition: pval.h:13
void reset_argcount(yyscan_t yyscanner)
Definition: ael_lex.c:3333
static pval * nword(char *string, YYLTYPE *pos)
Definition: ael.tab.c:3993
int asprintf(char **str, const char *fmt,...)
YYSTYPE yyval
Definition: ast_expr2.c:1818
YYSTYPE * yyvsp
Definition: ast_expr2.c:1800
Definition: pval.h:21
char * my_file
Definition: ael_lex.c:873
char * str
Definition: pval.h:59
Definition: pval.h:48
void destroy_pval(pval *item)
Definition: pval.c:4979
char * str
Definition: ael.tab.c:217
#define free(a)
Definition: astmm.h:94
Definition: pval.h:24
union pval::@201 u4
struct pval * arglist
Definition: pval.h:68
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
Definition: pval.h:9
Definition: pval.h:31
pval * linku1(pval *head, pval *tail)
Definition: pval.c:5926
int intval
Definition: ael.tab.c:216
char * prev_word
Definition: ael_lex.c:874
static pval * npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last)
Definition: ael.tab.c:3979
Definition: pval.h:25
Definition: pval.h:30
Definition: pval.h:23
struct pval * next
Definition: pval.h:93
pval * npval(pvaltype type, int first_line, int last_line, int first_column, int last_column)
Definition: ael.tab.c:3966
static pval * update_last(pval *, YYLTYPE *)
Definition: ael.tab.c:3985
Definition: pval.h:27
#define strdup(a)
Definition: astmm.h:106
void reset_parencount(yyscan_t yyscanner)
Definition: ael_lex.c:3314
Definition: pval.h:26
Definition: pval.h:16
yylloc first_line
Definition: ast_expr2.c:1857
static struct pval * update_last ( pval obj,
YYLTYPE last 
)
static

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

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

Referenced by switch().

3986 {
3987  obj->endline = last->last_line;
3988  obj->endcol = last->last_column;
3989  return obj;
3990 }
int last_line
Definition: ast_expr2.h:95
int last_column
Definition: ast_expr2.h:96
int endcol
Definition: pval.h:54
int endline
Definition: pval.h:52
while ( yyssp!  = yyss)

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

References yydestruct(), and YYPOPSTACK.

3807  {
3808  yydestruct ("Cleanup: popping",
3809  yystos[*yyssp], yyvsp, yylsp, parseio);
3810  YYPOPSTACK (1);
3811  }
struct parse_io * parseio
Definition: ael.tab.c:1485
#define YYPOPSTACK(N)
Definition: ast_expr2.c:1828
yytype_int16 * yyssp
Definition: ast_expr2.c:1795
YYLTYPE * yylsp
Definition: ast_expr2.c:1805
YYSTYPE * yyvsp
Definition: ast_expr2.c:1800
yydestruct("Cleanup: discarding lookahead", yytoken,&yylval,&yylloc)
static const yytype_uint8 yystos[]
Definition: ael.tab.c:909
yyexhaustedlab YY_ ( "memory exhausted"  )
YY_REDUCE_PRINT ( yyn  )
YY_STACK_PRINT ( yyss  ,
yyssp   
)
YY_SYMBOL_PRINT ( yymsg  ,
yytype  ,
yyvaluep  ,
yylocationp   
)
YY_SYMBOL_PRINT ( "Next token is"  ,
yytoken  ,
yylval,
yylloc 
)
YY_SYMBOL_PRINT ( "Shifting"  ,
yytoken  ,
yylval,
yylloc 
)
YY_SYMBOL_PRINT ( )
YY_SYMBOL_PRINT ( "Shifting"  ,
yystos  [yyn],
yyvsp  ,
yylsp   
)
yydestruct ( "Cleanup: discarding lookahead"  ,
yytoken  ,
yylval,
yylloc,
parseio   
)
YYDPRINTF ( (stderr,"Starting parse\n")  )
YYDPRINTF ( (stderr,"Entering state %d\n", yystate)  )
void yyerror ( YYLTYPE locp,
struct parse_io parseio,
char const *  s 
)

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

3955 {
3956  char *s2 = ael_token_subst((char *)s);
3957  if (locp->first_line == locp->last_line) {
3958  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);
3959  } else {
3960  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);
3961  }
3962  free(s2);
3963  parseio->syntax_error_count++;
3964 }
static char * ael_token_subst(const char *mess)
Definition: ael.tab.c:3911
int last_line
Definition: ast_expr2.h:95
char * my_file
Definition: ael_lex.c:873
int last_column
Definition: ast_expr2.h:96
int first_line
Definition: ast_expr2.h:93
int syntax_error_count
Definition: ael_structs.h:79
#define LOG_ERROR
Definition: logger.h:155
#define free(a)
Definition: astmm.h:94
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
Definition: logger.c:1207
int first_column
Definition: ast_expr2.h:94
return YYID ( yyresult  )
YYLLOC_DEFAULT ( yyloc  ,
(yylsp-yylen ,
yylen   
)
YYLLOC_DEFAULT ( yyloc  ,
yyerror_range  ,
 
)
int yyparse ( )
YYPOPSTACK ( yylen  )
YYSTACK_FREE ( yyss  )
YYSTACK_FREE ( yymsg  )
static int yysyntax_error ( YYSIZE_T yymsg_alloc,
char **  yymsg,
yytype_int16 yyssp,
int  yytoken 
)
static

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

References YY_, YYCASE_, YYEMPTY, YYLAST, yymsg, yyn, YYNTOKENS, yypact_value_is_default, YYSIZE_T, yyssp, YYSTACK_ALLOC_MAXIMUM, yytable_value_is_error, YYTERROR, yytnamerr(), and yytoken.

1343 {
1344  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1345  YYSIZE_T yysize = yysize0;
1346  YYSIZE_T yysize1;
1347  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1348  /* Internationalized format string. */
1349  const char *yyformat = 0;
1350  /* Arguments of yyformat. */
1351  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1352  /* Number of reported tokens (one for the "unexpected", one per
1353  "expected"). */
1354  int yycount = 0;
1355 
1356  /* There are many possibilities here to consider:
1357  - Assume YYFAIL is not used. It's too flawed to consider. See
1358  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1359  for details. YYERROR is fine as it does not invoke this
1360  function.
1361  - If this state is a consistent state with a default action, then
1362  the only way this function was invoked is if the default action
1363  is an error action. In that case, don't check for expected
1364  tokens because there are none.
1365  - The only way there can be no lookahead present (in yychar) is if
1366  this state is a consistent state with a default action. Thus,
1367  detecting the absence of a lookahead is sufficient to determine
1368  that there is no unexpected or expected token to report. In that
1369  case, just report a simple "syntax error".
1370  - Don't assume there isn't a lookahead just because this state is a
1371  consistent state with a default action. There might have been a
1372  previous inconsistent state, consistent state with a non-default
1373  action, or user semantic action that manipulated yychar.
1374  - Of course, the expected token list depends on states to have
1375  correct lookahead information, and it depends on the parser not
1376  to perform extra reductions after fetching a lookahead from the
1377  scanner and before detecting a syntax error. Thus, state merging
1378  (from LALR or IELR) and default reductions corrupt the expected
1379  token list. However, the list is correct for canonical LR with
1380  one exception: it will still contain any token that will not be
1381  accepted due to an error action in a later state.
1382  */
1383  if (yytoken != YYEMPTY)
1384  {
1385  int yyn = yypact[*yyssp];
1386  yyarg[yycount++] = yytname[yytoken];
1387  if (!yypact_value_is_default (yyn))
1388  {
1389  /* Start YYX at -YYN if negative to avoid negative indexes in
1390  YYCHECK. In other words, skip the first -YYN actions for
1391  this state because they are default actions. */
1392  int yyxbegin = yyn < 0 ? -yyn : 0;
1393  /* Stay within bounds of both yycheck and yytname. */
1394  int yychecklim = YYLAST - yyn + 1;
1395  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1396  int yyx;
1397 
1398  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1399  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1400  && !yytable_value_is_error (yytable[yyx + yyn]))
1401  {
1402  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1403  {
1404  yycount = 1;
1405  yysize = yysize0;
1406  break;
1407  }
1408  yyarg[yycount++] = yytname[yyx];
1409  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1410  if (! (yysize <= yysize1
1411  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1412  return 2;
1413  yysize = yysize1;
1414  }
1415  }
1416  }
1417 
1418  switch (yycount)
1419  {
1420 # define YYCASE_(N, S) \
1421  case N: \
1422  yyformat = S; \
1423  break
1424  YYCASE_(0, YY_("syntax error"));
1425  YYCASE_(1, YY_("syntax error, unexpected %s"));
1426  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1427  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1428  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1429  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1430 # undef YYCASE_
1431  }
1432 
1433  yysize1 = yysize + yystrlen (yyformat);
1434  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1435  return 2;
1436  yysize = yysize1;
1437 
1438  if (*yymsg_alloc < yysize)
1439  {
1440  *yymsg_alloc = 2 * yysize;
1441  if (! (yysize <= *yymsg_alloc
1444  return 1;
1445  }
1446 
1447  /* Avoid sprintf, as that infringes on the user's name space.
1448  Don't have undefined behavior even if the translation
1449  produced a string with the wrong number of "%s"s. */
1450  {
1451  char *yyp = *yymsg;
1452  int yyi = 0;
1453  while ((*yyp = *yyformat) != '\0')
1454  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1455  {
1456  yyp += yytnamerr (yyp, yyarg[yyi++]);
1457  yyformat += 2;
1458  }
1459  else
1460  {
1461  yyp++;
1462  yyformat++;
1463  }
1464  }
1465  return 0;
1466 }
YYSIZE_T yymsg_alloc
Definition: ast_expr2.c:1825
yytype_int16 * yyssp
Definition: ast_expr2.c:1795
#define YYSTACK_ALLOC_MAXIMUM
Definition: ael.tab.c:398
static const yytype_int16 yypact[]
Definition: ael.tab.c:769
#define YYSIZE_T
Definition: ael.tab.c:313
static const yytype_int16 yytable[]
Definition: ael.tab.c:817
#define yytable_value_is_error(yytable_value)
Definition: ael.tab.c:862
#define YYLAST
Definition: ael.tab.c:491
#define YYNTOKENS
Definition: ael.tab.c:494
#define YYCASE_(N, S)
#define YYTERROR
Definition: ael.tab.c:986
static void const char * yymsg
Definition: ael.tab.c:1481
static const char *const yytname[]
Definition: ael.tab.c:643
int yyn
Definition: ast_expr2.c:1812
static const yytype_uint16 yycheck[]
Definition: ael.tab.c:865
#define YY_(msgid)
Definition: ast_expr2.c:571
#define YYEMPTY
Definition: ael.tab.c:944
#define yypact_value_is_default(yystate)
Definition: ael.tab.c:859
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ael.tab.c:1293
int yytoken
Definition: ast_expr2.c:1815
static YYSIZE_T yytnamerr ( char *  yyres,
const char *  yystr 
)
static

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

References yyn, YYSIZE_T, and yystr.

Referenced by yysyntax_error().

1294 {
1295  if (*yystr == '"')
1296  {
1297  YYSIZE_T yyn = 0;
1298  char const *yyp = yystr;
1299 
1300  for (;;)
1301  switch (*++yyp)
1302  {
1303  case '\'':
1304  case ',':
1305  goto do_not_strip_quotes;
1306 
1307  case '\\':
1308  if (*++yyp != '\\')
1309  goto do_not_strip_quotes;
1310  /* Fall through. */
1311  default:
1312  if (yyres)
1313  yyres[yyn] = *yyp;
1314  yyn++;
1315  break;
1316 
1317  case '"':
1318  if (yyres)
1319  yyres[yyn] = '\0';
1320  return yyn;
1321  }
1322  do_not_strip_quotes: ;
1323  }
1324 
1325  if (! yyres)
1326  return yystrlen (yystr);
1327 
1328  return yystpcpy (yyres, yystr) - yyres;
1329 }
#define YYSIZE_T
Definition: ael.tab.c:313
static YYSIZE_T const char * yystr
Definition: ael.tab.c:1245
int yyn
Definition: ast_expr2.c:1812
YYUSE ( yylocationp  )
YYUSE ( parseio  )

Variable Documentation

yynewstate __pad0__

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

yyexhaustedlab __pad10__

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

yyreturn __pad11__

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

yysetstate __pad1__

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

yybackup __pad2__

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

yydefault __pad3__

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

yyreduce __pad4__

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

yyerrlab __pad5__

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

yyerrorlab __pad6__

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

yyerrlab1 __pad7__

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

yyacceptlab __pad8__

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

yyabortlab __pad9__

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

continue
Initial value:
{
#define YYSIZE_T
Definition: ael.tab.c:313
return yylen
Definition: ast_expr2.c:1267

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

else
Initial value:
{
#define yychar
Definition: ast_expr2.c:69
int yytoken
Definition: ast_expr2.c:1815
#define YYTRANSLATE(YYX)
Definition: ael.tab.c:506

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

yylloc first_column = yylloc.last_column = 1

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

yylloc first_line = yylloc.last_line = 1

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

char* my_file

Definition at line 873 of file ael_lex.c.

yyexhaustedlab parseio

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

Referenced by switch().

char* token_equivs1[]
static

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

Referenced by ael_token_subst().

char* token_equivs2[]
static

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

YYACCEPT

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

goto yybackup

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

yychar = YYEMPTY

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

const yytype_uint16 yycheck[]
static

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

return yyd

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

const yytype_uint8 yydefact[]
static

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

goto yydefault

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

const yytype_int16 yydefgoto[]
static

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

char* char* yydest
static

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

goto yyerrlab

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

goto yyerrlab1

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

yyerror_range[2] = yylloc

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

yyerrstatus = 0

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

yylen = 0

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

YYLTYPE yylloc

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

YYLTYPE yyloc

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

YYLTYPE* yylocationp

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

yyls = yylsa

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

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

* yylsp = yyls

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

YYSTYPE yylval
Initial value:
{
int yychar
#define yychar
Definition: ast_expr2.c:69

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

char * yymsg = "Deleting"
static

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

Referenced by if(), and yysyntax_error().

YYSIZE_T yymsg_alloc = sizeof yymsgbuf

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

char yymsgbuf[128]

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

yyn = yytoken

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

yynerrs = 0

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

goto yynewstate

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

const yytype_int16 yypact[]
static

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

const yytype_int16 yypgoto[]
static

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

const yytype_uint8 yyr1[]
static

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

const yytype_uint8 yyr2[]
static

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

goto yyreduce

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

yyresult = 2

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

goto yyreturn

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

const char* yys = yysrc

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

goto yysetstate

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

const char* yysrc

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

yyss = yyssa

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

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

yyssp = yyss

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

yystacksize = YYINITDEPTH

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

yystate = 0

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

const yytype_uint8 yystos[]
static

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

YYSIZE_T const char* yystr
static

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

Referenced by yytnamerr().

const yytype_int16 yytable[]
static

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

const char* const yytname[]
static

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

yytoken = 0

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

const yytype_uint8 yytranslate[]
static

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

int yytype

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

yyval = yyvsp[1-yylen]

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

YYSTYPE* yyvaluep

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

yyvs = yyvsa

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

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

* yyvsp = yyvs

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