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