ezexpryacc.y

很管用的GIS控件

             { GetTwoOperators;
               AddExpression(TBinaryOp.Create(opShr, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr _GE basic_expr
             { GetTwoOperators;
               AddExpression(TRelationalOp.Create(opGTE, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr _LE basic_expr
             { GetTwoOperators;
               AddExpression(TRelationalOp.Create(opLTE, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr _GT basic_expr
             { GetTwoOperators;
               AddExpression(TRelationalOp.Create(opGT, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr _LT basic_expr
             { GetTwoOperators;
               AddExpression(TRelationalOp.Create(opLT, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr _EQ basic_expr
             { GetTwoOperators;
               AddExpression(TRelationalOp.Create(opEQ, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr _NEQ basic_expr
             { GetTwoOperators;
               AddExpression(TRelationalOp.Create(opNEQ, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr RW_AND basic_expr
             { GetTwoOperators;
               AddExpression(TBinaryOp.Create(opAnd, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr RW_OR basic_expr
             { GetTwoOperators;
               AddExpression(TBinaryOp.Create(opOr, Op1, Op2));
               FIsComplex:= True;}
           | basic_expr RW_XOR basic_expr
             { GetTwoOperators;
               AddExpression(TBinaryOp.Create(opXOr, Op1, Op2));
               FIsComplex:= True;}
           | _LPAREN basic_expr _RPAREN
             { FIsComplex:= True; }
           | spatial_query
           ;

parameter_list : /* empty */
                 { FStackedParamCount.Add(Pointer(0)); }
               | start_list _RPAREN
               | start_list list_param _RPAREN
               ;

start_list : _LPAREN
             { FStackedParamCount.Add(Pointer(0)); }
           ;

list_param : basic_expr
             { AddParam; }
           | list_param _COMA basic_expr
             { AddParam; }
           ;

/* CASE...WHEN...THEN...ELSE...END clause */
case_clause : RW_CASE when_list else_clause RW_END
            ;

when_list : when_clause
          | when_list when_clause
          ;

when_clause : RW_WHEN basic_expr RW_THEN basic_expr
              { if FWhenParamList=nil then
                  FWhenParamList:= TParameterList.Create;
                if FThenParamList=nil then
                  FThenParamList:= TParameterList.Create;
                FWhenParamList.Add(FExprList[FExprList.Count-2]);
                FThenParamList.Add(FExprList[FExprList.Count-1]);
                FExprList.Delete(FExprList.Count-1);
                FExprList.Delete(FExprList.Count-1);
              }
            ;

else_clause : /* empty */
            | RW_ELSE basic_expr
              { FElseExpr:= TExpression(FExprList[FExprList.Count-1]);
                FExprList.Delete(FExprList.Count-1);
              }
            ;

define_identifier : _IDENTIFIER
                    { FGroupIdentList.Add('');
                      FIdentifierList.Add(UpperCase($<string>1));
                    }
                  | _IDENTIFIER _PERIOD _IDENTIFIER
                    { FGroupIdentList.Add(UpperCase($<string>1));
                      FIdentifierList.Add(UpperCase($<string>3));
                    }
                  ;

expr_constant : _UINTEGER
                { Val($<string>1, IntVal, Code);
                  if Code=0 then
                    FExprList.Add(TIntegerLiteral.Create(StrToInt($<string>1)))
                  else
                    FExprList.Add(TFloatLiteral.Create(StrToFloat($<string>1)));
                }
              | _SINTEGER
                { Val($<string>1, IntVal, Code);
                  if Code=0 then
                    FExprList.Add(TIntegerLiteral.Create(StrToInt($<string>1)))
                  else
                    FExprList.Add(TFloatLiteral.Create(StrToFloat($<string>1)));
                }
              | _NUMERIC   { FExprList.Add(TFloatLiteral.Create(StrToFloat($<string>1))); }
              | _STRING    { FExprList.Add(TStringLiteral.Create(GetString( $<string>1 ))); }
              | RW_TRUE    { FExprList.Add(TBooleanLiteral.Create(True)); }
              | RW_FALSE   { FExprList.Add(TBooleanLiteral.Create(False)); }
              ;

escape_character : /* empty */
                   { FExprList.Add(TStringLiteral.Create('')); }
                 | RW_ESCAPE _STRING
                   { FExprList.Add(TStringLiteral.Create(GetString( $<string>2 ) )); }
                 ;

/* for expressions involving graphical operators, like WITHIN, CONTAINS,...,etc */

graphic_operator : RW_INTERSECTS
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goIntersects) ); }
                 | RW_WITHIN
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goWithin) ); }
                 | RW_ENTIRELY RW_WITHIN
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goEntirelyWithin) ); }
                 | RW_CONTAINS
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goContains) ); }
                 | RW_CONTAINS RW_ENTIRE
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goContainsEntire) ); }

                 | RW_ENTIRELY RW_WITHIN RW_NOT RW_EDGE RW_TOUCH
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goEntirelyWithinNoEdgeTouched) ); }
                 | RW_CONTAINS RW_ENTIRE RW_NOT RW_EDGE RW_TOUCH
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goContainsEntireNoEdgeTouched) ); }
                 | RW_EXTENT RW_OVERLAPS
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goExtentOverlaps) ); }
                 | RW_SHARE RW_COMMON RW_POINT
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goShareCommonPoint) ); }
                 | RW_SHARE RW_COMMON RW_LINE
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goShareCommonLine) ); }
                 | RW_LINE RW_CROSS
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goLineCross) ); }
                 | RW_COMMON RW_POINT RW_OR RW_LINE RW_CROSS
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goCommonPointOrLineCross) ); }
                 | RW_EDGE RW_TOUCH
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goEdgeTouch) ); }
                 | RW_EDGE RW_TOUCH RW_OR RW_INTERSECTS
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goEdgeTouchOrIntersect) ); }
                 | RW_POINT RW_IN RW_POLYGON
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goPointInPolygon) ); }
                 | RW_CENTROID RW_IN RW_POLYGON
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goCentroidInPolygon) ); }
                 | RW_IDENTICAL
                   { AddExpression( TEzGraphicOperatorExpr.Create(nil, goIdentical) ); }

                 ;

