cql.y

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

           _ptrs.append(_ObjPtr);
		}else{
		    sprintf(msg,"BISON::literal_string-> 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("literal_string"),
							   CQL_globalParserState->currentTokenPos)
						 );
		}
             }
;

/* CQLValue */
binary_value : BINARY 
	       { 
		   CQL_globalParserState->currentRule = "binary_value->BINARY";
                   sprintf(msg,"BISON::binary_value-> %s\n",CQL_lval.strValue); 
		   printf_(msg);

                   $$ = new CQLValue(CQL_lval.strValue, CQLValue::Binary); 
						 _ObjPtr._ptr = $$;
                   _ObjPtr.type = Val;
                   _ptrs.append(_ObjPtr);
               }
             | NEGATIVE_BINARY 
               { 
		   CQL_globalParserState->currentRule = "binary_value->NEGATIVE_BINARY";
                   sprintf(msg,"BISON::binary_value-> %s\n",CQL_lval.strValue); 
		   printf_(msg);

                   $$ = new CQLValue(CQL_lval.strValue, CQLValue::Binary, false); 
						 _ObjPtr._ptr = $$;
                   _ObjPtr.type = Val;
                   _ptrs.append(_ObjPtr);
               }
;

/* CQLValue */
hex_value : HEXADECIMAL 
            { 
		CQL_globalParserState->currentRule = "hex_value->HEXADECIMAL";
                sprintf(msg,"BISON::hex_value-> %s\n",CQL_lval.strValue); 
		printf_(msg);

                $$ = new CQLValue(CQL_lval.strValue, CQLValue::Hex);
					 _ObjPtr._ptr = $$;
                _ObjPtr.type = Val;
                _ptrs.append(_ObjPtr);
            }
          | NEGATIVE_HEXADECIMAL 
            { 
		CQL_globalParserState->currentRule = "hex_value->NEGATIVE_HEXADECIMAL";
                sprintf(msg,"BISON::hex_value-> %s\n",CQL_lval.strValue); 
		printf_(msg);

                $$ = new CQLValue(CQL_lval.strValue, CQLValue::Hex, false);
				    _ObjPtr._ptr = $$;
                _ObjPtr.type = Val;
                _ptrs.append(_ObjPtr);
            }
;

/* CQLValue */
decimal_value : INTEGER 
                { 
		    CQL_globalParserState->currentRule = "decimal_value->INTEGER";
                    sprintf(msg,"BISON::decimal_value-> %s\n",CQL_lval.strValue); 
		    printf_(msg);

                    $$ = new CQLValue(CQL_lval.strValue, CQLValue::Decimal); 
						  _ObjPtr._ptr = $$;
                    _ObjPtr.type = Val;
                    _ptrs.append(_ObjPtr);
                }
              | NEGATIVE_INTEGER 
                { 
		    CQL_globalParserState->currentRule = "decimal_value->NEGATIVE_INTEGER";
                    sprintf(msg,"BISON::decimal_value-> %s\n",CQL_lval.strValue); 
		    printf_(msg);

                    $$ = new CQLValue(CQL_lval.strValue, CQLValue::Decimal, false);
						  _ObjPtr._ptr = $$;
                    _ObjPtr.type = Val;
                    _ptrs.append(_ObjPtr);
                }
;

/* CQLValue */
real_value : REAL 
             { 
		 CQL_globalParserState->currentRule = "real_value->REAL";
                 sprintf(msg,"BISON::real_value-> %s\n",CQL_lval.strValue); 
		 printf_(msg);
                 $$ = new CQLValue(CQL_lval.strValue, CQLValue::Real);
					  _ObjPtr._ptr = $$;
                 _ObjPtr.type = Val;
                 _ptrs.append(_ObjPtr);
             }
           | NEGATIVE_REAL 
             { 
		 CQL_globalParserState->currentRule = "real_value->NEGATIVE_REAL";
                 sprintf(msg,"BISON::real_value-> %s\n",CQL_lval.strValue); 
		 printf_(msg);
                 $$ = new CQLValue(CQL_lval.strValue, CQLValue::Real, false);
					  _ObjPtr._ptr = $$;
                 _ObjPtr.type = Val;
                 _ptrs.append(_ObjPtr);
             }
;

