(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.5 and 1.11

version 1.1.2.5, 2001/12/02 20:36:49 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 11 
Line 39 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/WQL/WQLOperation.h> #include <Pegasus/WQL/WQLOperation.h>
 #include <Pegasus/WQL/WQLOperand.h> #include <Pegasus/WQL/WQLOperand.h>
   #include <Pegasus/WQL/WQLParserState.h>
 #include <Pegasus/WQL/WQLSelectStatement.h> #include <Pegasus/WQL/WQLSelectStatement.h>
 #include <string.h> #include <string.h>
 #include <stdlib.h> #include <stdlib.h>
Line 23 
Line 52 
 # include <alloca.h> # include <alloca.h>
 #endif #endif
  
 #if 1  #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 64 
Line 105 
 %token <intValue> TOK_TRUE %token <intValue> TOK_TRUE
 %token <intValue> TOK_FALSE %token <intValue> TOK_FALSE
 %token <intValue> TOK_NULL %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 82 
Line 125 
 %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> propertyName  %type <strValue> propertyName
 %type <nodeValue> propertyList %type <nodeValue> propertyList
 %type <nodeValue> predicate %type <nodeValue> predicate
 %type <nodeValue> comparisonPredicate %type <nodeValue> comparisonPredicate
 %type <nodeValue> comparisonTerm  // %type <nodeValue> comparisonTerm
 %type <nodeValue> nullPredicate %type <nodeValue> nullPredicate
 %type <nodeValue> searchCondition %type <nodeValue> searchCondition
 %type <nodeValue> fromClause %type <nodeValue> fromClause
Line 97 
Line 140 
 %type <nodeValue> selectList %type <nodeValue> selectList
 %type <nodeValue> selectExpression %type <nodeValue> selectExpression
 %type <strValue> className %type <strValue> className
   %type <intValue> truthValue
  
 %left TOK_OR %left TOK_OR
 %left TOK_AND %left TOK_AND
Line 115 
Line 159 
 start start
     : selectStatement     : selectStatement
     {     {
         printf("YACC: start\n");      WQL_TRACE(("YACC: start\n"));
     }     }
  
 selectStatement selectStatement
Line 127 
Line 171 
 selectList selectList
     : '*'     : '*'
     {     {
       globalParserState->statement->setAllProperties(true);
     }     }
     | propertyList     | propertyList
     {     {
Line 137 
Line 181 
 propertyList propertyList
     : propertyName     : propertyName
     {     {
       globalParserState->statement->appendSelectPropertyName(CIMName($1));
     }     }
     | propertyList ',' propertyName     | propertyList ',' propertyName
     {     {
       globalParserState->statement->appendSelectPropertyName(CIMName($3));
     }     }
  
 selectExpression selectExpression
Line 157 
Line 201 
 fromClause fromClause
     : TOK_FROM className     : TOK_FROM className
     {     {
       WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", $2));
       globalParserState->statement->setClassName(CIMName($2));
     }     }
  
 whereClause whereClause
Line 170 
Line 215 
     : searchCondition TOK_OR searchCondition     : searchCondition TOK_OR searchCondition
     {     {
         WQL_TRACE(("YACC: TOK_OR\n"));         WQL_TRACE(("YACC: TOK_OR\n"));
       globalParserState->statement->appendOperation(WQL_OR);
     }     }
     | searchCondition TOK_AND searchCondition     | searchCondition TOK_AND searchCondition
     {     {
         WQL_TRACE(("YACC: TOK_AND\n"));         WQL_TRACE(("YACC: TOK_AND\n"));
       globalParserState->statement->appendOperation(WQL_AND);
     }     }
     | TOK_NOT searchCondition     | TOK_NOT searchCondition
     {     {
       WQL_TRACE(("YACC: TOK_NOT\n"));
  
       globalParserState->statement->appendOperation(WQL_NOT);
     }     }
     | '(' searchCondition ')'     | '(' searchCondition ')'
     {     {
Line 189 
Line 238 
     }     }
     | predicate TOK_IS truthValue     | predicate TOK_IS truthValue
     {     {
       WQLOperation op = $3 ? WQL_IS_TRUE : WQL_IS_FALSE;
       globalParserState->statement->appendOperation(op);
     }     }
     | predicate TOK_IS TOK_NOT truthValue     | predicate TOK_IS TOK_NOT truthValue
     {     {
       WQLOperation op = $4 ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE;
       globalParserState->statement->appendOperation(op);
     }     }
  
   /******************************************************************************/
   
 predicate predicate
     : comparisonPredicate     : comparisonPredicate
     {     {
Line 210 
Line 263 
     : comparisonTerm TOK_LT comparisonTerm     : comparisonTerm TOK_LT comparisonTerm
     {     {
         WQL_TRACE(("YACC: TOK_LT\n"));         WQL_TRACE(("YACC: TOK_LT\n"));
       globalParserState->statement->appendOperation(WQL_LT);
     }     }
     | comparisonTerm TOK_GT comparisonTerm     | comparisonTerm TOK_GT comparisonTerm
     {     {
         WQL_TRACE(("YACC: TOK_GT\n"));         WQL_TRACE(("YACC: TOK_GT\n"));
       globalParserState->statement->appendOperation(WQL_GT);
     }     }
     | comparisonTerm TOK_LE comparisonTerm     | comparisonTerm TOK_LE comparisonTerm
     {     {
         WQL_TRACE(("YACC: TOK_LE\n"));         WQL_TRACE(("YACC: TOK_LE\n"));
       globalParserState->statement->appendOperation(WQL_LE);
     }     }
     | comparisonTerm TOK_GE comparisonTerm     | comparisonTerm TOK_GE comparisonTerm
     {     {
         WQL_TRACE(("YACC: TOK_GE\n"));         WQL_TRACE(("YACC: TOK_GE\n"));
       globalParserState->statement->appendOperation(WQL_GE);
     }     }
     | comparisonTerm TOK_EQ comparisonTerm     | comparisonTerm TOK_EQ comparisonTerm
     {     {
         WQL_TRACE(("YACC: TOK_EQ\n"));         WQL_TRACE(("YACC: TOK_EQ\n"));
       globalParserState->statement->appendOperation(WQL_EQ);
     }     }
     | comparisonTerm TOK_NE comparisonTerm     | comparisonTerm TOK_NE comparisonTerm
     {     {
         WQL_TRACE(("YACC: TOK_NE\n"));         WQL_TRACE(("YACC: TOK_NE\n"));
       globalParserState->statement->appendOperation(WQL_NE);
       }
       | 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
     }     }
  
 nullPredicate nullPredicate
     : comparisonTerm TOK_IS TOK_NULL     : comparisonTerm TOK_IS TOK_NULL
     {     {
         WQL_TRACE(("YACC: TOK_IS TOK_NULL\n"));      WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n"));
       globalParserState->statement->appendOperation(WQL_IS_NULL);
     }     }
     | comparisonTerm TOK_IS TOK_NOT TOK_NULL     | comparisonTerm TOK_IS TOK_NOT TOK_NULL
     {     {
         WQL_TRACE(("YACC: TOK_NOT TOK_NULL\n"));      WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n"));
       globalParserState->statement->appendOperation(WQL_IS_NOT_NULL);
     }     }
  
 truthValue truthValue
     : TOK_TRUE     : TOK_TRUE
     {     {
       $$ = 1;
     }     }
     | TOK_FALSE     | TOK_FALSE
     {     {
       $$ = 0;
     }     }
   /**************
 propertyName propertyName
     : TOK_IDENTIFIER     : TOK_IDENTIFIER
     {     {
       WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
       $$ = $1;
     }     }
   *****************/
   propertyName
       : TOK_IDENTIFIER
       {
           WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
           $$ = $1;
       }
       | 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
       }
   
  
 className : TOK_IDENTIFIER className : TOK_IDENTIFIER
     {     {
       WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", $1));
       $$ = $1;
     }     }
  
 comparisonTerm comparisonTerm
     : propertyName     : propertyName
     {     {
       globalParserState->statement->appendOperand(
           WQLOperand($1, WQL_PROPERTY_NAME_TAG));
       globalParserState->statement->appendWherePropertyName(CIMName($1));
     }     }
     | TOK_INTEGER     | TOK_INTEGER
     {     {
       globalParserState->statement->appendOperand(
           WQLOperand($1, WQL_INTEGER_VALUE_TAG));
     }     }
     | TOK_DOUBLE     | TOK_DOUBLE
     {     {
       globalParserState->statement->appendOperand(
           WQLOperand($1, WQL_DOUBLE_VALUE_TAG));
     }     }
     | TOK_STRING     | TOK_STRING
     {     {
       globalParserState->statement->appendOperand(
           WQLOperand($1, WQL_STRING_VALUE_TAG));
     }     }
     | truthValue     | 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.5  
changed lines
  Added in v.1.11
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2