1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/**************************************************************************/
/* */
/* OCaml */
/* */
/* Xavier Leroy, projet Cristal, INRIA Rocquencourt */
/* */
/* Copyright 2001 Institut National de Recherche en Informatique et */
/* en Automatique. */
/* */
/* All rights reserved. This file is distributed under the terms of */
/* the GNU Lesser General Public License version 2.1, with the */
/* special exception on linking described in the file LICENSE. */
/* */
/**************************************************************************/
/* Operating system - specific stuff */
#ifndef CAML_OSDEPS_H
#define CAML_OSDEPS_H
#ifdef CAML_INTERNALS
#include "misc.h"
#include "memory.h"
/* Read at most [n] bytes from file descriptor [fd] into buffer [buf].
[flags] indicates whether [fd] is a socket
(bit [CHANNEL_FLAG_FROM_SOCKET] is set in this case, see [io.h]).
(This distinction matters for Win32, but not for Unix.)
Return number of bytes read.
In case of error, set [errno] and return -1. */
extern int caml_read_fd(int fd, int flags, void * buf, int n);
/* Write at most [n] bytes from buffer [buf] onto file descriptor [fd].
[flags] indicates whether [fd] is a socket
(bit [CHANNEL_FLAG_FROM_SOCKET] is set in this case, see [io.h]).
(This distinction matters for Win32, but not for Unix.)
Return number of bytes written.
In case of error, set [errno] and return -1. */
extern int caml_write_fd(int fd, int flags, void * buf, int n);
/* Decompose the given path into a list of directories, and add them
to the given table. */
extern char_os * caml_decompose_path(struct ext_table * tbl, char_os * path);
/* Search the given file in the given list of directories.
If not found, return a copy of [name]. */
extern char_os * caml_search_in_path(struct ext_table * path,
const char_os * name);
/* Same, but search an executable name in the system path for executables. */
CAMLextern char_os * caml_search_exe_in_path(const char_os * name);
/* Same, but search a shared library in the given path. */
extern char_os * caml_search_dll_in_path(struct ext_table * path,
const char_os * name);
/* Open a shared library and return a handle on it.
If [global] is true, symbols from the shared library can be used
to resolve for other libraries to be opened later on.
Return [NULL] on error. */
extern void * caml_dlopen(char_os * libname, int global);
/* Close a shared library handle */
extern void caml_dlclose(void * handle);
/* Look up the given symbol in the given shared library.
Return [NULL] if not found, or symbol value if found. */
extern void * caml_dlsym(void * handle, const char * name);
extern void * caml_globalsym(const char * name);
/* Return an error message describing the most recent dynlink failure. */
extern char * caml_dlerror(void);
/* Recover executable name if possible (/proc/sef/exe under Linux,
GetModuleFileName under Windows). Return NULL on error,
string allocated with [caml_stat_alloc] on success. */
extern char_os * caml_executable_name(void);
/* Secure version of [getenv]: returns NULL if the process has special
privileges (setuid bit, setgid bit, capabilities).
*/
extern char_os *caml_secure_getenv(char_os const *var);
/* If [fd] refers to a terminal or console, return the number of rows
(lines) that it displays. Otherwise, or if the number of rows
cannot be determined, return -1. */
extern int caml_num_rows_fd(int fd);
/* Memory management platform-specific operations */
void *caml_plat_mem_map(uintnat, int);
void *caml_plat_mem_commit(void *, uintnat);
void caml_plat_mem_decommit(void *, uintnat);
void caml_plat_mem_unmap(void *, uintnat);
#ifdef _WIN32
#include <time.h>
/* Map a Win32 error code (as returned by GetLastError) to a POSIX error code
(from <errno.h>). Return 0 if no POSIX error code matches. */
CAMLextern int caml_posixerr_of_win32err(unsigned int win32err);
extern int caml_win32_rename(const wchar_t *, const wchar_t *);
CAMLextern int caml_win32_unlink(const wchar_t *);
extern void caml_probe_win32_version(void);
extern void caml_setup_win32_terminal(void);
extern void caml_restore_win32_terminal(void);
extern wchar_t *caml_win32_getenv(wchar_t const *);
/* Windows Unicode support */
CAMLextern int caml_win32_multi_byte_to_wide_char(const char* s,
int slen,
wchar_t *out,
int outlen);
CAMLextern int caml_win32_wide_char_to_multi_byte(const wchar_t* s,
int slen,
char *out,
int outlen);
/* Legacy names */
#define win_multi_byte_to_wide_char caml_win32_multi_byte_to_wide_char
#define win_wide_char_to_multi_byte caml_win32_wide_char_to_multi_byte
CAMLextern int caml_win32_isatty(int fd);
CAMLextern void caml_expand_command_line (int *, wchar_t ***);
CAMLextern clock_t caml_win32_clock(void);
CAMLextern value caml_win32_xdg_defaults(void);
#endif /* _WIN32 */
/* Returns the current value of a counter that increments once per nanosecond.
On systems that support it, this uses a monotonic timesource which ignores
changes in the system time (so that this counter increases by 1000000 each
millisecond, even if the system clock was set back by an hour during that
millisecond). This makes it useful for benchmarking and timeouts, but not
for telling the time. The units are always nanoseconds, but the achieved
resolution may be less. The starting point is unspecified. */
extern uint64_t caml_time_counter(void);
extern void caml_init_os_params(void);
#endif /* CAML_INTERNALS */
#ifdef _WIN32
#ifdef __cplusplus
extern "C" {
#endif
extern unsigned short caml_win32_major;
extern unsigned short caml_win32_minor;
extern unsigned short caml_win32_build;
extern unsigned short caml_win32_revision;
/* [caml_stat_strdup_to_utf16(s)] returns a null-terminated copy of [s],
re-encoded in UTF-16. The encoding of [s] is assumed to be UTF-8 if
[caml_windows_unicode_runtime_enabled] is non-zero **and** [s] is valid
UTF-8, or the current Windows code page otherwise.
The returned string is allocated with [caml_stat_alloc], so it should be free
using [caml_stat_free].
*/
CAMLextern wchar_t* caml_stat_strdup_to_utf16(const char *s);
/* [caml_stat_strdup_noexc_of_utf16(s)] returns a null-terminated copy of [s],
re-encoded in UTF-8 if [caml_windows_unicode_runtime_enabled] is non-zero or
the current Windows code page otherwise.
The returned string is allocated with [caml_stat_alloc_noexc], so
it should be freed using [caml_stat_free].
If allocation fails, this returns NULL.
*/
CAMLextern char* caml_stat_strdup_noexc_of_utf16(const wchar_t *s);
/* [caml_stat_strdup_of_utf16(s)] returns a null-terminated copy of [s],
re-encoded in UTF-8 if [caml_windows_unicode_runtime_enabled] is non-zero or
the current Windows code page otherwise.
The returned string is allocated with [caml_stat_alloc_noexc], so
it should be freed using [caml_stat_free].
If allocation fails, this raises Out_of_memory.
*/
CAMLextern char* caml_stat_strdup_of_utf16(const wchar_t *s);
/* [caml_copy_string_of_utf16(s)] returns an OCaml string containing a copy of
[s] re-encoded in UTF-8 if [caml_windows_unicode_runtime_enabled] is non-zero
or in the current code page otherwise.
*/
CAMLextern value caml_copy_string_of_utf16(const wchar_t *s);
#ifdef __cplusplus
}
#endif
#endif /* _WIN32 */
#endif /* CAML_OSDEPS_H */
|
