cqlyacc.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

  263,  264,  265,  266,  267,  268,  269,  270,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  271,   -1,  273,  274,  275,   -1,  277,
   -1,  279,   -1,   -1,   -1,   -1,  284,   -1,  286,  287,
  288,  289,  290,  291,  292,  293,   -1,  295,  296,  271,
   -1,  273,  274,  275,   -1,  277,   -1,  279,   -1,  309,
  308,   -1,  284,   -1,  286,  287,  288,  289,  290,  291,
  292,  293,  271,  295,  296,   -1,  275,   -1,  277,   -1,
  279,   -1,   -1,   -1,   -1,  284,  308,  286,  287,  288,
  289,  290,  291,  292,  293,  271,  295,  296,  271,  275,
   -1,  277,  275,   -1,  277,   -1,   -1,   -1,  284,  308,
  286,  287,  288,  289,  290,  291,  292,  293,   -1,  295,
  296,  271,  295,  296,  271,  275,   -1,  277,  275,   -1,
  277,   -1,  308,   -1,   -1,  308,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  296,   -1,   -1,  296,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  308,   -1,
   -1,  308,
};
#define YYFINAL 2
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 315
#if YYDEBUG
const char * const CQL_name[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"IDENTIFIER","STRING_LITERAL",
"BINARY","NEGATIVE_BINARY","HEXADECIMAL","NEGATIVE_HEXADECIMAL","INTEGER",
"NEGATIVE_INTEGER","REAL","NEGATIVE_REAL","_TRUE","_FALSE","SCOPED_PROPERTY",
"LPAR","RPAR","HASH","DOT","LBRKT","RBRKT","UNDERSCORE","COMMA","CONCAT",
"DBL_PIPE","PLUS","MINUS","TIMES","DIV","IS","_NULL","_EQ","_NE","_GT","_LT",
"_GE","_LE","_ISA","_LIKE","NOT","_AND","_OR","SCOPE","ANY","EVERY","IN",
"SATISFIES","STAR","DOTDOT","SHARP","DISTINCT","SELECT","FIRST","FROM","WHERE",
"ORDER","BY","ASC","DESC","AS","UNEXPECTED_CHAR",
};
const char * const CQL_rule[] = {
"$accept : select_statement",
"identifier : IDENTIFIER",
"class_name : identifier",
"class_path : class_name",
"scoped_property : SCOPED_PROPERTY",
"literal_string : STRING_LITERAL",
"binary_value : BINARY",
"binary_value : NEGATIVE_BINARY",
"hex_value : HEXADECIMAL",
"hex_value : NEGATIVE_HEXADECIMAL",
"decimal_value : INTEGER",
"decimal_value : NEGATIVE_INTEGER",
"real_value : REAL",
"real_value : NEGATIVE_REAL",
"literal : literal_string",
"literal : decimal_value",
"literal : binary_value",
"literal : hex_value",
"literal : real_value",
"literal : _TRUE",
"literal : _FALSE",
"array_index : expr",
"array_index_list : array_index",
"chain : literal",
"chain : LPAR expr RPAR",
"chain : identifier",
"chain : identifier HASH literal_string",
"chain : scoped_property",
"chain : identifier LPAR arg_list RPAR",
"chain : chain DOT scoped_property",
"chain : chain DOT identifier",
"chain : chain DOT identifier HASH literal_string",
"chain : chain LBRKT array_index_list RBRKT",
"concat : chain",
"concat : concat DBL_PIPE literal_string",
"factor : concat",
"term : factor",
"arith : term",
"value_symbol : HASH literal_string",
"arith_or_value_symbol : arith",
"arith_or_value_symbol : value_symbol",
"comp_op : _EQ",
"comp_op : _NE",
"comp_op : _GT",
"comp_op : _LT",
"comp_op : _GE",
"comp_op : _LE",
"comp : arith",
"comp : arith IS NOT _NULL",
"comp : arith IS _NULL",
"comp : arith comp_op arith_or_value_symbol",
"comp : value_symbol comp_op arith",
"comp : arith _ISA identifier",
"comp : arith _LIKE literal_string",
"expr_factor : comp",
"expr_factor : NOT comp",
"expr_term : expr_factor",
"expr_term : expr_term _AND expr_factor",
"expr : expr_term",
"expr : expr _OR expr_term",
"arg_list :",
"arg_list : expr",
"from_specifier : class_path",
"from_specifier : class_path AS identifier",
"from_specifier : class_path identifier",
"from_criteria : from_specifier",
"star_expr : STAR",
"star_expr : chain DOT STAR",
"selected_entry : expr",
"selected_entry : star_expr",
"select_list : selected_entry select_list_tail",
"select_list_tail :",
"select_list_tail : COMMA selected_entry select_list_tail",
"search_condition : expr",
"optional_where :",
"optional_where : WHERE search_condition",
"select_statement : SELECT select_list FROM from_criteria optional_where",
};
#endif
#if YYDEBUG
#include <stdio.h>
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
int yystacksize;
#line 1372 "CQL.y"

/*int yyerror(char * err){yyclearin; yyerrok;throw Exception(String(err));return 1;}*/
#line 502 "y.tab.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack()
{
    int newsize, i;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    i = yyssp - yyss;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss);
    if (newss == NULL)
        return -1;
    yyss = newss;
    yyssp = newss + i;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs);
    if (newvs == NULL)
        return -1;
    yyvs = newvs;
    yyvsp = newvs + i;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab

#ifndef YYPARSE_PARAM
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG void
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif	/* ANSI-C/C++ */
#else	/* YYPARSE_PARAM */
#ifndef YYPARSE_PARAM_TYPE
#define YYPARSE_PARAM_TYPE void *
#endif
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
#endif	/* ANSI-C/C++ */
#endif	/* ! YYPARSE_PARAM */

int
yyparse (YYPARSE_PARAM_ARG)
    YYPARSE_PARAM_DECL
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register const char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate])) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(lint) || defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(lint) || defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 1:
#line 247 "CQL.y"
{ 
		 CQL_globalParserState->currentRule = "identifier";
                 sprintf(msg,"BISON::identifier\n");
		 printf_(msg);
                 if(isUTF8Str(CQL_lval.strValue)){	
                    yyval._identifier = new CQLIdentifier(String(CQL_lval.strValue));
					     _ObjPtr._ptr = yyval._identifier;
					     _ObjPtr.type = Id;
					     _ptrs.append(_ObjPtr);
					  }else{
                    sprintf(msg,"BISON::identifier-> BAD UTF\n");
		              printf_(msg);
		              throw CQLSyntaxErrorException(
					         MessageLoaderParms(String("CQL.CQL_y.BAD_UTF8"),
							   String("Bad UTF8 encountered parsing rule $0 in position $1."),
							   String("identifier"),
							   CQL_globalParserState->currentTokenPos)
						  );
					  }