void free(void * ptr) {
if (ptr) {
size_t sz = malloc_size(ptr);
g_global_memory.dec(sz);
}
free_core(ptr);
}
/**
Free any memory associated with your scheduler.
Assumptions:
- This function will be the last function called in your library.
*/
void scheduler_clean_up()
{
void* p = NULL;
while( (p = priqueue_poll(jobs)) != NULL )
free_job((job_t*)p);
priqueue_destroy(jobs);
free(jobs);
free_core(&cores);
}//scheduler_clean_up
int main(int argc, char** argv) {
init_core();
debug_message("[hunter] initialized core");
init_graphic();
debug_message("[hunter] initialized graphics, mode W%d H%d", window_get_width(global_get(global_get_singleton(), GLOBAL_WINDOW)), window_get_height(global_get(global_get_singleton(), GLOBAL_WINDOW)));
init_sound();
debug_message("[hunter] initialized sound");
init_systems();
debug_message("[hunter] initialized systems");
window* window_handle = global_get(global_get_singleton(), GLOBAL_WINDOW);
input* input_handle = global_get(global_get_singleton(), GLOBAL_INPUT);
syscontainer* syscontainer_handle = global_get(global_get_singleton(), GLOBAL_SYSCONTAINER);
text* text_handle = global_get(global_get_singleton(), GLOBAL_TEXT);
hl_render* hl_render_handle = global_get(global_get_singleton(), GLOBAL_HL_RENDER);
shader* shader_texture_handle = global_get(global_get_singleton(), GLOBAL_SHADER_TEXTURE);
camera* camera_handle = global_get(global_get_singleton(), GLOBAL_CAMERA);
debug_draw* debug_draw_handle = global_get(global_get_singleton(), GLOBAL_DEBUG_DRAW);
float delta_ref_point = time_get_elapsed(window_handle);
float delta_accumulator = 0.0f;
float delta_frame_time = 0.0f;
float fps_accumulator = 0.0f;
float fps_value = 0.0f;
float fps_value_last = fps_value;
unsigned int fps_counter = 0;
unsigned int game_kill_flag = 0;
debug_message("[hunter] posting init event to systems");
syscontainer_post_event(syscontainer_handle, EVENT_INIT);
while (!game_kill_flag) {
delta_frame_time = time_get_elapsed(window_handle) - delta_ref_point;
delta_ref_point = time_get_elapsed(window_handle);
window_update(window_handle);
input_state current_input_state;
input_get_input_state(input_handle, ¤t_input_state);
game_kill_flag |= window_get_should_close(window_handle);
game_kill_flag |= current_input_state.key_dev;
window_set_clear_color(window_handle, 1.0f, 0.0f, 1.0f, 0.0f);
debug_draw_clear(debug_draw_handle);
window_clear(window_handle);
delta_accumulator += delta_frame_time;
if (delta_accumulator < 0.0f) {
delta_accumulator = 0.0f;
}
while (delta_accumulator >= 1.0f / DELTA_REFERENCE_FPS) {
syscontainer_post_event(syscontainer_handle, EVENT_PRE_LOGIC);
syscontainer_post_event(syscontainer_handle, EVENT_LOGIC);
syscontainer_post_event(syscontainer_handle, EVENT_POST_LOGIC);
delta_accumulator -= 1.0f / DELTA_REFERENCE_FPS;
}
syscontainer_post_event(syscontainer_handle, EVENT_DRAW);
window_set_blend_mode(window_handle, WINDOW_BLEND_ALPHA);
debug_draw_render_all(debug_draw_handle);
hl_render_draw(hl_render_handle, shader_texture_handle, camera_handle);
hl_render_clear(hl_render_handle);
fps_counter++;
fps_accumulator += delta_frame_time;
if (fps_accumulator >= 1.0f) {
fps_value_last = fps_value;
fps_value = (float) fps_counter / fps_accumulator;
fps_counter = 0;
fps_accumulator = 0.0f;
}
text_batch fps_batch = {20, 20, 0.2f, 0.8f, 1.0f, 1.0f, "", "monospace", 12};
sprintf(fps_batch.text_data, "FPS : %3.2f (%3.2f)", fps_value, fps_value - fps_value_last);
text_submit_batch(text_handle, &fps_batch);
text_render_all(text_handle);
text_flush_batch(text_handle);
window_swap_buffers(window_handle);
}
debug_message("[hunter] posting destroy event to systems");
syscontainer_post_event(syscontainer_handle, EVENT_DESTROY);
free_systems();
free_sound();
free_graphic();
free_core();
h_free_all();
debug_message("[hunter] terminated cleanly");
return 0;
}
int main(int argc, char **argv)
{
Job job;
int i;
FILE *pjf;
init_job(&job);
job.core = create_core();
for (i = 1; i < argc; i++)
{
char *opt = argv[i];
char *arg = argv[i + 1];
if (opt[0] == '-' && strcmp(opt, "-"))
{
if (!strcmp(opt, "-L") || !strcmp(opt, "--letter"))
{
job.just_one_letter = 1;
job.just_one_word = 0;
}
if (!strcmp(opt, "-t") || !strcmp(opt, "--truth"))
{
i++; if (!arg) usage();
job.just_one_letter = 1;
job.just_one_word = 0;
job.ground_truth = arg;
}
if (!strcmp(opt, "-a") || !strcmp(opt, "--append"))
{
job.append = 1;
}
else if (!strcmp(opt, "-W") || !strcmp(opt, "--word"))
{
job.just_one_letter = 0;
job.just_one_word = 1;
}
else if (!strcmp(opt, "-l") || !strcmp(opt, "--lib"))
{
Library l;
i++; if (!arg) usage();
l = library_open(arg);
library_discard_prototypes(l);
add_to_core(job.core, l);
}
else if (!strcmp(opt, "-p") || !strcmp(opt, "-j") || !strcmp(opt, "--pjf"))
{
i++; if (!arg) usage();
job.job_file_path = arg;
}
else if (!strcmp(opt, "-i") || !strcmp(opt, "--in"))
{
i++; if (!arg) usage();
job.input_path = arg;
}
else if (!strcmp(opt, "-o") || !strcmp(opt, "--out"))
{
i++; if (!arg) usage();
set_core_orange_policy(job.core, 1);
job.out_library_path = arg;
}
else if (!strcmp(opt, "-c") || !strcmp(opt, "--color"))
{
job.colored_output = 1;
}
else if (!strcmp(opt, "-n") || !strcmp(opt, "--nocolor"))
{
job.colored_output = 0;
}
}
}
load_image(&job);
if (job.just_one_letter)
{
process_letter(&job, 0, 0, job.width, job.height);
putchar('\n');
if (job.ground_truth && job.out_library_path)
{
Library l = get_core_orange_library(job.core);
if (library_shelves_count(l))
{
Shelf *s = library_get_shelf(l, 0);
if (s->count)
{
strncpy(s->records[0].text, job.ground_truth, MAX_TEXT_SIZE);
}
}
}
}
else if (job.just_one_word)
{
process_word(&job, 0, 0, job.width, job.height);
putchar('\n');
}
else
{
if (!job.job_file_path)
{
fprintf(stderr, "You must specify a pjf file (or either -L or -W).\n");
usage();
}
pjf = fopen(job.job_file_path, "r");
if (!pjf)
{
perror(job.job_file_path);
exit(1);
}
go(&job, pjf);
}
if (job.out_library_path)
library_save(get_core_orange_library(job.core), job.out_library_path, job.append);
free_bitmap(job.pixels);
free_core(job.core);
return 0;
}
int main(int argc, char **argv)
{
extern int alloc_core(void);
extern void free_core(void);
char *outfname = 0, *netfile;
FILE *infile, *outfile;
int status;
static char const str_opts[] = "rf:dpvIsN:S:P:L:M:l:Vhu";
static const struct option long_opts[] = {
{"remote", 0, 0, 'r'},
{"file", 1, 0, 'f'},
{"Nodes", 1, 0, 'N'},
{"Switches", 1, 0, 'S'},
{"Ports", 1, 0, 'P'},
{"Linearcap", 1, 0, 'L'},
{"Mcastcap", 1, 0, 'M'},
{"listen", 1, 0, 'l'},
{"Ignoredups", 0, 0, 'I'},
{"start", 0, 0, 's'},
{"debug", 0, 0, 'd'},
{"parsedebug", 0, 0, 'p'},
{"verbose", 0, 0, 'v'},
{"Version", 0, 0, 'V'},
{"help", 0, 0, 'h'},
{"usage", 0, 0, 'u'},
{}
};
while (1) {
int ch = getopt_long(argc, argv, str_opts, long_opts, NULL);
if (ch == -1)
break;
switch (ch) {
case 'r':
remote_mode = 1;
break;
case 'f':
outfname = optarg;
break;
case 'd':
ibdebug++;
break;
case 'p':
parsedebug++;
break;
case 'v':
simverb++;
break;
case 's':
netstarted = 1;
break;
case 'I':
ignoreduplicate = 1;
break;
case 'N':
maxnetnodes = strtoul(optarg, 0, 0);
break;
case 'S':
maxnetswitches = strtoul(optarg, 0, 0);
break;
case 'P':
maxnetports = strtoul(optarg, 0, 0);
break;
case 'L':
maxlinearcap = strtoul(optarg, 0, 0);
break;
case 'M':
maxmcastcap = strtoul(optarg, 0, 0);
break;
case 'l':
listen_to_port = strtoul(optarg, 0, 0);
break;
case 'V':
default:
usage(argv[0]);
}
}
maxnetaliases = maxnetports;
infile = stdin;
outfile = stdout;
if (outfname && (outfile = fopen(outfname, "w")) == 0)
IBPANIC("can't open out file %s for write", outfname);
if (optind >= argc)
usage(argv[0]);
netfile = argv[optind];
if (alloc_core() < 0)
IBPANIC("not enough memory for core structure");
DEBUG("initializing net \"%s\"", netfile);
status = sim_init_net(netfile, outfile);
if (status < 0)
IBPANIC("sim_init failed, status %d", status);
sim_init_console(outfile);
sim_run(fileno(infile));
free_core();
exit(0);
}
