/**
* gtk_targets_include_uri:
* @targets: (array length=n_targets): an array of #GdkAtoms
* @n_targets: the length of @targets
*
* Determines if any of the targets in @targets can be used to
* provide an uri list.
*
* Returns: %TRUE if @targets include a suitable target for uri lists,
* otherwise %FALSE.
**/
gboolean
gtk_targets_include_uri (GdkAtom *targets,
gint n_targets)
{
gint i;
gboolean result = FALSE;
g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
/* Keep in sync with gdk_content_formats_add_uri_targets()
*/
init_atoms ();
for (i = 0; i < n_targets; i++)
{
if (targets[i] == text_uri_list_atom)
{
result = TRUE;
break;
}
}
return result;
}
/*
* NOTE: must be called after awt_root_shell is created and realized.
*/
Boolean
awt_dnd_init(Display* display) {
static Boolean inited = False;
if (!inited) {
Boolean atoms_inited = False;
Boolean ds_inited = False;
unsigned int value = 1;
MOTIF_BYTE_ORDER = (*((char*)&value) != 0) ? 'l' : 'B';
/* NOTE: init_atoms() should be called before the rest of initialization
so that atoms can be used. */
inited = init_atoms(display);
if (inited) {
if (XtIsRealized(awt_root_shell)) {
awt_root_window = XtWindow(awt_root_shell);
} else {
inited = False;
}
}
inited = inited && awt_dnd_ds_init(display);
}
return inited;
}
/*
* Class: com_sun_glass_ui_gtk_GtkSystemClipboard
* Method: popFromSystem
* Signature: (Ljava/lang/String;)Ljava/lang/Object;
*/
JNIEXPORT jobject JNICALL Java_com_sun_glass_ui_gtk_GtkSystemClipboard_popFromSystem
(JNIEnv * env, jobject obj, jstring mime)
{
const char* cmime = env->GetStringUTFChars(mime, NULL);
jobject result;
init_atoms();
if (g_strcmp0(cmime, "text/plain") == 0) {
result = get_data_text(env);
} else if (g_strcmp0(cmime, "text/uri-list") == 0) {
result = get_data_uri_list(env, FALSE);
} else if (g_str_has_prefix(cmime, "text/")) {
result = get_data_raw(env, cmime, TRUE);
} else if (g_strcmp0(cmime, "application/x-java-file-list") == 0) {
result = get_data_uri_list(env, TRUE);
} else if (g_strcmp0(cmime, "application/x-java-rawimage") == 0 ) {
result = get_data_image(env);
} else {
result = get_data_raw(env, cmime, FALSE);
}
LOG_EXCEPTION(env)
env->ReleaseStringUTFChars(mime, cmime);
return result;
}
/**
* gtk_targets_include_text:
* @targets: (array length=n_targets): an array of #GdkAtoms
* @n_targets: the length of @targets
*
* Determines if any of the targets in @targets can be used to
* provide text.
*
* Returns: %TRUE if @targets include a suitable target for text,
* otherwise %FALSE.
**/
gboolean
gtk_targets_include_text (GdkAtom *targets,
gint n_targets)
{
gint i;
gboolean result = FALSE;
g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
/* Keep in sync with gdk_content_formats_add_text_targets()
*/
init_atoms ();
for (i = 0; i < n_targets; i++)
{
if (targets[i] == utf8_atom ||
targets[i] == text_atom ||
targets[i] == g_intern_static_string ("STRING") ||
targets[i] == ctext_atom ||
targets[i] == text_plain_atom ||
targets[i] == text_plain_utf8_atom ||
targets[i] == text_plain_locale_atom)
{
result = TRUE;
break;
}
}
return result;
}
/**
* gtk_content_formats_add_text_targets:
* @list: a #GdkContentFormats
*
* Appends the text targets supported by #GtkSelectionData to
* the target list. All targets are added with the same @info.
**/
GdkContentFormats *
gtk_content_formats_add_text_targets (GdkContentFormats *list)
{
GdkContentFormatsBuilder *builder;
g_return_val_if_fail (list != NULL, NULL);
init_atoms ();
builder = gdk_content_formats_builder_new ();
gdk_content_formats_builder_add_formats (builder, list);
gdk_content_formats_unref (list);
/* Keep in sync with gtk_selection_data_targets_include_text()
*/
gdk_content_formats_builder_add_mime_type (builder, utf8_atom);
gdk_content_formats_builder_add_mime_type (builder, ctext_atom);
gdk_content_formats_builder_add_mime_type (builder, text_atom);
gdk_content_formats_builder_add_mime_type (builder, g_intern_static_string ("STRING"));
gdk_content_formats_builder_add_mime_type (builder, text_plain_utf8_atom);
if (!g_get_charset (NULL))
gdk_content_formats_builder_add_mime_type (builder, text_plain_locale_atom);
gdk_content_formats_builder_add_mime_type (builder, text_plain_atom);
return gdk_content_formats_builder_free_to_formats (builder);
}
static int on_load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{
ErlNifResourceFlags flags = ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER;
cberl_handle = enif_open_resource_type(env, "cberl_nif",
"cberl_handle",
&cberl_handle_cleanup,
flags, 0);
init_atoms(env);
return 0;
}
/**
* \brief Initialize a new SCS context.
*
* Return a new SCS context in the result argument \p ps. The context is
* initialized with the supplied \p tid, keyset (\p key and \p hkey),
* \p cipherset, compression (\p comp) and \p session_max_age parameters.
* In case zlib support is disabled, the \p comp value will be silently
* ignored (i.e. always set to false).
*
* \param tid A string uniquely identifying the cipherset
* associated to keys \p key and \p hkey.
* \param cipherset The cipherset type (at present only \p
* AES_128_CBC_HMAC_SHA1 is supported).
* \param key Encryption key; it is assumed to be of the correct
* size, i.e. 16 bytes for AES 128.
* \param hkey HMAC key; it is assumed to be of the correct size,
* i.e. 20 bytes for SHA1-based HMAC.
* \param comp Compression flag (non zero means: use compression).
* \param session_max_age Max duration of the associated session (i.e.
* lifetime between two subsequent use of the cookie).
* \param ps The scs_t object as a result argument.
*
* \return ::SCS_OK on success, one of the ::scs_err_t values on error.
*/
int scs_init (const char *tid, scs_cipherset_t cipherset, const uint8_t *key,
const uint8_t *hkey, int comp, time_t session_max_age, scs_t **ps)
{
scs_err_t rc;
scs_t *s = NULL;
/* Initialize the crypto toolkit. */
if (D.init() == -1)
return SCS_ERR_CRYPTO;
/* Make room for the SCS context structure. */
if ((s = calloc(1, sizeof *s)) == NULL)
return SCS_ERR_MEM;
/* Initialize current keyset. */
if ((rc = init_keyset(s, &s->cur_keyset, tid, comp, cipherset, key, hkey)))
goto err;
/* Initialize last refresh timestamp. */
if (what_time_is_it(s, &s->last_refresh))
{
rc = SCS_ERR_OS;
goto err;
}
s->refresh_mode = SCS_REFRESH_MANUAL;
/* Upper bound session lifetime. */
s->session_max_age = session_max_age;
/* New SCS context'es have one only active keyset (cur). */
s->cur_keyset.active = 1;
s->prev_keyset.active = 0;
/* Initialize error reporting. */
s->rc = SCS_OK;
s->estr[0] = '\0';
/* Init protocol atoms. */
(void) init_atoms(&s->atoms);
/*
* Note: .tag_sz will be set by each driver tag() function.
*/
/* Copy out to the result argument. */
*ps = s;
return SCS_OK;
err:
if (s)
free(s);
return rc;
}
int main(int argc, char *argv[])
{
if (!open_display()) {
printf("Cannot open display\n");
return 1;
}
init_atoms();
iterate_client_list(get_number_of_desktops());
event_loop();
XCloseDisplay (dpy);
return 0;
}
void caml_main(char **argv)
{
char * exe_name;
#ifdef __linux__
static char proc_self_exe[256];
#endif
value res;
char tos;
caml_init_ieee_floats();
#ifdef _MSC_VER
caml_install_invalid_parameter_handler();
#endif
caml_init_custom_operations();
#ifdef DEBUG
caml_verb_gc = 63;
#endif
caml_top_of_stack = &tos;
parse_camlrunparam();
caml_init_gc (minor_heap_init, heap_size_init, heap_chunk_init,
percent_free_init, max_percent_free_init);
init_atoms();
caml_init_signals();
#if !defined(__FreeBSD__) && !defined(_KERNEL)
caml_debugger_init (); /* force debugger.o stub to be linked */
#endif
exe_name = argv[0];
if (exe_name == NULL) exe_name = "";
#ifdef __linux__
if (caml_executable_name(proc_self_exe, sizeof(proc_self_exe)) == 0)
exe_name = proc_self_exe;
else
exe_name = caml_search_exe_in_path(exe_name);
#elif defined(__FreeBSD__) && defined(_KERNEL)
exe_name = "mirage.ko";
#else
exe_name = caml_search_exe_in_path(exe_name);
#endif
caml_sys_init(exe_name, argv);
if (sigsetjmp(caml_termination_jmpbuf.buf, 0)) {
if (caml_termination_hook != NULL) caml_termination_hook(NULL);
return;
}
res = caml_start_program();
if (Is_exception_result(res))
caml_fatal_uncaught_exception(Extract_exception(res));
}
static int on_load(ErlNifEnv* env, void**, ERL_NIF_TERM)
{
ErlNifResourceFlags flags =
(ErlNifResourceFlags)(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER);
ErlNifResourceType* rt = enif_open_resource_type(env, NULL,
"re2_resource",
&re2_resource_cleanup,
flags, NULL);
if (rt == NULL)
return -1;
re2_resource_type = rt;
init_atoms(env);
return 0;
}
/**
* gtk_content_formats_add_uri_targets:
* @list: a #GdkContentFormats
*
* Appends the URI targets supported by #GtkSelectionData to
* the target list. All targets are added with the same @info.
**/
GdkContentFormats *
gtk_content_formats_add_uri_targets (GdkContentFormats *list)
{
GdkContentFormatsBuilder *builder;
g_return_val_if_fail (list != NULL, NULL);
init_atoms ();
builder = gdk_content_formats_builder_new ();
gdk_content_formats_builder_add_formats (builder, list);
gdk_content_formats_unref (list);
gdk_content_formats_builder_add_mime_type (builder, text_uri_list_atom);
return gdk_content_formats_builder_free_to_formats (builder);
}
CAMLexport void caml_startup_code(
code_t code, asize_t code_size,
char *data, asize_t data_size,
char *section_table, asize_t section_table_size,
char **argv)
{
value res;
caml_init_ieee_floats();
caml_init_custom_operations();
#ifdef DEBUG
caml_verb_gc = 63;
#endif
parse_camlrunparam();
caml_external_raise = NULL;
/* Initialize the abstract machine */
caml_init_gc (minor_heap_init, heap_size_init, heap_chunk_init,
percent_free_init, max_percent_free_init);
caml_init_stack (max_stack_init);
init_atoms();
/* Initialize the interpreter */
caml_interprete(NULL, 0);
/* Load the code */
caml_start_code = code;
#ifdef THREADED_CODE
caml_thread_code(caml_start_code, code_size);
#endif
/* Use the builtin table of primitives */
caml_build_primitive_table_builtin();
/* Load the globals */
caml_global_data = caml_input_value_from_block(data, data_size);
/* Ensure that the globals are in the major heap. */
caml_oldify_one (caml_global_data, &caml_global_data);
caml_oldify_mopup ();
/* Record the sections (for caml_get_section_table in meta.c) */
caml_section_table = section_table;
caml_section_table_size = section_table_size;
/* Run the code */
caml_init_exceptions();
caml_sys_init("", argv);
res = caml_interprete(caml_start_code, code_size);
if (Is_exception_result(res))
caml_fatal_uncaught_exception(Extract_exception(res));
}
/**
* gtk_selection_data_targets_include_uri:
* @selection_data: a #GtkSelectionData object
*
* Given a #GtkSelectionData object holding a list of targets,
* determines if any of the targets in @targets can be used to
* provide a list or URIs.
*
* Returns: %TRUE if @selection_data holds a list of targets,
* and a suitable target for URI lists is included, otherwise %FALSE.
**/
gboolean
gtk_selection_data_targets_include_uri (const GtkSelectionData *selection_data)
{
GdkAtom *targets;
gint n_targets;
gboolean result = FALSE;
g_return_val_if_fail (selection_data != NULL, FALSE);
init_atoms ();
if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets))
{
result = gtk_targets_include_uri (targets, n_targets);
g_free (targets);
}
return result;
}
/**
* gtk_selection_data_set_uris:
* @selection_data: a #GtkSelectionData
* @uris: (array zero-terminated=1): a %NULL-terminated array of
* strings holding URIs
*
* Sets the contents of the selection from a list of URIs.
* The string is converted to the form determined by
* @selection_data->target.
*
* Returns: %TRUE if the selection was successfully set,
* otherwise %FALSE.
**/
gboolean
gtk_selection_data_set_uris (GtkSelectionData *selection_data,
gchar **uris)
{
g_return_val_if_fail (selection_data != NULL, FALSE);
g_return_val_if_fail (uris != NULL, FALSE);
init_atoms ();
if (selection_data->target == text_uri_list_atom)
{
GString *list;
gint i;
gchar *result;
gsize length;
list = g_string_new (NULL);
for (i = 0; uris[i]; i++)
{
g_string_append (list, uris[i]);
g_string_append (list, "\r\n");
}
result = g_convert (list->str, list->len,
"ASCII", "UTF-8",
NULL, &length, NULL);
g_string_free (list, TRUE);
if (result)
{
gtk_selection_data_set (selection_data,
text_uri_list_atom,
8, (guchar *)result, length);
g_free (result);
return TRUE;
}
}
return FALSE;
}
/**
* gtk_selection_data_set_text:
* @selection_data: a #GtkSelectionData
* @str: a UTF-8 string
* @len: the length of @str, or -1 if @str is nul-terminated.
*
* Sets the contents of the selection from a UTF-8 encoded string.
* The string is converted to the form determined by
* @selection_data->target.
*
* Returns: %TRUE if the selection was successfully set,
* otherwise %FALSE.
**/
gboolean
gtk_selection_data_set_text (GtkSelectionData *selection_data,
const gchar *str,
gint len)
{
g_return_val_if_fail (selection_data != NULL, FALSE);
if (len < 0)
len = strlen (str);
init_atoms ();
if (selection_data->target == utf8_atom)
{
gtk_selection_data_set (selection_data,
utf8_atom,
8, (guchar *)str, len);
return TRUE;
}
else if (selection_data->target == g_intern_static_string ("STRING"))
{
return selection_set_string (selection_data, str, len);
}
else if (selection_data->target == ctext_atom ||
selection_data->target == text_atom)
{
if (selection_set_compound_text (selection_data, str, len))
return TRUE;
else if (selection_data->target == text_atom)
return selection_set_string (selection_data, str, len);
}
else if (selection_data->target == text_plain_atom ||
selection_data->target == text_plain_utf8_atom ||
selection_data->target == text_plain_locale_atom)
{
return selection_set_text_plain (selection_data, str, len);
}
return FALSE;
}
/*
* Class: com_sun_glass_ui_gtk_GtkSystemClipboard
* Method: pushToSystem
* Signature: (Ljava/util/HashMap;I)V
*/
JNIEXPORT void JNICALL Java_com_sun_glass_ui_gtk_GtkSystemClipboard_pushToSystem
(JNIEnv * env, jobject obj, jobject data, jint supported)
{
GtkTargetEntry* targets = NULL;
gint ntargets;
data = env->NewGlobalRef(data);
init_atoms();
data_to_targets(env, data, &targets, &ntargets);
CHECK_JNI_EXCEPTION(env)
if (targets) {
gtk_clipboard_set_with_data(get_clipboard(), targets, ntargets, set_data_func, clear_data_func, data);
gtk_target_table_free(targets, ntargets);
} else {
// targets == NULL means that we want to clear clipboard.
// Passing NULL as targets parameter to gtk_clipboard_set_with_data will produce Gtk-CRITICAL assertion
// but passing 0 as n_targets parameter allows to set empty list of available mime types
GtkTargetEntry dummy_targets = {(gchar*) "MIME_DUMMY_TARGET", 0, 0};
gtk_clipboard_set_with_data(get_clipboard(), &dummy_targets, 0, set_data_func, clear_data_func, data);
}
is_clipboard_updated_by_glass = TRUE;
}
/**
* gtk_selection_data_get_text:
* @selection_data: a #GtkSelectionData
*
* Gets the contents of the selection data as a UTF-8 string.
*
* Returns: (type utf8) (nullable) (transfer full): if the selection data contained a
* recognized text type and it could be converted to UTF-8, a newly
* allocated string containing the converted text, otherwise %NULL.
* If the result is non-%NULL it must be freed with g_free().
**/
guchar *
gtk_selection_data_get_text (const GtkSelectionData *selection_data)
{
guchar *result = NULL;
g_return_val_if_fail (selection_data != NULL, NULL);
init_atoms ();
if (selection_data->length >= 0 &&
(selection_data->type == g_intern_static_string ("STRING") ||
selection_data->type == ctext_atom ||
selection_data->type == utf8_atom))
{
gchar **list;
gint i;
gint count = gdk_text_property_to_utf8_list_for_display (selection_data->display,
selection_data->type,
selection_data->format,
selection_data->data,
selection_data->length,
&list);
if (count > 0)
result = (guchar *) list[0];
for (i = 1; i < count; i++)
g_free (list[i]);
g_free (list);
}
else if (selection_data->length >= 0 &&
(selection_data->type == text_plain_atom ||
selection_data->type == text_plain_utf8_atom ||
selection_data->type == text_plain_locale_atom))
{
result = selection_get_text_plain (selection_data);
}
return result;
}
Eterm erts_instr_get_memory_map(Process *proc)
{
MapStatBlock_t *org_mem_anchor;
Eterm hdr_tuple, md_list, res;
Eterm *hp;
Uint hsz;
MapStatBlock_t *bp;
#ifdef DEBUG
Eterm *end_hp;
#endif
if (!erts_instr_memory_map)
return am_false;
if (!atoms_initialized)
init_atoms();
if (!am_n)
init_am_n();
if (!am_c)
init_am_c();
if (!am_a)
init_am_a();
erts_mtx_lock(&instr_x_mutex);
erts_mtx_lock(&instr_mutex);
/* Header size */
hsz = 5 + 1 + (ERTS_ALC_N_MAX+1-ERTS_ALC_N_MIN)*(1 + 4);
/* Memory data list */
for (bp = mem_anchor; bp; bp = bp->next) {
if (is_internal_pid(bp->pid)) {
#if (_PID_NUM_SIZE - 1 > MAX_SMALL)
if (internal_pid_number(bp->pid) > MAX_SMALL)
hsz += BIG_UINT_HEAP_SIZE;
#endif
#if (_PID_SER_SIZE - 1 > MAX_SMALL)
if (internal_pid_serial(bp->pid) > MAX_SMALL)
hsz += BIG_UINT_HEAP_SIZE;
#endif
hsz += 4;
}
if ((UWord) bp->mem > MAX_SMALL)
hsz += BIG_UINT_HEAP_SIZE;
if (bp->size > MAX_SMALL)
hsz += BIG_UINT_HEAP_SIZE;
hsz += 5 + 2;
}
hsz += 3; /* Root tuple */
org_mem_anchor = mem_anchor;
mem_anchor = NULL;
erts_mtx_unlock(&instr_mutex);
hp = HAlloc(proc, hsz); /* May end up calling map_stat_alloc() */
erts_mtx_lock(&instr_mutex);
#ifdef DEBUG
end_hp = hp + hsz;
#endif
{ /* Build header */
ErtsAlcType_t n;
Eterm type_map;
Uint *hp2 = hp;
#ifdef DEBUG
Uint *hp2_end;
#endif
hp += (ERTS_ALC_N_MAX + 1 - ERTS_ALC_N_MIN)*4;
#ifdef DEBUG
hp2_end = hp;
#endif
type_map = make_tuple(hp);
*(hp++) = make_arityval(ERTS_ALC_N_MAX + 1 - ERTS_ALC_N_MIN);
for (n = ERTS_ALC_N_MIN; n <= ERTS_ALC_N_MAX; n++) {
ErtsAlcType_t t = ERTS_ALC_N2T(n);
ErtsAlcType_t a = ERTS_ALC_T2A(t);
ErtsAlcType_t c = ERTS_ALC_T2C(t);
if (!erts_allctrs_info[a].enabled)
a = ERTS_ALC_A_SYSTEM;
*(hp++) = TUPLE3(hp2, am_n[n], am_a[a], am_c[c]);
hp2 += 4;
}
ASSERT(hp2 == hp2_end);
hdr_tuple = TUPLE4(hp,
am.instr_hdr,
make_small(ERTS_INSTR_VSN),
make_small(MAP_STAT_BLOCK_HEADER_SIZE),
type_map);
hp += 5;
}
/* Build memory data list */
for (md_list = NIL, bp = org_mem_anchor; bp; bp = bp->next) {
Eterm tuple;
Eterm type;
Eterm ptr;
Eterm size;
Eterm pid;
if (is_not_internal_pid(bp->pid))
pid = am_undefined;
else {
Eterm c;
Eterm n;
Eterm s;
#if (ERST_INTERNAL_CHANNEL_NO > MAX_SMALL)
#error Oversized internal channel number
#endif
c = make_small(ERST_INTERNAL_CHANNEL_NO);
#if (_PID_NUM_SIZE - 1 > MAX_SMALL)
if (internal_pid_number(bp->pid) > MAX_SMALL) {
n = uint_to_big(internal_pid_number(bp->pid), hp);
hp += BIG_UINT_HEAP_SIZE;
}
else
#endif
n = make_small(internal_pid_number(bp->pid));
#if (_PID_SER_SIZE - 1 > MAX_SMALL)
if (internal_pid_serial(bp->pid) > MAX_SMALL) {
s = uint_to_big(internal_pid_serial(bp->pid), hp);
hp += BIG_UINT_HEAP_SIZE;
}
else
#endif
s = make_small(internal_pid_serial(bp->pid));
pid = TUPLE3(hp, c, n, s);
hp += 4;
}
#if ERTS_ALC_N_MAX > MAX_SMALL
#error Oversized memory type number
#endif
type = make_small(bp->type_no);
if ((UWord) bp->mem > MAX_SMALL) {
ptr = uint_to_big((UWord) bp->mem, hp);
hp += BIG_UINT_HEAP_SIZE;
}
else
ptr = make_small((UWord) bp->mem);
if (bp->size > MAX_SMALL) {
size = uint_to_big(bp->size, hp);
hp += BIG_UINT_HEAP_SIZE;
}
else
size = make_small(bp->size);
tuple = TUPLE4(hp, type, ptr, size, pid);
hp += 5;
md_list = CONS(hp, tuple, md_list);
hp += 2;
}
res = TUPLE2(hp, hdr_tuple, md_list);
ASSERT(hp + 3 == end_hp);
if (mem_anchor) {
for (bp = mem_anchor; bp->next; bp = bp->next)
;
ASSERT(org_mem_anchor);
org_mem_anchor->prev = bp;
bp->next = org_mem_anchor;
}
else {
mem_anchor = org_mem_anchor;
}
erts_mtx_unlock(&instr_mutex);
erts_mtx_unlock(&instr_x_mutex);
return res;
}
/*
* Class: com_sun_glass_ui_gtk_GtkSystemClipboard
* Method: mimesFromSystem
* Signature: ()[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_com_sun_glass_ui_gtk_GtkSystemClipboard_mimesFromSystem
(JNIEnv * env, jobject obj)
{
GdkAtom *targets;
gint ntargets;
gint i;
GdkAtom *convertible;
GdkAtom *convertible_ptr;
gchar *name;
jobjectArray result;
jstring tmpString;
init_atoms();
gtk_clipboard_wait_for_targets(get_clipboard(), &targets, &ntargets);
convertible = (GdkAtom*) glass_try_malloc0_n(ntargets * 2, sizeof(GdkAtom)); //theoretically, the number can double
if (!convertible) {
if (ntargets > 0) {
glass_throw_oom(env, "Failed to allocate mimes");
}
g_free(targets);
return NULL;
}
convertible_ptr = convertible;
bool uri_list_added = false;
bool text_added = false;
bool image_added = false;
for (i = 0; i < ntargets; ++i) {
//handle text targets
//if (targets[i] == TEXT_TARGET || targets[i] == STRING_TARGET || targets[i] == UTF8_STRING_TARGET) {
if (gtk_targets_include_text(targets + i, 1) && !text_added) {
*(convertible_ptr++) = MIME_TEXT_PLAIN_TARGET;
text_added = true;
} else if (gtk_targets_include_image(targets + i, 1, TRUE) && !image_added) {
*(convertible_ptr++) = MIME_JAVA_IMAGE;
image_added = true;
}
//TODO text/x-moz-url ? RT-17802
if (targets[i] == MIME_TEXT_URI_LIST_TARGET) {
if (uri_list_added) {
continue;
}
gchar** uris = gtk_clipboard_wait_for_uris(get_clipboard());
if (uris) {
guint size = g_strv_length(uris);
guint files_cnt = get_files_count(uris);
if (files_cnt) {
*(convertible_ptr++) = MIME_FILES_TARGET;
}
if (size - files_cnt) {
*(convertible_ptr++) = MIME_TEXT_URI_LIST_TARGET;
}
g_strfreev(uris);
}
uri_list_added = true;
} else {
*(convertible_ptr++) = targets[i];
}
}
result = env->NewObjectArray(convertible_ptr - convertible, jStringCls, NULL);
for (i = 0; convertible + i < convertible_ptr; ++i) {
name = gdk_atom_name(convertible[i]);
tmpString = env->NewStringUTF(name);
env->SetObjectArrayElement(result, (jsize)i, tmpString);
g_free(name);
}
g_free(targets);
g_free(convertible);
return result;
}
static int initialize(ErlNifEnv* env, ERL_NIF_TERM load_info)
{
#ifdef OPENSSL_THREADS
ErlNifSysInfo sys_info;
#endif
get_crypto_callbacks_t* funcp;
struct crypto_callbacks* ccb;
int nlocks = 0;
int tpl_arity;
const ERL_NIF_TERM* tpl_array;
int vernum;
ErlNifBinary lib_bin;
char lib_buf[1000];
#ifdef HAVE_DYNAMIC_CRYPTO_LIB
void *handle;
#endif
if (!verify_lib_version())
return __LINE__;
/* load_info: {302, <<"/full/path/of/this/library">>,true|false} */
if (!enif_get_tuple(env, load_info, &tpl_arity, &tpl_array))
return __LINE__;
if (tpl_arity != 3)
return __LINE__;
if (!enif_get_int(env, tpl_array[0], &vernum))
return __LINE__;
if (vernum != 302)
return __LINE__;
if (!enif_inspect_binary(env, tpl_array[1], &lib_bin))
return __LINE__;
if (!init_hmac_ctx(env)) {
return __LINE__;
}
if (!init_hash_ctx(env)) {
return __LINE__;
}
if (!init_cipher_ctx(env)) {
return __LINE__;
}
if (!init_engine_ctx(env)) {
return __LINE__;
}
if (library_initialized) {
/* Repeated loading of this library (module upgrade).
* Atoms and callbacks are already set, we are done.
*/
return 0;
}
if (!init_atoms(env, tpl_array[2], load_info)) {
return __LINE__;
}
#ifdef HAVE_DYNAMIC_CRYPTO_LIB
if (!change_basename(&lib_bin, lib_buf, sizeof(lib_buf), crypto_callback_name))
return __LINE__;
if ((handle = enif_dlopen(lib_buf, &error_handler, NULL)) == NULL)
return __LINE__;
if ((funcp = (get_crypto_callbacks_t*) enif_dlsym(handle, "get_crypto_callbacks",
&error_handler, NULL)) == NULL)
return __LINE__;
#else /* !HAVE_DYNAMIC_CRYPTO_LIB */
funcp = &get_crypto_callbacks;
#endif
#ifdef OPENSSL_THREADS
enif_system_info(&sys_info, sizeof(sys_info));
if (sys_info.scheduler_threads > 1) {
nlocks = CRYPTO_num_locks();
}
/* else no need for locks */
#endif
ccb = (*funcp)(nlocks);
if (!ccb || ccb->sizeof_me != sizeof(*ccb)) {
PRINTF_ERR0("Invalid 'crypto_callbacks'");
return __LINE__;
}
#ifdef HAS_CRYPTO_MEM_FUNCTIONS
if (!CRYPTO_set_mem_functions(ccb->crypto_alloc, ccb->crypto_realloc, ccb->crypto_free))
return __LINE__;
#endif
#ifdef OPENSSL_THREADS
if (nlocks > 0) {
CRYPTO_set_locking_callback(ccb->locking_function);
CRYPTO_set_id_callback(ccb->id_function);
CRYPTO_set_dynlock_create_callback(ccb->dyn_create_function);
CRYPTO_set_dynlock_lock_callback(ccb->dyn_lock_function);
CRYPTO_set_dynlock_destroy_callback(ccb->dyn_destroy_function);
}
#endif /* OPENSSL_THREADS */
init_digest_types(env);
init_cipher_types(env);
init_algorithms_types(env);
library_initialized = 1;
return 0;
}
int main(int argc, char * argv[])
{
int fd;
struct exec_trailer trail;
int i, r;
struct longjmp_buffer raise_buf;
struct channel * chan;
int verbose_init = 0, percent_free_init = Percent_free_def;
long minor_heap_init = Minor_heap_def, heap_chunk_init = Heap_chunk_def;
#ifdef DEBUG
char * debugger_address = NULL;
verbose_init = 1;
#endif
i = 0;
fd = attempt_open(&argv[0], &trail, 0);
if (fd < 0) {
for(i = 1; i < argc && argv[i][0] == '-'; i++) {
switch(argv[i][1]) {
#ifdef DEBUG
case 't': {
extern int trace_flag;
trace_flag = 1;
break;
}
#endif
case 'v':
verbose_init = 1;
break;
case 'V':
fprintf(stderr, "The Caml Light runtime system for Ex-SML, version %s\n",
VERSION);
fprintf(stderr, " git commit %s\n", GIT_HEAD);
sys_exit(INT_TO_VAL(0));
default:
fatal_error_arg("Unknown option %s.\n", argv[i]);
}
}
if (argv[i] == 0)
fatal_error("No bytecode file specified.\n");
fd = attempt_open(&argv[i], &trail, 1);
switch(fd) {
case FILE_NOT_FOUND:
fatal_error_arg("Fatal error: cannot find file %s\n", argv[i]);
break;
case TRUNCATED_FILE:
case BAD_MAGIC_NUM:
fatal_error_arg(
"Fatal error: the file %s is not a bytecode executable file\n",
argv[i]);
break;
default: /* By default, accept */
break;
}
}
/* Runtime options. The option letter is the first letter of the
last word of the ML name of the option (see [lib/gc.mli]). */
{ char *opt = getenv ("CAMLRUNPARAM");
if (opt != NULL){
while (*opt != '\0'){
switch (*opt++){
case 's': sscanf (opt, "=%ld", &minor_heap_init); break;
case 'i': sscanf (opt, "=%ld", &heap_chunk_init); break;
case 'o': sscanf (opt, "=%d", &percent_free_init); break;
case 'v': sscanf (opt, "=%d", &verbose_init); break;
default:
perror("Unknown CAMLRUNPARAM Option");
break;
}
}
}
}
#ifdef DEBUG
if (debugger_address == NULL)
debugger_address = getenv("CAML_DEBUG_SOCKET");
#endif
if (setjmp(raise_buf.buf) == 0) {
external_raise = &raise_buf;
init_gc (minor_heap_init, heap_chunk_init, percent_free_init,
verbose_init);
init_stack();
init_atoms();
lseek(fd, - (long) (TRAILER_SIZE + trail.code_size + trail.data_size
+ trail.symbol_size + trail.debug_size), 2);
code_size = trail.code_size;
start_code = (bytecode_t) stat_alloc(code_size);
r = read(fd, (char *) start_code, code_size);
if (r == -1) {
fatal(NULL);
} else if ((unsigned) r != code_size) {
fatal_error("Fatal error: truncated bytecode file.\n");
}
#if defined(WORDS_BIGENDIAN) && !defined(HAVE_ALIGNED_ACCESS_REQUIRED)
fixup_endianness(start_code, code_size);
#endif
chan = open_descr(fd);
global_data = intern_val(chan);
modify(&Field(global_data, GLOBAL_DATA), global_data);
close_in(chan);
sys_init(argv + i);
interprete(/* mode=init */ 0, NULL, NULL);
interprete(/* mode=byte exec */ 1, start_code, NULL);
sys_exit(INT_TO_VAL(0));
} else {
if (Field(exn_bucket, 0) == Field(global_data, SYS__EXN_MEMORY))
fatal_error ("Fatal error: out of memory.\n");
else {
char* buf = (char*)malloc(201);
char* exnmsg = exnmessage_aux(exn_bucket);
snprintf(buf, 200, "Uncaught exception:\n%s\n", exnmsg);
free(exnmsg);
fatal_error(buf);
}
}
return 0; /* Can't get here */
}
int
main (int argc, char *argv[])
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *table;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *hscrollbar;
GtkWidget *vscrollbar;
GtkWidget *hbox;
static GtkTargetEntry targetlist[] = {
{ "STRING", 0, STRING },
{ "TEXT", 0, TEXT },
{ "COMPOUND_TEXT", 0, COMPOUND_TEXT }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
gtk_init (&argc, &argv);
init_atoms();
selection_widget = gtk_invisible_new ();
dialog = gtk_dialog_new ();
gtk_widget_set_name (dialog, "Test Input");
gtk_container_set_border_width (GTK_CONTAINER(dialog), 0);
g_signal_connect (dialog, "destroy",
G_CALLBACK (quit), NULL);
table = gtk_table_new (4, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER(table), 10);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 5);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox),
table, TRUE, TRUE, 0);
gtk_widget_show (table);
selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
gtk_table_attach (GTK_TABLE (table), selection_button, 0, 2, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (selection_button);
g_signal_connect (selection_button, "toggled",
G_CALLBACK (selection_toggled), NULL);
g_signal_connect (selection_widget, "selection_clear_event",
G_CALLBACK (selection_clear), NULL);
g_signal_connect (selection_widget, "selection_received",
G_CALLBACK (selection_received), NULL);
gtk_selection_add_targets (selection_widget, GDK_SELECTION_PRIMARY,
targetlist, ntargets);
g_signal_connect (selection_widget, "selection_get",
G_CALLBACK (selection_get), NULL);
selection_text = gtk_text_new (NULL, NULL);
gtk_table_attach_defaults (GTK_TABLE (table), selection_text, 0, 1, 1, 2);
gtk_widget_show (selection_text);
hscrollbar = gtk_hscrollbar_new (GTK_TEXT (selection_text)->hadj);
gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hscrollbar);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (selection_text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (vscrollbar);
hbox = gtk_hbox_new (FALSE, 2);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 2, 3, 4,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (hbox);
label = gtk_label_new ("Target:");
gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX(hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Paste");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (paste), entry);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), dialog);
gtk_widget_show (button);
gtk_widget_show (dialog);
gtk_main ();
return 0;
}
CAMLexport void caml_startup_code(
code_t code, asize_t code_size,
char *data, asize_t data_size,
char *section_table, asize_t section_table_size,
char **argv)
{
value res;
char* cds_file;
char * exe_name;
#ifdef __linux__
static char proc_self_exe[256];
#endif
caml_init_ieee_floats();
#ifdef _MSC_VER
caml_install_invalid_parameter_handler();
#endif
caml_init_custom_operations();
#ifdef DEBUG
caml_verb_gc = 63;
#endif
cds_file = getenv("CAML_DEBUG_FILE");
if (cds_file != NULL) {
caml_cds_file = caml_stat_alloc(strlen(cds_file) + 1);
strcpy(caml_cds_file, cds_file);
}
parse_camlrunparam();
exe_name = argv[0];
#ifdef __linux__
if (caml_executable_name(proc_self_exe, sizeof(proc_self_exe)) == 0)
exe_name = proc_self_exe;
#endif
caml_external_raise = NULL;
/* Initialize the abstract machine */
caml_init_gc (minor_heap_init, heap_size_init, heap_chunk_init,
percent_free_init, max_percent_free_init);
caml_init_stack (max_stack_init);
init_atoms();
/* Initialize the interpreter */
caml_interprete(NULL, 0);
/* Initialize the debugger, if needed */
caml_debugger_init();
/* Load the code */
caml_start_code = code;
caml_code_size = code_size;
caml_init_code_fragments();
if (caml_debugger_in_use) {
int len, i;
len = code_size / sizeof(opcode_t);
caml_saved_code = (unsigned char *) caml_stat_alloc(len);
for (i = 0; i < len; i++) caml_saved_code[i] = caml_start_code[i];
}
#ifdef THREADED_CODE
caml_thread_code(caml_start_code, code_size);
#endif
/* Use the builtin table of primitives */
caml_build_primitive_table_builtin();
/* Load the globals */
caml_global_data = caml_input_value_from_block(data, data_size);
/* Ensure that the globals are in the major heap. */
caml_oldify_one (caml_global_data, &caml_global_data);
caml_oldify_mopup ();
/* Record the sections (for caml_get_section_table in meta.c) */
caml_section_table = section_table;
caml_section_table_size = section_table_size;
/* Initialize system libraries */
caml_init_exceptions();
caml_sys_init(exe_name, argv);
/* Execute the program */
caml_debugger(PROGRAM_START);
res = caml_interprete(caml_start_code, caml_code_size);
if (Is_exception_result(res)) {
caml_exn_bucket = Extract_exception(res);
if (caml_debugger_in_use) {
caml_extern_sp = &caml_exn_bucket; /* The debugger needs the
exception value.*/
caml_debugger(UNCAUGHT_EXC);
}
caml_fatal_uncaught_exception(caml_exn_bucket);
}
}
int main(int argc, char * argv[])
#endif
{
int fd;
struct exec_trailer trail;
int i;
struct longjmp_buffer raise_buf;
struct channel * chan;
int verbose_init = 0, percent_free_init = Percent_free_def;
long minor_heap_init = Minor_heap_def, heap_chunk_init = Heap_chunk_def;
char * debugger_address = NULL;
#ifdef MSDOS
extern char ** check_args();
argv = check_args(argv);
#endif
#ifdef DEBUG
verbose_init = 1;
#endif
#ifdef WIN32
BOOL fOk;
fOk = SetConsoleCtrlHandler(NULL, FALSE);
#endif
i = 0;
fd = attempt_open(&argv[0], &trail, 0);
if (fd < 0) {
for(i = 1; i < argc && argv[i][0] == '-'; i++) {
switch(argv[i][1]) {
#ifdef DEBUG
case 't': {
extern int trace_flag;
trace_flag = 1;
break;
}
#endif
case 'v':
verbose_init = 1;
break;
case 'V':
fprintf(stderr, "The Caml Light runtime system, version %s\n",
VERSION);
sys_exit(Val_int(0));
default:
fatal_error_arg("Unknown option %s.\n", argv[i]);
}
}
if (argv[i] == 0)
fatal_error("No bytecode file specified.\n");
fd = attempt_open(&argv[i], &trail, 1);
switch(fd) {
case FILE_NOT_FOUND:
fatal_error_arg("Fatal error: cannot find file %s\n", argv[i]);
break;
case TRUNCATED_FILE:
case BAD_MAGIC_NUM:
fatal_error_arg(
"Fatal error: the file %s is not a bytecode executable file\n",
argv[i]);
break;
}
}
/* Runtime options. The option letter is the first letter of the
last word of the ML name of the option (see [lib/gc.mli]). */
{ char *opt = getenv ("CAMLRUNPARAM");
if (opt != NULL){
while (*opt != '\0'){
switch (*opt++){
case 's': sscanf (opt, "=%ld", &minor_heap_init); break;
case 'i': sscanf (opt, "=%ld", &heap_chunk_init); break;
case 'o': sscanf (opt, "=%d", &percent_free_init); break;
case 'v': sscanf (opt, "=%d", &verbose_init); break;
}
}
}
}
#ifdef HAS_SOCKETS
if (debugger_address == NULL)
debugger_address = getenv("CAML_DEBUG_SOCKET");
#endif
if (setjmp(raise_buf.buf) == 0) {
external_raise = &raise_buf;
init_gc (minor_heap_init, heap_chunk_init, percent_free_init,
verbose_init);
init_stack();
init_atoms();
lseek(fd, - (long) (TRAILER_SIZE + trail.code_size + trail.data_size
+ trail.symbol_size + trail.debug_size), 2);
code_size = trail.code_size;
#if defined(DIRECT_JUMP) && defined(THREADED)
start_code = (bytecode_t) alloc_string(code_size);
#else
start_code = (bytecode_t) stat_alloc(code_size);
#endif
if (read(fd, (char *) start_code, code_size) != code_size)
fatal_error("Fatal error: truncated bytecode file.\n");
#if defined(MOSML_BIG_ENDIAN) && !defined(ALIGNMENT)
fixup_endianness(start_code, code_size);
#endif
chan = open_descr(fd);
global_data = intern_val(chan);
modify(&Field(global_data, GLOBAL_DATA), global_data);
close_in(chan);
sys_init(argv + i);
interprete(/* mode=init */ 0, NULL, 0, NULL);
interprete(/* mode=byte exec */ 1, start_code, code_size, NULL);
sys_exit(Val_int(0));
} else {
if (Field(exn_bucket, 0) == Field(global_data, SYS__EXN_MEMORY))
fatal_error ("Fatal error: out of memory.\n");
else {
char* buf = (char*)malloc(201);
char* exnmsg = exnmessage_aux(exn_bucket);
#if defined(__CYGWIN__) || defined(hpux)
sprintf(buf, "Uncaught exception:\n%s\n", exnmsg);
#elif defined(WIN32)
_snprintf(buf, 200, "Uncaught exception:\n%s\n", exnmsg);
#else
snprintf(buf, 200, "Uncaught exception:\n%s\n", exnmsg);
#endif
free(exnmsg);
fatal_error(buf);
}
}
return 0; /* Can't get here */
}
void WindowManager::init_internals(int argc, char* argv[])
{
DBG("starting window manager");
fl_open_display();
XSetErrorHandler(xerror_handler);
XShapeQueryExtension(fl_display, &XShapeEventBase, &XShapeErrorBase);
wm_area.set(0, 0/*22*/, Fl::w(), Fl::h()/*-22*/);
// TODO: make this part of class
program_name = fl_file_filename(argv[0]);
int i;
if(Fl::args(argc, argv, i, arg) < argc)
Fl::error("options are:\n"
" -d[isplay] host:#.#\tX display & screen to use\n"
" -v[isual] #\t\tvisual to use\n"
" -g[eometry] WxH+X+Y\tlimits windows to this area\n"
" -x\t\t\tmenu says Exit instead of logout\n"
" -bg color\t\tFrame color\n"
" -fg color\t\tLabel color\n"
" -bg2 color\t\tText field color\n"
" -cfg color\t\tCursor color\n"
" -cbg color\t\tCursor outline color" );
// Init started
is_init = false;
Fl::add_handler(wm_event_handler);
// intern atoms
init_atoms();
read_configuration();
read_xset_configuration();
// Set XID now
show();
set_default_cursor();
ICCCM::set_iconsizes(this);
MWM::set_motif_info(this);
register_protocols(fl_xid(this));
Grab_Hotkeys(this);
XSync(fl_display, 0);
init_desktops(this);
//Init done
is_init = true;
// find all the windows and create a Frame for each:
Frame *f=0;
unsigned int n;
Window w1, w2, *wins;
XWindowAttributes attr;
XQueryTree(fl_display, fl_xid(this), &w1, &w2, &wins, &n);
for (i = 0; i < (int)n; ++i)
{
XGetWindowAttributes(fl_display, wins[i], &attr);
if(attr.override_redirect) continue;
if(!attr.map_state)
{
if(getIntProperty(wins[i], _XA_WM_STATE, _XA_WM_STATE, 0) != IconicState)
continue;
}
f = new Frame(wins[i], &attr);
}
XFree((void *)wins);
// Activate last one
for(uint n=0; n<map_order.size(); n++)
{
Frame *f = map_order[n];
if(f->desktop()==Desktop::current())
{
f->activate();
f->raise();
break;
}
}
update_workarea(true);
is_running = true;
}
int
main(int argc, char *argv[])
{
int i;
char *displayname = NULL;
Bool all_screens = False;
Bool verbose = False;
xcb_connection_t *dpy;
const xcb_setup_t *setup;
int screen_number = 0;
int maxcmdlen = 10000;
ProgramName = argv[0];
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (arg[0] == '-') {
char *cp;
switch (arg[1]) {
case 'd': /* -display dpyname */
if (++i >= argc) usage ();
displayname = argv[i];
continue;
case 'm': /* -max maxcmdlen */
if (++i >= argc) usage ();
maxcmdlen = atoi (argv[i]);
continue;
}
for (cp = &arg[1]; *cp; cp++) {
switch (*cp) {
case 'a': /* -all */
all_screens = True;
continue;
case 'l': /* -long */
verbose = True;
continue;
default:
usage ();
}
}
} else {
usage ();
}
}
dpy = xcb_connect(displayname, &screen_number);
if (xcb_connection_has_error(dpy)) {
char *name = displayname;
if (!name)
name = getenv("DISPLAY");
if (!name)
name = "";
fprintf (stderr, "%s: unable to open display \"%s\"\r\n",
ProgramName, name);
exit (1);
}
init_atoms(dpy);
setup = xcb_get_setup(dpy);
if (all_screens) {
xcb_screen_iterator_t screen;
screen = xcb_setup_roots_iterator(setup);
do {
lookat(dpy, screen.data->root, verbose, maxcmdlen);
xcb_screen_next(&screen);
} while (screen.rem);
} else {
xcb_screen_iterator_t screen;
screen = xcb_setup_roots_iterator(setup);
for (i = 0; i < screen_number; i++)
xcb_screen_next(&screen);
lookat (dpy, screen.data->root, verbose, maxcmdlen);
}
run_queue();
xcb_disconnect(dpy);
exit (0);
}
Eterm
erts_instr_get_stat(Process *proc, Eterm what, int begin_max_period)
{
int i, len, max, min, allctr;
Eterm *names, *values, res;
Uint arr_size, stat_size, hsz, *hszp, *hp, **hpp;
Stat_t *stat_src, *stat;
if (!erts_instr_stat)
return am_false;
if (!atoms_initialized)
init_atoms();
if (what == am.total) {
min = 0;
max = 0;
allctr = 0;
stat_size = sizeof(Stat_t);
stat_src = &stats->tot;
if (!am_tot)
init_am_tot();
names = am_tot;
}
else if (what == am.allocators) {
min = ERTS_ALC_A_MIN;
max = ERTS_ALC_A_MAX;
allctr = 1;
stat_size = sizeof(Stat_t)*(ERTS_ALC_A_MAX+1);
stat_src = stats->a;
if (!am_a)
init_am_a();
names = am_a;
}
else if (what == am.classes) {
min = ERTS_ALC_C_MIN;
max = ERTS_ALC_C_MAX;
allctr = 0;
stat_size = sizeof(Stat_t)*(ERTS_ALC_C_MAX+1);
stat_src = stats->c;
if (!am_c)
init_am_c();
names = &am_c[ERTS_ALC_C_MIN];
}
else if (what == am.types) {
min = ERTS_ALC_N_MIN;
max = ERTS_ALC_N_MAX;
allctr = 0;
stat_size = sizeof(Stat_t)*(ERTS_ALC_N_MAX+1);
stat_src = stats->n;
if (!am_n)
init_am_n();
names = &am_n[ERTS_ALC_N_MIN];
}
else {
return THE_NON_VALUE;
}
stat = (Stat_t *) erts_alloc(ERTS_ALC_T_TMP, stat_size);
arr_size = (max - min + 1)*sizeof(Eterm);
if (allctr)
names = (Eterm *) erts_alloc(ERTS_ALC_T_TMP, arr_size);
values = (Eterm *) erts_alloc(ERTS_ALC_T_TMP, arr_size);
erts_mtx_lock(&instr_mutex);
update_max_ever_values(stat_src, min, max);
sys_memcpy((void *) stat, (void *) stat_src, stat_size);
if (begin_max_period)
begin_new_max_period(stat_src, min, max);
erts_mtx_unlock(&instr_mutex);
hsz = 0;
hszp = &hsz;
hpp = NULL;
restart_bld:
len = 0;
for (i = min; i <= max; i++) {
if (!allctr || erts_allctrs_info[i].enabled) {
Eterm s[2];
if (allctr)
names[len] = am_a[i];
s[0] = bld_tuple(hpp, hszp, 4,
am.sizes,
bld_uint(hpp, hszp, stat[i].size),
bld_uint(hpp, hszp, stat[i].max_size),
bld_uint(hpp, hszp, stat[i].max_size_ever));
s[1] = bld_tuple(hpp, hszp, 4,
am.blocks,
bld_uint(hpp, hszp, stat[i].blocks),
bld_uint(hpp, hszp, stat[i].max_blocks),
bld_uint(hpp, hszp, stat[i].max_blocks_ever));
values[len] = bld_list(hpp, hszp, 2, s);
len++;
}
}
res = bld_2tup_list(hpp, hszp, len, names, values);
if (!hpp) {
hp = HAlloc(proc, hsz);
hszp = NULL;
hpp = &hp;
goto restart_bld;
}
erts_free(ERTS_ALC_T_TMP, (void *) stat);
erts_free(ERTS_ALC_T_TMP, (void *) values);
if (allctr)
erts_free(ERTS_ALC_T_TMP, (void *) names);
return res;
}
CAMLexport void caml_main(char **argv)
{
/* int fd, pos; */
/* struct exec_trailer trail; */
/* struct channel * chan; */
value res;
/* char * shared_lib_path, * shared_libs, * req_prims; */
char * exe_name;
#ifdef __linux__
static char proc_self_exe[256];
#endif
/* Machine-dependent initialization of the floating-point hardware
so that it behaves as much as possible as specified in IEEE */
caml_init_ieee_floats();
caml_init_custom_operations();
/* caml_ext_table_init(&caml_shared_libs_path, 8); */
caml_external_raise = NULL;
/* Determine options and position of bytecode file */
#ifdef DEBUG
caml_verb_gc = 0xBF;
#endif
parse_camlrunparam();
/* pos = 0; */
exe_name = argv[0];
#ifdef __linux__
if (caml_executable_name(proc_self_exe, sizeof(proc_self_exe)) == 0)
exe_name = proc_self_exe;
#endif
/* fd = caml_attempt_open(&exe_name, &trail, 0); */
/* if (fd < 0) { */
/* pos = parse_command_line(argv); */
/* if (argv[pos] == 0) */
/* caml_fatal_error("No bytecode file specified.\n"); */
/* exe_name = argv[pos]; */
/* fd = caml_attempt_open(&exe_name, &trail, 1); */
/* switch(fd) { */
/* case FILE_NOT_FOUND: */
/* caml_fatal_error_arg("Fatal error: cannot find file '%s'\n", argv[pos]); */
/* break; */
/* case BAD_BYTECODE: */
/* caml_fatal_error_arg( */
/* "Fatal error: the file '%s' is not a bytecode executable file\n", */
/* exe_name); */
/* break; */
/* } */
/* } */
/* Read the table of contents (section descriptors) */
/* caml_read_section_descriptors(fd, &trail); */
/* Initialize the abstract machine */
caml_init_gc (minor_heap_init, heap_size_init, heap_chunk_init,
percent_free_init, max_percent_free_init);
caml_init_stack (max_stack_init);
init_atoms();
/* Initialize the interpreter */
/* caml_interprete(NULL, 0); */
/* Initialize the debugger, if needed */
caml_debugger_init();
/* Load the code */
/* caml_code_size = caml_seek_section(fd, &trail, "CODE"); */
/* caml_load_code(fd, caml_code_size); */
/* Build the table of primitives */
/* shared_lib_path = read_section(fd, &trail, "DLPT"); */
/* shared_libs = read_section(fd, &trail, "DLLS"); */
/* req_prims = read_section(fd, &trail, "PRIM"); */
/* if (req_prims == NULL) caml_fatal_error("Fatal error: no PRIM section\n"); */
/* caml_build_primitive_table(shared_lib_path, shared_libs, req_prims); */
/* caml_stat_free(shared_lib_path); */
/* caml_stat_free(shared_libs); */
/* caml_stat_free(req_prims); */
/* Load the globals */
/* caml_seek_section(fd, &trail, "DATA"); */
/* chan = caml_open_descriptor_in(fd); */
/* caml_global_data = caml_input_val(chan); */
caml_global_data =
caml_input_value_from_block((char *) ocamlcc_global_data,
OCAMLCC_GLOBAL_DATA_LENGTH);
/* caml_close_channel(chan); /\* this also closes fd *\/ */
/* caml_stat_free(trail.section); */
/* Ensure that the globals are in the major heap. */
caml_oldify_one (caml_global_data, &caml_global_data);
caml_oldify_mopup ();
/* Initialize system libraries */
caml_init_exceptions();
/* caml_sys_init(exe_name, argv + pos); */
caml_sys_init(exe_name, argv);
#ifdef _WIN32
/* Start a thread to handle signals */
if (getenv("CAMLSIGPIPE"))
_beginthread(caml_signal_thread, 4096, NULL);
#endif
/* Execute the program */
caml_debugger(PROGRAM_START);
/* res = caml_interprete(caml_start_code, caml_code_size); */
res = ocamlcc_main();
if (Is_exception_result(res)) {
caml_exn_bucket = Extract_exception(res);
if (caml_debugger_in_use) {
caml_extern_sp = &caml_exn_bucket; /* The debugger needs the
exception value.*/
caml_debugger(UNCAUGHT_EXC);
}
caml_fatal_uncaught_exception(caml_exn_bucket);
/*
fprintf(stderr, "Fatal error!\n");
exit(2);
*/
}
}
int
main(int argc, char *argv[]) {
char *wmiirc;
WMScreen *s;
WinAttr wa;
int i;
fmtinstall('r', errfmt);
fmtinstall('C', Cfmt);
wmiirc = "wmiistartrc";
ARGBEGIN{
case 'v':
print("%s", version);
exit(0);
case 'V':
verbose = True;
break;
case 'a':
address = EARGF(usage());
break;
case 'r':
wmiirc = EARGF(usage());
break;
default:
usage();
break;
}ARGEND;
if(argc)
usage();
setlocale(LC_CTYPE, "");
starting = True;
initdisplay();
xlib_errorhandler = XSetErrorHandler(errorhandler);
check_other_wm = True;
XSelectInput(display, scr.root.w,
SubstructureRedirectMask
| EnterWindowMask);
XSync(display, False);
check_other_wm = False;
passwd = getpwuid(getuid());
user = estrdup(passwd->pw_name);
init_environment();
sock = ixp_announce(address);
if(sock < 0)
fatal("Can't create socket '%s': %r", address);
if(wmiirc)
spawn_command(wmiirc);
init_traps();
init_atoms();
init_cursors();
init_lock_keys();
srv.preselect = check_preselect;
ixp_listen(&srv, sock, &p9srv, serve_9pcon, nil);
ixp_listen(&srv, ConnectionNumber(display), nil, check_x_event, closedisplay);
def.font = loadfont(FONT);
def.border = 1;
def.colmode = Coldefault;
def.mod = Mod1Mask;
strcpy(def.grabmod, "Mod1");
loadcolor(&def.focuscolor, FOCUSCOLORS);
loadcolor(&def.normcolor, NORMCOLORS);
num_screens = 1;
screens = emallocz(num_screens * sizeof(*screens));
screen = &screens[0];
for(i = 0; i < num_screens; i++) {
s = &screens[i];
init_screen(s);
s->ibuf = allocimage(Dx(s->r), Dy(s->r), scr.depth);
wa.event_mask =
SubstructureRedirectMask
| SubstructureNotifyMask
| EnterWindowMask
| LeaveWindowMask
| FocusChangeMask;
wa.cursor = cursor[CurNormal];
setwinattr(&scr.root, &wa,
CWEventMask
| CWCursor);
initbar(s);
}
screen->focus = nil;
setfocus(screen->barwin, RevertToParent);
scan_wins();
starting = False;
select_view("nil");
update_views();
write_event("FocusTag %s\n", screen->sel->name);
check_x_event(nil);
i = ixp_serverloop(&srv);
if(i)
fprint(2, "%s: error: %r\n", argv0);
cleanup();
if(exitsignal)
raise(exitsignal);
if(execstr)
execl("/bin/sh", "sh", "-c", execstr, nil);
return i;
}