/* CQLValue */
literal : literal_string 
          {
	      CQL_globalParserState->currentRule = "literal->literal_string";
              sprintf(msg,"BISON::literal->literal_string\n");
	      printf_(msg);
              $$ = new CQLValue(*$1);
				  _ObjPtr._ptr = $$;
              _ObjPtr.type = Val;
              _ptrs.append(_ObjPtr);
          }
        | decimal_value
          {
	      CQL_globalParserState->currentRule = "literal->decimal_value";
              sprintf(msg,"BISON::literal->decimal_value\n");
	      printf_(msg);

          }
        | binary_value
          {
              CQL_globalParserState->currentRule = "literal->binary_value";
              sprintf(msg,"BISON::literal->binary_value\n");
	      printf_(msg);

          }
        | hex_value
          {
              CQL_globalParserState->currentRule = "literal->hex_value";
              sprintf(msg,"BISON::literal->hex_value\n");
	      printf_(msg);

          }
        | real_value
          {
              CQL_globalParserState->currentRule = "literal->real_value";
              sprintf(msg,"BISON::literal->real_value\n");
	      printf_(msg);

          }
        | _TRUE
          {
	      CQL_globalParserState->currentRule = "literal->_TRUE";
              sprintf(msg,"BISON::literal->_TRUE\n");
	      printf_(msg);

              $$ = new CQLValue(Boolean(true));
				  _ObjPtr._ptr = $$;
              _ObjPtr.type = Val;
              _ptrs.append(_ObjPtr);
          }
        | _FALSE
          {
	      CQL_globalParserState->currentRule = "literal->_FALSE";
              sprintf(msg,"BISON::literal->_FALSE\n");
	      printf_(msg);

              $$ = new CQLValue(Boolean(false));
				  _ObjPtr._ptr = $$;
              _ObjPtr.type = Val;
              _ptrs.append(_ObjPtr);
          }
;

/* String */
array_index : expr
              {
		  CQL_globalParserState->currentRule = "array_index->expr";
                  sprintf(msg,"BISON::array_index->expr\n");
		  printf_(msg);

		  CQLValue* _val = (CQLValue*)_factory.getObject($1,Predicate,Value);
		  $$ = new String(_val->toString());
		  _ObjPtr._ptr = $$;
        _ObjPtr.type = Str;
        _ptrs.append(_ObjPtr);
              }
;

/* String */
array_index_list : array_index
                   {
		       CQL_globalParserState->currentRule = "array_index_list->array_index";
                       sprintf(msg,"BISON::array_index_list->array_index\n");
		       printf_(msg);
 		       $$ = $1;
                   }
;

