Grammar.cpp File Reference

#include <Ice/Ice.h>
#include <IceStorm/Parser.h>
#include <stdio.h>

Classes
union	yyalloc

Macros
#define	YY_(Msgid)
#define	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define	YY_IGNORE_MAYBE_UNINITIALIZED_END
#define	YY_INITIAL_VALUE(Value)
#define	YY_LOCATION_PRINT(File, Loc)
#define	YY_NULL   0
#define	YY_REDUCE_PRINT(Rule)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YY_SYMBOL_PRINT(Title, Type, Value, Location)
#define	YY_YY_SRC_ICESTORM_GRAMMAR_HPP_INCLUDED
#define	YYABORT   goto yyabortlab
#define	YYACCEPT   goto yyacceptlab
#define	YYBACKUP(Token, Value)
#define	YYBISON   1
#define	YYBISON_VERSION   "2.7"
#define	yyclearin   (yychar = YYEMPTY)
#define	YYCOPY(Dst, Src, Count)
#define	YYCOPY_NEEDED   1
#define	YYDEBUG   1
#define	YYDPRINTF(Args)
#define	YYEMPTY   (-2)
#define	YYEOF   0
#define	YYERRCODE   256
#define	yyerrok   (yyerrstatus = 0)
#define	YYERROR   goto yyerrorlab
#define	YYERROR_VERBOSE   0
#define	YYFAIL   goto yyerrlab
#define	YYFINAL   42
#define	YYFPRINTF   fprintf
#define	YYFREE   free
#define	YYID(N)
#define	YYINITDEPTH   200
#define	YYLAST   65
#define	YYLEX   yylex(&yylval)
#define	YYMALLOC   malloc
#define	YYMAXDEPTH   10000
#define	YYMAXUTOK   269
#define	YYNNTS   6
#define	YYNRULES   31
#define	YYNSTATES   56
#define	YYNTOKENS   16
#define	YYPACT_NINF   -6
#define	yypact_value_is_default(Yystate)
#define	YYPOPSTACK(N)
#define	YYPULL   1
#define	YYPURE   1
#define	YYPUSH   0
#define	YYRECOVERING()
#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	YYTABLE_NINF   -4
#define	yytable_value_is_error(Yytable_value)
#define	YYTERROR   1
#define	YYTOKENTYPE
#define	YYTRANSLATE(YYX)
#define	YYUNDEFTOK   2
#define	YYUSE(E)

Typedefs
typedef int	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 {   ICE_STORM_HELP = 258 , ICE_STORM_EXIT = 259 , ICE_STORM_CURRENT = 260 , ICE_STORM_CREATE = 261 ,   ICE_STORM_DESTROY = 262 , ICE_STORM_LINK = 263 , ICE_STORM_UNLINK = 264 , ICE_STORM_LINKS = 265 ,   ICE_STORM_TOPICS = 266 , ICE_STORM_REPLICA = 267 , ICE_STORM_SUBSCRIBERS = 268 , ICE_STORM_STRING = 269 }

Functions
	for (;yybottom<=yytop;yybottom++)
	for (yyi=0;yyi< yynrhs;yyi++)
	if (!yyvaluep)
	switch (yytype)
	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp)
void	yyerror (const char *s)
	YYFPRINTF (stderr, "\n")
	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno)
	YYFPRINTF (yyoutput, ")")
int	yyparse ()
	YYUSE (yyo)
	YYUSE (yyoutput)

Variables
int	yydebug
int	yyi
unsigned long int	yylno = yyrline[yyrule]
int	yyrule
yytype_int16 *	yytop
int	yytype
YYSTYPE const *const	yyvaluep

Macro Definition Documentation

YY_

#define YY_

(

Msgid

)

Value:

Msgid

YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

YY_INITIAL_VALUE

#define YY_INITIAL_VALUE

(

Value

)

Value:

= Value

YY_LOCATION_PRINT

#define YY_LOCATION_PRINT	(		File,
			Loc )

Value:

((void)0)

YY_NULL

#define YY_NULL   0

YY_REDUCE_PRINT

