(file) Return to WQL.y CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / WQL

Diff for /pegasus/src/Pegasus/WQL/WQL.y between version 1.1.2.2 and 1.11

version 1.1.2.2, 2001/12/01 18:38:16 version 1.11, 2008/12/02 09:02:20
Line 1 
Line 1 
   //%LICENSE////////////////////////////////////////////////////////////////
   //
   // Licensed to The Open Group (TOG) under one or more contributor license
   // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
   //
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //////////////////////////////////////////////////////////////////////////
 /* /*
 **============================================================================== **==============================================================================
 ** **
Line 8 
Line 36 
  
 %{ %{
  
   #include <Pegasus/Common/Config.h>
   #include <Pegasus/WQL/WQLOperation.h>
   #include <Pegasus/WQL/WQLOperand.h>
   #include <Pegasus/WQL/WQLParserState.h>
   #include <Pegasus/WQL/WQLSelectStatement.h>
 #include <string.h> #include <string.h>
 #include <stdlib.h> #include <stdlib.h>
  
Line 20 
Line 53 
 #endif #endif
  
 #if 0 #if 0
 # define WQL_TRACE(X) printf(X)  # define WQL_TRACE(X) printf X
 #else #else
 # define WQL_TRACE(X) # define WQL_TRACE(X)
 #endif #endif
  
 extern int WQL_lex(); extern int WQL_lex();
 extern int WQL_error(char*);  extern int WQL_error(const char*);
   
   //
   // Define the global parser state object:
   //
   
   PEGASUS_USING_PEGASUS;
   
   PEGASUS_NAMESPACE_BEGIN
   
   extern WQLParserState* globalParserState;
   
   PEGASUS_NAMESPACE_END
  
 %} %}
  
Line 59 
Line 104 
 %token <strValue> TOK_STRING %token <strValue> TOK_STRING
 %token <intValue> TOK_TRUE %token <intValue> TOK_TRUE
 %token <intValue> TOK_FALSE %token <intValue> TOK_FALSE
   %token <intValue> TOK_NULL
   %token <intValue> TOK_ISA
   %token <intValue> TOK_DOT
  
 %token <intValue> TOK_EQ %token <intValue> TOK_EQ
 %token <intValue> TOK_NE %token <intValue> TOK_NE
Line 70 
Line 118 
 %token <intValue> TOK_NOT %token <intValue> TOK_NOT
 %token <intValue> TOK_OR %token <intValue> TOK_OR
 %token <intValue> TOK_AND %token <intValue> TOK_AND
 %token <intValue> TOK_ISA  %token <intValue> TOK_IS
  
 %token <strValue> TOK_IDENTIFIER %token <strValue> TOK_IDENTIFIER
 %token <intValue> TOK_SELECT %token <intValue> TOK_SELECT
 %token <intValue> TOK_WHERE %token <intValue> TOK_WHERE
 %token <intValue> TOK_FROM %token <intValue> TOK_FROM
  
 %token <strValue> TOK_UNEXPECTED_CHAR  %token <intValue> TOK_UNEXPECTED_CHAR
  
 %type <nodeValue> constant  %type <strValue> propertyName
 %type <nodeValue> property  
 %type <nodeValue> propertyListOrStar  
 %type <nodeValue> propertyList %type <nodeValue> propertyList
 %type <nodeValue> expressionTerm  %type <nodeValue> predicate
 %type <nodeValue> expression  %type <nodeValue> comparisonPredicate
   // %type <nodeValue> comparisonTerm
   %type <nodeValue> nullPredicate
   %type <nodeValue> searchCondition
   %type <nodeValue> fromClause
 %type <nodeValue> whereClause %type <nodeValue> whereClause
 %type <strValue> fromClass  
 %type <nodeValue> selectStatement %type <nodeValue> selectStatement
   %type <nodeValue> selectList
   %type <nodeValue> selectExpression
 %type <strValue> className %type <strValue> className
 %type <nodeValue> function  %type <intValue> truthValue
 %type <nodeValue> functionParameterList  
 %type <nodeValue> functionParameter  
  
 %left TOK_OR %left TOK_OR
 %left TOK_AND %left TOK_AND
Line 110 
Line 159 
 start start
     : selectStatement     : selectStatement
     {     {
         WQL_TRACE(("YACC: start: selectStatement\n"));      WQL_TRACE(("YACC: start\n"));
     }     }
  
 selectStatement selectStatement
     : TOK_SELECT propertyListOrStar fromClass      : TOK_SELECT selectList selectExpression
     {     {
         WQL_TRACE(("YACC: selectStatement\n"));  
     }  
     | TOK_SELECT propertyListOrStar fromClass whereClause  
     {  
         WQL_TRACE(("YACC: selectStatement\n"));  
     }  
  
 fromClass : TOK_FROM className  
     {  
         WQL_TRACE(("YACC: fromClass : TOK_FROM %s\n", $2));  
         $$ = $2;  
     }     }
  
 className : TOK_IDENTIFIER  selectList
       : '*'
     {     {
         WQL_TRACE(("YACC: className : %s\n", $1));      globalParserState->statement->setAllProperties(true);
         $$ = $1  
     }     }
       | propertyList
 whereClause : TOK_WHERE expression  
     {     {
         WQL_TRACE(("YACC: whereClause : TOK_WHERE expression\n"));  
     }     }
  
 propertyListOrStar  propertyList
     : propertyList      : propertyName
     {     {
       globalParserState->statement->appendSelectPropertyName(CIMName($1));
     }     }
     | '*'      | propertyList ',' propertyName
     {     {
         WQL_TRACE(("YACC: propertyListOrStar: '*'\n"));      globalParserState->statement->appendSelectPropertyName(CIMName($3));
     }     }
  
 propertyList : property  selectExpression
       : fromClause whereClause
     {     {
  
     }     }
     | propertyList ',' property      | fromClause
     {     {
  
     }     }
  
 property  fromClause
     : TOK_IDENTIFIER      : TOK_FROM className
     {     {
       WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", $2));
     }      globalParserState->statement->setClassName(CIMName($2));
     | TOK_IDENTIFIER '.' TOK_IDENTIFIER  
     {  
   
     }     }
  
 expression  whereClause
     : expression TOK_OR expression      : TOK_WHERE searchCondition
     {     {
  
     }     }
     | expression TOK_AND expression  
     {  
  
     }  searchCondition
     | TOK_NOT expression      : searchCondition TOK_OR searchCondition
     {     {
       WQL_TRACE(("YACC: TOK_OR\n"));
       globalParserState->statement->appendOperation(WQL_OR);
     }     }
     | '(' expression ')'      | searchCondition TOK_AND searchCondition
     {     {
       WQL_TRACE(("YACC: TOK_AND\n"));
       globalParserState->statement->appendOperation(WQL_AND);
     }     }
     | expressionTerm      | TOK_NOT searchCondition
     {     {
       WQL_TRACE(("YACC: TOK_NOT\n"));
  
       globalParserState->statement->appendOperation(WQL_NOT);
     }     }
       | '(' searchCondition ')'
 expressionTerm  
     : property TOK_LT constant  
     {     {
  
     }     }
     | property TOK_GT constant      | predicate
     {     {
  
     }     }
     | property TOK_LE constant      | predicate TOK_IS truthValue
     {     {
       WQLOperation op = $3 ? WQL_IS_TRUE : WQL_IS_FALSE;
       globalParserState->statement->appendOperation(op);
     }     }
     | property TOK_GE constant      | predicate TOK_IS TOK_NOT truthValue
     {     {
       WQLOperation op = $4 ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE;
       globalParserState->statement->appendOperation(op);
     }     }
     | property TOK_EQ constant  
     {  
  
     }  /******************************************************************************/
     | property TOK_NE constant  
     {  
  
     }  predicate
     | constant TOK_LT property      : comparisonPredicate
     {     {
  
     }     }
     | constant TOK_GT property      | nullPredicate
     {     {
  
     }     }
     | constant TOK_LE property  
     {  
  
     }  comparisonPredicate
     | constant TOK_GE property      : comparisonTerm TOK_LT comparisonTerm
     {     {
       WQL_TRACE(("YACC: TOK_LT\n"));
       globalParserState->statement->appendOperation(WQL_LT);
     }     }
     | constant TOK_EQ property      | comparisonTerm TOK_GT comparisonTerm
     {     {
       WQL_TRACE(("YACC: TOK_GT\n"));
       globalParserState->statement->appendOperation(WQL_GT);
     }     }
     | constant TOK_NE property      | comparisonTerm TOK_LE comparisonTerm
     {     {
       WQL_TRACE(("YACC: TOK_LE\n"));
       globalParserState->statement->appendOperation(WQL_LE);
     }     }
     | function TOK_LT constant      | comparisonTerm TOK_GE comparisonTerm
     {     {
       WQL_TRACE(("YACC: TOK_GE\n"));
       globalParserState->statement->appendOperation(WQL_GE);
     }     }
     | function TOK_GT constant      | comparisonTerm TOK_EQ comparisonTerm
     {     {
       WQL_TRACE(("YACC: TOK_EQ\n"));
       globalParserState->statement->appendOperation(WQL_EQ);
     }     }
     | function TOK_LE constant      | comparisonTerm TOK_NE comparisonTerm
     {     {
       WQL_TRACE(("YACC: TOK_NE\n"));
       globalParserState->statement->appendOperation(WQL_NE);
     }     }
     | function TOK_GE constant      | propertyName TOK_ISA className
     {     {
       WQL_TRACE(("YACC: TOK_ISA\n"));
   #ifndef PEGASUS_SNIA_EXTENSIONS
           // If SNIA tests, allow the ISA but do not pass className
           yyerror("ISA Token Not Supported");
   #endif
     }     }
     | function TOK_EQ constant  
     {  
  
     }  nullPredicate
     | function TOK_NE constant      : comparisonTerm TOK_IS TOK_NULL
     {     {
       WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n"));
       globalParserState->statement->appendOperation(WQL_IS_NULL);
     }     }
     | constant TOK_LT function      | comparisonTerm TOK_IS TOK_NOT TOK_NULL
     {     {
       WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n"));
       globalParserState->statement->appendOperation(WQL_IS_NOT_NULL);
     }     }
     | constant TOK_GT function  
     {  
  
     }  truthValue
     | constant TOK_LE function      : TOK_TRUE
     {     {
       $$ = 1;
     }     }
     | constant TOK_GE function      | TOK_FALSE
     {     {
       $$ = 0;
     }     }
     | constant TOK_EQ function  /**************
   propertyName
       : TOK_IDENTIFIER
     {     {
       WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
       $$ = $1;
     }     }
     | constant TOK_NE function  *****************/
   propertyName
       : TOK_IDENTIFIER
     {     {
           WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
           $$ = $1;
     }     }
     | className TOK_ISA className      | TOK_IDENTIFIER TOK_DOT TOK_IDENTIFIER
     {     {
           WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s.%s)\n", $1, $3));
   #ifdef PEGASUS_SNIA_EXTENSIONS
           // Pass anything as a property name to fool parser for SNIA testing
           $$ = strdup("dummy");
   #else
           yyerror("Scoped (dotted) property names not supported");
   #endif
     }     }
  
 function  
     : TOK_IDENTIFIER '(' ')'  
     {  
  
     }  className : TOK_IDENTIFIER
     | TOK_IDENTIFIER '(' functionParameterList ')'  
     {     {
       WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", $1));
       $$ = $1;
     }     }
  
 functionParameterList  comparisonTerm
     : functionParameter      : propertyName
     {     {
       globalParserState->statement->appendOperand(
           WQLOperand($1, WQL_PROPERTY_NAME_TAG));
       globalParserState->statement->appendWherePropertyName(CIMName($1));
     }     }
     | functionParameterList ',' functionParameter      | TOK_INTEGER
     {     {
       globalParserState->statement->appendOperand(
     }          WQLOperand($1, WQL_INTEGER_VALUE_TAG));
   
 functionParameter  
     : property  
     | constant  
     | function  
     ;  
   
 constant  
     : TOK_INTEGER  
     {  
   
     }     }
     | TOK_DOUBLE     | TOK_DOUBLE
     {     {
       globalParserState->statement->appendOperand(
           WQLOperand($1, WQL_DOUBLE_VALUE_TAG));
     }     }
     | TOK_STRING     | TOK_STRING
     {     {
         WQL_TRACE(("YACC: TOK_STRING: %s\n", $1));      globalParserState->statement->appendOperand(
         $$ = $1;          WQLOperand($1, WQL_STRING_VALUE_TAG));
     }     }
       | truthValue
 %%  
   
 int WQL_error(char* errorMessage)  
 { {
     fprintf(stderr, "WQL_error: %s\n", errorMessage);      globalParserState->statement->appendOperand(
     return -1;          WQLOperand($1 != 0, WQL_BOOLEAN_VALUE_TAG));
 } }
   
   %%

Legend:
Removed from v.1.1.2.2  
changed lines
  Added in v.1.11
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2