(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.1 and 1.9

version 1.1.2.1, 2001/11/30 02:53:56 version 1.9, 2006/01/30 16:18:36
Line 1 
Line 1 
   //%2006////////////////////////////////////////////////////////////////////////
   //
   // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
   //
   // 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 38 
  
 %{ %{
  
   #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 19 
Line 54 
 # include <alloca.h> # include <alloca.h>
 #endif #endif
  
   #if 0
   # define WQL_TRACE(X) printf X
   #else
   # define WQL_TRACE(X)
   #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 50 
Line 103 
  
 %token <intValue> TOK_INTEGER %token <intValue> TOK_INTEGER
 %token <doubleValue> TOK_DOUBLE %token <doubleValue> TOK_DOUBLE
 %token <strValue> STRING_LITERAL  %token <strValue> TOK_STRING
 %token <intValue> EQ  %token <intValue> TOK_TRUE
 %token <intValue> NE  %token <intValue> TOK_FALSE
 %token <intValue> LT  %token <intValue> TOK_NULL
 %token <intValue> LE  %token <intValue> TOK_ISA
 %token <intValue> GT  %token <intValue> TOK_DOT
 %token <intValue> GE  
 %token <intValue> TOK_SELECT  %token <intValue> TOK_EQ
 %token <intValue> WHERE  %token <intValue> TOK_NE
 %token <intValue> FROM  %token <intValue> TOK_LT
   %token <intValue> TOK_LE
   %token <intValue> TOK_GT
   %token <intValue> TOK_GE
   
   %token <intValue> TOK_NOT
   %token <intValue> TOK_OR
   %token <intValue> TOK_AND
   %token <intValue> TOK_IS
   
 %token <strValue> TOK_IDENTIFIER %token <strValue> TOK_IDENTIFIER
 %token <intValue> NOT  %token <intValue> TOK_SELECT
 %token <intValue> OR  %token <intValue> TOK_WHERE
 %token <intValue> AND  %token <intValue> TOK_FROM
 %token <intValue> ISA  
 %token <intValue> WQL_TRUE  %token <intValue> TOK_UNEXPECTED_CHAR
 %token <intValue> WQL_FALSE  
   %type <strValue> propertyName
 %type <nodeValue> constant  
 %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 OR  
 %left AND  
 %nonassoc NOT  
  
 /*  %left TOK_OR
 **==============================================================================  %left TOK_AND
 **  %nonassoc TOK_NOT
 ** The grammar itself.  
 **  
 **==============================================================================  
 */  
  
 %% %%
  
 /* /*
 **------------------------------------------------------------------------------  **==============================================================================
 ** **
 ** start rule:  ** The grammar itself.
 ** **
 **------------------------------------------------------------------------------  **==============================================================================
 */ */
  
 start start
     : selectStatement     : selectStatement
     {     {
           WQL_TRACE(("YACC: start\n"));
     }     }
  
 /* BOOKMARK */  
   
 /*  
 **------------------------------------------------------------------------------  
 **  
 ** Select Statement  
 **  
 **------------------------------------------------------------------------------  
 */  
   
 selectStatement selectStatement
     : TOK_SELECT propertyListOrStar fromClass      : TOK_SELECT selectList selectExpression
     {  
   
     }  
     | TOK_SELECT propertyListOrStar fromClass whereClause  
     {     {
  
     }     }
  
 fromClass : FROM className  selectList
     {      : '*'
         $$ = $2;  
     }  
   
 className : TOK_IDENTIFIER  
     {     {
         $$ = $1          globalParserState->statement->setAllProperties(true);
     }     }
       | propertyList
 whereClause : WHERE expression  
     {     {
  
     }     }
  
 propertyListOrStar  propertyList
     : propertyList      : propertyName
     {     {
           globalParserState->statement->appendSelectPropertyName(CIMName($1));
     }     }
     | '*'      | propertyList ',' propertyName
     {     {
           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  
     {  
  
     }  whereClause
       : TOK_WHERE searchCondition
 expression  
     : expression OR expression  
     {     {
  
     }     }
     | expression AND expression  
     {  
  
     }  searchCondition
     | 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 LT constant  
     {     {
  
     }     }
     | property GT constant      | predicate
     {     {
  
     }     }
     | property LE constant      | predicate TOK_IS truthValue
     {     {
           WQLOperation op = $3 ? WQL_IS_TRUE : WQL_IS_FALSE;
           globalParserState->statement->appendOperation(op);
     }     }
     | property GE constant      | predicate TOK_IS TOK_NOT truthValue
     {     {
           WQLOperation op = $4 ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE;
           globalParserState->statement->appendOperation(op);
     }     }
     | property EQ constant  
     {  
  
     }  /******************************************************************************/
     | property NE constant  
     {  
  
     }  predicate
     | constant LT property      : comparisonPredicate
     {     {
  
     }     }
     | constant GT property      | nullPredicate
     {     {
  
     }     }
     | constant LE property  
     {  
  
     }  comparisonPredicate
     | constant GE property      : comparisonTerm TOK_LT comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_LT\n"));
           globalParserState->statement->appendOperation(WQL_LT);
     }     }
     | constant EQ property      | comparisonTerm TOK_GT comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_GT\n"));
           globalParserState->statement->appendOperation(WQL_GT);
     }     }
     | constant NE property      | comparisonTerm TOK_LE comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_LE\n"));
           globalParserState->statement->appendOperation(WQL_LE);
     }     }
     | function LT constant      | comparisonTerm TOK_GE comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_GE\n"));
           globalParserState->statement->appendOperation(WQL_GE);
     }     }
     | function GT constant      | comparisonTerm TOK_EQ comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_EQ\n"));
           globalParserState->statement->appendOperation(WQL_EQ);
     }     }
     | function LE constant      | comparisonTerm TOK_NE comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_NE\n"));
           globalParserState->statement->appendOperation(WQL_NE);
     }     }
     | function 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 EQ constant  
     {  
  
     }  nullPredicate
     | function NE constant      : comparisonTerm TOK_IS TOK_NULL
     {     {
           WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n"));
           globalParserState->statement->appendOperation(WQL_IS_NULL);
     }     }
     | constant 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 GT function  
     {  
  
     }  truthValue
     | constant LE function      : TOK_TRUE
     {     {
           $$ = 1;
     }     }
     | constant GE function      | TOK_FALSE
     {     {
           $$ = 0;
     }     }
     | constant EQ function  /**************
   propertyName
       : TOK_IDENTIFIER
     {     {
           WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
           $$ = $1;
     }     }
     | constant NE function  *****************/
   propertyName
       : TOK_IDENTIFIER
     {     {
           WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
           $$ = $1;
     }     }
     | className 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));
     }     }
       | TOK_DOUBLE
 functionParameter  
     : property  
     | constant  
     | function  
     ;  
   
 constant  
     : TOK_INTEGER  
     {     {
           globalParserState->statement->appendOperand(
               WQLOperand($1, WQL_DOUBLE_VALUE_TAG));
     }     }
     | TOK_DOUBLE      | TOK_STRING
     {     {
           globalParserState->statement->appendOperand(
               WQLOperand($1, WQL_STRING_VALUE_TAG));
     }     }
     | STRING_LITERAL      | truthValue
     {     {
           globalParserState->statement->appendOperand(
               WQLOperand($1 != 0, WQL_BOOLEAN_VALUE_TAG));
     }     }
  
 %% %%
   
 int WQL_error(char* errorMessage)  
 {  
     fprintf(stderr, "WQL_error: %s\n", errorMessage);  
     return -1;  
 }  

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