/* ------------- Platform de/init --------- */ void pl_platform_init(FILE * debug_out) { gp_init(); /* debug flags we reset this out of gs_lib_init0 which sets these and the allocator we want the debug setting but we do our own allocator */ #ifdef PACIFY_VALGRIND VALGRIND_HG_DISABLE_CHECKING(gs_debug, 128); #endif memset(gs_debug, 0, 128); gs_log_errors = 0; }
static void gimp_plug_in_class_init (GimpPlugInClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->finalize = gimp_plug_in_finalize; /* initialize the gimp protocol library and set the read and * write handlers. */ gp_init (); gimp_wire_set_writer (gimp_plug_in_write); gimp_wire_set_flusher (gimp_plug_in_flush); }
int main(int argc, char *argv[]) { int c; gp_boolean usage = false; int display_flags; char temp_buf[12]; char *processor_name; const struct px *processor_info; proc_class_t processor_class; gp_init(); #define DISPLAY_NOTHING 0 #define DISPLAY_DIR 1 #define DISPLAY_SYM 2 #define DISPLAY_ROM 4 #define DISPLAY_SRC 8 #define DISPLAY_MESS 16 #define DISPLAY_ALL 0xff display_flags = DISPLAY_NOTHING; while ((c = getopt_long(argc, argv, GET_OPTIONS, longopts, NULL)) != EOF) { switch (c) { case '?': case 'h': usage = true; break; case 'a': display_flags = DISPLAY_ALL; break; case 'd': display_flags |= DISPLAY_DIR; break; case 's': display_flags |= DISPLAY_SYM; break; case 'r': display_flags |= DISPLAY_ROM; break; case 'l': display_flags |= DISPLAY_SRC; break; case 'm': display_flags |= DISPLAY_MESS; break; case 'v': fprintf(stderr, "%s\n", GPVC_VERSION_STRING); exit(0); } if (usage) { break; } } if ((optind + 1) == argc) { strncpy(filename, argv[optind], sizeof(filename)); } else { usage = 1; } if (display_flags == DISPLAY_NOTHING) { display_flags = DISPLAY_ALL; } if (usage) { show_usage(); } codefile = fopen(filename,"rb"); if (codefile == NULL) { perror(filename); exit(1); } /* Start off by reading the directory block */ main_dir = read_directory(); /* Determine if byte address and org are different */ processor_name = substr(temp_buf, sizeof(temp_buf), &main_dir->dir[COD_DIR_PROCESSOR], 8); processor_info = gp_find_processor(processor_name); processor_class = gp_processor_class(processor_info); if (display_flags & DISPLAY_DIR) { dump_directory_blocks(); } if (display_flags & DISPLAY_ROM) { dump_code(processor_class); } if (display_flags & DISPLAY_SYM) { dump_symbols(); dump_lsymbols(); dump_local_vars(processor_class); } dump_source_files(); if (display_flags & DISPLAY_SRC) { dump_line_symbols(); } if (display_flags & DISPLAY_MESS) { dump_message_area(); } return EXIT_SUCCESS; }
int main(int argc, const char *argv[]) { char achar = '0'; gs_memory_t *mem; gs_state *pgs; const gx_device *const *list; gx_device *dev; gx_device_bbox *bbdev; int code; gp_init(); mem = gs_malloc_init(); gs_lib_init1(mem); if (argc < 2 || (achar = argv[1][0]) < '1' || achar > '0' + countof(tests) - 1 ) { lprintf1("Usage: gslib 1..%c\n", '0' + (char)countof(tests) - 1); gs_abort(mem); } gs_debug['@'] = 1; gs_debug['?'] = 1; /*gs_debug['B'] = 1; *//****** PATCH ******/ /*gs_debug['L'] = 1; *//****** PATCH ******/ /* * gs_iodev_init must be called after the rest of the inits, for * obscure reasons that really should be documented! */ gs_iodev_init(mem); /****** WRONG ******/ gs_lib_device_list(&list, NULL); gs_copydevice(&dev, list[0], mem); check_device_separable(dev); gx_device_fill_in_procs(dev); bbdev = gs_alloc_struct_immovable(mem, gx_device_bbox, &st_device_bbox, "bbox"); gx_device_bbox_init(bbdev, dev, mem); code = dev_proc(dev, get_profile)(dev, &bbdev->icc_struct); rc_increment(bbdev->icc_struct); /* Print out the device name just to test the gsparam.c API. */ { gs_c_param_list list; gs_param_string nstr; gs_c_param_list_write(&list, mem); code = gs_getdeviceparams(dev, (gs_param_list *) & list); if (code < 0) { lprintf1("getdeviceparams failed! code = %d\n", code); gs_abort(mem); } gs_c_param_list_read(&list); code = param_read_string((gs_param_list *) & list, "Name", &nstr); if (code < 0) { lprintf1("reading Name failed! code = %d\n", code); gs_abort(mem); } dputs("Device name = "); debug_print_string(nstr.data, nstr.size); dputs("\n"); gs_c_param_list_release(&list); } /* * If this is a device that takes an OutputFile, set the OutputFile * to "-" in the copy. */ { gs_c_param_list list; gs_param_string nstr; gs_c_param_list_write(&list, mem); param_string_from_string(nstr, "-"); code = param_write_string((gs_param_list *)&list, "OutputFile", &nstr); if (code < 0) { lprintf1("writing OutputFile failed! code = %d\n", code); gs_abort(mem); } gs_c_param_list_read(&list); code = gs_putdeviceparams(dev, (gs_param_list *)&list); gs_c_param_list_release(&list); if (code < 0 && code != gs_error_undefined) { lprintf1("putdeviceparams failed! code = %d\n", code); gs_abort(mem); } } dev = (gx_device *) bbdev; pgs = gs_state_alloc(mem); gs_setdevice_no_erase(pgs, dev); /* can't erase yet */ { gs_point dpi; gs_screen_halftone ht; gs_dtransform(pgs, 72.0, 72.0, &dpi); ht.frequency = min(fabs(dpi.x), fabs(dpi.y)) / 16.001; ht.angle = 0; ht.spot_function = odsf; gs_setscreen(pgs, &ht); } /* gsave and grestore (among other places) assume that */ /* there are at least 2 gstates on the graphics stack. */ /* Ensure that now. */ gs_gsave(pgs); gs_erasepage(pgs); code = (*tests[achar - '1']) (pgs, mem); gs_output_page(pgs, 1, 1); { gs_rect bbox; gx_device_bbox_bbox(bbdev, &bbox); dprintf4("Bounding box: [%g %g %g %g]\n", bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y); } if (code) dprintf1("**** Test returned code = %d.\n", code); dputs("Done. Press <enter> to exit."); fgetc(mem->gs_lib_ctx->fstdin); gs_lib_finit(0, 0, mem); return 0; #undef mem }
void gtkpod_init(int argc, char *argv[]) { AnjutaPluginManager *plugin_manager; AnjutaProfileManager *profile_manager; AnjutaApp *app; AnjutaStatus *status; AnjutaProfile *profile; GFile *session_profile; GError *error = NULL; gchar *default_profile_file = NULL; gchar *user_profile_file = NULL; gchar *ui_file = NULL; gchar *remembered_plugins = NULL; gchar *session_dir = NULL; gchar *splash = NULL; /* Initialise important directories */ init_directories(argv); register_stock_icon(GTKPOD_ICON, GTKPOD_ICON_STOCK_ID); /* Initialise the ui file */ ui_file = g_build_filename(get_ui_dir(), "gtkpod.ui", NULL); anjuta_set_ui_file_path(ui_file); /* Register the application icon */ register_stock_icon("gtkpod", GTKPOD_APP_ICON_STOCK_ID); /* Initialize application class instance*/ app = ANJUTA_APP(anjuta_app_new()); gtkpod_app = GTKPOD_APP(app); /* Initialise the preferences as required for the display of the splash screen */ prefs_init(argc, argv); /* Show some progress as the app is initialised */ status = anjuta_shell_get_status(ANJUTA_SHELL(app), NULL); anjuta_status_progress_add_ticks(status, 1); /* Show the splash screen if user requires */ if (! prefs_get_int(DISABLE_SPLASH_SCREEN)) { splash = g_build_filename(get_icon_dir(), "gtkpod-splash.png", NULL); if (g_file_test(splash, G_FILE_TEST_IS_REGULAR)) anjuta_status_set_splash(status, splash, 100); else { anjuta_status_disable_splash(status, TRUE); } g_free(splash); } /* * initialise gtkpod library items. Needs to be safety threaded due * to splash screen. */ gdk_threads_enter(); gp_init(argc, argv); gdk_threads_leave(); /* Add blocking widgets from the framework */ add_blocked_widget(app->toolbar); add_blocked_widget(app->view_menu); /* Set up shutdown signals */ g_signal_connect(G_OBJECT(app), "delete_event", G_CALLBACK( on_gtkpod_delete_event), NULL); g_signal_connect(G_OBJECT(app), "destroy", G_CALLBACK(on_gtkpod_destroy), NULL); plugin_manager = anjuta_shell_get_plugin_manager(ANJUTA_SHELL(app), NULL); profile_manager = anjuta_shell_get_profile_manager(ANJUTA_SHELL(app), NULL); /* Restore remembered plugins */ remembered_plugins = g_settings_get_string(app->settings, GTKPOD_REMEMBERED_PLUGINS); if (remembered_plugins) anjuta_plugin_manager_set_remembered_plugins(plugin_manager, remembered_plugins); g_free(remembered_plugins); /* Load default profile */ default_profile_file = get_default_profile_path(); profile = anjuta_profile_new(USER_PROFILE_NAME, plugin_manager); session_profile = g_file_new_for_path(default_profile_file); anjuta_profile_add_plugins_from_xml(profile, session_profile, TRUE, &error); if (error) { anjuta_util_dialog_error(GTK_WINDOW(app), "%s", error->message); g_error_free(error); error = NULL; } g_object_unref(session_profile); g_free(default_profile_file); /* Load user session profile */ user_profile_file = get_user_profile_path(); session_profile = g_file_new_for_path(user_profile_file); if (g_file_query_exists(session_profile, NULL)) { anjuta_profile_add_plugins_from_xml(profile, session_profile, FALSE, &error); if (error) { anjuta_util_dialog_error(GTK_WINDOW(app), "%s", error->message); g_error_free(error); error = NULL; } } anjuta_profile_set_sync_file(profile, session_profile); g_object_unref(session_profile); g_free(user_profile_file); /* Load profile */ anjuta_profile_manager_freeze(profile_manager); anjuta_profile_manager_push(profile_manager, profile, &error); if (error) { anjuta_util_dialog_error(GTK_WINDOW(app), "%s", error->message); g_error_free(error); error = NULL; } /* Prepare for session save and load on profile change */ g_signal_connect (profile_manager, "profile-scoped", G_CALLBACK (on_profile_scoped), app); anjuta_profile_manager_thaw(profile_manager, &error); if (error) { anjuta_util_dialog_error(GTK_WINDOW(app), "%s", error->message); g_error_free(error); error = NULL; } g_signal_connect (profile_manager, "profile-descoped", G_CALLBACK (on_profile_descoped), app); gdk_threads_enter(); gp_init_itdbs(); gdk_threads_leave(); /* Load layout.*/ session_dir = get_user_session_dir(); if (!g_file_test(session_dir, G_FILE_TEST_IS_DIR)) session_dir = g_strdup(get_data_dir()); /* Restore session */ anjuta_shell_session_load(ANJUTA_SHELL(app), session_dir, NULL); g_free(session_dir); anjuta_status_progress_tick(status, NULL, _("Loaded Session...")); anjuta_status_disable_splash(status, TRUE); gtk_window_set_default_icon_name("gtkpod"); gtk_window_set_auto_startup_notification(TRUE); gtk_window_set_role(GTK_WINDOW(app), "gtkpod-app"); gtk_widget_show(GTK_WIDGET(app)); }
int main(int argc, char *argv[]) { extern int optind; int i = 0; int c; gp_boolean usage = false; gp_boolean update_archive = false; gp_boolean no_index = false; gp_archive_type *object = NULL; gp_init(); /* symbols are case sensitive */ definition_tbl = push_symbol_table(NULL, false); symbol_index = push_symbol_table(NULL, false); while ((c = GETOPT_FUNC) != EOF) { switch (c) { case '?': case 'h': usage = true; break; case 'c': select_mode(ar_create); break; case 'd': select_mode(ar_delete); break; case 'n': no_index = true; break; case 'q': gp_quiet = true; break; case 'r': select_mode(ar_replace); break; case 's': select_mode(ar_symbols); break; case 't': select_mode(ar_list); break; case 'v': fprintf(stderr, "%s\n", GPLIB_VERSION_STRING); exit(0); break; case 'x': select_mode(ar_extract); break; } if (usage) break; } if (optind < argc) { /* fetch the library name */ state.filename = argv[optind++]; /* some operations require object filenames or membernames */ for ( ; optind < argc; optind++) { state.objectname[state.numobjects] = argv[optind]; if (state.numobjects >= MAX_OBJ_NAMES) { gp_error("exceeded maximum number of object files"); break; } state.numobjects++; } } else { usage = true; } /* User did not select an operation */ if (state.mode == ar_null) { usage = true; } /* User did not provide object names */ if ((state.mode != ar_list) && (state.mode != ar_symbols) && (state.numobjects == 0)) { usage = true; } if (usage) { show_usage(); } /* if we are not creating a new archive, we have to read an existing one */ if (state.mode != ar_create) { if (gp_identify_coff_file(state.filename) != archive_file) { gp_error("\"%s\" is not a valid archive file", state.filename); exit(1); } else { state.archive = gp_archive_read(state.filename); } } /* process the option */ i = 0; switch (state.mode) { case ar_create: case ar_replace: while (i < state.numobjects) { if (gp_identify_coff_file(state.objectname[i]) != object_file) { gp_error("\"%s\" is not a valid object file", state.objectname[i]); break; } else { state.archive = gp_archive_add_member(state.archive, state.objectname[i], object_name(state.objectname[i])); } i++; } update_archive = true; break; case ar_delete: while (i < state.numobjects) { if (has_path(state.objectname[i])) { gp_error("invalid object name \"%s\"", state.objectname[i]); break; } object = gp_archive_find_member(state.archive, state.objectname[i]); if (object == NULL) { gp_error("object \"%s\" not found", state.objectname[i]); break; } else { state.archive = gp_archive_delete_member(state.archive, state.objectname[i]); } i++; } update_archive = true; break; case ar_extract: while (i < state.numobjects) { if (has_path(state.objectname[i])) { gp_error("invalid object name \"%s\"", state.objectname[i]); break; } object = gp_archive_find_member(state.archive, state.objectname[i]); if (object == NULL) { gp_error("object \"%s\" not found", state.objectname[i]); break; } else { if (gp_archive_extract_member(state.archive, state.objectname[i])) { gp_error("can't write file \"%s\"", state.objectname[i]); break; } } i++; } break; case ar_list: gp_archive_list_members(state.archive); break; case ar_symbols: if (gp_archive_have_index(state.archive) == 0) { gp_error("this archive has no symbol index"); } else { gp_archive_read_index(symbol_index, state.archive); gp_archive_print_table(symbol_index); } break; case ar_null: default: assert(0); } /* If the archive is being modified remove the old symbol index */ if (update_archive) { state.archive = gp_archive_remove_index(state.archive); } /* check for duplicate symbols */ gp_archive_make_index(state.archive, definition_tbl); /* add the symbol index to the archive */ if (update_archive && (!no_index)) { state.archive = gp_archive_add_index(definition_tbl, state.archive); } /* write the new or modified archive */ if (update_archive && (gp_num_errors == 0)) { if (gp_archive_write(state.archive, state.filename)) gp_error("can't write the new archive file"); } if (gp_num_errors > 0) return EXIT_FAILURE; else return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { extern int optind; int c; int usage = 0; gp_init(); /* initalize */ verbose = false; state.strip_debug = false; state.preserve_dates = false; state.strip_all = false; state.strip_unneeded = false; state.discard_all = false; state.output_file = NULL; state.symbol_keep = push_symbol_table(NULL, false); state.symbol_remove = push_symbol_table(NULL, false); state.section_remove = push_symbol_table(NULL, false); while ((c = GETOPT_FUNC) != EOF) { switch (c) { case '?': case 'h': usage = 1; break; case 'g': state.strip_debug = true; break; case 'k': add_name(state.symbol_keep, optarg); break; case 'n': add_name(state.symbol_remove, optarg); break; case 'o': state.output_file = optarg; break; case 'p': state.preserve_dates = true; break; case 'r': add_name(state.section_remove, optarg); break; case 's': state.strip_all = true; break; case 'u': state.strip_unneeded = true; break; case 'x': state.discard_all = true; break; case 'V': verbose = true; break; case 'v': fprintf(stderr, "%s\n", GPSTRIP_VERSION_STRING); exit(0); } if (usage) break; } if ((optind == argc) || (usage)) { show_usage(); } for ( ; optind < argc; optind++) { state.input_file = argv[optind]; if (gp_identify_coff_file(state.input_file) != object_file_v2 && gp_identify_coff_file(state.input_file) != object_file) { gp_error("\"%s\" is not a valid object file", state.input_file); exit(1); } state.object = gp_read_coff(state.input_file); if (state.object) { remove_sections(); remove_symbols(); if (state.strip_all) { strip_all(); } if (state.strip_debug) { if (state.strip_all) { gp_message("strip debug ignored"); } else { strip_debug(); } } if (state.strip_unneeded) { if (state.strip_all) { gp_message("strip unneeded ignored"); } else { strip_unneeded(); } } if (state.discard_all) { if (state.strip_all) { gp_message("discard all ignored"); } else { discard_all(); } } if (state.output_file) { state.object->filename = state.output_file; } if (!state.preserve_dates) { /* FIXME: need to update the output file dates */ state.object->time = (long)time(NULL); } if (gp_num_errors == 0) { /* no errors have occured so write the file */ if (gp_write_coff(state.object, 0)) gp_error("system error while writing object file"); } else if (state.output_file) { /* a new file is being written, but errors have occurred, delete the file if it exists */ unlink(state.output_file); } /* FIXME: free state.output_file */ } } if (gp_num_errors) return EXIT_FAILURE; else return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { extern int optind; unsigned int buffer_size; int c,usage=0; int display_flags; Directory *dir; gp_init(); byte_addr = 0; #define DISPLAY_NOTHING 0 #define DISPLAY_DIR 1 #define DISPLAY_SYM 2 #define DISPLAY_ROM 4 #define DISPLAY_SRC 8 #define DISPLAY_MESS 16 #define DISPLAY_ALL 0xff display_flags = DISPLAY_NOTHING; while ((c = GETOPT_FUNC) != EOF) { switch (c) { case '?': case 'h': usage = 1; break; case 'a': display_flags = DISPLAY_ALL; break; case 'd': display_flags |= DISPLAY_DIR; break; case 's': display_flags |= DISPLAY_SYM; break; case 'r': display_flags |= DISPLAY_ROM; break; case 'l': display_flags |= DISPLAY_SRC; break; case 'm': display_flags |= DISPLAY_MESS; break; case 'v': fprintf(stderr, "%s\n", GPVC_VERSION_STRING); exit(0); } if (usage) break; } if ((optind + 1) == argc) strncpy(filename, argv[optind], sizeof(filename)); else usage = 1; if(display_flags == DISPLAY_NOTHING) display_flags = DISPLAY_ALL; if (usage) { show_usage(); } codefile = fopen(filename,"rb"); if(codefile == NULL) { perror(filename); exit(1); } /* Start off by reading the directory block */ read_directory(); fseek(codefile, 0,SEEK_SET); buffer_size = fread(directory_block_data, 1, COD_BLOCK_SIZE, codefile); if(display_flags & DISPLAY_DIR) directory_block(); dir = (Directory *)directory_block_data; if(display_flags & DISPLAY_ROM) dump_code(); if(display_flags & DISPLAY_SYM) { dump_symbols(); dump_lsymbols(); dump_local_vars(); } dump_source_files(); if(display_flags & DISPLAY_SRC) dump_line_symbols(); if(display_flags & DISPLAY_MESS) dump_message_area(); return EXIT_SUCCESS; }
int main(int argc, CmdArg* argv) { int i = 0; char result[0x10]; if(!gGpHasInit || gCmdCount == 0) { if(gp_init()) { puts("Unable to initialize greenpois0n!!\n"); return -1; } puts("=========================\n"); puts("iFaith Thanks & Credits:\n"); puts("=========================\n"); puts("* AKi_nG\n"); puts("* bile\n"); puts("* Chronic Dev-Team\n"); puts("* CPICH\n"); puts("* cj\n"); puts("* demize\n"); puts("* geohot\n"); puts("* GreySyntax\n"); puts("* iFish12\n"); puts("* msftguy\n"); puts("* MuscleNerd\n"); puts("* Neal\n"); puts("* planetbeing\n"); puts("* pod2g\n"); puts("* posixninja\n"); puts("* qwertyoruiop\n"); puts("* sbingner\n"); puts("* ThePirate\n"); puts("* vonswanko\n"); puts("=========================\n"); cmd_detect(); fs_mount("nand0a", "hfs", "/boot"); //puts("HFS+ filesystem mounted.\n") //puts("=========================\n"); return 0; } for(i = 1; i < argc; i++) { if(!strcmp(argv[i].string, "$_")) { NvramVar* retval = nvram_find_var("?"); argv[i].string = retval->string; continue; } if(argv[i].string[0] == '$') { NvramVar* var = nvram_find_var(&(argv[i].string[1])); if(var == NULL) { printf("Unable to find nvram var for %s\n", &(argv[i].string[1])); } else { argv[i].string = var->string; } } } if(argc > 1) { int i = 0; char* command = argv[1].string; for(i = 0; i < gCmdCount; i++) { if(!strcmp(gCmdCommands[i]->name, command)) { int ret = gCmdCommands[i]->handler(argc-1, &argv[1]); snprintf(result, 0xF, "0x%x", ret); nvram_set_var("cmd-results", result); return ret; } } printf("Command %s not found.\n\n", command); return -1; } return 0; }