1097 lines
28 KiB
ObjectPascal
1097 lines
28 KiB
ObjectPascal
unit libc;
|
|
|
|
interface
|
|
{$IFDEF MSWINDOWS}
|
|
{$ALIGN ON}
|
|
{$MINENUMSIZE 4}
|
|
{$WEAKPACKAGEUNIT}
|
|
|
|
uses Winapi.Windows;
|
|
|
|
const
|
|
msvcrt = 'msvcrt.dll';
|
|
{$EXTERNALSYM msvcrt}
|
|
|
|
type
|
|
{$IFDEF NEXTGEN}
|
|
PAnsiChar = MarshaledAString;
|
|
PPAnsiChar = ^PAnsiChar;
|
|
{$ENDIF}
|
|
|
|
va_list = Pointer;
|
|
{$EXTERNALSYM va_list}
|
|
|
|
qsort_compare_func = function(P1, P2: Pointer): Integer; cdecl;
|
|
{$EXTERNALSYM qsort_compare_func}
|
|
|
|
time_t = {$IFDEF Win32} Integer {$ENDIF}
|
|
{$IFDEF Win64} Int64 {$ENDIF};
|
|
{$EXTERNALSYM time_t}
|
|
Ptime_t = ^time_t;
|
|
{$EXTERNALSYM Ptime_t}
|
|
_time64_t = Int64;
|
|
{$EXTERNALSYM _time64_t}
|
|
P_time64_t = ^_time64_t;
|
|
{$EXTERNALSYM P_time64_t}
|
|
tm = packed record
|
|
tm_sec: Integer; { Seconds. [0-60] (1 leap second) }
|
|
tm_min: Integer; { Minutes. [0-59] }
|
|
tm_hour: Integer; { Hours. [0-23] }
|
|
tm_mday: Integer; { Day. [1-31] }
|
|
tm_mon: Integer; { Month. [0-11] }
|
|
tm_year: Integer; { Year - 1900. }
|
|
tm_wday: Integer; { Day of week. [0-6] }
|
|
tm_yday: Integer; { Days in year. [0-365] }
|
|
tm_isdst: Integer; { DST. [-1/0/1]}
|
|
end;
|
|
{$EXTERNALSYM tm}
|
|
Ptm = ^tm;
|
|
{$EXTERNALSYM Ptm}
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Memory }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function malloc(size: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM malloc}
|
|
|
|
function realloc(P: Pointer; NewSize: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM realloc}
|
|
|
|
procedure free(pBlock: Pointer); cdecl;
|
|
{$EXTERNALSYM free}
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ CString }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function memchr(s: Pointer; c: Integer; n: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM memchr}
|
|
|
|
function memcmp(buf1: Pointer; buf2: Pointer; n: size_t): Integer; cdecl;
|
|
{$EXTERNALSYM memcmp}
|
|
|
|
function memcpy(dest, src: Pointer; count: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM memcpy}
|
|
|
|
function memmove(dest, src: Pointer; count: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM memmove}
|
|
|
|
function memset(dest: Pointer; val: Integer; count: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM memset}
|
|
|
|
function strcat(dest: PAnsiChar; src: PAnsiChar): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strcat}
|
|
|
|
function strcpy(dest, src: PAnsiChar): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strcpy}
|
|
|
|
function strncpy(dest, src: PAnsiChar; n: size_t): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strncpy}
|
|
|
|
function strcmp(s1: PAnsiChar; s2: PAnsiChar): Integer; cdecl;
|
|
{$EXTERNALSYM strcmp}
|
|
|
|
function strncmp(s1: PAnsiChar; s2: PAnsiChar; n: size_t): Integer; cdecl;
|
|
{$EXTERNALSYM strncmp}
|
|
|
|
function strlen(s: PAnsiChar): size_t; cdecl;
|
|
{$EXTERNALSYM strlen}
|
|
|
|
function strnlen(s: PAnsiChar; n: size_t): size_t; cdecl;
|
|
{$EXTERNALSYM strnlen}
|
|
|
|
function strchr(__s: PAnsiChar; __c: Integer): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strchr}
|
|
|
|
function strrchr(__s: PAnsiChar; __c: Integer): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strrchr}
|
|
|
|
function strerror(__errnum: Integer): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strerror}
|
|
|
|
function strcspn(const str1, str2: PAnsiChar): size_t; cdecl;
|
|
{$EXTERNALSYM strcspn}
|
|
|
|
function stricmp(const str1, str2: PAnsiChar): Integer; cdecl;
|
|
{$EXTERNALSYM stricmp}
|
|
|
|
function _stricmp(const str1, str2: PAnsiChar): Integer; cdecl;
|
|
{$EXTERNALSYM _stricmp}
|
|
|
|
function _mbscspn(const str, strCharSet: PWideChar): size_t; cdecl;
|
|
{$EXTERNALSYM _mbscspn}
|
|
|
|
function mbstowcs(pwcs: PWideChar; const s: PWideChar;n: size_t): size_t; cdecl;
|
|
{$EXTERNALSYM mbstowcs}
|
|
|
|
function wcslen(str: PWideChar): size_t; cdecl;
|
|
{$EXTERNALSYM wcslen}
|
|
|
|
function wcsnlen(str: PWideChar; n: size_t): size_t; cdecl;
|
|
{$EXTERNALSYM wcsnlen}
|
|
|
|
function wcstombs(s:Pointer; const pwcs:Pointer; n:Integer):Integer; cdecl;
|
|
{$EXTERNALSYM wcstombs}
|
|
|
|
function strstr(const str1, str2: PAnsiChar): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM strstr}
|
|
|
|
function wcscpy(dest, src: PWideChar): PWideChar; cdecl;
|
|
{$EXTERNALSYM wcscpy}
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Locale }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function tolower(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM tolower}
|
|
|
|
function toupper(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM toupper}
|
|
|
|
function towlower(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM towlower}
|
|
|
|
function towupper(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM towupper}
|
|
|
|
function isalnum(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isalnum}
|
|
|
|
function isalpha(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isalpha}
|
|
|
|
function iscntrl(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM iscntrl}
|
|
|
|
function isdigit(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isdigit}
|
|
|
|
function isgraph(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isgraph}
|
|
|
|
function islower(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM islower}
|
|
|
|
function isprint(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isprint}
|
|
|
|
function ispunct(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM ispunct}
|
|
|
|
function isspace(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isspace}
|
|
|
|
function isupper(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isupper}
|
|
|
|
function isxdigit(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM isxdigit}
|
|
|
|
function _ismbblead(c: Cardinal): Integer; cdecl;
|
|
{$EXTERNALSYM _ismbblead}
|
|
function __ismbblead(c: Cardinal): Integer; cdecl;
|
|
{$EXTERNALSYM __ismbblead}
|
|
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ IO }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function _open(const __path: PAnsiChar; __access: Integer; __permission: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM _open}
|
|
|
|
function _wopen(const __path: PChar; __access: Integer; __permission: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM _wopen}
|
|
|
|
function _close(__handle: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM _close}
|
|
|
|
function _lseek(__handle: Integer; __offset: Integer; __fromwhere: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM _lseek}
|
|
|
|
function _read(__handle: Integer; __buf: Pointer; __len: LongWord): Integer; cdecl;
|
|
{$EXTERNALSYM _read}
|
|
|
|
function _write(__handle: Integer; __buf: Pointer; __len: LongWord): Integer; cdecl;
|
|
{$EXTERNALSYM _write}
|
|
|
|
function open(const __path: PAnsiChar; __access: Integer; __permission: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM open}
|
|
function close(__handle: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM close}
|
|
function lseek(__handle: Integer; __offset: Integer; __fromwhere: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM lseek}
|
|
function read(__handle: Integer; __buf: Pointer; __len: LongWord): Integer; cdecl;
|
|
{$EXTERNALSYM read}
|
|
function write(__handle: Integer; __buf: Pointer; __len: LongWord): Integer; cdecl;
|
|
{$EXTERNALSYM write}
|
|
function rename(const __oldname, __newname: PAnsiChar): Integer; cdecl;
|
|
{$EXTERNALSYM rename}
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Standard IO }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function printf(format: PAnsiChar {args}): Integer; cdecl; varargs;
|
|
{$EXTERNALSYM printf}
|
|
|
|
function fprintf(fHandle: Pointer; format: PAnsiChar {args}): Integer; cdecl; varargs;
|
|
{$EXTERNALSYM fprintf}
|
|
|
|
function sprintf(buf: Pointer; format: PAnsiChar {args}): Integer; cdecl; varargs;
|
|
{$EXTERNALSYM sprintf}
|
|
|
|
function snprintf(buf: Pointer; nzize: size_t; format: PAnsiChar; param: va_list): Integer; cdecl;
|
|
{$EXTERNALSYM snprintf}
|
|
|
|
function _snprintf(buf: Pointer; nzize: size_t; format: PAnsiChar; param: va_list): Integer; cdecl;
|
|
{$EXTERNALSYM _snprintf}
|
|
|
|
function vsnprintf(buf: Pointer; nzize: size_t; format: PAnsiChar; param: va_list): Integer; cdecl;
|
|
{$EXTERNALSYM vsnprintf}
|
|
|
|
function _vsnprintf(buf: Pointer; nzize: size_t; format: PAnsiChar; param: va_list): Integer; cdecl;
|
|
{$EXTERNALSYM _vsnprintf}
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Conversion }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function _itoa(value: Integer; str: PAnsiChar; radix: Integer): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM _itoa}
|
|
|
|
function itoa(value: Integer; str: PAnsiChar; radix: Integer): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM itoa}
|
|
|
|
function _i64toa(value: Int64; str: PAnsiChar; radix: Integer): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM _i64toa}
|
|
|
|
function _atoi64(const str: PAnsiChar): Int64; cdecl;
|
|
{$EXTERNALSYM _atoi64}
|
|
|
|
function atoi(const str: PAnsiChar): Integer; cdecl;
|
|
{$EXTERNALSYM atoi}
|
|
|
|
function atof(value: PAnsiChar): Double; cdecl;
|
|
{$EXTERNALSYM atof}
|
|
|
|
function atol(const str: PAnsiChar): LongInt; cdecl;
|
|
{$EXTERNALSYM atol}
|
|
|
|
function strtod(value: PAnsiChar; endPtr: PPAnsiChar): Double; cdecl;
|
|
{$EXTERNALSYM strtod}
|
|
|
|
function gcvt(value: double; digits: Integer; buffer: PAnsiChar): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM gcvt}
|
|
function _gcvt(value: double; digits: Integer; buffer: PAnsiChar): PAnsiChar; cdecl;
|
|
{$EXTERNALSYM _gcvt}
|
|
|
|
const
|
|
_fltused: Integer = $9875; // from stubs.c in MS crtl
|
|
{$EXTERNALSYM _fltused}
|
|
_streams: array [0..2] of NativeInt = (0, 1, 2);
|
|
{$EXTERNALSYM _streams}
|
|
var
|
|
_errno: Integer;
|
|
{$EXTERNALSYM _errno}
|
|
__errno: Integer;
|
|
{$EXTERNALSYM __errno}
|
|
___errno: Integer;
|
|
{$EXTERNALSYM ___errno}
|
|
__turboFloat: Integer = 0; // Win32
|
|
{$EXTERNALSYM __turboFloat}
|
|
|
|
|
|
procedure _mbctype; // Not a function, pointer to data
|
|
{$EXTERNALSYM _mbctype}
|
|
{$IFDEF WIN64}
|
|
procedure _purecall; cdecl;
|
|
function _lseeki64(__handle: Integer; __offset: Int64; __fromwhere: Integer): Int64; cdecl;
|
|
{$EXTERNALSYM _lseeki64}
|
|
{$ENDIF}
|
|
{$IFDEF WIN32}
|
|
procedure __pure_error_;
|
|
{$EXTERNALSYM __pure_error_}
|
|
function GetMem2(Size: NativeInt): Pointer;
|
|
{$EXTERNALSYM GetMem2}
|
|
function SysFreeMem2(p: Pointer): Integer;
|
|
{$EXTERNALSYM SysFreeMem2}
|
|
function _malloc(size: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM _malloc}
|
|
function _realloc(P: Pointer; NewSize: size_t): Pointer; cdecl;
|
|
{$EXTERNALSYM _realloc}
|
|
procedure _free(pBlock: Pointer); cdecl;
|
|
{$EXTERNALSYM _free}
|
|
|
|
function __atold(value: PAnsiChar; endPtr: PPAnsiChar): Extended; cdecl;
|
|
{$EXTERNALSYM __atold}
|
|
procedure _ftol; cdecl; external;
|
|
{$EXTERNALSYM _ftol}
|
|
procedure __ftol; cdecl; external; {$L ftol.obj}
|
|
{$EXTERNALSYM __ftol}
|
|
procedure _ftoul; cdecl;
|
|
{$EXTERNALSYM _ftoul}
|
|
procedure __ftoul; cdecl; external; {$L _ftoul.obj}
|
|
{$EXTERNALSYM __ftoul}
|
|
{$ENDIF WIN32}
|
|
|
|
procedure __mbctype; // Not a function, pointer to data
|
|
{$EXTERNALSYM __mbctype}
|
|
function _ltolower(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM _ltolower}
|
|
function _ltoupper(__ch: Integer): Integer; cdecl;
|
|
{$EXTERNALSYM _ltoupper}
|
|
function _ltowlower(c:Integer):Integer; cdecl;
|
|
{$EXTERNALSYM _ltowlower}
|
|
function _ltowupper(c:Integer):Integer; cdecl;
|
|
{$EXTERNALSYM _ltowupper}
|
|
procedure __ltolower; cdecl;
|
|
{$EXTERNALSYM __ltolower}
|
|
procedure __ltoupper; cdecl;
|
|
{$EXTERNALSYM __ltoupper}
|
|
procedure __ltowlower; cdecl;
|
|
{$EXTERNALSYM __ltowlower}
|
|
procedure __ltowupper; cdecl;
|
|
{$EXTERNALSYM __ltowupper}
|
|
|
|
{$IFDEF WIN32}
|
|
procedure _atof; cdecl;
|
|
{$EXTERNALSYM _atof}
|
|
procedure _atol; cdecl;
|
|
{$EXTERNALSYM _atol}
|
|
procedure _strcspn; cdecl;
|
|
{$EXTERNALSYM _strcspn}
|
|
procedure _strcat; cdecl;
|
|
{$EXTERNALSYM _strcat}
|
|
procedure _strcmp; cdecl;
|
|
{$EXTERNALSYM _strcmp}
|
|
procedure _strncmp; cdecl;
|
|
{$EXTERNALSYM _strncmp}
|
|
procedure _strcpy; cdecl;
|
|
{$EXTERNALSYM _strcpy}
|
|
procedure _strncpy; cdecl;
|
|
{$EXTERNALSYM _strncpy}
|
|
procedure _memmove; cdecl;
|
|
{$EXTERNALSYM _memmove}
|
|
procedure _memset; cdecl;
|
|
{$EXTERNALSYM _memset}
|
|
procedure _memcpy; cdecl;
|
|
{$EXTERNALSYM _memcpy}
|
|
procedure _memcmp; cdecl;
|
|
{$EXTERNALSYM _memcmp}
|
|
procedure _memchr; cdecl;
|
|
{$EXTERNALSYM _memchr}
|
|
procedure _strlen; cdecl;
|
|
{$EXTERNALSYM _strlen}
|
|
procedure _islower; cdecl;
|
|
{$EXTERNALSYM _islower}
|
|
procedure _isdigit; cdecl;
|
|
{$EXTERNALSYM _isdigit}
|
|
procedure _isupper; cdecl;
|
|
{$EXTERNALSYM _isupper}
|
|
procedure _isalnum; cdecl;
|
|
{$EXTERNALSYM _isalnum}
|
|
procedure _isspace; cdecl;
|
|
{$EXTERNALSYM _isspace}
|
|
procedure _isxdigit; cdecl;
|
|
{$EXTERNALSYM _isxdigit}
|
|
procedure _isgraph; cdecl;
|
|
{$EXTERNALSYM _isgraph}
|
|
procedure _isprint; cdecl;
|
|
{$EXTERNALSYM _isprint}
|
|
procedure _ispunct; cdecl;
|
|
{$EXTERNALSYM _ispunct}
|
|
procedure _iscntrl; cdecl;
|
|
{$EXTERNALSYM _iscntrl}
|
|
procedure _isalpha; cdecl;
|
|
{$EXTERNALSYM _isalpha}
|
|
procedure _strchr; cdecl;
|
|
{$EXTERNALSYM _strchr}
|
|
procedure _strnlen; cdecl;
|
|
{$EXTERNALSYM _strnlen}
|
|
procedure _wcslen; cdecl;
|
|
{$EXTERNALSYM _wcslen}
|
|
procedure _wcsnlen; cdecl;
|
|
{$EXTERNALSYM _wcsnlen}
|
|
procedure _printf; cdecl;
|
|
{$EXTERNALSYM _printf}
|
|
procedure _fprintf; cdecl;
|
|
{$EXTERNALSYM _fprintf}
|
|
procedure _sprintf; cdecl;
|
|
{$EXTERNALSYM _sprintf}
|
|
procedure __vsnprintf; cdecl;
|
|
{$EXTERNALSYM __vsnprintf}
|
|
procedure _tolower; cdecl;
|
|
{$EXTERNALSYM _tolower}
|
|
procedure _toupper; cdecl;
|
|
{$EXTERNALSYM _toupper}
|
|
procedure __mbscspn; cdecl;
|
|
{$EXTERNALSYM __mbscspn}
|
|
procedure __i64toa; cdecl;
|
|
{$EXTERNALSYM __i64toa}
|
|
procedure __atoi64; cdecl;
|
|
{$EXTERNALSYM __atoi64}
|
|
procedure _strstr; cdecl;
|
|
{$EXTERNALSYM _strstr}
|
|
procedure _mbstowcs; cdecl;
|
|
{$EXTERNALSYM _mbstowcs}
|
|
procedure _wcstombs; cdecl;
|
|
{$EXTERNALSYM _wcstombs}
|
|
procedure _strerror; cdecl;
|
|
{$EXTERNALSYM _strerror}
|
|
procedure _llmod; cdecl;
|
|
{$EXTERNALSYM _llmod}
|
|
procedure _lldiv; cdecl;
|
|
{$EXTERNALSYM _lldiv}
|
|
procedure _lludiv; cdecl;
|
|
{$EXTERNALSYM _lludiv}
|
|
procedure _llmul; cdecl;
|
|
{$EXTERNALSYM _llmul}
|
|
procedure _llumod; cdecl;
|
|
{$EXTERNALSYM _llumod}
|
|
procedure _llshl; cdecl;
|
|
{$EXTERNALSYM _llshl}
|
|
procedure _llshr; cdecl;
|
|
{$EXTERNALSYM _llshr}
|
|
procedure _llushr; cdecl;
|
|
{$EXTERNALSYM _llushr}
|
|
{$ENDIF WIN32}
|
|
|
|
procedure qsort(baseP: PByte; NElem, Width: size_t; comparF: qsort_compare_func); cdecl;
|
|
{$EXTERNALSYM qsort}
|
|
function localtime(t: Ptime_t): Ptm; cdecl;
|
|
{$EXTERNALSYM localtime}
|
|
|
|
function _beginthreadex(security_attr: Pointer; stksize: LongWord;
|
|
start: Pointer; arg: Pointer; create_flags: LongWord;
|
|
var thread_id: LongWord): LongWord; cdecl;
|
|
{$EXTERNALSYM _beginthreadex}
|
|
procedure _endthreadex(thread_retval: LongWord);
|
|
{$EXTERNALSYM _endthreadex}
|
|
|
|
function log(__x: Double): Double; cdecl;
|
|
{$EXTERNALSYM log}
|
|
{$IFDEF WIN32}
|
|
var
|
|
___favor,
|
|
___isa_available,
|
|
___isa_enabled : Cardinal;
|
|
__imp___errno, ___mingw_vsnprintf, __lseeki64, __imp___wopen : UInt64;
|
|
{$ENDIF}
|
|
{$IFDEF WIN64}
|
|
var
|
|
__favor,__isa_available : Cardinal;
|
|
__memset_nt_iters : NativeInt;
|
|
__security_cookie : UInt64;
|
|
__imp__errno,__mingw_vsnprintf,__imp__wopen : UInt64;
|
|
{$ENDIF}
|
|
{$IFDEF WIN32}
|
|
//void *calloc(size_t nitems, size_t size)
|
|
function _calloc(nitems,size : NativeInt):Pointer; cdecl;
|
|
function ___divdi3(a,b:int64):Int64;cdecl;external;
|
|
function ___udivdi3(a,b:UInt64):UInt64; cdecl; external;
|
|
procedure ___ctzdi2; cdecl; external;
|
|
procedure __aulldiv; cdecl; external;
|
|
procedure __allmul; cdecl; external;
|
|
procedure __aullshr; cdecl; external;
|
|
procedure __alloca; cdecl; external;
|
|
{$ENDIF}
|
|
{$IFDEF WIN64}
|
|
//void *calloc(size_t nitems, size_t size)
|
|
function __imp_malloc(size: size_t): Pointer; cdecl;
|
|
function __imp_calloc(nitems,size : NativeInt):Pointer;
|
|
procedure __imp_free(pBlock: Pointer); cdecl;
|
|
procedure __security_check_cookie(cookie : UInt64);
|
|
function calloc(nitems,size : NativeInt):Pointer;
|
|
{$ENDIF}
|
|
procedure __chkstk; cdecl; external;
|
|
procedure ___chkstk_ms; cdecl; external;
|
|
{$ENDIF}
|
|
implementation
|
|
{$IFDEF MSWINDOWS}
|
|
uses System.SysUtils, System.Character;
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Memory }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function malloc(size: size_t): Pointer; cdecl;
|
|
begin
|
|
Result := AllocMem(size);
|
|
end;
|
|
|
|
function realloc(P: Pointer; NewSize: size_t): Pointer; cdecl;
|
|
begin
|
|
ReallocMem(P, Newsize);
|
|
Result := P;
|
|
end;
|
|
|
|
procedure free(pBlock: Pointer); cdecl;
|
|
begin
|
|
FreeMem(pBlock);
|
|
end;
|
|
|
|
{$IFDEF WIN64}
|
|
function __imp_malloc;
|
|
begin
|
|
Result := AllocMem(size);
|
|
end;
|
|
|
|
procedure __imp_free;
|
|
begin
|
|
FreeMem(pBlock);
|
|
end;
|
|
|
|
function __imp_calloc(nitems,size : NativeInt):Pointer;
|
|
begin
|
|
Result := Allocmem(nitems*size);
|
|
end;
|
|
|
|
procedure __security_check_cookie;
|
|
begin
|
|
if cookie=__security_cookie then exit;
|
|
raise Exception.Create('!!! stack overflow check failed in cookie checker!!!');
|
|
end;
|
|
|
|
procedure _purecall; cdecl;
|
|
asm
|
|
jmp System.@AbstractError
|
|
end;
|
|
|
|
function _lseeki64; external msvcrt;
|
|
|
|
{$ENDIF}
|
|
|
|
{$IFDEF WIN32}
|
|
procedure _llmod; cdecl;
|
|
asm
|
|
jmp System.@_llmod;
|
|
end;
|
|
|
|
procedure _lldiv; cdecl;
|
|
asm
|
|
jmp System.@_lldiv
|
|
end;
|
|
|
|
procedure _lludiv; cdecl;
|
|
asm
|
|
jmp System.@_lludiv
|
|
end;
|
|
|
|
procedure _llmul; cdecl;
|
|
asm
|
|
jmp System.@_llmul
|
|
end;
|
|
|
|
procedure _llumod; cdecl;
|
|
asm
|
|
jmp System.@_llumod
|
|
end;
|
|
|
|
procedure _llshl; cdecl;
|
|
asm
|
|
jmp System.@_llshl
|
|
end;
|
|
|
|
procedure _llshr; cdecl;
|
|
asm
|
|
AND CL, $3F
|
|
CMP CL, 32
|
|
JL @__llshr@below32
|
|
MOV EAX, EDX
|
|
CDQ
|
|
SAR EAX,CL
|
|
RET
|
|
|
|
@__llshr@below32:
|
|
SHRD EAX, EDX, CL
|
|
SAR EDX, CL
|
|
RET
|
|
end;
|
|
|
|
procedure _llushr; cdecl;
|
|
asm
|
|
jmp System.@_llushr
|
|
end;
|
|
|
|
function _malloc(size: size_t): Pointer; cdecl;
|
|
begin
|
|
try
|
|
Result := AllocMem(size);
|
|
except
|
|
Result := nil;
|
|
end;
|
|
end;
|
|
|
|
function _realloc(P: Pointer; NewSize: size_t): Pointer; cdecl;
|
|
begin
|
|
try
|
|
ReallocMem(P, Newsize);
|
|
Result := P;
|
|
except
|
|
Result := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure _free(pBlock: Pointer); cdecl;
|
|
begin
|
|
FreeMem(pBlock);
|
|
end;
|
|
|
|
procedure __pure_error_;
|
|
asm
|
|
JMP System.@AbstractError
|
|
end;
|
|
|
|
// C++'s alloc allocates 1 byte if size is 0.
|
|
function GetMem2(Size: NativeInt): Pointer;
|
|
begin
|
|
if Size = 0 then Inc(Size);
|
|
GetMem(Result, Size);
|
|
end;
|
|
|
|
// C++'s free allow NULL pointer.
|
|
function SysFreeMem2(p: Pointer): Integer;
|
|
begin
|
|
result := 0;
|
|
if (p <> NIL) then result := FreeMemory(p);
|
|
end;
|
|
|
|
function __atold(value: PAnsiChar; endPtr: PPAnsiChar): Extended; cdecl;
|
|
var
|
|
s: string;
|
|
begin
|
|
s := string(Value);
|
|
if endPtr <> nil then
|
|
endPtr^ := value;
|
|
if not TryStrToFloat(s, Result) then
|
|
Result := 0
|
|
else if endPtr <> nil then
|
|
endPtr^ := PAnsiChar(PByte(Value) + Length(s));
|
|
end;
|
|
|
|
procedure _ftoul; cdecl;
|
|
asm
|
|
JMP System.@Trunc
|
|
end;
|
|
{$ENDIF WIN32}
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ CString }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function memchr; external msvcrt;
|
|
|
|
function memcmp; external msvcrt;
|
|
|
|
function memcpy; external msvcrt;
|
|
|
|
function memmove; external msvcrt;
|
|
|
|
function memset; external msvcrt;
|
|
|
|
function strcat; external msvcrt;
|
|
|
|
function strcpy; external msvcrt;
|
|
|
|
function strncpy; external msvcrt;
|
|
|
|
function strcmp; external msvcrt;
|
|
|
|
function strncmp; external msvcrt;
|
|
|
|
function strlen; external msvcrt;
|
|
|
|
function strnlen; external msvcrt;
|
|
|
|
function strchr; external msvcrt;
|
|
|
|
function strrchr; external msvcrt;
|
|
|
|
function strerror; external msvcrt;
|
|
|
|
function strcspn; external msvcrt;
|
|
|
|
function stricmp; external msvcrt name '_stricmp';
|
|
|
|
function _stricmp; external msvcrt;
|
|
|
|
function _mbscspn; external msvcrt;
|
|
|
|
function mbstowcs; external msvcrt;
|
|
|
|
function wcslen; external msvcrt;
|
|
|
|
function wcsnlen; external msvcrt;
|
|
|
|
function wcstombs; external msvcrt;
|
|
|
|
function strstr; external msvcrt;
|
|
|
|
function wcscpy; external msvcrt;
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Locale }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function tolower; external msvcrt;
|
|
|
|
function toupper; external msvcrt;
|
|
|
|
function towlower; external msvcrt;
|
|
|
|
function towupper; external msvcrt;
|
|
|
|
function isalnum; external msvcrt;
|
|
|
|
function isalpha; external msvcrt;
|
|
|
|
function iscntrl; external msvcrt;
|
|
|
|
function isdigit; external msvcrt;
|
|
|
|
function isgraph; external msvcrt;
|
|
|
|
function islower; external msvcrt;
|
|
|
|
function isprint; external msvcrt;
|
|
|
|
function ispunct; external msvcrt;
|
|
|
|
function isspace; external msvcrt;
|
|
|
|
function isupper; external msvcrt;
|
|
|
|
function isxdigit; external msvcrt;
|
|
|
|
function _ismbblead; external msvcrt;
|
|
function __ismbblead; external msvcrt name '_ismbblead';
|
|
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ IO }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function _wopen; external msvcrt;
|
|
|
|
function _open; external msvcrt;
|
|
|
|
function _close; external msvcrt;
|
|
|
|
function _lseek; external msvcrt;
|
|
|
|
function _read; external msvcrt;
|
|
|
|
function _write; external msvcrt;
|
|
|
|
function open; external msvcrt name '_open';
|
|
|
|
function close; external msvcrt name '_close';
|
|
|
|
function lseek; external msvcrt name '_lseek';
|
|
|
|
function read; external msvcrt name '_read';
|
|
|
|
function write; external msvcrt name '_write';
|
|
|
|
function rename; external msvcrt;
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Standard IO }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function printf; external msvcrt;
|
|
|
|
function fprintf; external msvcrt;
|
|
|
|
function sprintf; external msvcrt;
|
|
|
|
function snprintf; external msvcrt name '_snprintf';
|
|
|
|
function _snprintf; external msvcrt;
|
|
|
|
function vsnprintf; external msvcrt name '_vsnprintf';
|
|
|
|
function _vsnprintf; external msvcrt;
|
|
|
|
{ ----------------------------------------------------- }
|
|
{ Conversion }
|
|
{ ----------------------------------------------------- }
|
|
|
|
function _itoa; external msvcrt;
|
|
|
|
function itoa; external msvcrt name '_itoa';
|
|
|
|
function _i64toa; external msvcrt;
|
|
|
|
function _atoi64; external msvcrt;
|
|
|
|
function atoi; external msvcrt;
|
|
|
|
function atof; external msvcrt;
|
|
|
|
function atol; external msvcrt;
|
|
|
|
function strtod; external msvcrt;
|
|
|
|
function gcvt; external msvcrt name '_gcvt';
|
|
|
|
function _gcvt; external msvcrt;
|
|
|
|
procedure _mbctype; external msvcrt; // Not a function, pointer to data
|
|
|
|
procedure __mbctype; external msvcrt name '_mbctype'; // Not a function, pointer to data
|
|
|
|
function _ltolower; external msvcrt name 'tolower';
|
|
|
|
function _ltoupper; external msvcrt name 'toupper';
|
|
|
|
function _ltowlower; external msvcrt name 'towlower';
|
|
|
|
function _ltowupper; external msvcrt name 'towupper';
|
|
|
|
procedure __ltolower; external msvcrt name 'tolower';
|
|
|
|
procedure __ltoupper; external msvcrt name 'toupper';
|
|
|
|
procedure __ltowlower; external msvcrt name 'towlower';
|
|
|
|
procedure __ltowupper; external msvcrt name 'towupper';
|
|
|
|
procedure _atof; external msvcrt name 'atof';
|
|
|
|
procedure _atol; external msvcrt name 'atol';
|
|
|
|
procedure _strcspn; external msvcrt name 'strcspn';
|
|
|
|
procedure _strcat; external msvcrt name 'strcat';
|
|
|
|
procedure _strcmp; external msvcrt name 'strcmp';
|
|
|
|
procedure _strncmp; external msvcrt name 'strncmp';
|
|
|
|
procedure _strcpy; external msvcrt name 'strcpy';
|
|
|
|
procedure _strncpy; external msvcrt name 'strncpy';
|
|
|
|
procedure _memmove; external msvcrt name 'memmove';
|
|
|
|
procedure _memset; external msvcrt name 'memset';
|
|
|
|
procedure _memcpy; external msvcrt name 'memcpy';
|
|
|
|
procedure _memcmp; external msvcrt name 'memcmp';
|
|
|
|
procedure _memchr; external msvcrt name 'memchr';
|
|
|
|
procedure _strlen; external msvcrt name 'strlen';
|
|
|
|
procedure _islower; external msvcrt name 'islower';
|
|
|
|
procedure _isdigit; external msvcrt name 'isdigit';
|
|
|
|
procedure _isupper; external msvcrt name 'isupper';
|
|
|
|
procedure _isalnum; external msvcrt name 'isalnum';
|
|
|
|
procedure _isspace; external msvcrt name 'isspace';
|
|
|
|
procedure _isxdigit; external msvcrt name 'isxdigit';
|
|
|
|
procedure _isgraph; external msvcrt name 'isgraph';
|
|
|
|
procedure _isprint; external msvcrt name 'isprint';
|
|
|
|
procedure _ispunct; external msvcrt name 'ispunct';
|
|
|
|
procedure _iscntrl; external msvcrt name 'iscntrl';
|
|
|
|
procedure _isalpha; external msvcrt name 'isalpha';
|
|
|
|
procedure _strchr; external msvcrt name 'strchr';
|
|
|
|
procedure _strrchr; external msvcrt name 'strrchr';
|
|
|
|
procedure _strnlen; external msvcrt name 'strnlen';
|
|
|
|
procedure _wcslen; external msvcrt name 'wcslen';
|
|
|
|
procedure _wcsnlen; external msvcrt name 'wcsnlen';
|
|
|
|
procedure _printf; external msvcrt name 'printf';
|
|
|
|
procedure _fprintf; external msvcrt name 'fprintf';
|
|
|
|
procedure _sprintf; external msvcrt name 'sprintf';
|
|
|
|
procedure __vsnprintf; external msvcrt name '_vsnprintf';
|
|
|
|
procedure _tolower; external msvcrt name 'tolower';
|
|
|
|
procedure _toupper; external msvcrt name 'toupper';
|
|
|
|
procedure __mbscspn; external msvcrt name '_mbscspn';
|
|
|
|
procedure __i64toa; external msvcrt name '_i64toa';
|
|
|
|
procedure __atoi64; external msvcrt name '_atoi64';
|
|
|
|
procedure _strstr; external msvcrt name 'strstr';
|
|
|
|
procedure _mbstowcs; external msvcrt name 'mbstowcs';
|
|
|
|
procedure _wcstombs; external msvcrt name 'wcstombs';
|
|
|
|
procedure _strerror; external msvcrt name 'strerror';
|
|
|
|
procedure qsort; external msvcrt;
|
|
|
|
function localtime; external msvcrt;
|
|
|
|
function _beginthreadex; external msvcrt;
|
|
|
|
procedure _endthreadex; external msvcrt;
|
|
|
|
function log; external msvcrt;
|
|
{$IFDEF WIN32}
|
|
{$L chkstk.x86.o}
|
|
{$L chkstk_ms.x86.o}
|
|
{$L divdi3.x86.o}
|
|
{$L udivdi3.x86.o}
|
|
{$L ctzdi2.x86.o}
|
|
{$L ulldiv.x86.o}
|
|
{$L ullshr.x86.o}
|
|
{$L llmul.x86.o}
|
|
{$L _chkstk.x86.o}
|
|
function _calloc(nitems,size : NativeInt):Pointer;
|
|
begin
|
|
Result := Allocmem(nitems*size);
|
|
end;
|
|
{$ENDIF}
|
|
{$IFDEF WIN64}
|
|
{$L chkstk.x64.o}
|
|
{$L chkstk_ms.x64.o}
|
|
function calloc(nitems,size : NativeInt):Pointer;
|
|
begin
|
|
Result := Allocmem(nitems*size);
|
|
end;
|
|
{$ENDIF}
|
|
procedure CallCPUID(ValueEAX, ValueECX: Cardinal; var ReturnedEAX, ReturnedEBX, ReturnedECX, ReturnedEDX);
|
|
asm
|
|
{$IFDEF CPU32BITS}
|
|
// save context
|
|
PUSH EDI
|
|
PUSH EBX
|
|
// init parameters
|
|
MOV EDI, ReturnedEAX
|
|
MOV EAX, ValueEAX
|
|
MOV ECX, ValueECX
|
|
CPUID
|
|
// store results
|
|
MOV Cardinal PTR [EDI], EAX
|
|
MOV EAX, ReturnedEBX
|
|
MOV EDI, ReturnedECX
|
|
MOV Cardinal PTR [EAX], EBX
|
|
MOV Cardinal PTR [EDI], ECX
|
|
MOV EAX, ReturnedEDX
|
|
MOV Cardinal PTR [EAX], EDX
|
|
// restore context
|
|
POP EBX
|
|
POP EDI
|
|
{$ELSE}
|
|
// save context
|
|
PUSH RBX
|
|
// init parameters
|
|
MOV R8, ReturnedEAX
|
|
MOV R9, ReturnedEBX
|
|
MOV R10, ReturnedECX
|
|
MOV R11, ReturnedEDX
|
|
MOV EAX, ValueEAX
|
|
MOV ECX, ValueECX
|
|
// CPUID
|
|
CPUID
|
|
// store results
|
|
MOV Cardinal PTR [R8], EAX
|
|
MOV Cardinal PTR [R9], EBX
|
|
MOV Cardinal PTR [R10], ECX
|
|
MOV Cardinal PTR [R11], EDX
|
|
// restore context
|
|
POP RBX
|
|
{$ENDIF}
|
|
end;
|
|
var EAX,EBX,ECX,EDX,H :Cardinal;
|
|
CpuName : array[0..47] of ansichar;
|
|
type TTT = array[0..7]of byte;
|
|
initialization
|
|
var Name : String;
|
|
{$IFDEF CPU32BITS}
|
|
___isa_available := 0;
|
|
___favor := 2;
|
|
{$ELSE}
|
|
__isa_available := 0;
|
|
__favor := 2;
|
|
__memset_nt_iters := 63488;
|
|
{$ENDIF}
|
|
CallCPUID(7,0,EAX,EBX,ECX,EDX);
|
|
if EBX and $20 >0 then begin //Check AVX2
|
|
{$IFDEF CPU32BITS}
|
|
___isa_available := 5;
|
|
___isa_enabled := 47;
|
|
{$ELSE}
|
|
__isa_available := 5;
|
|
{$ENDIF}
|
|
end else begin
|
|
CallCPUID(1,0,EAX,EBX,ECX,EDX);
|
|
if ECX and $10000000 >0 then begin //Check AVX
|
|
{$IFDEF CPU32BITS}
|
|
___isa_available := 3;
|
|
___isa_enabled := 15;
|
|
{$ELSE}
|
|
__isa_available := 3;
|
|
{$ENDIF}
|
|
end else begin
|
|
if ECX and $100000>0 then begin //Check SSE4.2
|
|
{$IFDEF CPU32BITS}
|
|
___isa_available := 2;
|
|
___isa_enabled := 7;
|
|
{$ELSE}
|
|
__isa_available := 2;
|
|
{$ENDIF}
|
|
end else if EDX and $4000000>0 then begin //Check SSE2
|
|
{$IFDEF CPU32BITS}
|
|
___isa_available := 1;
|
|
___isa_enabled := 3;
|
|
{$ELSE}
|
|
__isa_available := 1;
|
|
{$ENDIF}
|
|
end else begin
|
|
{$IFDEF CPU32BITS}
|
|
___isa_enabled := 1;
|
|
{$ENDIF}
|
|
end;
|
|
CallCPUID($80000000, 0, H, EBX, ECX, EDX);
|
|
if H >= $80000002 then
|
|
CallCPUID($80000002, 0, CpuName[0], CpuName[4], CpuName[8], CpuName[12]);
|
|
if H >= $80000003 then
|
|
CallCPUID($80000003, 0, CpuName[16], CpuName[20], CpuName[24], CpuName[28]);
|
|
if H >= $80000004 then
|
|
CallCPUID($80000004, 0, CpuName[32], CpuName[36], CpuName[40], CpuName[44]);
|
|
Name := CPUName;
|
|
if Name.ToUpper.IndexOf('ATOM')>=0 then begin
|
|
{$IFDEF CPU32BITS}
|
|
___favor := 3; //Set ATOM bit
|
|
{$ELSE}
|
|
__favor := 3; //Set ATOM bit
|
|
{$ENDIF}
|
|
end;
|
|
end;
|
|
end;
|
|
{$IFDEF WIN64}
|
|
randomize;
|
|
PDouble(@__security_cookie)^ := Random;
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
end.
|