unit IMPORT_SysUtils;
interface
uses
SysUtils,
PaxCompiler;
procedure Register_SysUtils;
implementation
function _Format(const S: string; const Args: array of const): string;
begin
result := Format(S, Args);
end;
// Exception -------------------------------------------------------------------
function Exception_GetMessage(Self: Exception): String;
begin
result := Self.Message;
end;
procedure Exception_SetMessage(Self: Exception; const Value: String);
begin
Self.Message := Value;
end;
function Exception_GetHelpContext(Self: Exception): Integer;
begin
result := Self.HelpContext;
end;
procedure Exception_SetHelpContext(Self: Exception; Value: Integer);
begin
Self.HelpContext := Value;
end;
procedure Register_SysUtils;
var
H, G: Integer;
begin
RegisterTypeAlias(0, 'TDateTime', _typeDOUBLE);
H := RegisterNamespace(0, 'SysUtils');
RegisterRTTIType(H, TypeInfo(TReplaceFlags));
G := RegisterRecordType(H, 'TTimeStamp');
RegisterRecordTypeField(G, 'Time', _typeINTEGER);
RegisterRecordTypeField(G, 'Date', _typeINTEGER);
G := RegisterRecordType(H, 'TSystemTime');
RegisterRecordTypeField(G, 'wYear', _typeWORD);
RegisterRecordTypeField(G, 'wMonth', _typeWORD);
RegisterRecordTypeField(G, 'wDayOfWeek', _typeWORD);
RegisterRecordTypeField(G, 'wDay', _typeWORD);
RegisterRecordTypeField(G, 'wHour', _typeWORD);
RegisterRecordTypeField(G, 'wMinute', _typeWORD);
RegisterRecordTypeField(G, 'wSecond', _typeWORD);
RegisterRecordTypeField(G, 'wMilliSecond', _typeWORD);
{ File open modes }
RegisterConstant(H, 'fmOpenRead', fmOpenRead);
RegisterConstant(H, 'fmOpenWrite', fmOpenWrite);
RegisterConstant(H, 'fmOpenReadWrite', fmOpenReadWrite);
RegisterConstant(H, 'fmShareCompat', fmShareCompat);
RegisterConstant(H, 'fmShareExclusive', fmShareExclusive);
RegisterConstant(H, 'fmShareDenyWrite', fmShareDenyWrite);
RegisterConstant(H, 'fmShareDenyRead', fmShareDenyRead);
RegisterConstant(H, 'fmShareDenyNone', fmShareDenyNone);
{ File attribute constants }
RegisterConstant(H, 'faReadOnly', faReadOnly);
RegisterConstant(H, 'faHidden', faHidden);
RegisterConstant(H, 'faSysFile', faSysFile);
RegisterConstant(H, 'faVolumeID', faVolumeID);
RegisterConstant(H, 'faDirectory', faDirectory);
RegisterConstant(H, 'faArchive', faArchive);
RegisterConstant(H, 'faAnyFile', faAnyFile);
{ File mode magic numbers }
RegisterConstant(H, 'fmClosed', fmClosed);
RegisterConstant(H, 'fmInput', fmInput);
RegisterConstant(H, 'fmOutput', fmOutput);
RegisterConstant(H, 'fmInOut', fmInOut);
{ Seconds and milliseconds per day }
RegisterConstant(H, 'SecsPerDay', SecsPerDay);
RegisterConstant(H, 'MSecsPerDay', MSecsPerDay);
{ Days between 1/1/0001 and 12/31/1899 }
RegisterConstant(H, 'DateDelta', DateDelta);
RegisterTypeAlias(0, 'cardinal', _typeINTEGER);
RegisterTypeAlias(0, 'LongWord', _typeINTEGER);
RegisterHeader(H, 'function UpperCase(const S: string): string;', @UpperCase);
RegisterHeader(H, 'function LowerCase(const S: string): string;', @LowerCase);
RegisterHeader(H, 'function CompareStr(const S1, S2: string): Integer;', @CompareStr);
RegisterHeader(H, 'function CompareMem(P1, P2: Pointer; Length: Integer): Boolean;', @CompareMem);
RegisterHeader(H, 'function CompareText(const S1, S2: string): Integer;', @CompareText);
RegisterHeader(H, 'function SameText(const S1, S2: string): Boolean;', @SameText);
RegisterHeader(H, 'function AnsiUpperCase(const S: string): string;', @AnsiUpperCase);
RegisterHeader(H, 'function AnsiLowerCase(const S: string): string;', @AnsiLowerCase);
RegisterHeader(H, 'function AnsiCompareStr(const S1, S2: string): Integer;', @AnsiCompareStr);
RegisterHeader(H, 'function AnsiSameStr(const S1, S2: string): Boolean;', @AnsiSameStr);
RegisterHeader(H, 'function AnsiCompareText(const S1, S2: string): Integer;', @AnsiCompareText);
RegisterHeader(H, 'function AnsiSameText(const S1, S2: string): Boolean;', @AnsiSameText);
RegisterHeader(H, 'function AnsiStrComp(S1, S2: PChar): Integer;', @AnsiStrComp);
RegisterHeader(H, 'function AnsiStrIComp(S1, S2: PChar): Integer;', @AnsiStrIComp);
RegisterHeader(H, 'function AnsiStrLComp(S1, S2: PChar; MaxLen: Cardinal): Integer;', @AnsiStrLComp);
RegisterHeader(H, 'function AnsiStrLIComp(S1, S2: PChar; MaxLen: Cardinal): Integer;', @AnsiStrLIComp);
RegisterHeader(H, 'function AnsiStrLower(Str: PChar): PChar;', @AnsiStrLower);
RegisterHeader(H, 'function AnsiStrUpper(Str: PChar): PChar;', @AnsiStrUpper);
RegisterHeader(H, 'function AnsiLastChar(const S: string): PChar;', @AnsiLastChar);
RegisterHeader(H, 'function AnsiStrLastChar(P: PChar): PChar;', @AnsiStrLastChar);
RegisterHeader(H, 'function Trim(const S: string): string;', @Trim);
RegisterHeader(H, 'function TrimLeft(const S: string): string;', @TrimLeft);
RegisterHeader(H, 'function TrimRight(const S: string): string;', @TrimRight);
RegisterHeader(H, 'function QuotedStr(const S: string): string;', @QuotedStr);
RegisterHeader(H, 'function AnsiQuotedStr(const S: string; Quote: Char): string;', @AnsiQuotedStr);
RegisterHeader(H, 'function AnsiExtractQuotedStr(var Src: PChar; Quote: Char): string;', @AnsiExtractQuotedStr);
RegisterHeader(H, 'function AdjustLineBreaks(const S: string): string;', @AdjustLineBreaks);
RegisterHeader(H, 'function IsValidIdent(const Ident: string): Boolean;', @IsValidIdent);
RegisterHeader(H, 'function IntToStr(Value: Integer): string;', @IntToStr);
RegisterHeader(H, 'function IntToHex(Value: Integer; Digits: Integer): string;', @IntToHex);
RegisterHeader(H, 'function StrToInt(const S: string): Integer;', @StrToInt);
RegisterHeader(H, 'function StrToIntDef(const S: string; Default: Integer): Integer;', @StrToIntDef);
RegisterHeader(H, 'function LoadStr(Ident: Integer): string;', @LoadStr);
RegisterHeader(H, 'function FileOpen(const FileName: string; Mode: LongWord): Integer;', @FileOpen);
RegisterHeader(H, 'function FileCreate(const FileName: string): Integer;', @FileCreate);
RegisterHeader(H, 'function FileRead(Handle: Integer; var Buffer; Count: LongWord): Integer;', @FileRead);
RegisterHeader(H, 'function FileWrite(Handle: Integer; const Buffer; Count: LongWord): Integer;', @FileWrite);
RegisterHeader(H, 'function FileSeek(Handle, Offset, Origin: Integer): Integer;', @FileSeek);
RegisterHeader(H, 'procedure FileClose(Handle: Integer);', @FileClose);
RegisterHeader(H, 'function FileAge(const FileName: string): Integer;', @FileAge);
RegisterHeader(H, 'function FileExists(const FileName: string): Boolean;', @FileExists);
RegisterHeader(H, 'function FileGetDate(Handle: Integer): Integer;', @FileGetDate);
RegisterHeader(H, 'function FileSetDate(Handle: Integer; Age: Integer): Integer;', @FileSetDate);
RegisterHeader(H, 'function FileGetAttr(const FileName: string): Integer;', @FileGetAttr);
RegisterHeader(H, 'function FileSetAttr(const FileName: string; Attr: Integer): Integer;', @FileSetAttr);
RegisterHeader(H, 'function DeleteFile(const FileName: string): Boolean;', @DeleteFile);
RegisterHeader(H, 'function RenameFile(const OldName, NewName: string): Boolean;', @RenameFile);
RegisterHeader(H, 'function ChangeFileExt(const FileName, Extension: string): string;', @ChangeFileExt);
RegisterHeader(H, 'function ExtractFilePath(const FileName: string): string;', @ExtractFilePath);
RegisterHeader(H, 'function ExtractFileDir(const FileName: string): string;', @ExtractFileDir);
RegisterHeader(H, 'function ExtractFileDrive(const FileName: string): string;', @ExtractFileDrive);
RegisterHeader(H, 'function ExtractFileName(const FileName: string): string;', @ExtractFileName);
RegisterHeader(H, 'function ExtractFileExt(const FileName: string): string;', @ExtractFileExt);
RegisterHeader(H, 'function ExpandFileName(const FileName: string): string;', @ExpandFileName);
RegisterHeader(H, 'function ExpandUNCFileName(const FileName: string): string;', @ExpandUNCFileName);
RegisterHeader(H, 'function ExtractRelativePath(const BaseName, DestName: string): string;', @ExtractRelativePath);
RegisterHeader(H, 'function ExtractShortPathName(const FileName: string): string;', @ExtractShortPathName);
RegisterHeader(H, 'function FileSearch(const Name, DirList: string): string;', @FileSearch);
RegisterHeader(H, 'function GetCurrentDir: string;', @GetCurrentDir);
RegisterHeader(H, 'function SetCurrentDir(const Dir: string): Boolean;', @SetCurrentDir);
RegisterHeader(H, 'function CreateDir(const Dir: string): Boolean;', @CreateDir);
RegisterHeader(H, 'function RemoveDir(const Dir: string): Boolean;', @RemoveDir);
RegisterHeader(H, 'function StrLen(const Str: PChar): Cardinal;', @StrLen);
RegisterHeader(H, 'function StrEnd(const Str: PChar): PChar;', @StrEnd);
RegisterHeader(H, 'function StrMove(Dest: PChar; const Source: PChar; Count: Cardinal): PChar;', @StrMove);
RegisterHeader(H, 'function StrCopy(Dest: PChar; const Source: PChar): PChar;', @StrCopy);
RegisterHeader(H, 'function StrECopy(Dest:PChar; const Source: PChar): PChar;', @StrECopy);
RegisterHeader(H, 'function StrLCopy(Dest: PChar; const Source: PChar; MaxLen: Cardinal): PChar;', @StrLCopy);
RegisterHeader(H, 'function StrPCopy(Dest: PChar; const Source: string): PChar;', @StrPCopy);
RegisterHeader(H, 'function StrPLCopy(Dest: PChar; const Source: string; MaxLen: Cardinal): PChar;', @StrPLCopy);
RegisterHeader(H, 'function StrCat(Dest: PChar; const Source: PChar): PChar;', @StrCat);
RegisterHeader(H, 'function StrLCat(Dest: PChar; const Source: PChar; MaxLen: Cardinal): PChar;', @StrLCat);
RegisterHeader(H, 'function StrComp(const Str1, Str2: PChar): Integer;', @StrComp);
RegisterHeader(H, 'function StrIComp(const Str1, Str2: PChar): Integer;', @StrIComp);
RegisterHeader(H, 'function StrLComp(const Str1, Str2: PChar; MaxLen: Cardinal): Integer;', @StrLComp);
RegisterHeader(H, 'function StrLIComp(const Str1, Str2: PChar; MaxLen: Cardinal): Integer;', @StrLIComp);
RegisterHeader(H, 'function StrScan(const Str: PChar; Chr: Char): PChar;', @StrScan);
RegisterHeader(H, 'function StrRScan(const Str: PChar; Chr: Char): PChar;', @StrRScan);
RegisterHeader(H, 'function StrPos(const Str1, Str2: PChar): PChar;', @StrPos);
RegisterHeader(H, 'function StrUpper(Str: PChar): PChar;', @StrUpper);
RegisterHeader(H, 'function StrLower(Str: PChar): PChar;', @StrLower);
RegisterHeader(H, 'function StrPas(const Str: PChar): string;', @StrPas);
RegisterHeader(H, 'function StrAlloc(Size: Cardinal): PChar;', @StrAlloc);
RegisterHeader(H, 'function StrBufSize(const Str: PChar): Cardinal;', @StrBufSize);
RegisterHeader(H, 'function StrNew(const Str: PChar): PChar;', @StrNew);
RegisterHeader(H, 'procedure StrDispose(Str: PChar);', @StrDispose);
RegisterHeader(H, 'function FloatToStr(Value: Extended): string;', @FloatToStr);
RegisterHeader(H, 'function FormatFloat(const Format: string; Value: Extended): string;', @FormatFloat);
RegisterHeader(H, 'function StrToFloat(const S: string): Extended;', @StrToFloat);
RegisterHeader(H, 'function DateTimeToTimeStamp(DateTime: TDateTime): TTimeStamp;', @DateTimeToTimeStamp);
RegisterHeader(H, 'function TimeStampToDateTime(const TimeStamp: TTimeStamp): TDateTime;', @TimeStampToDateTime);
RegisterHeader(H, 'function EncodeDate(Year, Month, Day: Word): TDateTime;', @EncodeDate);
RegisterHeader(H, 'function EncodeTime(Hour, Min, Sec, MSec: Word): TDateTime;', @EncodeTime);
RegisterHeader(H, 'procedure DecodeDate(Date: TDateTime; var Year, Month, Day: Word);', @DecodeDate);
RegisterHeader(H, 'procedure DecodeTime(Time: TDateTime; var Hour, Min, Sec, MSec: Word);', @DecodeTime);
RegisterHeader(H, 'procedure DateTimeToSystemTime(DateTime: TDateTime; var SystemTime: TSystemTime);', @DateTimeToSystemTime);
RegisterHeader(H, 'function SystemTimeToDateTime(const SystemTime: TSystemTime): TDateTime;', @SystemTimeToDateTime);
RegisterHeader(H, 'function DayOfWeek(Date: TDateTime): Integer;', @DayOfWeek);
RegisterHeader(H, 'function Date: TDateTime;', @Date);
RegisterHeader(H, 'function Time: TDateTime;', @Time);
RegisterHeader(H, 'function Now: TDateTime;', @Now);
RegisterHeader(H, 'function IncMonth(const Date: TDateTime; NumberOfMonths: Integer): TDateTime;', @IncMonth);
RegisterHeader(H, 'procedure ReplaceTime(var DateTime: TDateTime; const NewTime: TDateTime);', @ReplaceTime);
RegisterHeader(H, 'procedure ReplaceDate(var DateTime: TDateTime; const NewDate: TDateTime);', @ReplaceDate);
RegisterHeader(H, 'function IsLeapYear(Year: Word): Boolean;', @IsLeapYear);
RegisterHeader(H, 'function DateToStr(Date: TDateTime): string;', @DateToStr);
RegisterHeader(H, 'function TimeToStr(Time: TDateTime): string;', @TimeToStr);
RegisterHeader(H, 'function DateTimeToStr(DateTime: TDateTime): string;', @DateTimeToStr);
RegisterHeader(H, 'function StrToDate(const S: string): TDateTime;', @StrToDate);
RegisterHeader(H, 'function StrToTime(const S: string): TDateTime;', @StrToTime);
RegisterHeader(H, 'function StrToDateTime(const S: string): TDateTime;', @StrToDateTime);
RegisterHeader(H, 'function FormatDateTime(const Format: string; DateTime: TDateTime): string;', @FormatDateTime);
RegisterHeader(H, 'procedure GetFormatSettings;', @GetFormatSettings);
RegisterHeader(H, 'function StringReplace(const S, OldPattern, NewPattern: string; Flags: TReplaceFlags): string;', @StringReplace);
RegisterHeader(H, 'procedure FreeAndNil(var Obj);', @FreeAndNil);
RegisterHeader(H, 'function Format(const S: string; const Args: array of const): string;',
@_Format);
// Exception -------------------------------------------------------------------
G := RegisterClassType(H, Exception);
RegisterClassReferenceType(H, 'ExceptClass', G);
RegisterHeader(G, 'constructor Create(const Msg: string);', @Exception.Create);
RegisterHeader(G, 'function _GetMessage: String;', @Exception_GetMessage);
RegisterHeader(G, 'procedure _SetMessage(const Value: String);', @Exception_SetMessage);
RegisterProperty(G, 'property Message: string read _GetMessage write _SetMessage;');
RegisterHeader(G, 'function _GetHelpContext: Integer;', @Exception_GetHelpContext);
RegisterHeader(G, 'procedure _SetHelpContext(Value: Integer);', @Exception_SetHelpContext);
RegisterProperty(G, 'property HelpContext: Integer read _GetHelpContext write _SetHelpContext;');
// EAbort ----------------------------------------------------------------------
G := RegisterClassType(H, EAbort);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EAbort.Create);
// EOutOfMemory ----------------------------------------------------------------
G := RegisterClassType(H, EOutOfMemory);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EOutOfMemory.Create);
// EInOutError -----------------------------------------------------------------
G := RegisterClassType(H, EInOutError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EInOutError.Create);
RegisterClassTypeField(G, 'ErrorCode', _typeINTEGER, Integer(@EInOutError(nil).ErrorCode));
// EExternal -------------------------------------------------------------------
G := RegisterClassType(H, EExternal);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EExternal.Create);
// EExternalException ----------------------------------------------------------
G := RegisterClassType(H, EExternalException);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EExternalException.Create);
// EIntError -------------------------------------------------------------------
G := RegisterClassType(H, EIntError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EIntError.Create);
// EDivByZero ------------------------------------------------------------------
G := RegisterClassType(H, EDivByZero);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EDivByZero.Create);
// ERangeError -----------------------------------------------------------------
G := RegisterClassType(H, ERangeError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @ERangeError.Create);
// EIntOverflow ----------------------------------------------------------------
G := RegisterClassType(H, EIntOverflow);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EIntOverflow.Create);
// EMathError ------------------------------------------------------------------
G := RegisterClassType(H, EMathError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EMathError.Create);
// EInvalidOp ------------------------------------------------------------------
G := RegisterClassType(H, EInvalidOp);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EInvalidOp.Create);
// EZeroDivide -----------------------------------------------------------------
G := RegisterClassType(H, EZeroDivide);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EZeroDivide.Create);
// EOverflow -------------------------------------------------------------------
G := RegisterClassType(H, EOverflow);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EOverflow.Create);
// EUnderflow ------------------------------------------------------------------
G := RegisterClassType(H, EUnderflow);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EUnderflow.Create);
// EInvalidPointer -------------------------------------------------------------
G := RegisterClassType(H, EInvalidPointer);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EInvalidPointer.Create);
// EInvalidCast ----------------------------------------------------------------
G := RegisterClassType(H, EInvalidCast);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EInvalidCast.Create);
// EConvertError ---------------------------------------------------------------
G := RegisterClassType(H, EConvertError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EConvertError.Create);
// EAccessViolation ---------------------------------------------------------------
G := RegisterClassType(H, EAccessViolation);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EAccessViolation.Create);
// EPrivilege ------------------------------------------------------------------
G := RegisterClassType(H, EPrivilege);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EPrivilege.Create);
// EStackOverflow ------------------------------------------------------------------
G := RegisterClassType(H, EStackOverflow);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EStackOverflow.Create);
// EControlC -------------------------------------------------------------------
G := RegisterClassType(H, EControlC);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EControlC.Create);
// EVariantError ---------------------------------------------------------------
G := RegisterClassType(H, EVariantError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EVariantError.Create);
// EPropReadOnly ---------------------------------------------------------------
G := RegisterClassType(H, EPropReadOnly);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EPropReadOnly.Create);
// EPropWriteOnly --------------------------------------------------------------
G := RegisterClassType(H, EPropWriteOnly);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EPropWriteOnly.Create);
// EAssertionFailed ------------------------------------------------------------
G := RegisterClassType(H, EAssertionFailed);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EAssertionFailed.Create);
// EAbstractError --------------------------------------------------------------
G := RegisterClassType(H, EAbstractError);
RegisterHeader(G, 'constructor Create(const Msg: string);', @EAbstractError.Create);
end;
initialization
Register_SysUtils;
end.