00001 {*********************************************************}
00002 { }
00003 { Zeos Database Objects }
00004 { Variables classes and interfaces }
00005 { }
00006 { Originally written by Sergey Seroukhov }
00007 { }
00008 {*********************************************************}
00009
00010 {@********************************************************}
00011 { Copyright (c) 1999-2006 Zeos Development Group }
00012 { }
00013 { License Agreement: }
00014 { }
00015 { This library is distributed in the hope that it will be }
00016 { useful, but WITHOUT ANY WARRANTY; without even the }
00017 { implied warranty of MERCHANTABILITY or FITNESS FOR }
00018 { A PARTICULAR PURPOSE. See the GNU Lesser General }
00019 { Public License for more details. }
00020 { }
00021 { The source code of the ZEOS Libraries and packages are }
00022 { distributed under the Library GNU General Public }
00023 { License (see the file COPYING / COPYING.ZEOS) }
00024 { with the following modification: }
00025 { As a special exception, the copyright holders of this }
00026 { library give you permission to link this library with }
00027 { independent modules to produce an executable, }
00028 { regardless of the license terms of these independent }
00029 { modules, and to copy and distribute the resulting }
00030 { executable under terms of your choice, provided that }
00031 { you also meet, for each linked independent module, }
00032 { the terms and conditions of the license of that module. }
00033 { An independent module is a module which is not derived }
00034 { from or based on this library. If you modify this }
00035 { library, you may extend this exception to your version }
00036 { of the library, but you are not obligated to do so. }
00037 { If you do not wish to do so, delete this exception }
00038 { statement from your version. }
00039 { }
00040 { }
00041 { The project web site is located on: }
00042 { http:
00043 { http:
00044 { svn:
00045 { }
00046 { http:
00047 { http:
00048 { }
00049 { }
00050 { }
00051 { Zeos Development Group. }
00052 {********************************************************@}
00053
00054 unit ZFunctions;
00055
00056 interface
00057
00058 {$I ZCore.inc}
00059
00060 uses SysUtils, {$IFNDEF VER130}StrUtils,{$ENDIF} Classes, ZClasses, ZCollections, ZCompatibility, ZVariant,
00061 ZExpression;
00062
00063 type
00064
00065 {** Implements a list of functions. }
00066 TZFunctionsList = class (TInterfacedObject, IZFunctionsList)
00067 private
00068 FFunctions: IZCollection;
00069 protected
00070 property Functions: IZCollection read FFunctions write FFunctions;
00071 public
00072 constructor Create;
00073 destructor Destroy; override;
00074
00075 function GetCount: Integer;
00076 function GetName(Index: Integer): string;
00077 function GetFunction(Index: Integer): IZFunction;
00078
00079 procedure Add(Func: IZFunction);
00080 procedure Remove(const Name: string);
00081 function FindByName(const Name: string): Integer;
00082
00083 procedure Clear;
00084 end;
00085
00086 {** Implements an abstract function. }
00087 TZAbstractFunction = class (TInterfacedObject, IZFunction)
00088 protected
00089 FName: string;
00090
00091 function CheckParamsCount(Stack: TZExecutionStack;
00092 ExpectedCount: Integer): Integer;
00093 public
00094 function GetName: string;
00095 function Execute(Stack: TZExecutionStack;
00096 VariantManager: IZVariantManager): TZVariant; virtual; abstract;
00097
00098 property Name: string read GetName;
00099 end;
00100
00101 {** Implements a TIME function. }
00102 TZTimeFunction = class (TZAbstractFunction)
00103 public
00104 constructor Create;
00105 function Execute(Stack: TZExecutionStack;
00106 VariantManager: IZVariantManager): TZVariant; override;
00107 end;
00108
00109 {** Implements a EMPTY function. }
00110 TZEmptyFunction = class (TZAbstractFunction)
00111 public
00112 constructor Create;
00113 function Execute(Stack: TZExecutionStack;
00114 VariantManager: IZVariantManager): TZVariant; override;
00115 end;
00116
00117 {** Implements a TRIM function. }
00118 TZTrimFunction = class (TZAbstractFunction)
00119 public
00120 constructor Create;
00121 function Execute(Stack: TZExecutionStack;
00122 VariantManager: IZVariantManager): TZVariant; override;
00123 end;
00124
00125 {** Implements a VAL function. }
00126 TZValFunction = class (TZAbstractFunction)
00127 public
00128 constructor Create;
00129 function Execute(Stack: TZExecutionStack;
00130 VariantManager: IZVariantManager): TZVariant; override;
00131 end;
00132
00133 {** Implements a DTOS function. }
00134 TZDtosFunction = class (TZAbstractFunction)
00135 public
00136 constructor Create;
00137 function Execute(Stack: TZExecutionStack;
00138 VariantManager: IZVariantManager): TZVariant; override;
00139 end;
00140
00141 {$IFNDEF VER130}
00142 {** Implements a CTOD function. }
00143 TZCtodFunction = class (TZAbstractFunction)
00144 public
00145 constructor Create;
00146 function Execute(Stack: TZExecutionStack;
00147 VariantManager: IZVariantManager): TZVariant; override;
00148 end;
00149 {$ENDIF}
00150 {** Implements a MIN function. }
00151 TZMinFunction = class (TZAbstractFunction)
00152 public
00153 constructor Create;
00154 function Execute(Stack: TZExecutionStack;
00155 VariantManager: IZVariantManager): TZVariant; override;
00156 end;
00157
00158 {** Implements a MAX function. }
00159 TZMaxFunction = class (TZAbstractFunction)
00160 public
00161 constructor Create;
00162 function Execute(Stack: TZExecutionStack;
00163 VariantManager: IZVariantManager): TZVariant; override;
00164 end;
00165
00166 {** Implements a IIF function. }
00167 TZIIFFunction = class (TZAbstractFunction)
00168 public
00169 constructor Create;
00170 function Execute(Stack: TZExecutionStack;
00171 VariantManager: IZVariantManager): TZVariant; override;
00172 end;
00173
00174 {** Implements a SUM function. }
00175 TZSUMFunction = class (TZAbstractFunction)
00176 public
00177 constructor Create;
00178 function Execute(Stack: TZExecutionStack;
00179 VariantManager: IZVariantManager): TZVariant; override;
00180 end;
00181
00182 {** Implements a E function. }
00183 TZEFunction = class (TZAbstractFunction)
00184 public
00185 constructor Create;
00186 function Execute(Stack: TZExecutionStack;
00187 VariantManager: IZVariantManager): TZVariant; override;
00188 end;
00189
00190 {** Implements a PI function. }
00191 TZPIFunction = class (TZAbstractFunction)
00192 public
00193 constructor Create;
00194 function Execute(Stack: TZExecutionStack;
00195 VariantManager: IZVariantManager): TZVariant; override;
00196 end;
00197
00198 {** Implements a RND function. }
00199 TZRndFunction = class (TZAbstractFunction)
00200 public
00201 constructor Create;
00202 function Execute(Stack: TZExecutionStack;
00203 VariantManager: IZVariantManager): TZVariant; override;
00204 end;
00205
00206 {** Implements a ABS function. }
00207 TZAbsFunction = class (TZAbstractFunction)
00208 public
00209 constructor Create;
00210 function Execute(Stack: TZExecutionStack;
00211 VariantManager: IZVariantManager): TZVariant; override;
00212 end;
00213
00214 {** Implements a ACOS function. }
00215 TZAcosFunction = class (TZAbstractFunction)
00216 public
00217 constructor Create;
00218 function Execute(Stack: TZExecutionStack;
00219 VariantManager: IZVariantManager): TZVariant; override;
00220 end;
00221
00222 {** Implements a ASIN function. }
00223 TZAsinFunction = class (TZAbstractFunction)
00224 public
00225 constructor Create;
00226 function Execute(Stack: TZExecutionStack;
00227 VariantManager: IZVariantManager): TZVariant; override;
00228 end;
00229
00230 {** Implements a ATAN function. }
00231 TZAtanFunction = class (TZAbstractFunction)
00232 public
00233 constructor Create;
00234 function Execute(Stack: TZExecutionStack;
00235 VariantManager: IZVariantManager): TZVariant; override;
00236 end;
00237
00238 {** Implements a CEIL function. }
00239 TZCeilFunction = class (TZAbstractFunction)
00240 public
00241 constructor Create;
00242 function Execute(Stack: TZExecutionStack;
00243 VariantManager: IZVariantManager): TZVariant; override;
00244 end;
00245
00246 {** Implements a FLOOR function. }
00247 TZFloorFunction = class (TZAbstractFunction)
00248 public
00249 constructor Create;
00250 function Execute(Stack: TZExecutionStack;
00251 VariantManager: IZVariantManager): TZVariant; override;
00252 end;
00253
00254 {** Implements a COS function. }
00255 TZCosFunction = class (TZAbstractFunction)
00256 public
00257 constructor Create;
00258 function Execute(Stack: TZExecutionStack;
00259 VariantManager: IZVariantManager): TZVariant; override;
00260 end;
00261
00262 {** Implements a SIN function. }
00263 TZSinFunction = class (TZAbstractFunction)
00264 public
00265 constructor Create;
00266 function Execute(Stack: TZExecutionStack;
00267 VariantManager: IZVariantManager): TZVariant; override;
00268 end;
00269
00270 {** Implements a TAN function. }
00271 TZTanFunction = class (TZAbstractFunction)
00272 public
00273 constructor Create;
00274 function Execute(Stack: TZExecutionStack;
00275 VariantManager: IZVariantManager): TZVariant; override;
00276 end;
00277
00278 {** Implements a EXP function. }
00279 TZExpFunction = class (TZAbstractFunction)
00280 public
00281 constructor Create;
00282 function Execute(Stack: TZExecutionStack;
00283 VariantManager: IZVariantManager): TZVariant; override;
00284 end;
00285
00286 {** Implements a LOG function. }
00287 TZLogFunction = class (TZAbstractFunction)
00288 public
00289 constructor Create;
00290 function Execute(Stack: TZExecutionStack;
00291 VariantManager: IZVariantManager): TZVariant; override;
00292 end;
00293
00294 {** Implements a LOG10 function. }
00295 TZLog10Function = class (TZAbstractFunction)
00296 public
00297 constructor Create;
00298 function Execute(Stack: TZExecutionStack;
00299 VariantManager: IZVariantManager): TZVariant; override;
00300 end;
00301
00302 {** Implements a ROUND function. }
00303 TZRoundFunction = class (TZAbstractFunction)
00304 public
00305 constructor Create;
00306 function Execute(Stack: TZExecutionStack;
00307 VariantManager: IZVariantManager): TZVariant; override;
00308 end;
00309
00310 {** Implements a SQR function. }
00311 TZSqrFunction = class (TZAbstractFunction)
00312 public
00313 constructor Create;
00314 function Execute(Stack: TZExecutionStack;
00315 VariantManager: IZVariantManager): TZVariant; override;
00316 end;
00317
00318 {** Implements a UPPER function. }
00319 TZUpperFunction = class (TZAbstractFunction)
00320 public
00321 constructor Create;
00322 function Execute(Stack: TZExecutionStack;
00323 VariantManager: IZVariantManager): TZVariant; override;
00324 end;
00325
00326 {** Implements a LOWER function. }
00327 TZLowerFunction = class (TZAbstractFunction)
00328 public
00329 constructor Create;
00330 function Execute(Stack: TZExecutionStack;
00331 VariantManager: IZVariantManager): TZVariant; override;
00332 end;
00333
00334 {** Implements a CONCAT function. }
00335 TZConcatFunction = class (TZAbstractFunction)
00336 public
00337 constructor Create;
00338 function Execute(Stack: TZExecutionStack;
00339 VariantManager: IZVariantManager): TZVariant; override;
00340 end;
00341
00342 {** Implements a SUBSTR function. }
00343 TZSubStrFunction = class (TZAbstractFunction)
00344 public
00345 constructor Create;
00346 function Execute(Stack: TZExecutionStack;
00347 VariantManager: IZVariantManager): TZVariant; override;
00348 end;
00349
00350 {** Implements a STRPOS function. }
00351 TZStrPosFunction = class (TZAbstractFunction)
00352 public
00353 constructor Create;
00354 function Execute(Stack: TZExecutionStack;
00355 VariantManager: IZVariantManager): TZVariant; override;
00356 end;
00357
00358 {$IFNDEF VER130}
00359 {** Implements a LEFT function. }
00360 TZLeftFunction = class (TZAbstractFunction)
00361 public
00362 constructor Create;
00363 function Execute(Stack: TZExecutionStack;
00364 VariantManager: IZVariantManager): TZVariant; override;
00365 end;
00366
00367 {** Implements a RIGHT function. }
00368 TZRightFunction = class (TZAbstractFunction)
00369 public
00370 constructor Create;
00371 function Execute(Stack: TZExecutionStack;
00372 VariantManager: IZVariantManager): TZVariant; override;
00373 end;
00374 {$ENDIF}
00375
00376 {** Implements a default function list. }
00377 TZDefaultFunctionsList = class (TZFunctionsList)
00378 public
00379 constructor Create;
00380 end;
00381
00382 implementation
00383
00384 uses Math, ZMessages;
00385
00386 { TZFunctionsList }
00387
00388 {**
00389 Constructs this object.
00390 }
00391 constructor TZFunctionsList.Create;
00392 begin
00393 FFunctions := TZCollection.Create;
00394 end;
00395
00396 {**
00397 Destroys this object and cleanup the memory.
00398 }
00399 destructor TZFunctionsList.Destroy;
00400 begin
00401 FFunctions := nil;
00402 inherited Destroy;
00403 end;
00404
00405 {**
00406 Finds a function reference
00407 }
00408 function TZFunctionsList.FindByName(const Name: string): Integer;
00409 var
00410 I: Integer;
00411 Current: IZFunction;
00412 UpperName: string;
00413 begin
00414 Result := -1;
00415 UpperName := UpperCase(Name);
00416 for I := 0 to FFunctions.Count - 1 do
00417 begin
00418 Current := FFunctions[I] as IZFunction;
00419 if UpperCase(Current.Name) = UpperName then
00420 begin
00421 Result := I;
00422 Break;
00423 end;
00424 end;
00425 end;
00426
00427 {**
00428 Adds a new function to this list.
00429 @param Func a function reference.
00430 }
00431 procedure TZFunctionsList.Add(Func: IZFunction);
00432 var
00433 Index: Integer;
00434 begin
00435 Index := FindByName(Func.Name);
00436 if Index < 0 then
00437 FFunctions.Add(Func);
00438 end;
00439
00440 {**
00441 Removes a reference to functoin by it's name.
00442 @param Name a name of the function to be removed.
00443 }
00444 procedure TZFunctionsList.Remove(const Name: string);
00445 var
00446 Index: Integer;
00447 begin
00448 Index := FindByName(Name);
00449 if Index >= 0 then
00450 FFunctions.Delete(Index);
00451 end;
00452
00453 {**
00454 Cleans the list of registered functions.
00455 }
00456 procedure TZFunctionsList.Clear;
00457 begin
00458 FFunctions.Clear;
00459 end;
00460
00461 {**
00462 Gets a number of registered functions.
00463 @returns a number of registered functions.
00464 }
00465 function TZFunctionsList.GetCount: Integer;
00466 begin
00467 Result := FFunctions.Count;
00468 end;
00469
00470 {**
00471 Gets a function reference by it's index.
00472 @param Index a function index.
00473 @returns a function reference.
00474 }
00475 function TZFunctionsList.GetFunction(Index: Integer): IZFunction;
00476 begin
00477 Result := FFunctions[Index] as IZFunction;
00478 end;
00479
00480 {**
00481 Gets a name of the functions by it's index.
00482 @param Index a functon index.
00483 @returns a name of the function.
00484 }
00485 function TZFunctionsList.GetName(Index: Integer): string;
00486 begin
00487 Result := (FFunctions[Index] as IZFunction).Name;
00488 end;
00489
00490 { TZDefaultFunctionsList }
00491
00492 {**
00493 Constructs a default functions list and adds all available
00494 standard functions.
00495 }
00496 constructor TZDefaultFunctionsList.Create;
00497 begin
00498 inherited Create;
00499 Functions.Add(TZTimeFunction.Create);
00500 Functions.Add(TZEmptyFunction.Create);
00501 Functions.Add(TZMinFunction.Create);
00502 Functions.Add(TZMaxFunction.Create);
00503 Functions.Add(TZIIFFunction.Create);
00504 Functions.Add(TZSumFunction.Create);
00505 Functions.Add(TZEFunction.Create);
00506 Functions.Add(TZPIFunction.Create);
00507 Functions.Add(TZRndFunction.Create);
00508 Functions.Add(TZAbsFunction.Create);
00509 Functions.Add(TZAcosFunction.Create);
00510 Functions.Add(TZAsinFunction.Create);
00511 Functions.Add(TZAtanFunction.Create);
00512 Functions.Add(TZCeilFunction.Create);
00513 Functions.Add(TZFloorFunction.Create);
00514 Functions.Add(TZCosFunction.Create);
00515 Functions.Add(TZSinFunction.Create);
00516 Functions.Add(TZTanFunction.Create);
00517 Functions.Add(TZExpFunction.Create);
00518 Functions.Add(TZLogFunction.Create);
00519 Functions.Add(TZLog10Function.Create);
00520 Functions.Add(TZRoundFunction.Create);
00521 Functions.Add(TZSqrFunction.Create);
00522 Functions.Add(TZUpperFunction.Create);
00523 Functions.Add(TZLowerFunction.Create);
00524 Functions.Add(TZConcatFunction.Create);
00525 Functions.Add(TZSubStrFunction.Create);
00526 Functions.Add(TZStrPosFunction.Create);
00527 Functions.Add(TZTrimFunction.Create);
00528 Functions.Add(TZValFunction.Create);
00529 Functions.Add(TZDtosFunction.Create);
00530 {$IFNDEF VER130}
00531 Functions.Add(TZCtodFunction.Create);
00532 Functions.Add(TZLeftFunction.Create);
00533 Functions.Add(TZRightFunction.Create);
00534 {$ENDIF}
00535 end;
00536
00537 { TZAbstractFunction }
00538
00539 {**
00540 Gets the assigned function name.
00541 @returns the assigned function name.
00542 }
00543 function TZAbstractFunction.GetName: string;
00544 begin
00545 Result := FName;
00546 end;
00547
00548 {**
00549 Checks the function parameter count number.
00550 @param Stack a stack object.
00551 @param ExpectedCount a number of expected parameters.
00552 @returns a real number of parameters.
00553 }
00554 function TZAbstractFunction.CheckParamsCount(Stack: TZExecutionStack;
00555 ExpectedCount: Integer): Integer;
00556 begin
00557 Result := DefVarManager.GetAsInteger(Stack.GetParameter(0));
00558 if Result <> ExpectedCount then
00559 begin
00560 raise TZExpressionError.Create(Format(SParametersError,
00561 [ExpectedCount, Result]));
00562 end;
00563 end;
00564
00565 { TZTimeFunction }
00566
00567 {**
00568 Creates this function object.
00569 }
00570 constructor TZTimeFunction.Create;
00571 begin
00572 FName := 'TIME';
00573 end;
00574
00575 {**
00576 Executes this function.
00577 @param Stack the stack object.
00578 @param VariantManager a reference to variant processor object.
00579 @returns a function value.
00580 }
00581 function TZTimeFunction.Execute(Stack: TZExecutionStack;
00582 VariantManager: IZVariantManager): TZVariant;
00583 begin
00584 CheckParamsCount(Stack, 0);
00585 VariantManager.SetAsDateTime(Result, Now);
00586 end;
00587
00588 { TZEmptyFunction }
00589
00590 {**
00591 Creates this function object.
00592 }
00593 constructor TZEmptyFunction.Create;
00594 begin
00595 FName := 'EMPTY';
00596 end;
00597
00598 {**
00599 Executes this function.
00600 @param Stack the stack object.
00601 @param VariantManager a reference to variant processor object.
00602 @returns a function value.
00603 }
00604 function TZEmptyFunction.Execute(Stack: TZExecutionStack;
00605 VariantManager: IZVariantManager): TZVariant;
00606 var
00607 Value: TZVariant;
00608 begin
00609 CheckParamsCount(Stack, 1);
00610 Value := Stack.GetParameter(1);
00611 VariantManager.SetAsBoolean(Result, VariantManager.IsNull(Value));
00612 end;
00613
00614 { TZMinFunction }
00615
00616 {**
00617 Creates this function object.
00618 }
00619 constructor TZMinFunction.Create;
00620 begin
00621 FName := 'MIN';
00622 end;
00623
00624 {**
00625 Executes this function.
00626 @param Stack the stack object.
00627 @param VariantManager a reference to variant processor object.
00628 @returns a function value.
00629 }
00630 function TZMinFunction.Execute(Stack: TZExecutionStack;
00631 VariantManager: IZVariantManager): TZVariant;
00632 var
00633 I, ParamsCount: Integer;
00634 Value: TZVariant;
00635 begin
00636 ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
00637 if ParamsCount < 2 then
00638 raise TZExpressionError.Create(SExpectedMoreParams);
00639
00640 Result := Stack.GetParameter(ParamsCount);
00641 for I := 1 to ParamsCount - 1 do
00642 begin
00643 Value := Stack.GetParameter(I);
00644 if VariantManager.Compare(Result, Value) > 0 then
00645 Result := Value;
00646 end;
00647 end;
00648
00649 { TZMaxFunction }
00650
00651 {**
00652 Creates this function object.
00653 }
00654 constructor TZMaxFunction.Create;
00655 begin
00656 FName := 'MAX';
00657 end;
00658
00659 {**
00660 Executes this function.
00661 @param Stack the stack object.
00662 @param VariantManager a reference to variant processor object.
00663 @returns a function value.
00664 }
00665 function TZMaxFunction.Execute(Stack: TZExecutionStack;
00666 VariantManager: IZVariantManager): TZVariant;
00667 var
00668 I, ParamsCount: Integer;
00669 Value: TZVariant;
00670 begin
00671 ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
00672 if ParamsCount < 2 then
00673 raise TZExpressionError.Create(SExpectedMoreParams);
00674
00675 Result := Stack.GetParameter(ParamsCount);
00676 for I := 1 to ParamsCount - 1 do
00677 begin
00678 Value := Stack.GetParameter(I);
00679 if VariantManager.Compare(Result, Value) < 0 then
00680 Result := Value;
00681 end;
00682 end;
00683
00684 { TZIIFFunction }
00685
00686 {**
00687 Creates this function object.
00688 }
00689 constructor TZIIFFunction.Create;
00690 begin
00691 FName := 'IIF';
00692 end;
00693
00694 {**
00695 Executes this function.
00696 @param Stack the stack object.
00697 @param VariantManager a reference to variant processor object.
00698 @returns a function value.
00699 }
00700 function TZIIFFunction.Execute(Stack: TZExecutionStack;
00701 VariantManager: IZVariantManager): TZVariant;
00702 begin
00703 CheckParamsCount(Stack, 3);
00704 if VariantManager.GetAsBoolean(Stack.GetParameter(3)) then
00705 Result := Stack.GetParameter(2)
00706 else Result := Stack.GetParameter(1);
00707 end;
00708
00709 { TZSumFunction }
00710
00711 {**
00712 Creates this function object.
00713 }
00714 constructor TZSumFunction.Create;
00715 begin
00716 FName := 'SUM';
00717 end;
00718
00719 {**
00720 Executes this function.
00721 @param Stack the stack object.
00722 @param VariantManager a reference to variant processor object.
00723 @returns a function value.
00724 }
00725 function TZSumFunction.Execute(Stack: TZExecutionStack;
00726 VariantManager: IZVariantManager): TZVariant;
00727 var
00728 I, ParamsCount: Integer;
00729 begin
00730 ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
00731 if ParamsCount < 2 then
00732 raise TZExpressionError.Create(SExpectedMoreParams);
00733
00734 Result := Stack.GetParameter(ParamsCount);
00735 for I := ParamsCount - 1 downto 1 do
00736 Result := VariantManager.OpAdd(Result, Stack.GetParameter(I));
00737 end;
00738
00739 { TZEFunction }
00740
00741 {**
00742 Creates this function object.
00743 }
00744 constructor TZEFunction.Create;
00745 begin
00746 FName := 'E';
00747 end;
00748
00749 {**
00750 Executes this function.
00751 @param Stack the stack object.
00752 @param VariantManager a reference to variant processor object.
00753 @returns a function value.
00754 }
00755 function TZEFunction.Execute(Stack: TZExecutionStack;
00756 VariantManager: IZVariantManager): TZVariant;
00757 begin
00758 CheckParamsCount(Stack, 0);
00759 VariantManager.SetAsFloat(Result, Exp(1));
00760 end;
00761
00762 { TZPIFunction }
00763
00764 {**
00765 Creates this function object.
00766 }
00767 constructor TZPIFunction.Create;
00768 begin
00769 FName := 'PI';
00770 end;
00771
00772 {**
00773 Executes this function.
00774 @param Stack the stack object.
00775 @param VariantManager a reference to variant processor object.
00776 @returns a function value.
00777 }
00778 function TZPIFunction.Execute(Stack: TZExecutionStack;
00779 VariantManager: IZVariantManager): TZVariant;
00780 begin
00781 CheckParamsCount(Stack, 0);
00782 VariantManager.SetAsFloat(Result, PI);
00783 end;
00784
00785 { TZRndFunction }
00786
00787 {**
00788 Creates this function object.
00789 }
00790 constructor TZRndFunction.Create;
00791 begin
00792 FName := 'RND';
00793 end;
00794
00795 {**
00796 Executes this function.
00797 @param Stack the stack object.
00798 @param VariantManager a reference to variant processor object.
00799 @returns a function value.
00800 }
00801 function TZRndFunction.Execute(Stack: TZExecutionStack;
00802 VariantManager: IZVariantManager): TZVariant;
00803 begin
00804 CheckParamsCount(Stack, 0);
00805 VariantManager.SetAsFloat(Result, Random);
00806 end;
00807
00808 { TZAbsFunction }
00809
00810 {**
00811 Creates this function object.
00812 }
00813 constructor TZAbsFunction.Create;
00814 begin
00815 FName := 'ABS';
00816 end;
00817
00818 {**
00819 Executes this function.
00820 @param Stack the stack object.
00821 @param VariantManager a reference to variant processor object.
00822 @returns a function value.
00823 }
00824 function TZAbsFunction.Execute(Stack: TZExecutionStack;
00825 VariantManager: IZVariantManager): TZVariant;
00826 var
00827 Value: TZVariant;
00828 begin
00829 CheckParamsCount(Stack, 1);
00830 Value := Stack.GetParameter(1);
00831 if Value.VType = vtInteger then
00832 VariantManager.SetAsInteger(Result, Abs(Value.VInteger))
00833 else if Value.VType = vtFloat then
00834 VariantManager.SetAsFloat(Result, Abs(Value.VFloat))
00835 else
00836 Result := Value;
00837 end;
00838
00839 { TZAcosFunction }
00840
00841 {**
00842 Creates this function object.
00843 }
00844 constructor TZAcosFunction.Create;
00845 begin
00846 FName := 'ACOS';
00847 end;
00848
00849 {**
00850 Executes this function.
00851 @param Stack the stack object.
00852 @param VariantManager a reference to variant processor object.
00853 @returns a function value.
00854 }
00855 function TZAcosFunction.Execute(Stack: TZExecutionStack;
00856 VariantManager: IZVariantManager): TZVariant;
00857 begin
00858 CheckParamsCount(Stack, 1);
00859 VariantManager.SetAsFloat(Result, ArcCos(
00860 VariantManager.GetAsFloat(Stack.GetParameter(1))));
00861 end;
00862
00863 { TZAsinFunction }
00864
00865 {**
00866 Creates this function object.
00867 }
00868 constructor TZAsinFunction.Create;
00869 begin
00870 FName := 'ASIN';
00871 end;
00872
00873 {**
00874 Executes this function.
00875 @param Stack the stack object.
00876 @param VariantManager a reference to variant processor object.
00877 @returns a function value.
00878 }
00879 function TZAsinFunction.Execute(Stack: TZExecutionStack;
00880 VariantManager: IZVariantManager): TZVariant;
00881 begin
00882 CheckParamsCount(Stack, 1);
00883 VariantManager.SetAsFloat(Result, ArcSin(
00884 VariantManager.GetAsFloat(Stack.GetParameter(1))));
00885 end;
00886
00887 { TZAtanFunction }
00888
00889 {**
00890 Creates this function object.
00891 }
00892 constructor TZAtanFunction.Create;
00893 begin
00894 FName := 'ATAN';
00895 end;
00896
00897 {**
00898 Executes this function.
00899 @param Stack the stack object.
00900 @param VariantManager a reference to variant processor object.
00901 @returns a function value.
00902 }
00903 function TZAtanFunction.Execute(Stack: TZExecutionStack;
00904 VariantManager: IZVariantManager): TZVariant;
00905 begin
00906 CheckParamsCount(Stack, 1);
00907 VariantManager.SetAsFloat(Result, ArcTan(
00908 VariantManager.GetAsFloat(Stack.GetParameter(1))));
00909 end;
00910
00911 { TZCeilFunction }
00912
00913 {**
00914 Creates this function object.
00915 }
00916 constructor TZCeilFunction.Create;
00917 begin
00918 FName := 'CEIL';
00919 end;
00920
00921 {**
00922 Executes this function.
00923 @param Stack the stack object.
00924 @param VariantManager a reference to variant processor object.
00925 @returns a function value.
00926 }
00927 function TZCeilFunction.Execute(Stack: TZExecutionStack;
00928 VariantManager: IZVariantManager): TZVariant;
00929 begin
00930 CheckParamsCount(Stack, 1);
00931 VariantManager.SetAsInteger(Result, Ceil(
00932 VariantManager.GetAsFloat(Stack.GetParameter(1))));
00933 end;
00934
00935 { TZFloorFunction }
00936
00937 {**
00938 Creates this function object.
00939 }
00940 constructor TZFloorFunction.Create;
00941 begin
00942 FName := 'FLOOR';
00943 end;
00944
00945 {**
00946 Executes this function.
00947 @param Stack the stack object.
00948 @param VariantManager a reference to variant processor object.
00949 @returns a function value.
00950 }
00951 function TZFloorFunction.Execute(Stack: TZExecutionStack;
00952 VariantManager: IZVariantManager): TZVariant;
00953 begin
00954 CheckParamsCount(Stack, 1);
00955 VariantManager.SetAsInteger(Result, Floor(
00956 VariantManager.GetAsFloat(Stack.GetParameter(1))));
00957 end;
00958
00959 { TZCosFunction }
00960
00961 {**
00962 Creates this function object.
00963 }
00964 constructor TZCosFunction.Create;
00965 begin
00966 FName := 'COS';
00967 end;
00968
00969 {**
00970 Executes this function.
00971 @param Stack the stack object.
00972 @param VariantManager a reference to variant processor object.
00973 @returns a function value.
00974 }
00975 function TZCosFunction.Execute(Stack: TZExecutionStack;
00976 VariantManager: IZVariantManager): TZVariant;
00977 begin
00978 CheckParamsCount(Stack, 1);
00979 VariantManager.SetAsFloat(Result, Cos(
00980 VariantManager.GetAsFloat(Stack.GetParameter(1))));
00981 end;
00982
00983 { TZSinFunction }
00984
00985 {**
00986 Creates this function object.
00987 }
00988 constructor TZSinFunction.Create;
00989 begin
00990 FName := 'SIN';
00991 end;
00992
00993 {**
00994 Executes this function.
00995 @param Stack the stack object.
00996 @param VariantManager a reference to variant processor object.
00997 @returns a function value.
00998 }
00999 function TZSinFunction.Execute(Stack: TZExecutionStack;
01000 VariantManager: IZVariantManager): TZVariant;
01001 begin
01002 CheckParamsCount(Stack, 1);
01003 VariantManager.SetAsFloat(Result, Sin(
01004 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01005 end;
01006
01007 { TZTanFunction }
01008
01009 {**
01010 Creates this function object.
01011 }
01012 constructor TZTanFunction.Create;
01013 begin
01014 FName := 'TAN';
01015 end;
01016
01017 {**
01018 Executes this function.
01019 @param Stack the stack object.
01020 @param VariantManager a reference to variant processor object.
01021 @returns a function value.
01022 }
01023 function TZTanFunction.Execute(Stack: TZExecutionStack;
01024 VariantManager: IZVariantManager): TZVariant;
01025 begin
01026 CheckParamsCount(Stack, 1);
01027 VariantManager.SetAsFloat(Result, Tan(
01028 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01029 end;
01030
01031 { TZExpFunction }
01032
01033 {**
01034 Creates this function object.
01035 }
01036 constructor TZExpFunction.Create;
01037 begin
01038 FName := 'EXP';
01039 end;
01040
01041 {**
01042 Executes this function.
01043 @param Stack the stack object.
01044 @param VariantManager a reference to variant processor object.
01045 @returns a function value.
01046 }
01047 function TZExpFunction.Execute(Stack: TZExecutionStack;
01048 VariantManager: IZVariantManager): TZVariant;
01049 begin
01050 CheckParamsCount(Stack, 1);
01051 VariantManager.SetAsFloat(Result, Exp(
01052 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01053 end;
01054
01055 { TZLogFunction }
01056
01057 {**
01058 Creates this function object.
01059 }
01060 constructor TZLogFunction.Create;
01061 begin
01062 FName := 'LOG';
01063 end;
01064
01065 {**
01066 Executes this function.
01067 @param Stack the stack object.
01068 @param VariantManager a reference to variant processor object.
01069 @returns a function value.
01070 }
01071 function TZLogFunction.Execute(Stack: TZExecutionStack;
01072 VariantManager: IZVariantManager): TZVariant;
01073 begin
01074 CheckParamsCount(Stack, 1);
01075 VariantManager.SetAsFloat(Result, Ln(
01076 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01077 end;
01078
01079 { TZLog10Function }
01080
01081 {**
01082 Creates this function object.
01083 }
01084 constructor TZLog10Function.Create;
01085 begin
01086 FName := 'LOG10';
01087 end;
01088
01089 {**
01090 Executes this function.
01091 @param Stack the stack object.
01092 @param VariantManager a reference to variant processor object.
01093 @returns a function value.
01094 }
01095 function TZLog10Function.Execute(Stack: TZExecutionStack;
01096 VariantManager: IZVariantManager): TZVariant;
01097 begin
01098 CheckParamsCount(Stack, 1);
01099 VariantManager.SetAsFloat(Result, Log10(
01100 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01101 end;
01102
01103 { TZRoundFunction }
01104
01105 {**
01106 Creates this function object.
01107 }
01108 constructor TZRoundFunction.Create;
01109 begin
01110 FName := 'ROUND';
01111 end;
01112
01113 {**
01114 Executes this function.
01115 @param Stack the stack object.
01116 @param VariantManager a reference to variant processor object.
01117 @returns a function value.
01118 }
01119 function TZRoundFunction.Execute(Stack: TZExecutionStack;
01120 VariantManager: IZVariantManager): TZVariant;
01121 begin
01122 CheckParamsCount(Stack, 1);
01123 VariantManager.SetAsInteger(Result, Round(
01124 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01125 end;
01126
01127 { TZSqrFunction }
01128
01129 {**
01130 Creates this function object.
01131 }
01132 constructor TZSqrFunction.Create;
01133 begin
01134 FName := 'SQR';
01135 end;
01136
01137 {**
01138 Executes this function.
01139 @param Stack the stack object.
01140 @param VariantManager a reference to variant processor object.
01141 @returns a function value.
01142 }
01143 function TZSqrFunction.Execute(Stack: TZExecutionStack;
01144 VariantManager: IZVariantManager): TZVariant;
01145 begin
01146 CheckParamsCount(Stack, 1);
01147 VariantManager.SetAsFloat(Result, Sqrt(
01148 VariantManager.GetAsFloat(Stack.GetParameter(1))));
01149 end;
01150
01151 { TZLowerFunction }
01152
01153 {**
01154 Creates this function object.
01155 }
01156 constructor TZLowerFunction.Create;
01157 begin
01158 FName := 'LOWER';
01159 end;
01160
01161 {**
01162 Executes this function.
01163 @param Stack the stack object.
01164 @param VariantManager a reference to variant processor object.
01165 @returns a function value.
01166 }
01167 function TZLowerFunction.Execute(Stack: TZExecutionStack;
01168 VariantManager: IZVariantManager): TZVariant;
01169 begin
01170 CheckParamsCount(Stack, 1);
01171 VariantManager.SetAsString(Result, AnsiLowerCase(
01172 VariantManager.GetAsString(Stack.GetParameter(1))));
01173 end;
01174
01175 { TZUpperFunction }
01176
01177 {**
01178 Creates this function object.
01179 }
01180 constructor TZUpperFunction.Create;
01181 begin
01182 FName := 'UPPER';
01183 end;
01184
01185 {**
01186 Executes this function.
01187 @param Stack the stack object.
01188 @param VariantManager a reference to variant processor object.
01189 @returns a function value.
01190 }
01191 function TZUpperFunction.Execute(Stack: TZExecutionStack;
01192 VariantManager: IZVariantManager): TZVariant;
01193 begin
01194 CheckParamsCount(Stack, 1);
01195 VariantManager.SetAsString(Result, AnsiUpperCase(
01196 VariantManager.GetAsString(Stack.GetParameter(1))));
01197 end;
01198
01199 { TZSubStrFunction }
01200
01201 {**
01202 Creates this function object.
01203 }
01204 constructor TZSubStrFunction.Create;
01205 begin
01206 FName := 'SUBSTR';
01207 end;
01208
01209 {**
01210 Executes this function.
01211 @param Stack the stack object.
01212 @param VariantManager a reference to variant processor object.
01213 @returns a function value.
01214 }
01215 function TZSubStrFunction.Execute(Stack: TZExecutionStack;
01216 VariantManager: IZVariantManager): TZVariant;
01217 begin
01218 CheckParamsCount(Stack, 3);
01219 VariantManager.SetAsString(Result, Copy(
01220 VariantManager.GetAsString(Stack.GetParameter(3)),
01221 VariantManager.GetAsInteger(Stack.GetParameter(2)),
01222 VariantManager.GetAsInteger(Stack.GetParameter(1))));
01223 end;
01224
01225 { TZStrPosFunction }
01226
01227 {**
01228 Creates this function object.
01229 }
01230 constructor TZStrPosFunction.Create;
01231 begin
01232 FName := 'STRPOS';
01233 end;
01234
01235 {**
01236 Executes this function.
01237 @param Stack the stack object.
01238 @param VariantManager a reference to variant processor object.
01239 @returns a function value.
01240 }
01241 function TZStrPosFunction.Execute(Stack: TZExecutionStack;
01242 VariantManager: IZVariantManager): TZVariant;
01243 begin
01244 CheckParamsCount(Stack, 2);
01245 VariantManager.SetAsInteger(Result, Pos(
01246 VariantManager.GetAsString(Stack.GetParameter(1)),
01247 VariantManager.GetAsString(Stack.GetParameter(2))));
01248 end;
01249
01250 { TZConcatFunction }
01251
01252 {**
01253 Creates this function object.
01254 }
01255 constructor TZConcatFunction.Create;
01256 begin
01257 FName := 'CONCAT';
01258 end;
01259
01260 {**
01261 Executes this function.
01262 @param Stack the stack object.
01263 @param VariantManager a reference to variant processor object.
01264 @returns a function value.
01265 }
01266 function TZConcatFunction.Execute(Stack: TZExecutionStack;
01267 VariantManager: IZVariantManager): TZVariant;
01268 var
01269 I, ParamsCount: Integer;
01270 Temp: string;
01271 begin
01272 ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
01273 if ParamsCount < 2 then
01274 raise TZExpressionError.Create(SExpectedMoreParams);
01275
01276 Temp := VariantManager.GetAsString(Stack.GetParameter(ParamsCount));
01277 for I := ParamsCount - 1 downto 1 do
01278 Temp := Temp + VariantManager.GetAsString(Stack.GetParameter(I));
01279 VariantManager.SetAsString(Result, Temp);
01280 end;
01281
01282 { TZTrimFunction }
01283
01284 constructor TZTrimFunction.Create;
01285 begin
01286 FName := 'TRIM';
01287 end;
01288
01289 function TZTrimFunction.Execute(Stack: TZExecutionStack;
01290 VariantManager: IZVariantManager): TZVariant;
01291 var
01292 Value: TZVariant;
01293 begin
01294 CheckParamsCount(Stack, 1);
01295 Value := Stack.GetParameter(1);
01296 VariantManager.SetAsString(Result, Trim(Value.VString));
01297 end;
01298
01299 { TZValFunction }
01300
01301 constructor TZValFunction.Create;
01302 begin
01303 FName := 'VAL';
01304 end;
01305
01306 function TZValFunction.Execute(Stack: TZExecutionStack;
01307 VariantManager: IZVariantManager): TZVariant;
01308 var
01309 Value: TZVariant;
01310 begin
01311 CheckParamsCount(Stack, 1);
01312 Value := Stack.GetParameter(1);
01313 VariantManager.SetAsInteger(Result, StrToInt64Def(Value.VString, 0));
01314 end;
01315
01316 { TZDtosFunction }
01317
01318 constructor TZDtosFunction.Create;
01319 begin
01320 FName := 'DTOS';
01321 end;
01322
01323 function TZDtosFunction.Execute(Stack: TZExecutionStack;
01324 VariantManager: IZVariantManager): TZVariant;
01325 var
01326 Value: TZVariant;
01327 begin
01328 CheckParamsCount(Stack, 1);
01329 Value := Stack.GetParameter(1);
01330 VariantManager.SetAsString(Result, FormatDateTime('yyyymmdd', Value.VDateTime));
01331 end;
01332
01333 {$IFNDEF VER130}
01334 { TZCtodFunction }
01335
01336 constructor TZCtodFunction.Create;
01337 begin
01338 FName := 'CTOD';
01339 end;
01340
01341 function TZCtodFunction.Execute(Stack: TZExecutionStack;
01342 VariantManager: IZVariantManager): TZVariant;
01343 var
01344 Value: TZVariant;
01345 begin
01346 CheckParamsCount(Stack, 1);
01347 Value := Stack.GetParameter(1);
01348 VariantManager.SetAsDateTime(Result, StrToDateDef(Value.VString, 0));
01349 end;
01350
01351 { TZLeftFunction }
01352
01353 constructor TZLeftFunction.Create;
01354 begin
01355 FName := 'LEFT';
01356 end;
01357
01358 function TZLeftFunction.Execute(Stack: TZExecutionStack;
01359 VariantManager: IZVariantManager): TZVariant;
01360 var
01361 Value1, Value2: TZVariant;
01362 begin
01363 CheckParamsCount(Stack, 2);
01364 Value1 := Stack.GetParameter(2);
01365 Value2 := Stack.GetParameter(1);
01366 VariantManager.SetAsString(Result, LeftStr(Value1.VString, Value2.VInteger));
01367 end;
01368
01369 { TZRightFunction }
01370
01371 constructor TZRightFunction.Create;
01372 begin
01373 FName := 'RIGHT';
01374 end;
01375
01376 function TZRightFunction.Execute(Stack: TZExecutionStack;
01377 VariantManager: IZVariantManager): TZVariant;
01378 var
01379 Value1, Value2: TZVariant;
01380 begin
01381 CheckParamsCount(Stack, 2);
01382 Value1 := Stack.GetParameter(2);
01383 Value2 := Stack.GetParameter(1);
01384 VariantManager.SetAsString(Result, RightStr(Value1.VString, Value2.VInteger));
01385 end;
01386 {$ENDIF}
01387 end.