#define YY_REDUCE_PRINT

(

Rule

)

Value:

    do                                                                                             \
    {                                                                                              \
        if (yydebug)                                                                               \
            yy_reduce_print(yyvsp, Rule);                                                          \
    } while (YYID(0))

YY_STACK_PRINT

#define YY_STACK_PRINT	(		Bottom,
			Top )

Value:

    do                                                                                             \
    {                                                                                              \
        if (yydebug)                                                                               \
            yy_stack_print((Bottom), (Top));                                                       \
    } while (YYID(0))

YY_SYMBOL_PRINT

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

Value:

    do                                                                                             \
    {                                                                                              \
        if (yydebug)                                                                               \
        {                                                                                          \
            YYFPRINTF(stderr, "%s ", Title);                                                       \
            yy_symbol_print(stderr, Type, Value);                                                  \
            YYFPRINTF(stderr, "\n");                                                               \
        }                                                                                          \
    } while (YYID(0))

YY_YY_SRC_ICESTORM_GRAMMAR_HPP_INCLUDED

#define YY_YY_SRC_ICESTORM_GRAMMAR_HPP_INCLUDED

YYABORT

#define YYABORT   goto yyabortlab

YYACCEPT

#define YYACCEPT   goto yyacceptlab

YYBACKUP

#define YYBACKUP	(		Token,
			Value )

Value:

    do                                                                                             \
        if (yychar == YYEMPTY)                                                                     \
        {                                                                                          \
            yychar = (Token);                                                                      \
            yylval = (Value);                                                                      \
            YYPOPSTACK(yylen);                                                                     \
            yystate = *yyssp;                                                                      \
            goto yybackup;                                                                         \
        }                                                                                          \
        else                                                                                       \
        {                                                                                          \
            yyerror(YY_("syntax error: cannot back up"));                                          \
            YYERROR;                                                                               \
        }                                                                                          \
    while (YYID(0))

YYBISON

#define YYBISON   1

YYBISON_VERSION

#define YYBISON_VERSION   "2.7"

yyclearin

#define yyclearin   (yychar = YYEMPTY)

YYCOPY

#define YYCOPY	(		Dst,
			Src,
			Count )

Value:

    do                                                                                             \
    {                                                                                              \
        YYSIZE_T yyi;                                                                              \
        for (yyi = 0; yyi < (Count); yyi++)                                                        \
            (Dst)[yyi] = (Src)[yyi];                                                               \
    } while (YYID(0))

YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

YYDEBUG

#define YYDEBUG   1

YYDPRINTF

#define YYDPRINTF

(

Args

)

Value:

    do                                                                                             \
    {                                                                                              \
        if (yydebug)                                                                               \
            YYFPRINTF Args;                                                                        \
    } while (YYID(0))

YYEMPTY

#define YYEMPTY   (-2)

YYEOF

#define YYEOF   0

YYERRCODE

#define YYERRCODE   256

yyerrok

#define yyerrok   (yyerrstatus = 0)

YYERROR

#define YYERROR   goto yyerrorlab

YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

YYFAIL

#define YYFAIL   goto yyerrlab

YYFINAL

#define YYFINAL   42

YYFPRINTF

#define YYFPRINTF   fprintf

YYFREE

#define YYFREE   free

YYID

#define YYID

(

N

)

Value:

(N)

YYINITDEPTH

#define YYINITDEPTH   200

YYLAST

#define YYLAST   65

YYLEX

#define YYLEX   yylex(&yylval)

YYMALLOC

#define YYMALLOC   malloc

YYMAXDEPTH

#define YYMAXDEPTH   10000

YYMAXUTOK

#define YYMAXUTOK   269

YYNNTS

#define YYNNTS   6

YYNRULES

#define YYNRULES   31

YYNSTATES

#define YYNSTATES   56

YYNTOKENS

#define YYNTOKENS   16

YYPACT_NINF

#define YYPACT_NINF   -6

yypact_value_is_default

#define yypact_value_is_default

(

Yystate

)

Value:

(!!((Yystate) == (-6)))

YYPOPSTACK

