/* Auxiliary function for freeing boxed types */
void boxed_free_helper (GType *gtype, void *boxed)
{
if (print_debug_info()) {
fprintf(stderr, "Freeing a boxed object at %p\n", boxed);
fprintf(stderr, "\tIt is of type %s\n", g_type_name(*gtype));
}
g_boxed_free (*gtype, boxed);
g_free (gtype);
if (print_debug_info()) {
fprintf(stderr, "\tdone\n");
}
}
void display()
{
handleInput(tf_world);
timer->tick();
monster->update();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
tf_world->applyST();
board->draw();
highlight->draw(mouse, tf_world);
gun1->draw();
gun2->draw();
tesbil->draw();
monster->draw();
planet->draw();
cursor->draw();
glPopMatrix();
print_debug_info(mouse, tf_world, timer->intervalTicks);
glutSwapBuffers();
glutPostRedisplay();
}
TTFSurfacePtr
TTFSurfaceManager::create_surface(const TTFFont& font, const std::string& text)
{
auto key = Key(font.get_ttf_font(), text);
auto it = m_cache.find(key);
if (it != m_cache.end())
{
auto& entry = m_cache[key];
entry.last_access = g_game_time;
return entry.ttf_surface;
}
else
{
if ((false))
{
// Font debug output should go to 'std::cerr', not any of the
// log_* functions, as those are mirrored on the console which
// in turn will lead to the creation of more TTFSurface's and
// screw up the results.
print_debug_info(std::cerr);
}
cache_cleanup_step();
TTFSurfacePtr ttf_surface = TTFSurface::create(font, text);
m_cache[key] = ttf_surface;
return ttf_surface;
}
}
uint8_t execute_interpreter_cycle(cpu_registers* registers, bool nmi_flag) {
static bool previous_nmi_flag = false;
uint8_t cpu_cycles_executed = 0;
uint8_t extra_cycles= 0;
if(DMA_is_executing()) cpu_cycles_executed = execute_DMA();
else {
uint8_t opcode = fetch_opcode(registers);
increment_PC(registers);
if(nmi_flag && !previous_nmi_flag) cpu_cycles_executed = execute_NMI(registers);
else {
#ifdef DEBUG
print_debug_info(registers, opcode);
#endif
extra_cycles = execute_instruction(registers, opcode);
cpu_cycles_executed = instruction_cycle_length[opcode] + extra_cycles;
// Do not increment PC if we jump because it will skip the first instruction at least
if(!is_JSR_or_JMP(opcode) && !is_RTI(opcode)) increment_PC_instruction_length(registers, opcode);
}
}
previous_nmi_flag = nmi_flag;
odd_cpu_cycle = cpu_cycles_executed & 0x1;
return cpu_cycles_executed;
}
gpointer dbg_g_object_newv (GType gtype, guint n_params, GParameter *params)
{
gpointer result;
if (print_debug_info()) {
fprintf(stderr, "Creating a new GObject of type %s\n",
g_type_name(gtype));
}
result = g_object_newv (gtype, n_params, params);
if (print_debug_info()) {
fprintf(stderr, "\tdone, got a pointer at %p\n", result);
}
return result;
}
void dbg_g_object_unref (GObject *obj)
{
GType gtype;
if (print_debug_info()) {
fprintf(stderr, "Freeing a GObject at %p\n", obj);
gtype = G_TYPE_FROM_INSTANCE (obj);
fprintf(stderr, "\tIt is of type %s\n", g_type_name(gtype));
fprintf(stderr, "\t**s refcount before unref is %d\n",
(int)obj->ref_count);
}
g_object_unref(obj);
if (print_debug_info()) {
fprintf(stderr, "\tdone\n");
}
}
std::unique_ptr<TileSet>
TileSet::from_file(const std::string& filename)
{
auto tileset = std::make_unique<TileSet>();
TileSetParser parser(*tileset, filename);
parser.parse();
tileset->print_debug_info(filename);
return tileset;
}
/*------------------------------------------------------------------------+*/
int
XeAppendToStringBuffer(XeStringBuffer buffer, XeString string)
/*------------------------------------------------------------------------+*/
{
int size = buffer->size;
XeString buffer_position; /* so operations are pointer based */
int i;
# if DEBUG >= 5
sprintf(debug_string, "appending: \"%s\" to: \"%s\"", string, buffer->buffer);
print_debug_info(5, debug_string);
# endif
if (!(string && string[0])) {
return(0);
}
buffer_position = &(buffer->buffer[buffer->last_char]);
for (i = buffer->last_char; *string ; i++) {
if (i == size) {
buffer->last_char = i - 1;
if (-1 == ExpandStringBuffer(buffer)) return(-1);
size = buffer->size;
buffer_position = &(buffer->buffer[i]);
}
*buffer_position++ = *string++;
}
if (i == size) {
buffer->last_char = i - 1;
if (-1 == ExpandStringBuffer(buffer)) return(-1);
}
buffer->buffer[i] = (XeChar) NULL;
buffer->last_char = i;
# if DEBUG >= 5
sprintf(debug_string, "new string is: \"%s\"", buffer->buffer);
print_debug_info(6, debug_string);
# endif
return(0);
}
static int print_thread(void * data)
{
while(1){
wake_lock(&messages_wakelock);
if (print_thread_enable)
print_debug_info();
has_wake_lock(WAKE_LOCK_SUSPEND);
msleep(100);
wake_unlock(&messages_wakelock);
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(print_thread_interval * HZ);
}
return 0;
}
/*------------------------------------------------------------------------+*/
static int
ExpandStringBuffer(XeStringBuffer buffer)
/*------------------------------------------------------------------------+*/
{
int new_size = buffer->size + buffer->increment;
XeString new_string = Xe_make_ntype(new_size, XeChar);
# if DEBUG >= 3
sprintf(debug_string, "expanding string buffer. current size is: %d", buffer->size);
print_debug_info(3, debug_string);
# endif
memcpy(new_string, buffer->buffer, buffer->last_char + 1);
XeFree(buffer->buffer);
buffer->size = new_size;
buffer->buffer = new_string;
buffer->increment += (buffer->increment % EXPANSION_FACTOR);
# if DEBUG >= 3
sprintf(debug_string, "new size is: %d", buffer->size);
print_debug_info(4, debug_string);
# endif
return(0);
}
void execute_loop(chip_8_cpu cpu, FILE *debug_log) {
if (pthread_create(&(cpu->delay_decrement_thread), NULL, delay_thread, cpu) != 0) {
shutdown_cpu(cpu, 1);
}
if (pthread_create(&(cpu->sound_decrement_thread), NULL, sound_thread, cpu) != 0) {
fprintf(stderr, "Failed to start the sound register thread, exiting...\n");
shutdown_cpu(cpu, 1);
}
pthread_detach(cpu->delay_decrement_thread);
pthread_detach(cpu->sound_decrement_thread);
cpu->chip_8_screen = init_ncurses(default_window_height, default_window_width);
refresh_window(cpu->chip_8_screen);
while (1) {
if (cpu->program_counter >= MEMORY_SIZE) {
fprintf(stderr, "ERR - Fatal memory error: invalid access at memory cell: '%d'\n", cpu->program_counter);
shutdown_cpu(cpu, 1);
}
if (cpu->halt) {
break;
}
opcode instr = fetch_opcode(cpu);
if (debug_log) {
print_debug_info(debug_log, instr, cpu);
}
execute_opcode(instr, cpu);
if (cpu->performed_jump) {
cpu->performed_jump = false;
continue;
}
if (cpu->skip_opcode) {
cpu->program_counter = cpu->program_counter + 2;
cpu->skip_opcode = false;
}
else {
cpu->program_counter = cpu->program_counter + 1;
}
}
// allow 0.1 seconds for the threads to clean up their memory
usleep(100000);
delwin(cpu->chip_8_screen);
endwin();
}
static int
my_action(void *new_ps, void **children, int n_children, int pn_offset,
struct D_Parser *parser, int speculative) {
D_ParseNode *dd = D_PN(new_ps, pn_offset);
PyObject *result = NULL;
PyObject *children_list, *string_list = NULL;
PNode *pn = (PNode *)new_ps;
int action_index = pn->reduction->action_index;
PyObject *tuple = NULL;
PyObject *arg_types = NULL;
D_ParserPyInterface *ppi = d_interface(parser);
int takes_speculative = 0;
PyObject *action = 0;
if (PyErr_Occurred()) {
/* just keep returning until finished parsing. Need a way to tell dparser to quit */
return 0;
}
if (action_index != -1) {
tuple = PyList_GetItem(ppi->actions, action_index);
PyArg_ParseTuple(tuple, "OOi", &action, &arg_types, &takes_speculative);
}
if (ppi->takes_globals) {
inc_global_state(parser, dd);
}
if (ppi->print_debug_info && tuple) {
print_debug_info(dd, tuple, speculative, ppi->print_debug_info);
}
if (takes_speculative == -1 && !speculative) {
/* user.t and user.s were already set when this was called speculatively */
return 0;
}
if (ppi->takes_strings) {
string_list = pylist_children(parser, dd, 1);
if (string_list == NULL) {
return -1;
}
}
/* this function owns string_list */
if (takes_speculative == 0 && speculative) {
Py_INCREF(Py_None);
Py_XDECREF(dd->user.t);
/* if (dd->user.s)
printf("freeing2:%d\n", dd->user.s);*/
Py_XDECREF(dd->user.s);
dd->user.t = Py_None;
// printf("dd1:%d\n", dd);
dd->user.s = NULL;
Py_XDECREF(string_list);
/* printf("setting:%d\n", string_list);*/
//dd->user.s = string_list;
return 0;
}
children_list = pylist_children(parser, dd, 0);
if (children_list == NULL) {
/* if (string_list)
printf("freeing3:%d\n", string_list);*/
Py_XDECREF(string_list);
return -1;
}
/* this function owns children_list */
if (action_index != -1) {
result = take_action(arg_types, children_list, speculative, dd, string_list,
n_children, parser, children, pn_offset, action);
Py_DECREF(children_list);
} else {
result = children_list;
}
/* function now owns result, string_list */
if (result == ppi->reject || result == NULL) {
/* if (string_list)
printf("freeing4:%d\n", string_list);*/
Py_XDECREF(result);
Py_XDECREF(string_list);
return -1; /* user rejected */
}
Py_XDECREF(dd->user.t); /* these may have been set in a speculative pass */
/* if(dd->user.s)
printf("freeing5:%d\n", dd->user.s);*/
Py_XDECREF(dd->user.s);
/* if(dd->user.s)
printf("setting2:%d\n", string_list);*/
// printf("dd2:%d\n", dd);
dd->user.t = result;
dd->user.s = string_list;
return 0;
}
int main(int argc, char **argv)
{
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
APP_LOG << "Failed to initialize SDL: " << SDL_GetError() << '\n';
return EXIT_FAILURE;
}
int window_width = 640;
int window_height = 480;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
SDL_Window *window = SDL_CreateWindow(
"Sample Application",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
window_width, window_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
if (window == NULL)
{
APP_LOG << "Failed to create a window: " << SDL_GetError() << '\n';
SDL_Quit();
return EXIT_FAILURE;
}
SDL_GLContext gl_context = SDL_GL_CreateContext(window);
SDL_GL_SetSwapInterval(1); // Wait for vertical refresh
glewExperimental = true;
GLenum glew_error = glewInit();
if (glew_error != GLEW_OK)
{
APP_LOG << "Failed to load OpenGL functions: " << glewGetErrorString(glew_error) << '\n';
SDL_GL_DeleteContext(gl_context);
SDL_DestroyWindow(window);
SDL_Quit();
return EXIT_FAILURE;
}
print_debug_info();
if(!load_game(window_width, window_height))
{
APP_LOG << "Failed to load content" << '\n';
SDL_GL_DeleteContext(gl_context);
SDL_DestroyWindow(window);
SDL_Quit();
return EXIT_FAILURE;
}
init_game();
gui::init(window_width, window_height);
uint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glViewport(0, 0, window_width, window_height);
double frame_time = 1.0 / 60.0;
bool running = true;
while (running)
{
double frame_begin = get_elapsed_time();
handle_events(running, window);
gui::update(frame_time);
update_game(frame_time);
render_game(frame_time);
SDL_GL_SwapWindow(window);
frame_time = get_elapsed_time() - frame_begin;
if (check_gl_errors())
running = false;
if (frame_time < 1.0 / 60.0)
{
sleep(1.0 / 60.0 - frame_time);
frame_time = get_elapsed_time() - frame_begin;
}
}
gui::dispose();
SDL_GL_DeleteContext(gl_context);
SDL_DestroyWindow(window);
SDL_Quit();
return EXIT_SUCCESS;
}
/* Buffer filling thread. */
static void buffer_thread (http_desc_t *desc)
{
pthread_mutex_t mut; /* Temporary mutex. */
int BLOCK_SIZE = HTTP_BLOCK_SIZE;
void *ibuffer;
int rest = 0;
int metasize = 0, metapos = 0, extra_read = 0;
char *p;
/* Init */
pthread_mutex_init (&mut, NULL);
if (desc->icy_metaint) {
BLOCK_SIZE = (HTTP_BLOCK_SIZE > desc->icy_metaint) ? desc->icy_metaint : HTTP_BLOCK_SIZE;
}
ibuffer = malloc (BLOCK_SIZE << 1);
/* Process while main thread allow it. */
while (desc->going) {
void *newbuf;
int readed;
#ifdef DEBUG_HTTP_BUFFERING
print_debug_info (desc);
#endif
rest = metasize = 0;
/* trying to shrink buffer */
pthread_mutex_lock (&desc->buffer_lock);
shrink_buffer (desc);
pthread_mutex_unlock (&desc->buffer_lock);
/* let them know about our state, heh */
status_notify (desc);
/* check for overflow */
if (desc->len > http_buffer_size) {
/* Notice waiting function that the new block of data has arrived */
desc->new_datablock = 1;
pthread_cond_signal (&desc->new_datablock_signal);
/* Make pause */
if (!desc->dont_wait) {
pthread_mutex_lock (&mut);
cond_timedwait_relative (&desc->dont_wait_signal, &mut, calc_time_to_wait (desc));
pthread_mutex_unlock (&mut);
} else {
desc->dont_wait--;
}
continue;
}
/* read to internal buffer */
readed = read_data (desc->sock, ibuffer, BLOCK_SIZE);
/* reasons to stop */
if (readed == 0) {
desc->going = 0;
} else if (readed <0) {
desc->error = 1;
desc->going = 0;
} else {
/* Something readed */
/* Metadata stuff */
if (desc->icy_metaint > 0 &&
(desc->buffer_pos+readed) > desc->icy_metaint) {
/* Metadata block is next! */
rest = (desc->buffer_pos+readed) - desc->icy_metaint;
p = ((char *)ibuffer);
p += (readed-rest);
metapos = (readed-rest);
if (rest) {
metasize = *(int8_t *)p;
metasize <<= 4;
if (rest < metasize) {
/* Uh oh, big trouble ahead, or maybe not? */
extra_read = read_data (desc->sock, ibuffer+readed, metasize);
readed += extra_read;
rest += extra_read;
}
if (metasize > 4080) {
alsaplayer_error("Invalid metasize (%d)", metasize);
} else if (metasize > 0) {
p++;
p[metasize] = '\0';
pthread_mutex_lock (&desc->meta_lock);
if (desc->metadata) {
free(desc->metadata);
}
desc->metadata = malloc(strlen(p)+1);
memcpy(desc->metadata, p, strlen(p));
pthread_mutex_unlock (&desc->meta_lock);
} else {
/* Metadata is zero length */
}
} else {
alsaplayer_error("Rest = 0???");
}
metasize++; /* Length byte */
} else {
desc->buffer_pos += readed;
}
/* These operations are fast. -> doesn't break reader_read */
/* ---------------- lock buffer ( */
pthread_mutex_lock (&desc->buffer_lock);
/* enlarge buffer */
newbuf = malloc (desc->len + (BLOCK_SIZE * 2)); /* HTTP_BLOCK_SIZE */
memcpy (newbuf, desc->buffer, desc->len);
if (metasize) {
memcpy(newbuf + desc->len, ibuffer, metapos);
memcpy(newbuf + desc->len + metapos, ibuffer+metapos+metasize, rest - metasize);
readed -= metasize;
desc->buffer_pos = rest - metasize;
} else {
memcpy (newbuf + desc->len, ibuffer, readed);
}
/* switch buffers */
free (desc->buffer);
desc->buffer = newbuf;
desc->len += readed;
/* unlock buffer ) */
pthread_mutex_unlock (&desc->buffer_lock);
}
/* Notice waiting function that the new block of data has arrived */
desc->new_datablock = 1;
pthread_cond_signal (&desc->new_datablock_signal);
/* Do wait */
if (desc->going && !desc->dont_wait) {
pthread_mutex_lock (&mut);
cond_timedwait_relative (&desc->dont_wait_signal, &mut, calc_time_to_wait (desc));
pthread_mutex_unlock (&mut);
}
if (desc->dont_wait)
desc->dont_wait--;
}
free (ibuffer);
pthread_exit (NULL);
} /* end of: buffer_thread */
int main(int argc, char *argv[])
{
/* mandatory function to initialize simple executive application */
cvmx_user_app_init();
sysinfo = cvmx_sysinfo_get();
if (cvmx_is_init_core()) {
/* may need to specify this manually for simulator */
cpu_clock_hz = sysinfo->cpu_clock_hz;
if(init_tasks(NUM_PACKET_BUFFERS) != 0) {
printf("Initialization failed!\n");
exit(-1);
}
/* get the FPA pool number of packet and WQE pools */
packet_pool = cvmx_fpa_get_packet_pool();
wqe_pool = cvmx_fpa_get_wqe_pool();
print_debug_info();
int num_interfaces = cvmx_helper_get_number_of_interfaces();
int interface;
bool found_valid_xaui_port = false;
for (interface=0; interface < num_interfaces && !found_valid_xaui_port; interface++) {
uint32_t num_ports = cvmx_helper_ports_on_interface(interface);
cvmx_helper_interface_mode_t imode = cvmx_helper_interface_get_mode(interface);
if (imode == CVMX_HELPER_INTERFACE_MODE_XAUI) {
printf("\nIdentified XAUI interface with %" PRIu32 " port(s)\n", num_ports);
printf("interface number: %d\n", interface);
uint32_t port;
for (port = 0; port < num_ports; port++) {
if (cvmx_helper_is_port_valid(interface, port)) {
xaui_ipd_port = cvmx_helper_get_ipd_port(interface, port);
printf("xaui_ipd_port: %d\n", xaui_ipd_port);
found_valid_xaui_port = true;
break;
}
}
}
printf("\n");
}
}
/* Wait (stall) until all cores in the given coremask have reached this
* point in the progam execution before proceeding. */
CORE_MASK_BARRIER_SYNC;
if (cvmx_is_init_core()) {
receive_packet();
} else if (cvmx_get_core_num() == 1) {
send_packet();
} else { /* for this program, all cores besides the first two are superfluous */
printf("Superfluous core #%02d\n", cvmx_get_core_num());
return 0;
}
printf("Execution complete for core #%02d\n", cvmx_get_core_num());
return 0;
}
