(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.4

version 1.1.2.1, 2001/11/30 02:53:56 version 1.4, 2003/02/12 17:18:39
Line 8 
Line 8 
  
 %{ %{
  
   #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 24 
 # 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 73 
  
 %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> GT  %token <intValue> TOK_EQ
 %token <intValue> GE  %token <intValue> TOK_NE
 %token <intValue> TOK_SELECT  %token <intValue> TOK_LT
 %token <intValue> WHERE  %token <intValue> TOK_LE
 %token <intValue> FROM  %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;          globalParserState->statement->setAllProperties(true);
     }     }
       | propertyList
 className : TOK_IDENTIFIER  
     {  
         $$ = $1  
     }  
   
 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
     {  
   
     }  
     | TOK_IDENTIFIER '.' TOK_IDENTIFIER  
     {     {
           WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", $2));
           globalParserState->statement->setClassName(CIMName($2));
     }     }
  
 expression  whereClause
     : expression OR expression      : TOK_WHERE searchCondition
     {     {
  
     }     }
     | 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  
     {  
   
     }     }
     | constant LT property  
     {  
  
     }  /******************************************************************************/
     | constant GT property  
     {  
  
     }  predicate
     | constant LE property      : comparisonPredicate
     {     {
  
     }     }
     | constant GE property      | nullPredicate
     {     {
  
     }     }
     | constant EQ property  
     {  
  
     }  comparisonPredicate
     | constant NE property      : comparisonTerm TOK_LT comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_LT\n"));
           globalParserState->statement->appendOperation(WQL_LT);
     }     }
     | function LT constant      | comparisonTerm TOK_GT comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_GT\n"));
           globalParserState->statement->appendOperation(WQL_GT);
     }     }
     | function GT constant      | comparisonTerm TOK_LE comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_LE\n"));
           globalParserState->statement->appendOperation(WQL_LE);
     }     }
     | function LE constant      | comparisonTerm TOK_GE comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_GE\n"));
           globalParserState->statement->appendOperation(WQL_GE);
     }     }
     | function GE constant      | comparisonTerm TOK_EQ comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_EQ\n"));
           globalParserState->statement->appendOperation(WQL_EQ);
     }     }
     | function EQ constant      | comparisonTerm TOK_NE comparisonTerm
     {     {
           WQL_TRACE(("YACC: TOK_NE\n"));
           globalParserState->statement->appendOperation(WQL_NE);
     }     }
     | function NE constant  
     {  
  
     }  nullPredicate
     | constant LT function      : comparisonTerm TOK_IS TOK_NULL
     {     {
           WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n"));
           globalParserState->statement->appendOperation(WQL_IS_NULL);
     }     }
     | constant GT 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 LE function  
     {  
  
     }  truthValue
     | constant GE function      : TOK_TRUE
     {     {
           $$ = 1;
     }     }
     | constant EQ function      | TOK_FALSE
     {     {
           $$ = 0;
     }     }
     | constant NE function  
     {  
  
     }  propertyName
     | className ISA className      : TOK_IDENTIFIER
     {     {
           WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", $1));
           $$ = $1;
     }     }
  
 function  className : TOK_IDENTIFIER
     : 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.4
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2