#define YYPOPSTACK

(

N

)

Value:

(yyvsp -= (N), yyssp -= (N))

YYPULL

#define YYPULL   1

YYPURE

#define YYPURE   1

YYPUSH

#define YYPUSH   0

YYRECOVERING

#define YYRECOVERING

(

)

Value:

(!!yyerrstatus)

YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T)-1)

YYSIZE_T

#define YYSIZE_T   unsigned int

YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

YYSTACK_BYTES

#define YYSTACK_BYTES

(

N

)

Value:

((N) * (sizeof(yytype_int16) + sizeof(YYSTYPE)) + YYSTACK_GAP_MAXIMUM)

YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

YYSTACK_GAP_MAXIMUM

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

YYSTACK_RELOCATE

#define YYSTACK_RELOCATE	(		Stack_alloc,
			Stack )

Value:

    do                                                                                             \
    {                                                                                              \
        YYSIZE_T yynewbytes;                                                                       \
        YYCOPY(&yyptr->Stack_alloc, Stack, yysize);                                                \
        Stack = &yyptr->Stack_alloc;                                                               \
        yynewbytes = yystacksize * sizeof(*Stack) + YYSTACK_GAP_MAXIMUM;                           \
        yyptr += yynewbytes / sizeof(*yyptr);                                                      \
    } while (YYID(0))

yystype

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

YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

YYTABLE_NINF

#define YYTABLE_NINF   -4

yytable_value_is_error

#define yytable_value_is_error

(

Yytable_value

)

Value:

YYID(0)

YYTERROR

#define YYTERROR   1

YYTOKENTYPE

#define YYTOKENTYPE

YYTRANSLATE

#define YYTRANSLATE

(

YYX

)

Value:

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

YYUNDEFTOK

#define YYUNDEFTOK   2

YYUSE

#define YYUSE

(

E

)

Value:

((void)(E))

Typedef Documentation

YYSTYPE

typedef int YYSTYPE

yytype_int16

typedef short int yytype_int16

yytype_int8

typedef short int yytype_int8

yytype_uint16

typedef unsigned short int yytype_uint16

yytype_uint8

typedef unsigned char yytype_uint8

Enumeration Type Documentation

yytokentype

enum yytokentype

Enumerator
ICE_STORM_HELP
ICE_STORM_EXIT
ICE_STORM_CURRENT
ICE_STORM_CREATE
ICE_STORM_DESTROY
ICE_STORM_LINK
ICE_STORM_UNLINK
ICE_STORM_LINKS
ICE_STORM_TOPICS
ICE_STORM_REPLICA
ICE_STORM_SUBSCRIBERS
ICE_STORM_STRING

Function Documentation

for() [1/2]

for

(

;yybottom<=yytop;yybottom++

)

for() [2/2]

for

(

)

if()

if

(

!

yyvaluep

)

Initial value:

{
    YYUSE(yyvaluep)

switch()

switch

(

yytype

)

YY_SYMBOL_PRINT()

YY_SYMBOL_PRINT	(	yymsg	,
		yytype	,
		yyvaluep	,
		yylocationp	)

yyerror()

void yyerror

(

const char *

s

)

YYFPRINTF() [1/3]

YYFPRINTF	(	stderr	,
		"\n"	)

YYFPRINTF() [2/3]

YYFPRINTF	(	stderr	,
		"Reducing stack by rule %d (line %lu):\n"	,
		yyrule -	1,
		yylno	)

YYFPRINTF() [3/3]

YYFPRINTF	(	yyoutput	,
		"	)

yyparse()

int yyparse

(

)

YYUSE() [1/2]

YYUSE

(

yyo

)

YYUSE() [2/2]

YYUSE

(

yyoutput

)

Variable Documentation

yydebug

int yydebug

yyi

int yyi

Initial value:

{
    int yynrhs = yyr2[yyrule]

yylno

unsigned long int yylno = yyrline[yyrule]

yyrule

int yyrule

yytop

yytype_int16* yytop

yytype

int yytype

yyvaluep

YYSTYPE * yyvaluep