define_vector : define_vector_type _LPAREN _LSQUARE multipart_list _RSQUARE _RPAREN buffer_width
                { AddExpression( TEzVectorExpr.Create( Nil, FVector, FVectorType, FBufferWidth ) );
                  FVector.Clear;
                  FBufferWidth:= 0; }
              ;

define_vector_type : RW_VECTOR     { FVectorType:= vtUndefined; }
                   | RW_POLYLINE   { FVectorType:= vtPolyline; }
                   | RW_POLYGON    { FVectorType:= vtPolygon; }
                   | RW_BUFFER     { FVectorType:= vtBuffer; }
                   ;

buffer_width : /* empty */
             | RW_WIDTH numeric_value  { FBufferWidth := StrToFloat( $<string>2 ); }
             ;

multipart_list : points_list
               | multipart_list part_separator points_list
               ;

part_separator : _SEMICOLON
                 { if FVector.Parts.Count=0 then FVector.Parts.Add(0);
                   FVector.Parts.Add(FVector.Count); }

points_list : define_point
            | points_list _COMA define_point
            ;

define_point : _LPAREN numeric_value _COMA numeric_value _RPAREN
               { FVector.AddPoint(StrToFloat($<string>2), StrToFloat($<string>4)); }
             ;

numeric_value : _UINTEGER
              | _SINTEGER
              | _NUMERIC
              ;

record_list : _UINTEGER
              { FExprList.Add(TIntegerLiteral.Create(StrToInt($<string>1)));
                Inc( FNumRecords ); }
            | record_list _COMA _UINTEGER
              { FExprList.Add(TIntegerLiteral.Create(StrToInt($<string>3)));
                Inc( FNumRecords ); }
            ;

ent_identifier : _IDENTIFIER _PERIOD RW_ENT
                 { AddExpression( TEntExpr.Create(nil, FMainExpr.Gis,
                     FMainExpr.Gis.Layers.LayerByName( $<string>1 )) ); }
               ;

spatial_query : ent_identifier graphic_operator define_vector
                { AddExpression( TEzQueryVectorExpr.Create(ForceParamList(3), FMainExpr ) ); }
              | ent_identifier RW_SCOPE _LPAREN basic_expr _RPAREN
                { AddExpression( TEzQueryScopeExpr.Create(ForceParamList(2), FMainExpr ) ); }
              | ent_identifier graphic_operator ent_identifier
                { //!!! pendiente de implementar aqui la comparacion registro a registro para JOINs en SQL!!! }
              | ent_identifier graphic_operator ent_identifier RW_RECORDS _LPAREN record_list _RPAREN
                { AddExpression( TEzQueryLayerExpr.Create(ForceParamList( FNumRecords + 3 ), FMainExpr ) );
                  FNumRecords:= 0; }
              | ent_identifier graphic_operator ent_identifier RW_ALL RW_RECORDS
                { AddExpression( TEzQueryLayerExpr.Create(ForceParamList(3), FMainExpr ) ); }
              | ent_identifier graphic_operator spatial_query
                { AddExpression( TEzQueryLayerExpr.Create(ForceParamList(3), FMainExpr ) ); }
              ;


orderby : /* empty */
        | RW_ORDER RW_BY orderby_list
        ;

orderby_list : orderby_one
             | orderby_list _COMA orderby_one
             ;

orderby_one : basic_expr descending
              { GetOneOperator;
                FreeAndNil( Op1 );
                FOrderBy.AddObject( $<string>1, Pointer( Ord( FDescending ) ) );
                FDescending := False;
              }
            ;

descending : /* empty */
           | RW_DESC       { FDescending := True; }
           | RW_DESCENDING { FDescending := True; }
           ;

%%