You've already forked lazarus-ccr
f8e3459ac4
git-svn-id: https://svn.code.sf.net/p/lazarus-ccr/svn@13 8e941d3f-bd1b-0410-a28a-d453659cc2b4
541 lines
19 KiB
PHP
541 lines
19 KiB
PHP
{ Copyright 2000-2005 The Apache Software Foundation or its licensors, as
|
|
* applicable.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
}
|
|
|
|
{ This header file is where you should put ANY platform specific information.
|
|
* This should be the only header file that programs need to include that
|
|
* actually has platform dependant code which refers to the .
|
|
}
|
|
|
|
{
|
|
* @file apr_portable.h
|
|
* @brief APR Portability Routines
|
|
}
|
|
|
|
{#include "apr.h"
|
|
#include "apr_pools.h"
|
|
#include "apr_thread_proc.h"
|
|
#include "apr_file_io.h"
|
|
#include "apr_network_io.h"
|
|
#include "apr_errno.h"
|
|
#include "apr_global_mutex.h"
|
|
#include "apr_proc_mutex.h"
|
|
#include "apr_time.h"
|
|
#include "apr_dso.h"
|
|
#include "apr_shm.h"
|
|
|
|
#if APR_HAVE_DIRENT_H
|
|
#include <dirent.h>
|
|
#endif
|
|
#if APR_HAVE_FCNTL_H
|
|
#include <fcntl.h>
|
|
#endif
|
|
#if APR_HAVE_PTHREAD_H
|
|
#include <pthread.h>
|
|
#endif}
|
|
|
|
{
|
|
* @defgroup apr_portabile Portability Routines
|
|
* @ingroup APR
|
|
}
|
|
|
|
|
|
|
|
type
|
|
|
|
{$ifdef WINDOWS}
|
|
{ The primitives for Windows types }
|
|
apr_os_file_t = THandle;
|
|
apr_os_dir_t = THandle;
|
|
apr_os_sock_t = TSocket;
|
|
apr_os_proc_mutex_t = THandle;
|
|
apr_os_thread_t = THandle;
|
|
apr_os_proc_t = THandle;
|
|
apr_os_threadkey_t = Cardinal;
|
|
apr_os_imp_time_t = TFILETIME;
|
|
apr_os_exp_time_t = TSYSTEMTIME;
|
|
apr_os_dso_handle_t = THandle;
|
|
apr_os_shm_t = THandle;
|
|
|
|
{$else}
|
|
{$ifdef OS2}
|
|
HFILE apr_os_file_t;
|
|
HDIR apr_os_dir_t;
|
|
int apr_os_sock_t;
|
|
HMTX apr_os_proc_mutex_t;
|
|
TID apr_os_thread_t;
|
|
PID apr_os_proc_t;
|
|
PULONG apr_os_threadkey_t;
|
|
struct timeval apr_os_imp_time_t;
|
|
struct tm apr_os_exp_time_t;
|
|
HMODULE apr_os_dso_handle_t;
|
|
apr_os_shm_t: Pointer;
|
|
|
|
{$else}
|
|
{$ifdef BEOS}
|
|
|
|
#include <kernel/OS.h>
|
|
#include <kernel/image.h>
|
|
|
|
apr_os_proc_mutex_t = record
|
|
sem_id sem;
|
|
int32 ben;
|
|
end;
|
|
|
|
apr_os_file_t: cint;
|
|
DIR apr_os_dir_t;
|
|
apr_os_sock_t: cint;
|
|
struct apr_os_proc_mutex_t apr_os_proc_mutex_t;
|
|
thread_id apr_os_thread_t;
|
|
thread_id apr_os_proc_t;
|
|
apr_os_threadkey_t: cint;
|
|
struct timeval apr_os_imp_time_t;
|
|
struct tm apr_os_exp_time_t;
|
|
image_id apr_os_dso_handle_t;
|
|
apr_os_shm_t: Pointer;
|
|
|
|
{$else}
|
|
{$ifdef NETWARE}
|
|
apr_os_file_t: cint;
|
|
DIR apr_os_dir_t;
|
|
apr_os_sock_t: cint;
|
|
NXMutex_t apr_os_proc_mutex_t;
|
|
NXThreadId_t apr_os_thread_t;
|
|
long apr_os_proc_t;
|
|
NXKey_t apr_os_threadkey_t;
|
|
struct timeval apr_os_imp_time_t;
|
|
struct tm apr_os_exp_time_t;
|
|
apr_os_dso_handle_t: Pointer;
|
|
apr_os_shm_t: Pointer;
|
|
|
|
{$else}
|
|
{ Any other OS should go above this one. This is the lowest common
|
|
* denominator typedefs for all UNIX-like systems. :)
|
|
}
|
|
|
|
{ Basic OS process mutex structure. }
|
|
apr_os_proc_mutex_t = record
|
|
{$if defined(APR_HAS_SYSVSEM_SERIALIZE) or defined(APR_HAS_FCNTL_SERIALIZE) or defined(APR_HAS_FLOCK_SERIALIZE)}
|
|
crossproc: Integer;
|
|
{$endif}
|
|
{$ifdef APR_HAS_PROC_PTHREAD_SERIALIZE}
|
|
pthread_mutex_t *pthread_interproc;
|
|
{$endif}
|
|
{$ifdef APR_HAS_THREADS}
|
|
{ If no threads, no need for thread locks }
|
|
{$if APR_USE_PTHREAD_SERIALIZE}
|
|
pthread_mutex_t *intraproc;
|
|
{$endif}
|
|
{$endif}
|
|
end;
|
|
|
|
apr_os_file_t: Integer; {< native file }
|
|
typedef DIR apr_os_dir_t; {< native dir }
|
|
apr_os_sock_t: Integer; {< native dir }
|
|
typedef struct apr_os_proc_mutex_t apr_os_proc_mutex_t; {< native proces
|
|
* mutex
|
|
}
|
|
{$if defined(APR_HAS_THREADS) and defined(APR_HAVE_PTHREAD_H)}
|
|
typedef pthread_t apr_os_thread_t; {< native thread }
|
|
typedef pthread_key_t apr_os_threadkey_t; {< native thread address
|
|
* space }
|
|
{$endif}
|
|
typedef pid_t apr_os_proc_t; {< native pid }
|
|
typedef struct timeval apr_os_imp_time_t; {< native timeval }
|
|
typedef struct tm apr_os_exp_time_t; {< native tm }
|
|
{ @var apr_os_dso_handle_t
|
|
* native dso types
|
|
}
|
|
{$ifdef HPUX}
|
|
#include <dl.h>
|
|
typedef shl_t apr_os_dso_handle_t;
|
|
{$else}
|
|
{$ifdef DARWIN}
|
|
#include <mach-o/dyld.h>
|
|
typedef NSModule apr_os_dso_handle_t;
|
|
{$else}
|
|
typedef void * apr_os_dso_handle_t;
|
|
{$endif}
|
|
{$endif}
|
|
typedef void* apr_os_shm_t; {< native SHM }
|
|
|
|
{$endif}
|
|
{$endif}
|
|
{$endif}
|
|
{$endif}
|
|
|
|
Papr_os_sock_t = ^apr_os_sock_t;
|
|
|
|
{
|
|
* @typedef apr_os_sock_info_t
|
|
* @brief alias for local OS socket
|
|
}
|
|
{
|
|
* everything APR needs to know about an active socket to construct
|
|
* an APR socket from it; currently, this is platform-independent
|
|
}
|
|
apr_os_sock_info_t = record
|
|
os_sock: Papr_os_sock_t; {< always required }
|
|
local: Psockaddr; {< NULL if not yet bound }
|
|
remote: Psockaddr; {< NULL if not connected }
|
|
family: Integer; {< always required (APR_INET, APR_INET6, etc.) }
|
|
type_: Integer; {< always required (SOCK_STREAM, SOCK_DGRAM, etc.) }
|
|
{$ifdef APR_ENABLE_FOR_1_0} {< enable with APR 1.0 }
|
|
protocol: Integer; {< 0 or actual protocol (APR_PROTO_SCTP, APR_PROTO_TCP, etc.) }
|
|
{$endif}
|
|
end;
|
|
|
|
Papr_os_sock_info_t = ^apr_os_sock_info_t;
|
|
|
|
{$if defined(APR_PROC_MUTEX_IS_GLOBAL) or defined(DOXYGEN)}
|
|
{ Opaque global mutex type }
|
|
#define apr_os_global_mutex_t apr_os_proc_mutex_t
|
|
{ @return apr_os_global_mutex }
|
|
#define apr_os_global_mutex_get apr_os_proc_mutex_get
|
|
{$else}
|
|
{ Thread and process mutex for those platforms where process mutexes
|
|
* are not held in threads.
|
|
}
|
|
apr_os_global_mutex_t = record
|
|
pool: Papr_pool_t;
|
|
proc_mutex: Papr_proc_mutex_t;
|
|
#if APR_HAS_THREADS
|
|
thread_mutex: Papr_proc_mutex_t;
|
|
#endif { APR_HAS_THREADS }
|
|
end;
|
|
Papr_os_global_mutex_t = ^apr_os_global_mutex_t;
|
|
|
|
APR_DECLARE(apr_status_t) apr_os_global_mutex_get(apr_os_global_mutex_t *ospmutex,
|
|
apr_global_mutex_t *pmutex);
|
|
{$endif}
|
|
|
|
|
|
{
|
|
* convert the file from apr type to os specific type.
|
|
* @param thefile The os specific file we are converting to
|
|
* @param file The apr file to convert.
|
|
* @remark On Unix, it is only possible to get a file descriptor from
|
|
* an apr file type.
|
|
}
|
|
function apr_os_file_get(thefile, file_: Papr_os_file_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_file_get' + LibSuff8;
|
|
|
|
{
|
|
* convert the dir from apr type to os specific type.
|
|
* @param thedir The os specific dir we are converting to
|
|
* @param dir The apr dir to convert.
|
|
}
|
|
function apr_os_dir_get(thedir: PPapr_os_dir_t; dir: Papr_dir_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_dir_get' + LibSuff8;
|
|
|
|
{
|
|
* Convert the socket from an apr type to an OS specific socket
|
|
* @param thesock The socket to convert.
|
|
* @param sock The os specifc equivelant of the apr socket..
|
|
}
|
|
function apr_os_sock_get(thesock, sock: Papr_os_sock_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_sock_get' + LibSuff8;
|
|
|
|
{
|
|
* Convert the proc mutex from os specific type to apr type
|
|
* @param ospmutex The os specific proc mutex we are converting to.
|
|
* @param pmutex The apr proc mutex to convert.
|
|
}
|
|
function apr_os_proc_mutex_get(ospmutex: Papr_os_proc_mutex_t;
|
|
pmutex: Papr_proc_mutex_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_proc_mutex_get' + LibSuff8;
|
|
|
|
{
|
|
* Get the exploded time in the platforms native format.
|
|
* @param ostime the native time format
|
|
* @param aprtime the time to convert
|
|
}
|
|
function apr_os_exp_time_get(ostime: PPapr_os_exp_time_t;
|
|
aprtime: Papr_time_exp_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_exp_time_get' + LibSuff8;
|
|
|
|
{
|
|
* Get the imploded time in the platforms native format.
|
|
* @param ostime the native time format
|
|
* @param aprtime the time to convert
|
|
}
|
|
function apr_os_imp_time_get(ostime: PPapr_os_imp_time_t;
|
|
aprtime: Papr_time_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_imp_time_get' + LibSuff8;
|
|
|
|
{
|
|
* convert the shm from apr type to os specific type.
|
|
* @param osshm The os specific shm representation
|
|
* @param shm The apr shm to convert.
|
|
}
|
|
function apr_os_shm_get(osshm: Papr_os_shm_t; shm: Papr_shm_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_shm_get' + LibSuff8;
|
|
|
|
{$if defined(APR_HAS_THREADS) or defined(DOXYGEN)}
|
|
{
|
|
* @defgroup apr_os_thread Thread portability Routines
|
|
}
|
|
{
|
|
* convert the thread to os specific type from apr type.
|
|
* @param thethd The apr thread to convert
|
|
* @param thd The os specific thread we are converting to
|
|
}
|
|
function apr_os_thread_get(thethd: PPapr_os_thread_t;
|
|
thd: Papr_thread_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_thread_get' + LibSuff8;
|
|
|
|
{
|
|
* convert the thread private memory key to os specific type from an apr type.
|
|
* @param thekey The apr handle we are converting from.
|
|
* @param key The os specific handle we are converting to.
|
|
}
|
|
function apr_os_threadkey_get(thekey: Papr_os_threadkey_t;
|
|
key: Papr_threadkey_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_threadkey_get' + LibSuff8;
|
|
|
|
{
|
|
* convert the thread from os specific type to apr type.
|
|
* @param thd The apr thread we are converting to.
|
|
* @param thethd The os specific thread to convert
|
|
* @param cont The pool to use if it is needed.
|
|
}
|
|
function apr_os_thread_put(thd: PPapr_thread_t;
|
|
thethd: Papr_os_thread_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_thread_put' + LibSuff12;
|
|
|
|
{
|
|
* convert the thread private memory key from os specific type to apr type.
|
|
* @param key The apr handle we are converting to.
|
|
* @param thekey The os specific handle to convert
|
|
* @param cont The pool to use if it is needed.
|
|
}
|
|
function apr_os_threadkey_put(key: PPapr_threadkey_t;
|
|
thekey: Papr_os_threadkey_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_threadkey_put' + LibSuff12;
|
|
|
|
{
|
|
* Get the thread ID
|
|
}
|
|
function apr_os_thread_current: apr_os_thread_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_thread_current' + LibSuff0;
|
|
|
|
{
|
|
* Compare two thread id's
|
|
* @param tid1 1st Thread ID to compare
|
|
* @param tid2 2nd Thread ID to compare
|
|
}
|
|
function apr_os_thread_equal(tid1, tid2: apr_os_thread_t): Integer;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_thread_equal' + LibSuff8;
|
|
|
|
{$endif} { APR_HAS_THREADS }
|
|
|
|
{
|
|
* convert the file from os specific type to apr type.
|
|
* @param file The apr file we are converting to.
|
|
* @param thefile The os specific file to convert
|
|
* @param flags The flags that were used to open this file.
|
|
* @param cont The pool to use if it is needed.
|
|
* @remark On Unix, it is only possible to put a file descriptor into
|
|
* an apr file type.
|
|
}
|
|
function apr_os_file_put(file_: PPapr_file_t;
|
|
pthefilemutex: Papr_os_file_t; flags: apr_int32_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_file_put' + LibSuff16;
|
|
|
|
{
|
|
* convert the file from os specific type to apr type.
|
|
* @param file The apr file we are converting to.
|
|
* @param thefile The os specific pipe to convert
|
|
* @param cont The pool to use if it is needed.
|
|
* @remark On Unix, it is only possible to put a file descriptor into
|
|
* an apr file type.
|
|
}
|
|
function apr_os_pipe_put(file_: PPapr_file_t;
|
|
thefile: Papr_os_file_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_pipe_put' + LibSuff12;
|
|
|
|
{
|
|
* convert the file from os specific type to apr type.
|
|
* @param file The apr file we are converting to.
|
|
* @param thefile The os specific pipe to convert
|
|
* @param register_cleanup A cleanup will be registered on the apr_file_t
|
|
* to issue apr_file_close().
|
|
* @param cont The pool to use if it is needed.
|
|
* @remark On Unix, it is only possible to put a file descriptor into
|
|
* an apr file type.
|
|
}
|
|
function apr_os_pipe_put_ex(file_: PPapr_file_t;
|
|
thefile: Papr_os_file_t; register_cleanup: Integer;
|
|
cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_pipe_put_ex' + LibSuff16;
|
|
|
|
{
|
|
* convert the dir from os specific type to apr type.
|
|
* @param dir The apr dir we are converting to.
|
|
* @param thedir The os specific dir to convert
|
|
* @param cont The pool to use when creating to apr directory.
|
|
}
|
|
function apr_os_dir_put(dir: PPapr_dir_t; thedir: Papr_os_dir_t;
|
|
cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_dir_put' + LibSuff12;
|
|
|
|
{
|
|
* Convert a socket from the os specific type to the apr type
|
|
* @param sock The pool to use.
|
|
* @param thesock The socket to convert to.
|
|
* @param cont The socket we are converting to an apr type.
|
|
* @remark If it is a true socket, it is best to call apr_os_sock_make()
|
|
* and provide APR with more information about the socket.
|
|
}
|
|
function apr_os_sock_put(sock: PPapr_socket_t; thesock: Papr_socket_t;
|
|
cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_sock_put' + LibSuff8;
|
|
|
|
{
|
|
* Create a socket from an existing descriptor and local and remote
|
|
* socket addresses.
|
|
* @param apr_sock The new socket that has been set up
|
|
* @param os_sock_info The os representation of the socket handle and
|
|
* other characteristics of the socket
|
|
* @param cont The pool to use
|
|
* @remark If you only know the descriptor/handle or if it isn't really
|
|
* a true socket, use apr_os_sock_put() instead.
|
|
}
|
|
function apr_os_sock_make(apr_sock: PPapr_socket_t;
|
|
os_sock_info: Papr_os_sock_info_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_sock_make' + LibSuff12;
|
|
|
|
{
|
|
* Convert the proc mutex from os specific type to apr type
|
|
* @param pmutex The apr proc mutex we are converting to.
|
|
* @param ospmutex The os specific proc mutex to convert.
|
|
* @param cont The pool to use if it is needed.
|
|
}
|
|
function apr_os_proc_mutex_put(pmutex: PPapr_proc_mutex_t;
|
|
ospmutex: Papr_os_proc_mutex_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_proc_mutex_put' + LibSuff12;
|
|
|
|
{
|
|
* Put the imploded time in the APR format.
|
|
* @param aprtime the APR time format
|
|
* @param ostime the time to convert
|
|
* @param cont the pool to use if necessary
|
|
}
|
|
function apr_os_imp_time_put(aprtime: Papr_time_t;
|
|
ostime: PPapr_os_imp_time_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_imp_time_put' + LibSuff12;
|
|
|
|
{
|
|
* Put the exploded time in the APR format.
|
|
* @param aprtime the APR time format
|
|
* @param ostime the time to convert
|
|
* @param cont the pool to use if necessary
|
|
}
|
|
function apr_os_exp_time_put(aprtime: Papr_time_exp_t;
|
|
ostime: PPapr_os_exp_time_t; cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_exp_time_put' + LibSuff12;
|
|
|
|
{
|
|
* convert the shared memory from os specific type to apr type.
|
|
* @param shm The apr shm representation of osshm
|
|
* @param osshm The os specific shm identity
|
|
* @param cont The pool to use if it is needed.
|
|
* @remark On fork()ed architectures, this is typically nothing more than
|
|
* the memory block mapped. On non-fork architectures, this is typically
|
|
* some internal handle to pass the mapping from process to process.
|
|
}
|
|
function apr_os_shm_put(shm: PPapr_shm_t; osshm: Papr_os_shm_t;
|
|
cont: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_shm_put' + LibSuff8;
|
|
|
|
{$if defined(APR_HAS_DSO) or defined(DOXYGEN)}
|
|
{
|
|
* @defgroup apr_os_dso DSO (Dynamic Loading) Portabiliity Routines
|
|
}
|
|
{
|
|
* convert the dso handle from os specific to apr
|
|
* @param dso The apr handle we are converting to
|
|
* @param thedso the os specific handle to convert
|
|
* @param pool the pool to use if it is needed
|
|
}
|
|
function apr_os_dso_handle_put(dso: PPapr_dso_handle_t;
|
|
thedso: apr_os_dso_handle_t; pool: Papr_pool_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_dso_handle_put' + LibSuff12;
|
|
|
|
{
|
|
* convert the apr dso handle into an os specific one
|
|
* @param aprdso The apr dso handle to convert
|
|
* @param dso The os specific dso to return
|
|
}
|
|
function apr_os_dso_handle_get(dso: Papr_os_dso_handle_t;
|
|
aprdso: Papr_dso_handle_t): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_dso_handle_get' + LibSuff8;
|
|
|
|
{$ifdef APR_HAS_OS_UUID}
|
|
{
|
|
* Private: apr-util's apr_uuid module when supported by the platform
|
|
}
|
|
function apr_os_uuid_get(uuid_data: PChar): apr_status_t;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_uuid_get' + LibSuff8;
|
|
{$endif}
|
|
|
|
{$endif} { APR_HAS_DSO }
|
|
|
|
|
|
{
|
|
* Get the name of the system default characer set.
|
|
* @param pool the pool to allocate the name from, if needed
|
|
}
|
|
function apr_os_default_encoding(pool: Papr_pool_t): PChar;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_default_encoding' + LibSuff4;
|
|
|
|
{
|
|
* Get the name of the current locale character set.
|
|
* @param pool the pool to allocate the name from, if needed
|
|
* @remark Defers to apr_os_default_encoding if the current locale's
|
|
* data can't be retreved on this system.
|
|
}
|
|
function apr_os_locale_encoding(pool: Papr_pool_t): PChar;
|
|
{$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
|
|
external LibAPR name LibNamePrefix + 'apr_os_locale_encoding' + LibSuff4;
|
|
|