/** * 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; }