rm_jvinterpreter_sysutils.pas

这是一个功能强大

end;

{ function Time: TDateTime; }

procedure JvInterpreter_Time(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Time;
end;

{ function Now: TDateTime; }

procedure JvInterpreter_Now(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Now;
end;

{ function IncMonth(const Date: TDateTime; NumberOfMonths: Integer): TDateTime; }

procedure JvInterpreter_IncMonth(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := IncMonth(Args.Values[0], Args.Values[1]);
end;

{ function IsLeapYear(Year: Word): Boolean; }

procedure JvInterpreter_IsLeapYear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := IsLeapYear(Args.Values[0]);
end;

{ function DateToStr(Date: TDateTime): string; }

procedure JvInterpreter_DateToStr(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := DateToStr(Args.Values[0]);
end;

{ function TimeToStr(Time: TDateTime): string; }

procedure JvInterpreter_TimeToStr(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TimeToStr(Args.Values[0]);
end;

{ function DateTimeToStr(DateTime: TDateTime): string; }

procedure JvInterpreter_DateTimeToStr(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := DateTimeToStr(Args.Values[0]);
end;

{ function StrToDate(const S: string): TDateTime; }

procedure JvInterpreter_StrToDate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := StrToDate(Args.Values[0]);
end;

{ function StrToTime(const S: string): TDateTime; }

procedure JvInterpreter_StrToTime(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := StrToTime(Args.Values[0]);
end;

{ function StrToDateTime(const S: string): TDateTime; }

procedure JvInterpreter_StrToDateTime(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := StrToDateTime(Args.Values[0]);
end;

{ function FormatDateTime(const Format: string; DateTime: TDateTime): string; }

procedure JvInterpreter_FormatDateTime(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := FormatDateTime(Args.Values[0], Args.Values[1]);
end;

{ procedure DateTimeToString(var Result: string; const Format: string; DateTime: TDateTime); }

procedure JvInterpreter_DateTimeToString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  DateTimeToString(string(TVarData(Args.Values[0]).vString), Args.Values[1], Args.Values[2]);
end;

{ function SysErrorMessage(ErrorCode: Integer): string; }

procedure JvInterpreter_SysErrorMessage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := SysErrorMessage(Args.Values[0]);
end;

{ function GetLocaleStr(Locale, LocaleType: Integer; const Default: string): string; }

procedure JvInterpreter_GetLocaleStr(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := GetLocaleStr(Args.Values[0], Args.Values[1], Args.Values[2]);
end;

{ function GetLocaleChar(Locale, LocaleType: Integer; Default: Char): Char; }

procedure JvInterpreter_GetLocaleChar(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := GetLocaleChar(Args.Values[0], Args.Values[1], string(Args.Values[2])[1]);
end;

{ procedure GetFormatSettings; }

procedure JvInterpreter_GetFormatSettings(var Value: Variant; Args: TJvInterpreterArgs);
begin
  GetFormatSettings;
end;

{ function ExceptObject: TObject; }

procedure JvInterpreter_ExceptObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(ExceptObject);
end;

{ function ExceptAddr: Pointer; }

procedure JvInterpreter_ExceptAddr(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(ExceptAddr);
end;

{ function ExceptionErrorMessage(ExceptObject: TObject; ExceptAddr: Pointer; Buffer: PChar; Size: Integer): Integer; }


procedure JvInterpreter_ExceptionErrorMessage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := ExceptionErrorMessage(V2O(Args.Values[0]), V2P(Args.Values[1]), PChar(string(Args.Values[2])),
    Args.Values[3]);
end;

{ procedure ShowException(ExceptObject: TObject; ExceptAddr: Pointer); }

procedure JvInterpreter_ShowException(var Value: Variant; Args: TJvInterpreterArgs);
begin
  ShowException(V2O(Args.Values[0]), V2P(Args.Values[1]));
end;

{ procedure Abort; }

procedure JvInterpreter_Abort(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Abort;
end;

{ procedure OutOfMemoryError; }

procedure JvInterpreter_OutOfMemoryError(var Value: Variant; Args: TJvInterpreterArgs);
begin
  OutOfMemoryError;
end;

{ procedure Beep; }

procedure JvInterpreter_Beep(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Beep;
end;

{ function ByteType(const S: string; Index: Integer): TMbcsByteType; }

procedure JvInterpreter_ByteType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := ByteType(Args.Values[0], Args.Values[1]);
end;

{ function StrByteType(Str: PChar; Index: Cardinal): TMbcsByteType; }

procedure JvInterpreter_StrByteType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := StrByteType(PChar(string(Args.Values[0])), Args.Values[1]);
end;

{ function ByteToCharLen(const S: string; MaxLen: Integer): Integer; }

procedure JvInterpreter_ByteToCharLen(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := ByteToCharLen(Args.Values[0], Args.Values[1]);
end;

{ function CharToByteLen(const S: string; MaxLen: Integer): Integer; }

procedure JvInterpreter_CharToByteLen(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := CharToByteLen(Args.Values[0], Args.Values[1]);
end;

{ function ByteToCharIndex(const S: string; Index: Integer): Integer; }

procedure JvInterpreter_ByteToCharIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := ByteToCharIndex(Args.Values[0], Args.Values[1]);
end;

{ function CharToByteIndex(const S: string; Index: Integer): Integer; }

procedure JvInterpreter_CharToByteIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := CharToByteIndex(Args.Values[0], Args.Values[1]);
end;

{ function IsPathDelimiter(const S: string; Index: Integer): Boolean; }

procedure JvInterpreter_IsPathDelimiter(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := IsPathDelimiter(Args.Values[0], Args.Values[1]);
end;

{ function IsDelimiter(const Delimiters, S: string; Index: Integer): Boolean; }

procedure JvInterpreter_IsDelimiter(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := IsDelimiter(Args.Values[0], Args.Values[1], Args.Values[2]);
end;

{ function LastDelimiter(const Delimiters, S: string): Integer; }

procedure JvInterpreter_LastDelimiter(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := LastDelimiter(Args.Values[0], Args.Values[1]);
end;

{ function AnsiCompareFileName(const S1, S2: string): Integer; }

procedure JvInterpreter_AnsiCompareFileName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := AnsiCompareFileName(Args.Values[0], Args.Values[1]);
end;

{ function AnsiLowerCaseFileName(const S: string): string; }

procedure JvInterpreter_AnsiLowerCaseFileName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := AnsiLowerCaseFileName(Args.Values[0]);
end;

{ function AnsiUpperCaseFileName(const S: string): string; }

procedure JvInterpreter_AnsiUpperCaseFileName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := AnsiUpperCaseFileName(Args.Values[0]);
end;

{ function AnsiPos(const Substr, S: string): Integer; }

procedure JvInterpreter_AnsiPos(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := AnsiPos(Args.Values[0], Args.Values[1]);
end;

{ function AnsiStrPos(Str, SubStr: PChar): PChar; }

procedure JvInterpreter_AnsiStrPos(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := string(AnsiStrPos(PChar(string(Args.Values[0])), PChar(string(Args.Values[1]))));
end;

{ function AnsiStrRScan(Str: PChar; Chr: Char): PChar; }

procedure JvInterpreter_AnsiStrRScan(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := string(AnsiStrRScan(PChar(string(Args.Values[0])), string(Args.Values[1])[1]));
end;

{ function AnsiStrScan(Str: PChar; Chr: Char): PChar; }

procedure JvInterpreter_AnsiStrScan(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := string(AnsiStrScan(PChar(string(Args.Values[0])), string(Args.Values[1])[1]));
end;

{ function LoadPackage(const Name: string): HMODULE; }

procedure JvInterpreter_LoadPackage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(LoadPackage(Args.Values[0]));
end;

{ procedure UnloadPackage(Module: HMODULE); }

procedure JvInterpreter_UnloadPackage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  UnloadPackage(Args.Values[0]);
end;

{$IFDEF MSWINDOWS}

{ procedure RaiseLastWin32Error; }

procedure JvInterpreter_RaiseLastWin32Error(var Value: Variant; Args: TJvInterpreterArgs);
begin
  {$IFDEF COMPILER6_UP}
  RaiseLastOSError;
  {$ELSE}
  RaiseLastWin32Error;
  {$ENDIF COMPILER6_UP}
end;

{ function Win32Check(RetVal: BOOL): BOOL; }

procedure JvInterpreter_Win32Check(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Win32Check(Args.Values[0]);
end;

{$ENDIF MSWINDOWS}

{ regional options }

(*
{ read CurrencyString: string }
procedure JvInterpreter_Read_CurrencyString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := CurrencyString;
end;

{ write CurrencyString: string }
procedure JvInterpreter_Write_CurrencyString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  CurrencyString := Value;
end;

{ read CurrencyFormat: Byte }
procedure JvInterpreter_Read_CurrencyFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := CurrencyFormat;
end;

{ write CurrencyFormat: Byte }
procedure JvInterpreter_Write_CurrencyFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  CurrencyFormat := Value;
end;

{ read NegCurrFormat: Byte }
procedure JvInterpreter_Read_NegCurrFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := NegCurrFormat;
end;

{ write NegCurrFormat: Byte }
procedure JvInterpreter_Write_NegCurrFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  NegCurrFormat := Value;
end;

{ read ThousandSeparator }
procedure JvInterpreter_Read_ThousandSeparator(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := ThousandSeparator;
end;

{ write ThousandSeparator }
procedure JvInterpreter_Write_ThousandSeparator(var Value: Variant; Args: TJvInterpreterArgs);
begin
  ThousandSeparator := string(Value)[1];
end;

{ read DecimalSeparator }
procedure JvInterpreter_Read_DecimalSeparator(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := DecimalSeparator;
end;

{ write DecimalSeparator }
procedure JvInterpreter_Write_DecimalSeparator(var Value: Variant; Args: TJvInterpreterArgs);
begin
  DecimalSeparator := string(Value)[1];
end;

{ read CurrencyDecimals }
procedure JvInterpreter_Read_CurrencyDecimals(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := CurrencyDecimals;
end;

{ write CurrencyDecimals }
procedure JvInterpreter_Write_CurrencyDecimals(var Value: Variant; Args: TJvInterpreterArgs);
begin
  CurrencyDecimals := Value;
end;

{ read DateSeparator }
procedure JvInterpreter_Read_DateSeparator(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := DateSeparator;
end;