static const GPtrArray * tm_workspace_find_namespace_members (const GPtrArray * file_tags, const char *name, gboolean search_global) { static GPtrArray *tags = NULL; GPtrArray *local = NULL; char *new_name = (char *) name; char *filename = NULL; int found = 0, del = 0; static langType langJava = -1; TMTag *tag = NULL; g_return_val_if_fail (name && name[0] != '\0', NULL); if (!tags) tags = g_ptr_array_new (); while (1) { const GPtrArray *tags2; guint got = 0; TMTagType types = (tm_tag_class_t tm_tag_struct_t | tm_tag_typedef_t | tm_tag_union_t | tm_tag_enum_t); if (file_tags) { g_ptr_array_set_size (tags, 0); got = fill_find_tags_array (tags, file_tags, new_name, NULL, types, FALSE, -1, FALSE); } if (got) { tags2 = tags; } else { TMTagAttrType attrs[] = { tm_tag_attr_name_t, tm_tag_attr_type_t, tm_tag_attr_none_t }; tags2 = tm_workspace_find (new_name, types, attrs, FALSE, -1); } if ((tags2) && (tags2->len == 1) && (tag = TM_TAG (tags2->pdata[0]))) { if (tag->type == tm_tag_typedef_t && tag->var_type && tag->var_type[0] != '\0') { new_name = tag->var_type; continue; } filename = (tag->file ? tag->file->short_name : NULL); if (tag->scope && tag->scope[0] != '\0') { del = 1; if (tag->file && tag->file->lang == langJava) { new_name = g_strdup_printf ("%s.%s", tag->scope, new_name); } else { new_name = g_strdup_printf ("%s::%s", tag->scope, new_name); } } break; } else { return NULL; } } g_ptr_array_set_size (tags, 0); if (tag && tag->file) { local = tm_tags_extract (tag->file->tags_array, (tm_tag_function_t | tm_tag_field_t | tm_tag_enumerator_t | tm_tag_namespace_t | tm_tag_class_t )); } else { local = tm_tags_extract (theWorkspace->tags_array, (tm_tag_function_t | tm_tag_prototype_t | tm_tag_member_t | tm_tag_field_t | tm_tag_enumerator_t | tm_tag_namespace_t | tm_tag_class_t )); } if (local) { found = find_namespace_members_tags (local, tags, langJava, new_name, filename); g_ptr_array_free (local, TRUE); } if (!found && search_global) { GPtrArray *global = tm_tags_extract (theWorkspace->global_tags, (tm_tag_member_t | tm_tag_prototype_t | tm_tag_field_t | tm_tag_method_t | tm_tag_function_t | tm_tag_enumerator_t | tm_tag_namespace_t | tm_tag_class_t )); if (global) { find_namespace_members_tags (global, tags, langJava, new_name, filename); /*/ DEBUG_PRINT ("returning these"); gint i; for (i=0; i < tags->len; i++) { TMTag *cur_tag; cur_tag = (TMTag*)g_ptr_array_index (tags, i); tm_tag_print (cur_tag, stdout ); } /*/ g_ptr_array_free (global, TRUE); } } if (del) { g_free (new_name); } return tags; }
void mono_ppdb_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points) { MonoPPDBFile *ppdb = minfo->handle->ppdb; MonoImage *image = ppdb->image; MonoMethod *method = minfo->method; MonoTableInfo *tables = image->tables; guint32 cols [MONO_METHODBODY_SIZE]; const char *ptr; const char *end; MonoDebugSourceInfo *docinfo; int i, method_idx, size, docidx, iloffset, delta_il, delta_lines, delta_cols, start_line, start_col, adv_line, adv_col; gboolean first = TRUE, first_non_hidden = TRUE; GArray *sps; MonoSymSeqPoint sp; GPtrArray *sfiles = NULL; GPtrArray *sindexes = NULL; if (source_file) *source_file = NULL; if (source_file_list) *source_file_list = NULL; if (source_files) *source_files = NULL; if (seq_points) *seq_points = NULL; if (n_seq_points) *n_seq_points = 0; if (source_file_list) *source_file_list = sfiles = g_ptr_array_new (); if (source_files) sindexes = g_ptr_array_new (); if (!method->token) return; method_idx = mono_metadata_token_index (method->token); mono_metadata_decode_row (&tables [MONO_TABLE_METHODBODY], method_idx-1, cols, MONO_METHODBODY_SIZE); docidx = cols [MONO_METHODBODY_DOCUMENT]; if (!cols [MONO_METHODBODY_SEQ_POINTS]) return; ptr = mono_metadata_blob_heap (image, cols [MONO_METHODBODY_SEQ_POINTS]); size = mono_metadata_decode_blob_size (ptr, &ptr); end = ptr + size; sps = g_array_new (FALSE, TRUE, sizeof (MonoSymSeqPoint)); /* Header */ /* LocalSignature */ mono_metadata_decode_value (ptr, &ptr); if (docidx == 0) docidx = mono_metadata_decode_value (ptr, &ptr); docinfo = get_docinfo (ppdb, image, docidx); if (sfiles) g_ptr_array_add (sfiles, docinfo); iloffset = 0; start_line = 0; start_col = 0; while (ptr < end) { delta_il = mono_metadata_decode_value (ptr, &ptr); if (!first && delta_il == 0) { /* subsequent-document-record */ docidx = mono_metadata_decode_value (ptr, &ptr); docinfo = get_docinfo (ppdb, image, docidx); if (sfiles) g_ptr_array_add (sfiles, docinfo); continue; } iloffset += delta_il; first = FALSE; delta_lines = mono_metadata_decode_value (ptr, &ptr); if (delta_lines == 0) delta_cols = mono_metadata_decode_value (ptr, &ptr); else delta_cols = mono_metadata_decode_signed_value (ptr, &ptr); if (delta_lines == 0 && delta_cols == 0) { /* Hidden sequence point */ continue; } if (first_non_hidden) { start_line = mono_metadata_decode_value (ptr, &ptr); start_col = mono_metadata_decode_value (ptr, &ptr); } else { adv_line = mono_metadata_decode_signed_value (ptr, &ptr); adv_col = mono_metadata_decode_signed_value (ptr, &ptr); start_line += adv_line; start_col += adv_col; } first_non_hidden = FALSE; memset (&sp, 0, sizeof (sp)); sp.il_offset = iloffset; sp.line = start_line; sp.column = start_col; sp.end_line = start_line + delta_lines; sp.end_column = start_col + delta_cols; g_array_append_val (sps, sp); if (source_files) g_ptr_array_add (sindexes, GUINT_TO_POINTER (sfiles->len - 1)); } if (n_seq_points) { *n_seq_points = sps->len; g_assert (seq_points); *seq_points = g_new (MonoSymSeqPoint, sps->len); memcpy (*seq_points, sps->data, sps->len * sizeof (MonoSymSeqPoint)); } if (source_file) *source_file = g_strdup (((MonoDebugSourceInfo*)g_ptr_array_index (sfiles, 0))->source_file); if (source_files) { *source_files = g_new (int, sps->len); for (i = 0; i < sps->len; ++i) (*source_files)[i] = GPOINTER_TO_INT (g_ptr_array_index (sindexes, i)); g_ptr_array_free (sindexes, TRUE); } g_array_free (sps, TRUE); }
/* * mono_debug_symfile_get_line_numbers_full: * * On return, SOURCE_FILE_LIST will point to a GPtrArray of MonoDebugSourceFile * structures, and SOURCE_FILES will contain indexes into this array. * The MonoDebugSourceFile structures are owned by this module. */ void mono_debug_symfile_get_line_numbers_full (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int *n_il_offsets, int **il_offsets, int **line_numbers, int **column_numbers, int **source_files) { // FIXME: Unify this with mono_debug_symfile_lookup_location MonoSymbolFile *symfile; const unsigned char *ptr; StatementMachine stm; uint32_t i; GPtrArray *il_offset_array, *line_number_array, *source_file_array; gboolean has_column_info; if (source_file_list) *source_file_list = NULL; if (n_il_offsets) *n_il_offsets = 0; if (source_files) *source_files = NULL; if (source_file) *source_file = NULL; if (column_numbers) *column_numbers = NULL; if ((symfile = minfo->handle->symfile) == NULL) return; has_column_info = method_has_column_info (minfo); il_offset_array = g_ptr_array_new (); line_number_array = g_ptr_array_new (); source_file_array = g_ptr_array_new (); stm.line_base = read32 (&symfile->offset_table->_line_number_table_line_base); stm.line_range = read32 (&symfile->offset_table->_line_number_table_line_range); stm.opcode_base = (uint8_t) read32 (&symfile->offset_table->_line_number_table_opcode_base); stm.max_address_incr = (255 - stm.opcode_base) / stm.line_range; mono_debugger_lock (); ptr = symfile->raw_contents + minfo->lnt_offset; stm.symfile = symfile; stm.offset = stm.last_offset = 0; stm.last_file = 0; stm.last_line = 0; stm.first_file = 0; stm.file = 1; stm.line = 1; stm.is_hidden = FALSE; while (TRUE) { uint8_t opcode = *ptr++; if (opcode == 0) { uint8_t size = *ptr++; const unsigned char *end_ptr = ptr + size; opcode = *ptr++; if (opcode == DW_LNE_end_sequence) { if (il_offset_array->len == 0) /* Empty table */ break; add_line (&stm, il_offset_array, line_number_array, source_file_array); break; } else if (opcode == DW_LNE_MONO_negate_is_hidden) { stm.is_hidden = !stm.is_hidden; } else if ((opcode >= DW_LNE_MONO__extensions_start) && (opcode <= DW_LNE_MONO__extensions_end)) { ; // reserved for future extensions } else { g_warning ("Unknown extended opcode %x in LNT", opcode); } ptr = end_ptr; continue; } else if (opcode < stm.opcode_base) { switch (opcode) { case DW_LNS_copy: add_line (&stm, il_offset_array, line_number_array, source_file_array); break; case DW_LNS_advance_pc: stm.offset += read_leb128 (ptr, &ptr); break; case DW_LNS_advance_line: stm.line += read_leb128 (ptr, &ptr); break; case DW_LNS_set_file: stm.file = read_leb128 (ptr, &ptr); break; case DW_LNS_const_add_pc: stm.offset += stm.max_address_incr; break; default: g_warning ("Unknown standard opcode %x in LNT", opcode); g_assert_not_reached (); } } else { opcode -= stm.opcode_base; stm.offset += opcode / stm.line_range; stm.line += stm.line_base + (opcode % stm.line_range); add_line (&stm, il_offset_array, line_number_array, source_file_array); } } if (!stm.file && stm.first_file) stm.file = stm.first_file; if (stm.file && source_file) { int offset = read32(&(stm.symfile->offset_table->_source_table_offset)) + (stm.file - 1) * sizeof (MonoSymbolFileSourceEntry); MonoSymbolFileSourceEntry *se = (MonoSymbolFileSourceEntry *) (stm.symfile->raw_contents + offset); if (source_file) *source_file = read_string (stm.symfile->raw_contents + read32(&(se->_data_offset)), NULL); } if (source_file_list) { int file, last_file = 0; *source_file_list = g_ptr_array_new (); if (source_files) *source_files = g_malloc (il_offset_array->len * sizeof (int)); for (i = 0; i < il_offset_array->len; ++i) { file = GPOINTER_TO_UINT (g_ptr_array_index (source_file_array, i)); if (file && file != last_file) { MonoDebugSourceInfo *info = get_source_info (symfile, file); g_ptr_array_add (*source_file_list, info); } last_file = file; if (source_files) (*source_files) [i] = (*source_file_list)->len - 1; } if ((*source_file_list)->len == 0 && stm.file) { MonoDebugSourceInfo *info = get_source_info (symfile, stm.file); g_ptr_array_add (*source_file_list, info); } } if (n_il_offsets) *n_il_offsets = il_offset_array->len; if (il_offsets && line_numbers) { *il_offsets = g_malloc (il_offset_array->len * sizeof (int)); *line_numbers = g_malloc (il_offset_array->len * sizeof (int)); for (i = 0; i < il_offset_array->len; ++i) { (*il_offsets) [i] = GPOINTER_TO_UINT (g_ptr_array_index (il_offset_array, i)); (*line_numbers) [i] = GPOINTER_TO_UINT (g_ptr_array_index (line_number_array, i)); } } if (column_numbers && has_column_info) { *column_numbers = g_malloc (il_offset_array->len * sizeof (int)); for (i = 0; i < il_offset_array->len; ++i) (*column_numbers) [i] = read_leb128 (ptr, &ptr); } g_ptr_array_free (il_offset_array, TRUE); g_ptr_array_free (line_number_array, TRUE); mono_debugger_unlock (); return; }
static gboolean ToolsCoreLoadDirectory(ToolsAppCtx *ctx, const gchar *pluginPath, GPtrArray *regs) { gboolean ret = FALSE; const gchar *staticEntry; guint i; GDir *dir = NULL; GError *err = NULL; GPtrArray *plugins; dir = g_dir_open(pluginPath, 0, &err); if (dir == NULL) { g_warning("Error opening dir: %s\n", err->message); goto exit; } plugins = g_ptr_array_new(); /* * Load plugins in alphabetical order, so the load order is the same * regardless of how the filesystem returns entries. */ while ((staticEntry = g_dir_read_name(dir)) != NULL) { if (g_str_has_suffix(staticEntry, "." G_MODULE_SUFFIX)) { g_ptr_array_add(plugins, g_strdup(staticEntry)); } } g_dir_close(dir); g_ptr_array_sort(plugins, ToolsCoreStrPtrCompare); for (i = 0; i < plugins->len; i++) { gchar *entry; gchar *path; GModule *module = NULL; ToolsPlugin *plugin = NULL; ToolsPluginOnLoad onload; entry = g_ptr_array_index(plugins, i); path = g_strdup_printf("%s%c%s", pluginPath, DIRSEPC, entry); if (!g_file_test(path, G_FILE_TEST_IS_REGULAR)) { g_warning("File '%s' is not a regular file, skipping.\n", entry); goto next; } #ifdef USE_APPLOADER /* Trying loading the plugins with system libraries */ if (!LoadDependencies(path, FALSE)) { g_warning("Loading of library dependencies for %s failed.\n", entry); goto next; } #endif module = g_module_open(path, G_MODULE_BIND_LOCAL); #ifdef USE_APPLOADER if (module == NULL) { /* Falling back to the shipped libraries */ if (!LoadDependencies(path, TRUE)) { g_warning("Loading of shipped library dependencies for %s failed.\n", entry); goto next; } module = g_module_open(path, G_MODULE_BIND_LOCAL); } #endif if (module == NULL) { g_warning("Opening plugin '%s' failed: %s.\n", entry, g_module_error()); goto next; } if (!g_module_symbol(module, "ToolsOnLoad", (gpointer *) &onload)) { g_warning("Lookup of plugin entry point for '%s' failed.\n", entry); goto next; } plugin = g_malloc(sizeof *plugin); plugin->fileName = entry; plugin->data = NULL; plugin->module = module; plugin->onload = onload; g_ptr_array_add(regs, plugin); next: g_free(path); if (plugin == NULL && module != NULL) { if (!g_module_close(module)) { g_warning("Error unloading plugin '%s': %s\n", entry, g_module_error()); } } } g_ptr_array_free(plugins, TRUE); ret = TRUE; exit: return ret; }
lcm_t * lcm_create (const char *url) { if (!g_thread_supported ()) g_thread_init (NULL); #ifdef WIN32 WSADATA wsd; int status = WSAStartup ( MAKEWORD ( 2, 0 ), &wsd ); if ( status ) { return NULL; } #endif char * provider_str = NULL; char * network = NULL; GHashTable * args = g_hash_table_new_full (g_str_hash, g_str_equal, free, free); GPtrArray * providers = g_ptr_array_new (); lcm_t *lcm = NULL; // initialize the list of providers lcm_udpm_provider_init (providers); lcm_logprov_provider_init (providers); lcm_tcpq_provider_init (providers); if (providers->len == 0) { fprintf (stderr, "Error: no LCM providers found\n"); goto fail; } if (!url || !strlen(url)) url = getenv ("LCM_DEFAULT_URL"); if (!url || !strlen(url)) url = LCM_DEFAULT_URL; if (0 != lcm_parse_url (url, &provider_str, &network, args)) { fprintf (stderr, "%s:%d -- invalid URL [%s]\n", __FILE__, __LINE__, url); goto fail; } lcm_provider_info_t * info = NULL; /* Find a matching provider */ for (unsigned int i = 0; i < providers->len; i++) { lcm_provider_info_t * pinfo = (lcm_provider_info_t *) g_ptr_array_index (providers, i); if (!strcmp (pinfo->name, provider_str)) { info = pinfo; break; } } if (!info) { fprintf (stderr, "Error: LCM provider \"%s\" not found\n", provider_str); g_ptr_array_free (providers, TRUE); free (provider_str); free (network); g_hash_table_destroy (args); return NULL; } lcm = (lcm_t *) calloc (1, sizeof (lcm_t)); lcm->vtable = info->vtable; lcm->handlers_all = g_ptr_array_new(); lcm->handlers_map = g_hash_table_new (g_str_hash, g_str_equal); g_static_rec_mutex_init (&lcm->mutex); g_static_rec_mutex_init (&lcm->handle_mutex); lcm->provider = info->vtable->create (lcm, network, args); lcm->in_handle = 0; free (provider_str); free (network); g_ptr_array_free (providers, TRUE); g_hash_table_destroy (args); if (!lcm->provider) { lcm_destroy (lcm); return NULL; } lcm->default_max_num_queued_messages = 30; return lcm; fail: free (provider_str); free (network); if (args) g_hash_table_destroy (args); if (providers) g_ptr_array_free (providers, TRUE); // if (lcm) // lcm_destroy (lcm); return NULL; }
static void rspamd_archive_process_rar (struct rspamd_task *task, struct rspamd_mime_part *part) { const guchar *p, *end, *section_start; const guchar rar_v5_magic[] = {0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01, 0x00}, rar_v4_magic[] = {0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00}; const guint rar_encrypted_header = 4, rar_main_header = 1, rar_file_header = 2; guint64 vint, sz, comp_sz = 0, uncomp_sz = 0, flags = 0, type = 0; struct rspamd_archive *arch; struct rspamd_archive_file *f; gint r; p = part->parsed_data.begin; end = p + part->parsed_data.len; if ((gsize)(end - p) <= sizeof (rar_v5_magic)) { msg_debug_task ("rar archive is invalid (too small)"); return; } if (memcmp (p, rar_v5_magic, sizeof (rar_v5_magic)) == 0) { p += sizeof (rar_v5_magic); } else if (memcmp (p, rar_v4_magic, sizeof (rar_v4_magic)) == 0) { p += sizeof (rar_v4_magic); rspamd_archive_process_rar_v4 (task, p, end, part); return; } else { msg_debug_task ("rar archive is invalid (no rar magic)"); return; } /* Rar v5 format */ arch = rspamd_mempool_alloc0 (task->task_pool, sizeof (*arch)); arch->files = g_ptr_array_new (); arch->type = RSPAMD_ARCHIVE_RAR; rspamd_mempool_add_destructor (task->task_pool, rspamd_archive_dtor, arch); /* Now we can have either encryption header or archive header */ /* Crc 32 */ RAR_SKIP_BYTES (sizeof (guint32)); /* Size */ RAR_READ_VINT_SKIP (); sz = vint; /* Type */ section_start = p; RAR_READ_VINT_SKIP (); type = vint; /* Header flags */ RAR_READ_VINT_SKIP (); flags = vint; if (flags & 0x1) { /* Have extra zone */ RAR_READ_VINT_SKIP (); } if (flags & 0x2) { /* Data zone is presented */ RAR_READ_VINT_SKIP (); sz += vint; } if (type == rar_encrypted_header) { /* We can't read any further information as archive is encrypted */ arch->flags |= RSPAMD_ARCHIVE_ENCRYPTED; goto end; } else if (type != rar_main_header) { msg_debug_task ("rar archive is invalid (bad main header)"); return; } /* Nothing useful in main header */ p = section_start; RAR_SKIP_BYTES (sz); while (p < end) { /* Read the next header */ /* Crc 32 */ RAR_SKIP_BYTES (sizeof (guint32)); /* Size */ RAR_READ_VINT_SKIP (); sz = vint; if (sz == 0) { /* Zero sized block - error */ msg_debug_task ("rar archive is invalid (zero size block)"); return; } section_start = p; /* Type */ RAR_READ_VINT_SKIP (); type = vint; /* Header flags */ RAR_READ_VINT_SKIP (); flags = vint; if (flags & 0x1) { /* Have extra zone */ RAR_READ_VINT_SKIP (); } if (flags & 0x2) { /* Data zone is presented */ RAR_READ_VINT_SKIP (); sz += vint; comp_sz = vint; } if (type != rar_file_header) { p = section_start; RAR_SKIP_BYTES (sz); } else { /* We have a file header, go forward */ guint64 fname_len; /* File header specific flags */ RAR_READ_VINT_SKIP (); flags = vint; /* Unpacked size */ RAR_READ_VINT_SKIP (); uncomp_sz = vint; /* Attributes */ RAR_READ_VINT_SKIP (); if (flags & 0x2) { /* Unix mtime */ RAR_SKIP_BYTES (sizeof (guint32)); } if (flags & 0x4) { /* Crc32 */ RAR_SKIP_BYTES (sizeof (guint32)); } /* Compression */ RAR_READ_VINT_SKIP (); /* Host OS */ RAR_READ_VINT_SKIP (); /* Filename length (finally!) */ RAR_READ_VINT_SKIP (); fname_len = vint; if (fname_len == 0 || fname_len > (gsize)(end - p)) { msg_debug_task ("rar archive is invalid (bad fileame size)"); return; } f = g_slice_alloc0 (sizeof (*f)); f->uncompressed_size = uncomp_sz; f->compressed_size = comp_sz; f->fname = g_string_new_len (p, fname_len); g_ptr_array_add (arch->files, f); /* Restore p to the beginning of the header */ p = section_start; RAR_SKIP_BYTES (sz); } } end: part->flags |= RSPAMD_MIME_PART_ARCHIVE; part->specific.arch = arch; if (part->cd != NULL) { arch->archive_name = &part->cd->filename; } arch->size = part->parsed_data.len; }
/*! * \brief Draw a string to _Textobj * To get objects more similar to what we had during export we * should probably use TextOutputDev. It reassembles strings * based on their position on the page. Or maybe Dia/cairo should * stop realigning single glyphs in it's output? * \todo Check alignment options - it's just guessed yet. */ void DiaOutputDev::drawString(GfxState *state, GooString *s) { Color text_color = this->fill_color; int len = s->getLength(); DiaObject *obj; gchar *utf8 = NULL; DiaFont *font; // ignore empty strings if (len == 0) return; // get the font if (!state->getFont()) return; if (!(state->getFontSize() > 0.0)) return; font = (DiaFont *)g_hash_table_lookup (this->font_map, state->getFont()); // we have to decode the string data first { GfxFont *f = state->getFont(); char *p = s->getCString(); CharCode code; int j = 0, m, n; utf8 = g_new (gchar, len * 6 + 1); Unicode *u; int uLen; double dx, dy, ox, oy; while (len > 0) { n = f->getNextChar(p, len, &code, &u, &uLen, &dx, &dy, &ox, &oy); p += n; len -= n; m = g_unichar_to_utf8 (u[0], &utf8[j]); j += m; } utf8[j] = '\0'; } // check for invisible text -- this is used by Acrobat Capture if (state->getRender() == 3) text_color.alpha = 0.0; double *mat = state->getTextMat(); double tx = state->getCurX(); double ty = state->getCurY(); obj = create_standard_text (tx * scale, page_height - ty * scale); //not applyStyle (obj, TEXT); GPtrArray *plist = g_ptr_array_new (); // the "text" property is special, it must be initialized with text // attributes, too. So here it comes first to avoid overwriting // the other values with defaults. prop_list_add_text (plist, "text", utf8); prop_list_add_font (plist, "text_font", font); prop_list_add_text_colour (plist, &text_color); prop_list_add_enum (plist, "text_alignment", this->alignment); if (mat[3] > 0.0) prop_list_add_fontsize (plist, "text_height", state->getFontSize() * mat[3] * scale / 0.8); else prop_list_add_fontsize (plist, "text_height", state->getFontSize() / 0.8); obj->ops->set_props (obj, plist); prop_list_free (plist); g_free (utf8); addObject (obj); }
/** * asb_task_init: **/ static void asb_task_init (AsbTask *task) { AsbTaskPrivate *priv = GET_PRIVATE (task); priv->plugins_to_run = g_ptr_array_new (); }
static gboolean output_initialize (GnomeRROutput *output, XRRScreenResources *res, GError **error) { XRROutputInfo *info = XRRGetOutputInfo ( DISPLAY (output), res, output->id); GPtrArray *a; int i; #if 0 g_print ("Output %lx Timestamp: %u\n", output->id, (guint32)info->timestamp); #endif if (!info || !output->info) { /* FIXME: see the comment in crtc_initialize() */ /* Translators: here, an "output" is a video output */ g_set_error (error, GNOME_RR_ERROR, GNOME_RR_ERROR_RANDR_ERROR, _("could not get information about output %d"), (int) output->id); return FALSE; } output->name = g_strdup (info->name); /* FIXME: what is nameLen used for? */ output->current_crtc = crtc_by_id (output->info, info->crtc); output->width_mm = info->mm_width; output->height_mm = info->mm_height; output->connected = (info->connection == RR_Connected); output->connector_type = get_connector_type_string (output); /* Possible crtcs */ a = g_ptr_array_new (); for (i = 0; i < info->ncrtc; ++i) { GnomeRRCrtc *crtc = crtc_by_id (output->info, info->crtcs[i]); if (crtc) g_ptr_array_add (a, crtc); } g_ptr_array_add (a, NULL); output->possible_crtcs = (GnomeRRCrtc **)g_ptr_array_free (a, FALSE); /* Clones */ a = g_ptr_array_new (); for (i = 0; i < info->nclone; ++i) { GnomeRROutput *gnome_rr_output = gnome_rr_output_by_id (output->info, info->clones[i]); if (gnome_rr_output) g_ptr_array_add (a, gnome_rr_output); } g_ptr_array_add (a, NULL); output->clones = (GnomeRROutput **)g_ptr_array_free (a, FALSE); /* Modes */ a = g_ptr_array_new (); for (i = 0; i < info->nmode; ++i) { GnomeRRMode *mode = mode_by_id (output->info, info->modes[i]); if (mode) g_ptr_array_add (a, mode); } g_ptr_array_add (a, NULL); output->modes = (GnomeRRMode **)g_ptr_array_free (a, FALSE); output->n_preferred = info->npreferred; /* Edid data */ output->edid_data = read_edid_data (output); XRRFreeOutputInfo (info); return TRUE; }
/* Returns all matching members tags found in given struct/union/class name. @param name Name of the struct/union/class. @param file_tags A GPtrArray of edited file TMTag pointers (for search speedup, can be NULL). @return A GPtrArray of TMTag pointers to struct/union/class members */ const GPtrArray * tm_workspace_find_scope_members (const GPtrArray * file_tags, const char *name, gboolean search_global, gboolean no_definitions) { static GPtrArray *tags = NULL; GPtrArray *local = NULL; char *new_name = (char *) name; char *filename = NULL; int found = 0, del = 0; static langType langJava = -1; TMTag *tag = NULL; /* FIXME */ /* langJava = getNamedLanguage ("Java"); */ g_return_val_if_fail ((theWorkspace && name && name[0] != '\0'), NULL); if (!tags) tags = g_ptr_array_new (); while (1) { const GPtrArray *tags2; guint got = 0; TMTagType types = (tm_tag_class_t | tm_tag_namespace_t | tm_tag_struct_t | tm_tag_typedef_t | tm_tag_union_t | tm_tag_enum_t); if (file_tags) { g_ptr_array_set_size (tags, 0); got = fill_find_tags_array (tags, file_tags, new_name, NULL, types, FALSE, -1, FALSE); } if (got) { tags2 = tags; } else { TMTagAttrType attrs[] = { tm_tag_attr_name_t, tm_tag_attr_type_t, tm_tag_attr_none_t }; tags2 = tm_workspace_find (new_name, types, attrs, FALSE, -1); } if ((tags2) && (tags2->len == 1) && (tag = TM_TAG (tags2->pdata[0]))) { if (tag->type == tm_tag_typedef_t && tag->var_type && tag->var_type[0] != '\0') { char *tmp_name; tmp_name = tag->var_type; if (strcmp(tmp_name, new_name) == 0) { new_name = NULL; } else { new_name = tmp_name; } continue; } filename = (tag->file ? tag->file->short_name : NULL); if (tag->scope && tag->scope[0] != '\0') { del = 1; if (tag->file && tag->file->lang == langJava) { new_name = g_strdup_printf ("%s.%s", tag->scope, new_name); } else { new_name = g_strdup_printf ("%s::%s", tag->scope, new_name); } } break; } else { return NULL; } } g_ptr_array_set_size (tags, 0); if (no_definitions && tag && tag->file) { local = tm_tags_extract (tag->file->tags_array, (tm_tag_function_t | tm_tag_prototype_t | tm_tag_member_t | tm_tag_field_t | tm_tag_method_t | tm_tag_enumerator_t)); } else { local = tm_tags_extract (theWorkspace->tags_array, (tm_tag_function_t | tm_tag_prototype_t | tm_tag_member_t | tm_tag_field_t | tm_tag_method_t | tm_tag_enumerator_t)); } if (local) { found = find_scope_members_tags (local, tags, langJava, new_name, filename, no_definitions); g_ptr_array_free (local, TRUE); } if (!found && search_global) { GPtrArray *global = tm_tags_extract (theWorkspace->global_tags, (tm_tag_member_t | tm_tag_prototype_t | tm_tag_field_t | tm_tag_method_t | tm_tag_function_t | tm_tag_enumerator_t |tm_tag_struct_t | tm_tag_typedef_t | tm_tag_union_t | tm_tag_enum_t)); if (global) { find_scope_members_tags (global, tags, langJava, new_name, filename, no_definitions); g_ptr_array_free (global, TRUE); } } if (del) { g_free (new_name); } return tags; }
/** * g_segraph_snapshot_new: * @data_triplets: array of data triplets. * @count: length of @data_pairs. * * Creates a graph from passed data triplets. Resulting construction can be * several separate graphs, so an array of #GSEGraphSnapshot is returned. Also, * if both first and second #GSEGraphDataTriplet member are %NULL, then this * triplet is omitted in creation. If @count is 0, it is assumed that * @data_triplets is %NULL terminated array. If one of first and second members * of #GSEGraphDataTriplet is %NULL, then only one node with not %NULL data and * a half-edge holding whatever data was passed as a third member of triplet * will be created. For performance reasons it would be good if in second and * later pairs one of node have data describing already created node. * Lets assume we want to create this graph: * <informalexample> * <programlisting> * cA--B- * | * -C--D * </programlisting> * </informalexample> * So best order of pairs is: * <itemizedlist> * <listitem> * <para> * A, B * </para> * </listitem> * <listitem> * <para> * A, A * </para> * </listitem> * <listitem> * <para> * B, %NULL * </para> * </listitem> * <listitem> * <para> * A, C * </para> * </listitem> * <listitem> * <para> * C, %NULL * </para> * </listitem> * <listitem> * <para> * C, D * </para> * </listitem> * </itemizedlist> * This way we never create a separate graph, because in given pair one of the * members is already created, so newly created one will be its neighbour and a * part of larger graph. * Swaping fourth and sixth pair will cause creation of a separate graph while * processing fourth pair and checking if two graphs are one when processing * sixth pair. * * Returns: array of newly created separate graphs or %NULL if no nodes were * created. */ GPtrArray* g_segraph_snapshot_new (GSEGraphDataTriplet** data_triplets, guint count) { GPtrArray* separate_graphs; GHashTable* data_to_nodes; GHashTable* nodes_to_wholes; guint iter; g_return_val_if_fail (data_triplets != NULL, NULL); if (!count) { while (data_triplets[count]) { ++count; } } if (!count) { return NULL; } separate_graphs = g_ptr_array_new (); data_to_nodes = g_hash_table_new (NULL, NULL); nodes_to_wholes = g_hash_table_new (NULL, NULL); for (iter = 0; iter < count; ++iter) { GSEGraphDataTriplet* data_triplet; data_triplet = data_triplets[iter]; if (g_segraph_data_triplet_is_valid (data_triplet)) { GSEGraphNode* first_node; GSEGraphNode* second_node; GSEGraphEdge* edge; GSEGraphConstructFlags created; created = G_SEGRAPH_NONE; if (data_triplet->first) { if (!g_hash_table_lookup_extended (data_to_nodes, data_triplet->first, NULL, (gpointer*)&first_node)) { first_node = g_segraph_node_new (data_triplet->first); g_hash_table_insert (data_to_nodes, data_triplet->first, first_node); created |= G_SEGRAPH_FIRST; } } else { first_node = NULL; } if (data_triplet->second) { if (!g_hash_table_lookup_extended (data_to_nodes, data_triplet->second, NULL, (gpointer*)&second_node)) { second_node = g_segraph_node_new (data_triplet->second); g_hash_table_insert (data_to_nodes, data_triplet->second, second_node); created |= G_SEGRAPH_SECOND; } } else { second_node = NULL; } edge = g_segraph_edge_new (data_triplet->edge); g_segraph_edge_connect_nodes (edge, first_node, second_node); switch (created) { case G_SEGRAPH_NONE: { /* no nodes were created, so they can join two separate graphs. */ #define JOIN_COUNT 2 guint which; GSEGraphSnapshot* joined_graphs[JOIN_COUNT]; GSEGraphNode* check_nodes[JOIN_COUNT]; /* if loop was created, then no graph join occurs. */ /* if half-edge was created, then no graph join occurs. */ if ((first_node == second_node) || !first_node || !second_node) { break; } check_nodes[0] = edge->first; check_nodes[1] = edge->second; for (which = 0; which < JOIN_COUNT; ++which) { guint iter2; for (iter2 = 0; iter2 < separate_graphs->len; ++iter2) { GSEGraphSnapshot* graph; guint iter3; gboolean hit; graph = g_ptr_array_index (separate_graphs, iter2); hit = FALSE; for (iter3 = 0; iter3 < graph->node_array->len; ++iter3) { GSEGraphNode* temp_node; temp_node = g_ptr_array_index (graph->node_array, iter3); if (temp_node == check_nodes[which]) { joined_graphs[which] = graph; hit = TRUE; break; } } if (hit) { break; } } } if (joined_graphs[0] != joined_graphs[1]) { guint iter2; for (iter2 = 0; iter2 < joined_graphs[1]->node_array->len; ++iter2) { GSEGraphNode* temp_node; temp_node = g_ptr_array_index (joined_graphs[1]->node_array, iter2); if (temp_node != check_nodes[1]) { g_ptr_array_add (joined_graphs[0]->node_array, temp_node); g_hash_table_insert (nodes_to_wholes, temp_node, joined_graphs[0]); } } for (iter2 = 0; iter2 < joined_graphs[1]->edge_array->len; ++iter2) { GSEGraphEdge* temp_edge; temp_edge = g_ptr_array_index (joined_graphs[1]->edge_array, iter2); g_ptr_array_add (joined_graphs[0]->edge_array, temp_edge); } g_ptr_array_remove_fast (separate_graphs, joined_graphs[1]); g_segraph_snapshot_free (joined_graphs[1], FALSE); } g_ptr_array_add (joined_graphs[0]->edge_array, edge); #undef JOIN_COUNT break; } case G_SEGRAPH_FIRST: { /* first node was created, so maybe it will belong to existing graph. */ GSEGraphSnapshot* temp_graph; /* creating self-connected node means it creates separate graph. */ /* creating half-edged node means it creates separate graph. */ if ((first_node == second_node) || !second_node) { temp_graph = _g_segraph_snapshot_new_blank (1, 1, TRUE, TRUE); g_ptr_array_add (separate_graphs, temp_graph); } else { temp_graph = g_hash_table_lookup (nodes_to_wholes, second_node); } g_ptr_array_add (temp_graph->node_array, first_node); g_ptr_array_add (temp_graph->edge_array, edge); g_hash_table_insert (nodes_to_wholes, first_node, temp_graph); break; } case G_SEGRAPH_SECOND: { /* second node was created, so maybe it will belong to existing graph. */ GSEGraphSnapshot* temp_graph; /* creating self-connected node means it creates separate graph. */ /* creating half-edged node means it creates separate graph. */ if ((first_node == second_node) || !first_node) { temp_graph = _g_segraph_snapshot_new_blank (1, 1, TRUE, TRUE); g_ptr_array_add (separate_graphs, temp_graph); } else { temp_graph = g_hash_table_lookup (nodes_to_wholes, first_node); } g_ptr_array_add (temp_graph->node_array, second_node); g_ptr_array_add (temp_graph->edge_array, edge); g_hash_table_insert (nodes_to_wholes, second_node, temp_graph); break; } case G_SEGRAPH_BOTH: { /* if both nodes were created then they create separate graph. */ GSEGraphSnapshot* temp_graph; temp_graph = _g_segraph_snapshot_new_blank (2, 1, TRUE, TRUE); g_ptr_array_add (temp_graph->node_array, first_node); g_ptr_array_add (temp_graph->node_array, second_node); g_ptr_array_add (temp_graph->edge_array, edge); g_ptr_array_add (separate_graphs, temp_graph); g_hash_table_insert (nodes_to_wholes, first_node, temp_graph); g_hash_table_insert (nodes_to_wholes, second_node, temp_graph); break; } } } } g_hash_table_unref (data_to_nodes); g_hash_table_unref (nodes_to_wholes); if (!separate_graphs->len) { g_ptr_array_free (separate_graphs, TRUE); separate_graphs = NULL; } return separate_graphs; }
static int find_scope_members_tags (const GPtrArray * all, GPtrArray * tags, const langType langJava, const char *name, const char *filename, gboolean no_definitions) { GPtrArray *local = g_ptr_array_new (); unsigned int i; TMTag *tag; size_t len = strlen (name); for (i = 0; (i < all->len); ++i) { tag = TM_TAG (all->pdata[i]); if (no_definitions && filename && tag->file && 0 != strcmp (filename, tag->file->short_name)) { continue; } if (tag && tag->scope && tag->scope[0] != '\0') { if (0 == strncmp (name, tag->scope, len)) { g_ptr_array_add (local, tag); } } } if (local->len > 0) { unsigned int j; TMTag *tag2; char backup = 0; char *s_backup = NULL; char *var_type = NULL; char *scope; for (i = 0; (i < local->len); ++i) { tag = TM_TAG (local->pdata[i]); scope = tag->scope; if (scope && 0 == strcmp (name, scope)) { g_ptr_array_add (tags, tag); continue; } s_backup = NULL; j = 0; /* someone could write better code :P */ while (scope) { if (s_backup) { backup = s_backup[0]; s_backup[0] = '\0'; if (0 == strcmp (name, tag->scope)) { j = local->len; s_backup[0] = backup; break; } } if (tag->file && tag->file->lang == langJava) { scope = strrchr (tag->scope, '.'); if (scope) var_type = scope + 1; } else { scope = strrchr (tag->scope, ':'); if (scope) { var_type = scope + 1; scope--; } } if (s_backup) { s_backup[0] = backup; } if (scope) { if (s_backup) { backup = s_backup[0]; s_backup[0] = '\0'; } for (j = 0; (j < local->len); ++j) { if (i == j) continue; tag2 = TM_TAG (local->pdata[j]); if (tag2->var_type && 0 == strcmp (var_type, tag2->var_type)) { break; } } if (s_backup) s_backup[0] = backup; } if (j < local->len) { break; } s_backup = scope; } if (j == local->len) { g_ptr_array_add (tags, tag); } } } g_ptr_array_free (local, TRUE); return (int) tags->len; }
/* Returns all matching tags found in the workspace. @param name The name of the tag to find. @param type The tag types to return (TMTagType). Can be a bitmask. @param attrs The attributes to sort and dedup on (0 terminated integer array). @param partial Whether partial match is allowed. @param lang Specifies the language(see the table in parsers.h) of the tags to be found, -1 for all @return Array of matching tags. Do not free() it since it is a static member. */ const GPtrArray *tm_workspace_find(const char *name, TMTagType type, TMTagAttrType *attrs, gboolean partial, langType lang) { static GPtrArray *tags = NULL; TMTag **matches[2]; size_t len; guint tagCount[2]={0,0}, tagIter; gint tags_lang; if (!name) return NULL; len = strlen(name); if (!len) return NULL; if (tags) g_ptr_array_set_size(tags, 0); else tags = g_ptr_array_new(); matches[0] = tm_tags_find(theWorkspace->tags_array, name, partial, TRUE, &tagCount[0]); matches[1] = tm_tags_find(theWorkspace->global_tags, name, partial, TRUE, &tagCount[1]); /* file tags */ if (matches[0] && *matches[0]) { tags_lang = (*matches[0])->lang; for (tagIter=0;tagIter<tagCount[0];++tagIter) { if ((type & (*matches[0])->type) && (lang == -1 || tags_lang == lang)) g_ptr_array_add(tags, *matches[0]); if (partial) { if (0 != strncmp((*matches[0])->name, name, len)) break; } else { if (0 != strcmp((*matches[0])->name, name)) break; } ++ matches[0]; } } /* global tags */ if (matches[1] && *matches[1]) { int tags_lang_alt = 0; tags_lang = (*matches[1])->lang; /* tags_lang_alt is used to load C global tags only once for C and C++ * lang = 1 is C++, lang = 0 is C * if we have lang 0, than accept also lang 1 for C++ */ if (tags_lang == 0) /* C or C++ */ tags_lang_alt = 1; else tags_lang_alt = tags_lang; /* otherwise just ignore it */ for (tagIter=0;tagIter<tagCount[1];++tagIter) { if ((type & (*matches[1])->type) && (lang == -1 || tags_lang == lang || tags_lang_alt == lang)) g_ptr_array_add(tags, *matches[1]); if (partial) { if (0 != strncmp((*matches[1])->name, name, len)) break; } else { if (0 != strcmp((*matches[1])->name, name)) break; } ++ matches[1]; } } if (attrs) tm_tags_sort(tags, attrs, TRUE, FALSE); return tags; }
/* Loads the global tag list from the specified file. The global tag list should have been first created using tm_workspace_create_global_tags(). @param tags_file The file containing global tags. @return TRUE on success, FALSE on failure. @see tm_workspace_create_global_tags() */ gboolean tm_workspace_load_global_tags(const char *tags_file, gint mode) { guchar buf[BUFSIZ]; FILE *fp; GPtrArray *file_tags, *new_tags; TMTag *tag; TMFileFormat format = TM_FILE_FORMAT_TAGMANAGER; if (NULL == (fp = g_fopen(tags_file, "r"))) return FALSE; if ((NULL == fgets((gchar*) buf, BUFSIZ, fp)) || ('\0' == *buf)) { fclose(fp); return FALSE; /* early out on error */ } else { /* We read the first line for the format specification. */ if (buf[0] == '#' && strstr((gchar*) buf, "format=pipe") != NULL) format = TM_FILE_FORMAT_PIPE; else if (buf[0] == '#' && strstr((gchar*) buf, "format=tagmanager") != NULL) format = TM_FILE_FORMAT_TAGMANAGER; else if (buf[0] == '#' && strstr((gchar*) buf, "format=ctags") != NULL) format = TM_FILE_FORMAT_CTAGS; else if (strncmp((gchar*) buf, "!_TAG_", 6) == 0) format = TM_FILE_FORMAT_CTAGS; else { /* We didn't find a valid format specification, so we try to auto-detect the format * by counting the pipe characters on the first line and asumme pipe format when * we find more than one pipe on the line. */ guint i, pipe_cnt = 0, tab_cnt = 0; for (i = 0; i < BUFSIZ && buf[i] != '\0' && pipe_cnt < 2; i++) { if (buf[i] == '|') pipe_cnt++; else if (buf[i] == '\t') tab_cnt++; } if (pipe_cnt > 1) format = TM_FILE_FORMAT_PIPE; else if (tab_cnt > 1) format = TM_FILE_FORMAT_CTAGS; } rewind(fp); /* reset the file pointer, to start reading again from the beginning */ } file_tags = g_ptr_array_new(); while (NULL != (tag = tm_tag_new_from_file(NULL, fp, mode, format))) g_ptr_array_add(file_tags, tag); fclose(fp); tm_tags_sort(file_tags, global_tags_sort_attrs, TRUE, TRUE); /* reorder the whole array, because tm_tags_find expects a sorted array */ new_tags = tm_tags_merge(theWorkspace->global_tags, file_tags, global_tags_sort_attrs, TRUE); g_ptr_array_free(theWorkspace->global_tags, TRUE); g_ptr_array_free(file_tags, TRUE); theWorkspace->global_tags = new_tags; return TRUE; }
static JSBool do_import(JSContext *context, JSObject *obj, Importer *priv, const char *name) { char *filename; char *native_filename; char *full_path; char *dirname = NULL; jsval search_path_val; JSObject *search_path; JSObject *module_obj = NULL; jsuint search_path_len; jsuint i; JSBool result; GPtrArray *directories; if (strcmp(name, MODULE_INIT_PROPERTY) == 0) { return JS_FALSE; } if (!gjs_object_require_property(context, obj, "importer", "searchPath", &search_path_val)) { return JS_FALSE; } if (!JSVAL_IS_OBJECT(search_path_val)) { gjs_throw(context, "searchPath property on importer is not an object"); return JS_FALSE; } search_path = JSVAL_TO_OBJECT(search_path_val); if (!JS_IsArrayObject(context, search_path)) { gjs_throw(context, "searchPath property on importer is not an array"); return JS_FALSE; } if (!JS_GetArrayLength(context, search_path, &search_path_len)) { gjs_throw(context, "searchPath array has no length"); return JS_FALSE; } result = JS_FALSE; filename = g_strdup_printf("%s.js", name); native_filename = g_strdup_printf("%s."G_MODULE_SUFFIX, name); full_path = NULL; directories = NULL; /* First try importing an internal module like byteArray */ if (gjs_is_registered_native_module(context, obj, name) && import_native_file(context, obj, name, NULL)) { gjs_debug(GJS_DEBUG_IMPORTER, "successfully imported module '%s'", name); result = JS_TRUE; goto out; } for (i = 0; i < search_path_len; ++i) { jsval elem; elem = JSVAL_VOID; if (!JS_GetElement(context, search_path, i, &elem)) { /* this means there was an exception, while elem == JSVAL_VOID * means no element found */ goto out; } if (JSVAL_IS_VOID(elem)) continue; if (!JSVAL_IS_STRING(elem)) { gjs_throw(context, "importer searchPath contains non-string"); goto out; } g_free(dirname); dirname = NULL; if (!gjs_string_to_utf8(context, elem, &dirname)) goto out; /* Error message already set */ /* Ignore empty path elements */ if (dirname[0] == '\0') continue; /* Try importing __init__.js and loading the symbol from it */ if (full_path) g_free(full_path); full_path = g_build_filename(dirname, MODULE_INIT_FILENAME, NULL); module_obj = load_module_init(context, obj, full_path); if (module_obj != NULL) { jsval obj_val; if (gjs_object_get_property(context, module_obj, name, &obj_val)) { if (!JSVAL_IS_VOID(obj_val) && JS_DefineProperty(context, obj, name, obj_val, NULL, NULL, GJS_MODULE_PROP_FLAGS & ~JSPROP_PERMANENT)) { result = JS_TRUE; goto out; } } } /* Second try importing a directory (a sub-importer) */ if (full_path) g_free(full_path); full_path = g_build_filename(dirname, name, NULL); if (g_file_test(full_path, G_FILE_TEST_IS_DIR)) { gjs_debug(GJS_DEBUG_IMPORTER, "Adding directory '%s' to child importer '%s'", full_path, name); if (directories == NULL) { directories = g_ptr_array_new(); } g_ptr_array_add(directories, full_path); /* don't free it twice - pass ownership to ptr array */ full_path = NULL; } /* If we just added to directories, we know we don't need to * check for a file. If we added to directories on an earlier * iteration, we want to ignore any files later in the * path. So, always skip the rest of the loop block if we have * directories. */ if (directories != NULL) { continue; } /* Third, if it's not a directory, try importing a file */ g_free(full_path); full_path = g_build_filename(dirname, filename, NULL); if (g_file_test(full_path, G_FILE_TEST_EXISTS)) { if (import_file(context, obj, name, full_path)) { gjs_debug(GJS_DEBUG_IMPORTER, "successfully imported module '%s'", name); result = JS_TRUE; } /* Don't keep searching path if we fail to load the file for * reasons other than it doesn't exist... i.e. broken files * block searching for nonbroken ones */ goto out; } /* Finally see if it's a native module */ g_free(full_path); full_path = g_build_filename(dirname, native_filename, NULL); if (g_file_test(full_path, G_FILE_TEST_EXISTS)) { if (import_native_file(context, obj, name, full_path)) { gjs_debug(GJS_DEBUG_IMPORTER, "successfully imported module '%s'", name); result = JS_TRUE; } /* Don't keep searching path if we fail to load the file for * reasons other than it doesn't exist... i.e. broken files * block searching for nonbroken ones */ goto out; } gjs_debug(GJS_DEBUG_IMPORTER, "JS import '%s' not found in %s", name, dirname); } if (directories != NULL) { /* NULL-terminate the char** */ g_ptr_array_add(directories, NULL); if (import_directory(context, obj, name, (const char**) directories->pdata)) { gjs_debug(GJS_DEBUG_IMPORTER, "successfully imported directory '%s'", name); result = JS_TRUE; } } out: if (directories != NULL) { char **str_array; /* NULL-terminate the char** * (maybe for a second time, but doesn't matter) */ g_ptr_array_add(directories, NULL); str_array = (char**) directories->pdata; g_ptr_array_free(directories, FALSE); g_strfreev(str_array); } g_free(full_path); g_free(filename); g_free(native_filename); g_free(dirname); if (!result && !JS_IsExceptionPending(context)) { /* If no exception occurred, the problem is just that we got to the * end of the path. Be sure an exception is set. */ gjs_throw(context, "No JS module '%s' found in search path", name); } return result; }
static gboolean crtc_initialize (GnomeRRCrtc *crtc, XRRScreenResources *res, GError **error) { XRRCrtcInfo *info = XRRGetCrtcInfo (DISPLAY (crtc), res, crtc->id); GPtrArray *a; int i; #if 0 g_print ("CRTC %lx Timestamp: %u\n", crtc->id, (guint32)info->timestamp); #endif if (!info) { /* FIXME: We need to reaquire the screen resources */ /* FIXME: can we actually catch BadRRCrtc, and does it make sense to emit that? */ /* Translators: CRTC is a CRT Controller (this is X terminology). * It is *very* unlikely that you'll ever get this error, so it is * only listed for completeness. */ g_set_error (error, GNOME_RR_ERROR, GNOME_RR_ERROR_RANDR_ERROR, _("could not get information about CRTC %d"), (int) crtc->id); return FALSE; } /* GnomeRRMode */ crtc->current_mode = mode_by_id (crtc->info, info->mode); crtc->x = info->x; crtc->y = info->y; /* Current outputs */ a = g_ptr_array_new (); for (i = 0; i < info->noutput; ++i) { GnomeRROutput *output = gnome_rr_output_by_id (crtc->info, info->outputs[i]); if (output) g_ptr_array_add (a, output); } g_ptr_array_add (a, NULL); crtc->current_outputs = (GnomeRROutput **)g_ptr_array_free (a, FALSE); /* Possible outputs */ a = g_ptr_array_new (); for (i = 0; i < info->npossible; ++i) { GnomeRROutput *output = gnome_rr_output_by_id (crtc->info, info->possible[i]); if (output) g_ptr_array_add (a, output); } g_ptr_array_add (a, NULL); crtc->possible_outputs = (GnomeRROutput **)g_ptr_array_free (a, FALSE); /* Rotations */ crtc->current_rotation = gnome_rr_rotation_from_xrotation (info->rotation); crtc->rotations = gnome_rr_rotation_from_xrotation (info->rotations); XRRFreeCrtcInfo (info); /* get an store gamma size */ crtc->gamma_size = XRRGetCrtcGammaSize (DISPLAY (crtc), crtc->id); return TRUE; }
static void rspamd_archive_process_rar_v4 (struct rspamd_task *task, const guchar *start, const guchar *end, struct rspamd_mime_part *part) { const guchar *p = start, *start_section; guint8 type; guint flags; guint64 sz, comp_sz = 0, uncomp_sz = 0; struct rspamd_archive *arch; struct rspamd_archive_file *f; arch = rspamd_mempool_alloc0 (task->task_pool, sizeof (*arch)); arch->files = g_ptr_array_new (); arch->type = RSPAMD_ARCHIVE_RAR; rspamd_mempool_add_destructor (task->task_pool, rspamd_archive_dtor, arch); while (p < end) { /* Crc16 */ start_section = p; RAR_SKIP_BYTES (sizeof (guint16)); type = *p; p ++; RAR_READ_UINT16 (flags); if (type == 0x73) { /* Main header, check for encryption */ if (flags & 0x80) { arch->flags |= RSPAMD_ARCHIVE_ENCRYPTED; goto end; } } RAR_READ_UINT16 (sz); if (flags & 0x8000) { /* We also need to read ADD_SIZE element */ guint32 tmp; RAR_READ_UINT32 (tmp); sz += tmp; /* This is also used as PACK_SIZE */ comp_sz = tmp; } if (sz == 0) { /* Zero sized block - error */ msg_debug_task ("rar archive is invalid (zero size block)"); return; } if (type == 0x74) { guint fname_len; /* File header */ /* Uncompressed size */ RAR_READ_UINT32 (uncomp_sz); /* Skip to NAME_SIZE element */ RAR_SKIP_BYTES (11); RAR_READ_UINT16 (fname_len); if (fname_len == 0 || fname_len > (gsize)(end - p)) { msg_debug_task ("rar archive is invalid (bad fileame size)"); return; } /* Attrs */ RAR_SKIP_BYTES (4); if (flags & 0x100) { /* We also need to read HIGH_PACK_SIZE */ guint32 tmp; RAR_READ_UINT32 (tmp); sz += tmp; comp_sz += tmp; /* HIGH_UNP_SIZE */ RAR_READ_UINT32 (tmp); uncomp_sz += tmp; } f = g_slice_alloc0 (sizeof (*f)); if (flags & 0x200) { /* We have unicode + normal version */ guchar *tmp; tmp = memchr (p, '\0', fname_len); if (tmp != NULL) { /* Just use ASCII version */ f->fname = g_string_new_len (p, tmp - p); } else { /* We have UTF8 filename, use it as is */ f->fname = g_string_new_len (p, fname_len); } } else { f->fname = g_string_new_len (p, fname_len); } f->compressed_size = comp_sz; f->uncompressed_size = uncomp_sz; if (flags & 0x4) { f->flags |= RSPAMD_ARCHIVE_FILE_ENCRYPTED; } g_ptr_array_add (arch->files, f); } p = start_section; RAR_SKIP_BYTES (sz); } end: part->flags |= RSPAMD_MIME_PART_ARCHIVE; part->specific.arch = arch; arch->archive_name = &part->cd->filename; arch->size = part->parsed_data.len; }
static gboolean fill_screen_info_from_resources (ScreenInfo *info, XRRScreenResources *resources, GError **error) { int i; GPtrArray *a; GnomeRRCrtc **crtc; GnomeRROutput **output; info->resources = resources; /* We create all the structures before initializing them, so * that they can refer to each other. */ a = g_ptr_array_new (); for (i = 0; i < resources->ncrtc; ++i) { GnomeRRCrtc *crtc = crtc_new (info, resources->crtcs[i]); g_ptr_array_add (a, crtc); } g_ptr_array_add (a, NULL); info->crtcs = (GnomeRRCrtc **)g_ptr_array_free (a, FALSE); a = g_ptr_array_new (); for (i = 0; i < resources->noutput; ++i) { GnomeRROutput *output = output_new (info, resources->outputs[i]); g_ptr_array_add (a, output); } g_ptr_array_add (a, NULL); info->outputs = (GnomeRROutput **)g_ptr_array_free (a, FALSE); a = g_ptr_array_new (); for (i = 0; i < resources->nmode; ++i) { GnomeRRMode *mode = mode_new (info, resources->modes[i].id); g_ptr_array_add (a, mode); } g_ptr_array_add (a, NULL); info->modes = (GnomeRRMode **)g_ptr_array_free (a, FALSE); /* Initialize */ for (crtc = info->crtcs; *crtc; ++crtc) { if (!crtc_initialize (*crtc, resources, error)) return FALSE; } for (output = info->outputs; *output; ++output) { if (!output_initialize (*output, resources, error)) return FALSE; } for (i = 0; i < resources->nmode; ++i) { GnomeRRMode *mode = mode_by_id (info, resources->modes[i].id); mode_initialize (mode, &(resources->modes[i])); } gather_clone_modes (info); return TRUE; }
static void rspamd_archive_process_zip (struct rspamd_task *task, struct rspamd_mime_part *part) { const guchar *p, *start, *end, *eocd = NULL, *cd; const guint32 eocd_magic = 0x06054b50, cd_basic_len = 46; const guchar cd_magic[] = {0x50, 0x4b, 0x01, 0x02}; guint32 cd_offset, cd_size, comp_size, uncomp_size; guint16 extra_len, fname_len, comment_len; struct rspamd_archive *arch; struct rspamd_archive_file *f; /* Zip files have interesting data at the end of archive */ p = part->parsed_data.begin + part->parsed_data.len - 1; start = part->parsed_data.begin; end = p; /* Search for EOCD: * 22 bytes is a typical size of eocd without a comment and * end points one byte after the last character */ p -= 21; while (p > start + sizeof (guint32)) { guint32 t; /* XXX: not an efficient approach */ memcpy (&t, p, sizeof (t)); if (GUINT32_FROM_LE (t) == eocd_magic) { eocd = p; break; } p --; } if (eocd == NULL) { /* Not a zip file */ msg_debug_task ("zip archive is invalid (no EOCD)"); return; } if (end - eocd < 21) { msg_debug_task ("zip archive is invalid (short EOCD)"); return; } memcpy (&cd_size, eocd + 12, sizeof (cd_size)); cd_size = GUINT32_FROM_LE (cd_size); memcpy (&cd_offset, eocd + 16, sizeof (cd_offset)); cd_offset = GUINT32_FROM_LE (cd_offset); /* We need to check sanity as well */ if (cd_offset + cd_size != (guint)(eocd - start)) { msg_debug_task ("zip archive is invalid (bad size/offset for CD)"); return; } cd = start + cd_offset; arch = rspamd_mempool_alloc0 (task->task_pool, sizeof (*arch)); arch->files = g_ptr_array_new (); arch->type = RSPAMD_ARCHIVE_ZIP; rspamd_mempool_add_destructor (task->task_pool, rspamd_archive_dtor, arch); while (cd < eocd) { /* Read central directory record */ if (eocd - cd < cd_basic_len || memcmp (cd, cd_magic, sizeof (cd_magic)) != 0) { msg_debug_task ("zip archive is invalid (bad cd record)"); return; } memcpy (&comp_size, cd + 20, sizeof (guint32)); comp_size = GUINT32_FROM_LE (comp_size); memcpy (&uncomp_size, cd + 24, sizeof (guint32)); uncomp_size = GUINT32_FROM_LE (uncomp_size); memcpy (&fname_len, cd + 28, sizeof (fname_len)); fname_len = GUINT16_FROM_LE (fname_len); memcpy (&extra_len, cd + 30, sizeof (extra_len)); extra_len = GUINT16_FROM_LE (extra_len); memcpy (&comment_len, cd + 32, sizeof (comment_len)); comment_len = GUINT16_FROM_LE (comment_len); if (cd + fname_len + comment_len + extra_len + cd_basic_len > eocd) { msg_debug_task ("zip archive is invalid (too large cd record)"); return; } f = g_slice_alloc0 (sizeof (*f)); f->fname = g_string_new_len (cd + cd_basic_len, fname_len); f->compressed_size = comp_size; f->uncompressed_size = uncomp_size; g_ptr_array_add (arch->files, f); msg_debug_task ("found file in zip archive: %v", f->fname); cd += fname_len + comment_len + extra_len + cd_basic_len; } part->flags |= RSPAMD_MIME_PART_ARCHIVE; part->specific.arch = arch; if (part->cd) { arch->archive_name = &part->cd->filename; } arch->size = part->parsed_data.len; }
static void test_g_ptr_array (void) { g_autoptr(GPtrArray) val = g_ptr_array_new (); g_assert (val != NULL); }
static gboolean category_filter_model_update( GtkTreeStore * store ) { int i, n; int low = 0; int all = 0; int high = 0; int public = 0; int normal = 0; int private = 0; int store_pos; GtkTreeIter top; GtkTreeIter iter; GtkTreeModel * model = GTK_TREE_MODEL( store ); GPtrArray * hosts = g_ptr_array_new( ); GHashTable * hosts_hash = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free ); GObject * o = G_OBJECT( store ); GtkTreeModel * tmodel = GTK_TREE_MODEL( g_object_get_data( o, TORRENT_MODEL_KEY ) ); g_object_steal_data( o, DIRTY_KEY ); /* walk through all the torrents, tallying how many matches there are * for the various categories. also make a sorted list of all tracker * hosts s.t. we can merge it with the existing list */ if( gtk_tree_model_get_iter_first( tmodel, &iter )) do { tr_torrent * tor; const tr_info * inf; int keyCount; char ** keys; gtk_tree_model_get( tmodel, &iter, MC_TORRENT_RAW, &tor, -1 ); inf = tr_torrentInfo( tor ); keyCount = 0; keys = g_new( char*, inf->trackerCount ); for( i=0, n=inf->trackerCount; i<n; ++i ) { int k; char * key = gtr_get_host_from_url( inf->trackers[i].announce ); int * count = g_hash_table_lookup( hosts_hash, key ); if( count == NULL ) { count = tr_new0( int, 1 ); g_hash_table_insert( hosts_hash, g_strdup( key ), count ); g_ptr_array_add( hosts, g_strdup( key ) ); } for( k=0; k<keyCount; ++k ) if( !strcmp( keys[k], key ) ) break; if( k==keyCount ) keys[keyCount++] = key; else g_free( key ); } for( i=0; i<keyCount; ++i ) { int * incrementme = g_hash_table_lookup( hosts_hash, keys[i] ); ++*incrementme; g_free( keys[i] ); } g_free( keys ); ++all; if( inf->isPrivate ) ++private; else ++public;
gint main (gint argc, gchar ** argv) { gint ret = 0; VsgPRTree3d *tree; VsgVector3d lb; VsgVector3d ub; MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &sz); MPI_Comm_rank (MPI_COMM_WORLD, &rk); vsg_init_gdouble (); parse_args (argc, argv); points = g_ptr_array_new (); regions = g_ptr_array_new (); lb.x = -1.; lb.y = -1.; lb.z = -1.; ub.x = 1.; ub.y = 1.; ub.z = 1.; /* create the tree */ tree = vsg_prtree3d_new_full (&lb, &ub, (VsgPoint3dLocFunc) vsg_vector3d_vector3d_locfunc, (VsgPoint3dDistFunc) vsg_vector3d_dist, (VsgRegion3dLocFunc) _sphere_loc3, 2); if (_hilbert) { /* configure for hilbert curve order traversal */ vsg_prtree3d_set_children_order_hilbert (tree); } if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: set_parallel begin\n", rk); } vsg_prtree3d_set_parallel (tree, &pconfig); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: set_parallel ok\n", rk); } if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: fill begin\n", rk); } _fill (tree, _np); _check_local_counts (tree); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: fill ok\n", rk); } /* update total points and regions count */ init_total_points_count (); init_total_regions_count (); if (_scatter_before) { if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: scatter nodes begin\n", rk); } vsg_prtree3d_distribute_scatter_leaves (tree); _check_local_counts (tree); ret += check_points_number (tree); ret += check_regions_number (tree); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: scatter nodes ok\n", rk); } _write_regions (tree, "rg-scatter"); _tree_write (tree, "scatter-"); } if (_do_contiguous) { if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: contiguous distribute begin\n", rk); } vsg_prtree3d_distribute_contiguous_leaves (tree); _check_local_counts (tree); ret += check_points_number (tree); ret += check_regions_number (tree); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: contiguous distribute ok\n", rk); } _write_regions (tree, "rg-contiguous"); } _exterior_points (tree); vsg_prtree3d_distribute_contiguous_leaves (tree); _check_local_counts (tree); if (_do_write) { MPI_Barrier (MPI_COMM_WORLD); _tree_write (tree, "prtree3parallel-"); } if (_do_write) { gchar fn[1024]; FILE *f; g_sprintf (fn, "prtree3parallel-%03d.txt", rk); f = fopen (fn, "w"); vsg_prtree3d_write (tree, f); fclose (f); } /* destroy the points */ g_ptr_array_foreach (points, empty_array, NULL); g_ptr_array_free (points, TRUE); /* destroy the spheres */ g_ptr_array_foreach (regions, empty_array, NULL); g_ptr_array_free (regions, TRUE); /* destroy the tree */ vsg_prtree3d_free (tree); MPI_Finalize (); return ret; }
gboolean ToolsCore_LoadPlugins(ToolsServiceState *state) { gboolean pluginDirExists; gboolean ret = FALSE; gchar *pluginRoot; guint i; GPtrArray *plugins = NULL; #if defined(sun) && defined(__x86_64__) const char *subdir = "/amd64"; #else const char *subdir = ""; #endif #if defined(OPEN_VM_TOOLS) pluginRoot = g_strdup(VMTOOLSD_PLUGIN_ROOT); #else char *instPath = GuestApp_GetInstallPath(); pluginRoot = g_strdup_printf("%s%cplugins", instPath, DIRSEPC); vm_free(instPath); #endif ASSERT(g_module_supported()); #ifdef USE_APPLOADER { Bool ret = FALSE; GModule *mainModule = g_module_open(NULL, G_MODULE_BIND_LAZY); ASSERT(mainModule); ret = g_module_symbol(mainModule, "AppLoader_LoadLibraryDependencies", (gpointer *)&LoadDependencies); g_module_close(mainModule); if (!ret) { g_critical("Unable to locate library dependency loading function.\n"); goto exit; } } #endif plugins = g_ptr_array_new(); /* * First, load plugins from the common directory. The common directory * is not required to exist unless provided on the command line. */ if (state->commonPath == NULL) { state->commonPath = g_strdup_printf("%s%s%c%s", pluginRoot, subdir, DIRSEPC, TOOLSCORE_COMMON); } else if (!g_file_test(state->commonPath, G_FILE_TEST_IS_DIR)) { g_warning("Common plugin path is not a directory: %s\n", state->commonPath); goto exit; } if (g_file_test(state->commonPath, G_FILE_TEST_IS_DIR) && !ToolsCoreLoadDirectory(&state->ctx, state->commonPath, plugins)) { goto exit; } /* * Load the container-specific plugins. Ignore if the plugin directory * doesn't exist when running in debug mode. */ if (state->pluginPath == NULL) { state->pluginPath = g_strdup_printf("%s%s%c%s", pluginRoot, subdir, DIRSEPC, state->name); } pluginDirExists = g_file_test(state->pluginPath, G_FILE_TEST_IS_DIR); if (state->debugPlugin == NULL && !pluginDirExists) { g_warning("Plugin path is not a directory: %s\n", state->pluginPath); goto exit; } if (pluginDirExists && !ToolsCoreLoadDirectory(&state->ctx, state->pluginPath, plugins)) { goto exit; } /* * All plugins are loaded, now initialize them. */ state->plugins = g_ptr_array_new(); for (i = 0; i < plugins->len; i++) { ToolsPlugin *plugin = g_ptr_array_index(plugins, i); plugin->data = plugin->onload(&state->ctx); if (plugin->data == NULL) { g_info("Plugin '%s' didn't provide deployment data, unloading.\n", plugin->fileName); ToolsCoreFreePlugin(plugin); } else if (state->ctx.errorCode != 0) { /* Break early if a plugin has requested the container to quit. */ ToolsCoreFreePlugin(plugin); break; } else { ASSERT(plugin->data->name != NULL); g_module_make_resident(plugin->module); g_ptr_array_add(state->plugins, plugin); VMTools_BindTextDomain(plugin->data->name, NULL, NULL); g_message("Plugin '%s' initialized.\n", plugin->data->name); } } /* * If there is a debug plugin, see if it exports standard plugin registration * data too. */ if (state->debugData != NULL && state->debugData->debugPlugin->plugin != NULL) { ToolsPluginData *data = state->debugData->debugPlugin->plugin; ToolsPlugin *plugin = g_malloc(sizeof *plugin); plugin->fileName = NULL; plugin->module = NULL; plugin->data = data; VMTools_BindTextDomain(data->name, NULL, NULL); g_ptr_array_add(state->plugins, plugin); } ret = TRUE; exit: if (plugins != NULL) { g_ptr_array_free(plugins, TRUE); } g_free(pluginRoot); return ret; }
callable_obj_t *create_new_call (callable_type_t type, call_state_t state, const gchar* const callID, const gchar* const accountID, const gchar* const peer_name, const gchar* const peer_number) { GError *err1 = NULL ; callable_obj_t *obj; DEBUG ("CallableObj: Create new call"); DEBUG ("CallableObj: Account: %s", accountID); // Allocate memory obj = g_new0 (callable_obj_t, 1); obj->_error_dialogs = g_ptr_array_new(); // Set fields obj->_type = type; obj->_state = state; obj->_state_code = 0; obj->_state_code_description = NULL; if (g_strcasecmp (callID, "") == 0) { obj->_callID = g_new0 (gchar, 30); if (obj->_callID) g_sprintf (obj->_callID, "%d", rand()); } else obj->_callID = g_strdup (callID); obj->_confID = NULL; obj->_historyConfID = NULL; obj->_accountID = g_strdup (accountID); set_timestamp (& (obj->_time_start)); set_timestamp (& (obj->_time_current)); set_timestamp (& (obj->_time_stop)); obj->_srtp_cipher = NULL; obj->_sas = NULL; obj->_peer_name = g_strdup (peer_name); obj->_peer_number = g_strdup (peer_number); obj->_trsft_to = NULL; obj->_peer_info = get_peer_info (peer_name, peer_number); obj->_audio_codec = NULL; obj->_recordfile = NULL; obj->_record_is_playing = FALSE; obj->clockStarted = 1; if (obj->_type == CALL) { // pthread_create(&(obj->tid), NULL, threaded_clock_incrementer, obj); if ( (obj->tid = g_thread_create ( (GThreadFunc) threaded_clock_incrementer, (void *) obj, TRUE, &err1)) == NULL) { DEBUG ("Thread creation failed!"); g_error_free (err1) ; } } obj->_time_added = 0; return obj; }
static gboolean egg_desktop_file_launchv (EggDesktopFile *desktop_file, GSList *documents, va_list args, GError **error) { EggDesktopFileLaunchOption option; GSList *translated_documents = NULL, *docs = NULL; char *command, **argv; int argc, i, screen_num; gboolean success, current_success; GdkDisplay *display; char *startup_id; GPtrArray *env = NULL; char **variables = NULL; GdkScreen *screen = NULL; int workspace = -1; const char *directory = NULL; guint32 launch_time = (guint32)-1; GSpawnFlags flags = G_SPAWN_SEARCH_PATH; GSpawnChildSetupFunc setup_func = NULL; gpointer setup_data = NULL; GPid *ret_pid = NULL; int *ret_stdin = NULL, *ret_stdout = NULL, *ret_stderr = NULL; char **ret_startup_id = NULL; if (documents && desktop_file->document_code == 0) { g_set_error (error, EGG_DESKTOP_FILE_ERROR, EGG_DESKTOP_FILE_ERROR_NOT_LAUNCHABLE, _("Application does not accept documents on command line")); return FALSE; } /* Read the options: technically it's incorrect for the caller to * NULL-terminate the list of options (rather than 0-terminating * it), but NULL-terminating lets us use G_GNUC_NULL_TERMINATED, * it's more consistent with other glib/gtk methods, and it will * work as long as sizeof (int) <= sizeof (NULL), and NULL is * represented as 0. (Which is true everywhere we care about.) */ while ((option = va_arg (args, EggDesktopFileLaunchOption))) { switch (option) { case EGG_DESKTOP_FILE_LAUNCH_CLEARENV: if (env) g_ptr_array_free (env, TRUE); env = g_ptr_array_new (); break; case EGG_DESKTOP_FILE_LAUNCH_PUTENV: variables = va_arg (args, char **); for (i = 0; variables[i]; i++) env = array_putenv (env, variables[i]); break; case EGG_DESKTOP_FILE_LAUNCH_SCREEN: screen = va_arg (args, GdkScreen *); break; case EGG_DESKTOP_FILE_LAUNCH_WORKSPACE: workspace = va_arg (args, int); break; case EGG_DESKTOP_FILE_LAUNCH_DIRECTORY: directory = va_arg (args, const char *); break; case EGG_DESKTOP_FILE_LAUNCH_TIME: launch_time = va_arg (args, guint32); break; case EGG_DESKTOP_FILE_LAUNCH_FLAGS: flags |= va_arg (args, GSpawnFlags); /* Make sure they didn't set any flags that don't make sense. */ flags &= ~G_SPAWN_FILE_AND_ARGV_ZERO; break; case EGG_DESKTOP_FILE_LAUNCH_SETUP_FUNC: setup_func = va_arg (args, GSpawnChildSetupFunc); setup_data = va_arg (args, gpointer); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_PID: ret_pid = va_arg (args, GPid *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDIN_PIPE: ret_stdin = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDOUT_PIPE: ret_stdout = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDERR_PIPE: ret_stderr = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID: ret_startup_id = va_arg (args, char **); break; default: g_set_error (error, EGG_DESKTOP_FILE_ERROR, EGG_DESKTOP_FILE_ERROR_UNRECOGNIZED_OPTION, _("Unrecognized launch option: %d"), GPOINTER_TO_INT (option)); success = FALSE; goto out; } } if (screen) { char *display_name = gdk_screen_make_display_name (screen); char *display_env = g_strdup_printf ("DISPLAY=%s", display_name); env = array_putenv (env, display_env); g_free (display_name); g_free (display_env); display = gdk_screen_get_display (screen); } else { display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); } screen_num = gdk_screen_get_number (screen); translated_documents = translate_document_list (desktop_file, documents); docs = translated_documents; success = FALSE; do { command = parse_exec (desktop_file, &docs, error); if (!command) goto out; if (!g_shell_parse_argv (command, &argc, &argv, error)) { g_free (command); goto out; } g_free (command); #if GTK_CHECK_VERSION (2, 12, 0) startup_id = start_startup_notification (display, desktop_file, argv[0], screen_num, workspace, launch_time); if (startup_id) { char *startup_id_env = g_strdup_printf ("DESKTOP_STARTUP_ID=%s", startup_id); env = array_putenv (env, startup_id_env); g_free (startup_id_env); } #else startup_id = NULL; #endif /* GTK 2.12 */ if (env != NULL) g_ptr_array_add (env, NULL); current_success = g_spawn_async_with_pipes (directory, argv, env ? (char **)(env->pdata) : NULL, flags, setup_func, setup_data, ret_pid, ret_stdin, ret_stdout, ret_stderr, error); g_strfreev (argv); if (startup_id) { #if GTK_CHECK_VERSION (2, 12, 0) if (current_success) { set_startup_notification_timeout (display, startup_id); if (ret_startup_id) *ret_startup_id = startup_id; else g_free (startup_id); } else #endif /* GTK 2.12 */ g_free (startup_id); } else if (ret_startup_id) *ret_startup_id = NULL; if (current_success) { /* If we successfully launch any instances of the app, make * sure we return TRUE and don't set @error. */ success = TRUE; error = NULL; /* Also, only set the output params on the first one */ ret_pid = NULL; ret_stdin = ret_stdout = ret_stderr = NULL; ret_startup_id = NULL; } } while (docs && current_success); out: if (env) { g_ptr_array_foreach (env, (GFunc)g_free, NULL); g_ptr_array_free (env, TRUE); } free_document_list (translated_documents); return success; }
int TvbRange_register(lua_State* L) { outstanding_TvbRange = g_ptr_array_new(); WSLUA_REGISTER_CLASS(TvbRange); return 0; }
gboolean success; gboolean broken_down; unsigned int i, j; /* loop counters */ char *prodtype_name; #if DEBUG g_debug ("----- ENTER new (%s)", MODEL_NAME); #endif m = g_new (naadsm_model_t, 1); local_data = g_new (local_data_t, 1); m->name = MODEL_NAME; m->events_listened_for = events_listened_for; m->nevents_listened_for = NEVENTS_LISTENED_FOR; m->outputs = g_ptr_array_new (); m->model_data = local_data; m->run = run; m->reset = reset; m->is_listening_for = is_listening_for; m->has_pending_actions = has_pending_actions; m->has_pending_infections = has_pending_infections; m->to_string = to_string; m->printf = local_printf; m->fprintf = local_fprintf; m->free = local_free; /* Make sure the right XML subtree was sent. */ g_assert (strcmp (scew_element_name (params), MODEL_NAME) == 0); local_data->exposures = RPT_new_reporting ("exposures", RPT_group, RPT_never);
int Tvb_register(lua_State* L) { WSLUA_REGISTER_CLASS(Tvb); outstanding_Tvb = g_ptr_array_new(); return 0; }
G_MODULE_EXPORT gboolean tracker_extract_get_metadata (TrackerExtractInfo *info) { struct jpeg_decompress_struct cinfo; struct tej_error_mgr tejerr; struct jpeg_marker_struct *marker; TrackerSparqlBuilder *preupdate, *metadata; TrackerXmpData *xd = NULL; TrackerExifData *ed = NULL; TrackerIptcData *id = NULL; MergeData md = { 0 }; GFile *file; FILE *f; goffset size; gchar *filename, *uri; gchar *comment = NULL; const gchar *dlna_profile, *dlna_mimetype, *graph; GPtrArray *keywords; gboolean success = TRUE; GString *where; guint i; metadata = tracker_extract_info_get_metadata_builder (info); preupdate = tracker_extract_info_get_preupdate_builder (info); graph = tracker_extract_info_get_graph (info); file = tracker_extract_info_get_file (info); filename = g_file_get_path (file); size = tracker_file_get_size (filename); if (size < 18) { g_free (filename); return FALSE; } f = tracker_file_open (filename); g_free (filename); if (!f) { return FALSE; } uri = g_file_get_uri (file); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:Image"); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nmm:Photo"); cinfo.err = jpeg_std_error (&tejerr.jpeg); tejerr.jpeg.error_exit = extract_jpeg_error_exit; if (setjmp (tejerr.setjmp_buffer)) { success = FALSE; goto fail; } jpeg_create_decompress (&cinfo); jpeg_save_markers (&cinfo, JPEG_COM, 0xFFFF); jpeg_save_markers (&cinfo, JPEG_APP0 + 1, 0xFFFF); jpeg_save_markers (&cinfo, JPEG_APP0 + 13, 0xFFFF); jpeg_stdio_src (&cinfo, f); jpeg_read_header (&cinfo, TRUE); /* FIXME? It is possible that there are markers after SOS, * but there shouldn't be. Should we decompress the whole file? * * jpeg_start_decompress(&cinfo); * jpeg_finish_decompress(&cinfo); * * jpeg_calc_output_dimensions(&cinfo); */ marker = (struct jpeg_marker_struct *) &cinfo.marker_list; while (marker) { gchar *str; gsize len; #ifdef HAVE_LIBIPTCDATA gsize offset; guint sublen; #endif /* HAVE_LIBIPTCDATA */ switch (marker->marker) { case JPEG_COM: g_free (comment); comment = g_strndup ((gchar*) marker->data, marker->data_length); break; case JPEG_APP0 + 1: str = (gchar*) marker->data; len = marker->data_length; #ifdef HAVE_LIBEXIF if (strncmp (EXIF_NAMESPACE, str, EXIF_NAMESPACE_LENGTH) == 0) { ed = tracker_exif_new ((guchar *) marker->data, len, uri); } #endif /* HAVE_LIBEXIF */ #ifdef HAVE_EXEMPI if (strncmp (XMP_NAMESPACE, str, XMP_NAMESPACE_LENGTH) == 0) { xd = tracker_xmp_new (str + XMP_NAMESPACE_LENGTH, len - XMP_NAMESPACE_LENGTH, uri); } #endif /* HAVE_EXEMPI */ break; case JPEG_APP0 + 13: str = (gchar*) marker->data; len = marker->data_length; #ifdef HAVE_LIBIPTCDATA if (len > 0 && strncmp (PS3_NAMESPACE, str, PS3_NAMESPACE_LENGTH) == 0) { offset = iptc_jpeg_ps3_find_iptc (str, len, &sublen); if (offset > 0 && sublen > 0) { id = tracker_iptc_new (str + offset, sublen, uri); } } #endif /* HAVE_LIBIPTCDATA */ break; default: marker = marker->next; continue; } marker = marker->next; } if (!ed) { ed = g_new0 (TrackerExifData, 1); } if (!xd) { xd = g_new0 (TrackerXmpData, 1); } if (!id) { id = g_new0 (TrackerIptcData, 1); } md.title = tracker_coalesce_strip (4, xd->title, ed->document_name, xd->title2, xd->pdf_title); md.orientation = tracker_coalesce_strip (3, xd->orientation, ed->orientation, id->image_orientation); md.copyright = tracker_coalesce_strip (4, xd->copyright, xd->rights, ed->copyright, id->copyright_notice); md.white_balance = tracker_coalesce_strip (2, xd->white_balance, ed->white_balance); md.fnumber = tracker_coalesce_strip (2, xd->fnumber, ed->fnumber); md.flash = tracker_coalesce_strip (2, xd->flash, ed->flash); md.focal_length = tracker_coalesce_strip (2, xd->focal_length, ed->focal_length); md.artist = tracker_coalesce_strip (3, xd->artist, ed->artist, xd->contributor); md.exposure_time = tracker_coalesce_strip (2, xd->exposure_time, ed->exposure_time); md.iso_speed_ratings = tracker_coalesce_strip (2, xd->iso_speed_ratings, ed->iso_speed_ratings); md.date = tracker_coalesce_strip (5, xd->date, xd->time_original, ed->time, id->date_created, ed->time_original); md.description = tracker_coalesce_strip (2, xd->description, ed->description); md.metering_mode = tracker_coalesce_strip (2, xd->metering_mode, ed->metering_mode); md.city = tracker_coalesce_strip (2, xd->city, id->city); md.state = tracker_coalesce_strip (2, xd->state, id->state); md.address = tracker_coalesce_strip (2, xd->address, id->sublocation); md.country = tracker_coalesce_strip (2, xd->country, id->country_name); /* FIXME We are not handling the altitude ref here for xmp */ md.gps_altitude = tracker_coalesce_strip (2, xd->gps_altitude, ed->gps_altitude); md.gps_latitude = tracker_coalesce_strip (2, xd->gps_latitude, ed->gps_latitude); md.gps_longitude = tracker_coalesce_strip (2, xd->gps_longitude, ed->gps_longitude); md.gps_direction = tracker_coalesce_strip (2, xd->gps_direction, ed->gps_direction); md.creator = tracker_coalesce_strip (3, xd->creator, id->byline, id->credit); md.comment = tracker_coalesce_strip (2, comment, ed->user_comment); md.make = tracker_coalesce_strip (2, xd->make, ed->make); md.model = tracker_coalesce_strip (2, xd->model, ed->model); /* Prioritize on native dimention in all cases */ tracker_sparql_builder_predicate (metadata, "nfo:width"); tracker_sparql_builder_object_int64 (metadata, cinfo.image_width); /* TODO: add ontology and store ed->software */ tracker_sparql_builder_predicate (metadata, "nfo:height"); tracker_sparql_builder_object_int64 (metadata, cinfo.image_height); if (guess_dlna_profile (cinfo.image_width, cinfo.image_height, &dlna_profile, &dlna_mimetype)) { tracker_sparql_builder_predicate (metadata, "nmm:dlnaProfile"); tracker_sparql_builder_object_string (metadata, dlna_profile); tracker_sparql_builder_predicate (metadata, "nmm:dlnaMime"); tracker_sparql_builder_object_string (metadata, dlna_mimetype); } if (id->contact) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", id->contact); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, id->contact); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nco:representative"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } keywords = g_ptr_array_new (); if (xd->keywords) { tracker_keywords_parse (keywords, xd->keywords); } if (xd->pdf_keywords) { tracker_keywords_parse (keywords, xd->pdf_keywords); } if (xd->subject) { tracker_keywords_parse (keywords, xd->subject); } if (xd->publisher) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", xd->publisher); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, xd->publisher); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nco:publisher"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (xd->type) { tracker_sparql_builder_predicate (metadata, "dc:type"); tracker_sparql_builder_object_unvalidated (metadata, xd->type); } if (xd->rating) { tracker_sparql_builder_predicate (metadata, "nao:numericRating"); tracker_sparql_builder_object_unvalidated (metadata, xd->rating); } if (xd->format) { tracker_sparql_builder_predicate (metadata, "dc:format"); tracker_sparql_builder_object_unvalidated (metadata, xd->format); } if (xd->identifier) { tracker_sparql_builder_predicate (metadata, "dc:indentifier"); tracker_sparql_builder_object_unvalidated (metadata, xd->identifier); } if (xd->source) { tracker_sparql_builder_predicate (metadata, "dc:source"); tracker_sparql_builder_object_unvalidated (metadata, xd->source); } if (xd->language) { tracker_sparql_builder_predicate (metadata, "dc:language"); tracker_sparql_builder_object_unvalidated (metadata, xd->language); } if (xd->relation) { tracker_sparql_builder_predicate (metadata, "dc:relation"); tracker_sparql_builder_object_unvalidated (metadata, xd->relation); } if (xd->coverage) { tracker_sparql_builder_predicate (metadata, "dc:coverage"); tracker_sparql_builder_object_unvalidated (metadata, xd->coverage); } if (xd->license) { tracker_sparql_builder_predicate (metadata, "nie:license"); tracker_sparql_builder_object_unvalidated (metadata, xd->license); } if (xd->regions) { tracker_xmp_apply_regions (preupdate, metadata, graph, xd); } if (id->keywords) { tracker_keywords_parse (keywords, id->keywords); } where = g_string_new (""); for (i = 0; i < keywords->len; i++) { gchar *p, *escaped, *var; p = g_ptr_array_index (keywords, i); escaped = tracker_sparql_escape_string (p); var = g_strdup_printf ("tag%d", i + 1); /* ensure tag with specified label exists */ tracker_sparql_builder_append (preupdate, "INSERT { "); if (graph) { tracker_sparql_builder_append (preupdate, "GRAPH <"); tracker_sparql_builder_append (preupdate, graph); tracker_sparql_builder_append (preupdate, "> { "); } tracker_sparql_builder_append (preupdate, "_:tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\""); if (graph) { tracker_sparql_builder_append (preupdate, " } "); } tracker_sparql_builder_append (preupdate, " }\n"); tracker_sparql_builder_append (preupdate, "WHERE { FILTER (NOT EXISTS { " "?tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\" }) }\n"); /* associate file with tag */ tracker_sparql_builder_predicate (metadata, "nao:hasTag"); tracker_sparql_builder_object_variable (metadata, var); g_string_append_printf (where, "?%s a nao:Tag ; nao:prefLabel \"%s\" .\n", var, escaped); g_free (var); g_free (escaped); g_free (p); } g_ptr_array_free (keywords, TRUE); tracker_extract_info_set_where_clause (info, where->str); g_string_free (where, TRUE); if (md.make || md.model) { gchar *equip_uri; equip_uri = tracker_sparql_escape_uri_printf ("urn:equipment:%s:%s:", md.make ? md.make : "", md.model ? md.model : ""); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, equip_uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nfo:Equipment"); if (md.make) { tracker_sparql_builder_predicate (preupdate, "nfo:manufacturer"); tracker_sparql_builder_object_unvalidated (preupdate, md.make); } if (md.model) { tracker_sparql_builder_predicate (preupdate, "nfo:model"); tracker_sparql_builder_object_unvalidated (preupdate, md.model); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nfo:equipment"); tracker_sparql_builder_object_iri (metadata, equip_uri); g_free (equip_uri); } tracker_guarantee_title_from_file (metadata, "nie:title", md.title, uri, NULL); if (md.orientation) { tracker_sparql_builder_predicate (metadata, "nfo:orientation"); tracker_sparql_builder_object (metadata, md.orientation); } if (md.copyright) { tracker_sparql_builder_predicate (metadata, "nie:copyright"); tracker_sparql_builder_object_unvalidated (metadata, md.copyright); } if (md.white_balance) { tracker_sparql_builder_predicate (metadata, "nmm:whiteBalance"); tracker_sparql_builder_object (metadata, md.white_balance); } if (md.fnumber) { gdouble value; value = g_strtod (md.fnumber, NULL); tracker_sparql_builder_predicate (metadata, "nmm:fnumber"); tracker_sparql_builder_object_double (metadata, value); } if (md.flash) { tracker_sparql_builder_predicate (metadata, "nmm:flash"); tracker_sparql_builder_object (metadata, md.flash); } if (md.focal_length) { gdouble value; value = g_strtod (md.focal_length, NULL); tracker_sparql_builder_predicate (metadata, "nmm:focalLength"); tracker_sparql_builder_object_double (metadata, value); } if (md.artist) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", md.artist); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, md.artist); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nco:contributor"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (md.exposure_time) { gdouble value; value = g_strtod (md.exposure_time, NULL); tracker_sparql_builder_predicate (metadata, "nmm:exposureTime"); tracker_sparql_builder_object_double (metadata, value); } if (md.iso_speed_ratings) { gdouble value; value = g_strtod (md.iso_speed_ratings, NULL); tracker_sparql_builder_predicate (metadata, "nmm:isoSpeed"); tracker_sparql_builder_object_double (metadata, value); } tracker_guarantee_date_from_file_mtime (metadata, "nie:contentCreated", md.date, uri); if (md.description) { tracker_sparql_builder_predicate (metadata, "nie:description"); tracker_sparql_builder_object_unvalidated (metadata, md.description); } if (md.metering_mode) { tracker_sparql_builder_predicate (metadata, "nmm:meteringMode"); tracker_sparql_builder_object (metadata, md.metering_mode); } if (md.creator) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", md.creator); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, md.creator); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); /* NOTE: We only have affiliation with * nco:PersonContact and we are using * nco:Contact here. */ /* if (id->byline_title) { */ /* tracker_sparql_builder_insert_open (preupdate, NULL); */ /* tracker_sparql_builder_subject (preupdate, "_:affiliation_by_line"); */ /* tracker_sparql_builder_predicate (preupdate, "a"); */ /* tracker_sparql_builder_object (preupdate, "nco:Affiliation"); */ /* tracker_sparql_builder_predicate (preupdate, "nco:title"); */ /* tracker_sparql_builder_object_unvalidated (preupdate, id->byline_title); */ /* tracker_sparql_builder_insert_close (preupdate); */ /* tracker_sparql_builder_predicate (preupdate, "a"); */ /* tracker_sparql_builder_object (preupdate, "nco:Contact"); */ /* tracker_sparql_builder_predicate (preupdate, "nco:hasAffiliation"); */ /* tracker_sparql_builder_object (preupdate, "_:affiliation_by_line"); */ /* } */ tracker_sparql_builder_predicate (metadata, "nco:creator"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (md.comment) { tracker_sparql_builder_predicate (metadata, "nie:comment"); tracker_sparql_builder_object_unvalidated (metadata, md.comment); } if (md.address || md.state || md.country || md.city || md.gps_altitude || md.gps_latitude || md.gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:location"); tracker_sparql_builder_object_blank_open (metadata); /* GeoPoint */ tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "slo:GeoLocation"); if (md.address || md.state || md.country || md.city) { gchar *addruri; addruri = tracker_sparql_get_uuid_urn (); tracker_sparql_builder_predicate (metadata, "slo:postalAddress"); tracker_sparql_builder_object_iri (metadata, addruri); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, addruri); g_free (addruri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:PostalAddress"); if (md.address) { tracker_sparql_builder_predicate (preupdate, "nco:streetAddress"); tracker_sparql_builder_object_unvalidated (preupdate, md.address); } if (md.state) { tracker_sparql_builder_predicate (preupdate, "nco:region"); tracker_sparql_builder_object_unvalidated (preupdate, md.state); } if (md.city) { tracker_sparql_builder_predicate (preupdate, "nco:locality"); tracker_sparql_builder_object_unvalidated (preupdate, md.city); } if (md.country) { tracker_sparql_builder_predicate (preupdate, "nco:country"); tracker_sparql_builder_object_unvalidated (preupdate, md.country); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); } if (md.gps_altitude) { tracker_sparql_builder_predicate (metadata, "slo:altitude"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_altitude); } if (md.gps_latitude) { tracker_sparql_builder_predicate (metadata, "slo:latitude"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_latitude); } if (md.gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:longitude"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_longitude); } tracker_sparql_builder_object_blank_close (metadata); /* GeoLocation */ } if (md.gps_direction) { tracker_sparql_builder_predicate (metadata, "nfo:heading"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_direction); } if (cinfo.density_unit != 0 || ed->x_resolution) { gdouble value; if (cinfo.density_unit == 0) { if (ed->resolution_unit != 3) value = g_strtod (ed->x_resolution, NULL); else value = g_strtod (ed->x_resolution, NULL) * CM_TO_INCH; } else { if (cinfo.density_unit == 1) value = cinfo.X_density; else value = cinfo.X_density * CM_TO_INCH; } tracker_sparql_builder_predicate (metadata, "nfo:horizontalResolution"); tracker_sparql_builder_object_double (metadata, value); } if (cinfo.density_unit != 0 || ed->y_resolution) { gdouble value; if (cinfo.density_unit == 0) { if (ed->resolution_unit != 3) value = g_strtod (ed->y_resolution, NULL); else value = g_strtod (ed->y_resolution, NULL) * CM_TO_INCH; } else { if (cinfo.density_unit == 1) value = cinfo.Y_density; else value = cinfo.Y_density * CM_TO_INCH; } tracker_sparql_builder_predicate (metadata, "nfo:verticalResolution"); tracker_sparql_builder_object_double (metadata, value); } jpeg_destroy_decompress (&cinfo); tracker_exif_free (ed); tracker_xmp_free (xd); tracker_iptc_free (id); g_free (comment); fail: tracker_file_close (f, FALSE); g_free (uri); return success; }
static gboolean teamd_start (NMDevice *device, NMSettingTeam *s_team) { NMDeviceTeam *self = NM_DEVICE_TEAM (device); NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (self); const char *iface = nm_device_get_ip_iface (device); gs_unref_ptrarray GPtrArray *argv = NULL; gs_free_error GError *error = NULL; gs_free char *tmp_str = NULL; const char *teamd_binary; const char *config; teamd_binary = nm_utils_find_helper ("teamd", NULL, NULL); if (!teamd_binary) { _LOGW (LOGD_TEAM, "Activation: (team) failed to start teamd: teamd binary not found"); return FALSE; } if (priv->teamd_process_watch || priv->teamd_pid > 0 || priv->tdc) { g_warn_if_reached (); if (!priv->teamd_pid) teamd_kill (self, teamd_binary, NULL); teamd_cleanup (device, TRUE); } /* Start teamd now */ argv = g_ptr_array_new (); g_ptr_array_add (argv, (gpointer) teamd_binary); g_ptr_array_add (argv, (gpointer) "-o"); g_ptr_array_add (argv, (gpointer) "-n"); g_ptr_array_add (argv, (gpointer) "-U"); g_ptr_array_add (argv, (gpointer) "-D"); g_ptr_array_add (argv, (gpointer) "-N"); g_ptr_array_add (argv, (gpointer) "-t"); g_ptr_array_add (argv, (gpointer) iface); config = nm_setting_team_get_config(s_team); if (config) { g_ptr_array_add (argv, (gpointer) "-c"); g_ptr_array_add (argv, (gpointer) config); } if (nm_logging_enabled (LOGL_DEBUG, LOGD_TEAM)) g_ptr_array_add (argv, (gpointer) "-gg"); g_ptr_array_add (argv, NULL); _LOGD (LOGD_TEAM, "running: %s", (tmp_str = g_strjoinv (" ", (gchar **) argv->pdata))); if (!g_spawn_async ("/", (char **) argv->pdata, NULL, G_SPAWN_DO_NOT_REAP_CHILD, nm_utils_setpgid, NULL, &priv->teamd_pid, &error)) { _LOGW (LOGD_TEAM, "Activation: (team) failed to start teamd: %s", error->message); teamd_cleanup (device, TRUE); return FALSE; } /* Start a timeout for teamd to appear at D-Bus */ if (!priv->teamd_timeout) priv->teamd_timeout = g_timeout_add_seconds (5, teamd_timeout_cb, device); /* Monitor the child process so we know when it dies */ priv->teamd_process_watch = g_child_watch_add (priv->teamd_pid, teamd_process_watch_cb, device); _LOGI (LOGD_TEAM, "Activation: (team) started teamd [pid %u]...", (guint) priv->teamd_pid); return TRUE; }