/* void* */
chain : literal
        {
            CQL_globalParserState->currentRule = "chain->literal";
            sprintf(msg,"BISON::chain->literal\n");
	    printf_(msg);

            chain_state = CQLVALUE;
	    $$ = _factory.makeObject($1,Predicate);  
        }
      | LPAR expr RPAR
        {
	    CQL_globalParserState->currentRule = "chain-> ( expr )";
            sprintf(msg,"BISON::chain-> ( expr )\n");
	    printf_(msg);

            chain_state = CQLPREDICATE;
	    $$ = $2;
        }
      | identifier
        {
	   CQL_globalParserState->currentRule = "chain->identifier";
           sprintf(msg,"BISON::chain->identifier\n");
	   printf_(msg);

           chain_state = CQLIDENTIFIER;
	   $$ = _factory.makeObject($1,Predicate);
        }
      | identifier HASH literal_string
        {
	    CQL_globalParserState->currentRule = "chain->identifier#literal_string";
            sprintf(msg,"BISON::chain->identifier#literal_string\n");
	    printf_(msg);

            String tmp = $1->getName().getString();
            tmp.append("#").append(*$3);
            CQLIdentifier _id(tmp);
   	    $$ = _factory.makeObject(&_id,Predicate);
	    chain_state = CQLIDENTIFIER;
        }
      | scoped_property
        {
	    CQL_globalParserState->currentRule = "chain->scoped_property";
	    sprintf(msg,"BISON::chain-> scoped_property\n");
	    printf_(msg);

            chain_state = CQLIDENTIFIER;
	    $$ = _factory.makeObject($1,Predicate);
        }
      | identifier LPAR arg_list RPAR
        {
	    CQL_globalParserState->currentRule = "chain->identifier( arg_list )";
            sprintf(msg,"BISON::chain-> identifier( arg_list )\n");
	    printf_(msg);
            chain_state = CQLFUNCTION;
	    CQLFunction _func(*$1,_arglist);
	    $$ = (CQLPredicate*)(_factory.makeObject(&_func,Predicate));
	    _arglist.clear();
        }
      | chain DOT scoped_property
        {
	    CQL_globalParserState->currentRule = "chain->chain.scoped_property";
	    sprintf(msg,"BISON::chain-> chain DOT scoped_property : chain_state = %d\n",chain_state);
	    printf_(msg);

	    CQLIdentifier *_id;
	    if(chain_state == CQLIDENTIFIER){
	        _id = ((CQLIdentifier*)(_factory.getObject($1,Predicate,Identifier)));
                CQLChainedIdentifier _cid(*_id);
                _cid.append(*$3);
		$$ = _factory.makeObject(&_cid,Predicate);
            }else if(chain_state == CQLCHAINEDIDENTIFIER){
		CQLChainedIdentifier *_cid;
		_cid = ((CQLChainedIdentifier*)(_factory.getObject($1,Predicate,ChainedIdentifier)));
		_cid->append(*$3);
		_factory.setObject(((CQLPredicate*)$1),_cid,ChainedIdentifier);
		$$ = $1;
	    }else{
		/* error */
		String _msg("chain-> chain DOT scoped_property : chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER");
		throw CQLSyntaxErrorException(
                                        MessageLoaderParms(String("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER"),
                                                           String("Chain state not a CQLIdentifier or a CQLChainedIdentifier while parsing rule $0 in position $1."),
							   String("chain.scoped_property"),
                                                           CQL_globalParserState->currentTokenPos)
                                                 );
            }

            chain_state = CQLCHAINEDIDENTIFIER;
        }
      | chain DOT identifier
        {
	    CQL_globalParserState->currentRule = "chain->chain.identifier";
            sprintf(msg,"BISON::chain->chain.identifier : chain_state = %d\n",chain_state);
	    printf_(msg);

            if(chain_state == CQLIDENTIFIER){
		CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject($1,Predicate,Identifier)));
                CQLChainedIdentifier _cid(*_id);
                _cid.append(*$3);
                $$ = _factory.makeObject(&_cid,Predicate);
            }else if(chain_state == CQLCHAINEDIDENTIFIER){
		CQLChainedIdentifier *_cid = ((CQLChainedIdentifier*)(_factory.getObject($1,Predicate,ChainedIdentifier)));
                _cid->append(*$3);
                _factory.setObject(((CQLPredicate*)$1),_cid,ChainedIdentifier);
                $$ = $1;
            }else{
                /* error */
		String _msg("chain-> chain DOT identifier : chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER");
		throw CQLSyntaxErrorException(
                                        MessageLoaderParms(String("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER"),
                                                           String("Chain state not a CQLIdentifier or a CQLChainedIdentifier while parsing rule $0 in position $1."),
							   String("chain.identifier"),
                                                           CQL_globalParserState->currentTokenPos)
                                                 );
            }
	    chain_state = CQLCHAINEDIDENTIFIER;

        }
      | chain DOT identifier HASH literal_string
        {
	    CQL_globalParserState->currentRule = "chain->chain.identifier#literal_string";
            sprintf(msg,"BISON::chain->chain.identifier#literal_string : chain_state = %d\n",chain_state);
	    printf_(msg);

            if(chain_state == CQLIDENTIFIER){
              CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject($1,Predicate,Identifier)));	
              CQLChainedIdentifier _cid(*_id);
                String tmp($3->getName().getString());
                tmp.append("#").append(*$5);
                CQLIdentifier _id1(tmp);
                _cid.append(_id1);
                _factory.setObject(((CQLPredicate*)$1),&_cid,ChainedIdentifier);
                $$ = $1;
            }else if(chain_state == CQLCHAINEDIDENTIFIER){
              CQLChainedIdentifier *_cid =  ((CQLChainedIdentifier*)(_factory.getObject($1,Predicate,ChainedIdentifier)));
              String tmp($3->getName().getString());
                tmp.append("#").append(*$5);
                CQLIdentifier _id1(tmp);
                _cid->append(_id1);
                _factory.setObject(((CQLPredicate*)$1),_cid,ChainedIdentifier);
                $$ = $1;
            }else{
                /* error */