static void check_equals (gl_list_t list1, gl_list_t list2) { size_t n, i; n = gl_list_size (list1); ASSERT (n == gl_list_size (list2)); for (i = 0; i < n; i++) { ASSERT (gl_list_get_at (list1, i) == gl_list_get_at (list2, i)); } }
static int l_anim_stop(lua_State *L) { l_anim *a; int i, j; uint32_t nevents; uint32_t push; SDL_Event event[20]; a = l_checkAnim(L, 1); for (i = 0; i < bta_getNumLoops(a->bta); i++) { l_loop_t *l = (l_loop_t *)gl_list_get_at(a->loopData, i); if (SDL_RemoveTimer(l->timer) == SDL_FALSE) { luaL_error(L, "Error removing animation timer"); } l->timer = 0; } /* * There could be outstanding animation events in the event * queue. Loop through the outstanding events and compare with * each loop pointer of the current animation. If they don't match * push the event back into the event queue. */ nevents = SDL_PeepEvents(event, 20, SDL_GETEVENT, BT_ANIM_EVENT, BT_ANIM_EVENT ); for (i = 0; i < nevents; i++) { push = 1; for (j = 0; j < bta_getNumLoops(a->bta); j++) { if (event[i].user.data2 == gl_list_get_at(a->loopData,j)) { push = 0; break; } } if (push) { SDL_PushEvent(&event[i]); } } nevents = SDL_PeepEvents(event, 20, SDL_GETEVENT, BT_ANIM_EVENT, BT_ANIM_EVENT ); return 0; }
static void html_ostream::end_span (html_ostream_t stream, const char *classname) { if (!(stream->curr_class_stack_size > 0 && strcmp ((char *) gl_list_get_at (stream->class_stack, stream->curr_class_stack_size - 1), classname) == 0)) /* Improperly nested begin_span/end_span calls. */ abort (); stream->curr_class_stack_size--; }
static void _bta_write_loops(FILE *fp, bta_t *bta) { uint32_t lnum; uint32_t cnum; gl_list_t loops; gl_list_t cells; loops = (gl_list_t)bta->loopData; fp_write32le(fp, gl_list_size(loops)); for (lnum = 0; lnum < gl_list_size(loops); lnum++) { bta_loop_t *l = (bta_loop_t *)gl_list_get_at(loops, lnum); cells = (gl_list_t)l->cellData; fp_write32le(fp, gl_list_size(cells)); for (cnum = 0; cnum < gl_list_size(cells); cnum++) { _bta_write_cell(fp, (bta_cell_t *)gl_list_get_at(cells, cnum)); } } }
/* * Calculate the maximum length of the completions. */ static size_t calculate_max_length (gl_list_t l, size_t size) { size_t i, maxlen = 0; for (i = 0; i < MIN (size, gl_list_size (l)); i++) { size_t len = strlen ((char *) gl_list_get_at (l, i)); maxlen = MAX (len, maxlen); } return maxlen; }
static void emit_pending_spans (html_ostream_t stream, bool shrink_stack) { if (stream->curr_class_stack_size > stream->last_class_stack_size) { size_t i; for (i = stream->last_class_stack_size; i < stream->curr_class_stack_size; i++) { char *classname = (char *) gl_list_get_at (stream->class_stack, i); ostream_write_str (stream->destination, "<span class=\""); ostream_write_str (stream->destination, classname); ostream_write_str (stream->destination, "\">"); } stream->last_class_stack_size = stream->curr_class_stack_size; } else if (stream->curr_class_stack_size < stream->last_class_stack_size) { size_t i = stream->last_class_stack_size; while (i > stream->curr_class_stack_size) { char *classname; --i; classname = (char *) gl_list_get_at (stream->class_stack, i); ostream_write_str (stream->destination, "</span>"); if (shrink_stack) { gl_list_remove_at (stream->class_stack, i); free (classname); } } stream->last_class_stack_size = stream->curr_class_stack_size; } }
static void html_ostream::begin_span (html_ostream_t stream, const char *classname) { if (stream->last_class_stack_size > stream->curr_class_stack_size && strcmp ((char *) gl_list_get_at (stream->class_stack, stream->curr_class_stack_size), classname) != 0) emit_pending_spans (stream, true); /* Now either last_class_stack_size <= curr_class_stack_size - in this case we have to append the given CLASSNAME - or last_class_stack_size > curr_class_stack_size && class_stack[curr_class_stack_size] == CLASSNAME - in this case we only need to increment curr_class_stack_size. */ if (stream->last_class_stack_size <= stream->curr_class_stack_size) gl_list_add_at (stream->class_stack, stream->curr_class_stack_size, xstrdup (classname)); stream->curr_class_stack_size++; }
/* * isSkipped() */ static uint32_t isSkipped(disasm_t *d) { size_t listSize; range_t *r; uint32_t i; listSize = gl_list_size(rangeSkipList); if (!listSize) return 0; for (i = 0; i < listSize; i++) { r = (range_t *)gl_list_get_at(rangeSkipList, i); if ((d->offset >= r->start) && (d->offset < r->end)) return 1; } return 0; }
static int l_anim_start(lua_State *L) { l_anim *anim; bta_cell_t *base; uint32_t index; anim = l_checkAnim(L, 1); anim->renderer = l_checkRenderer(L, 2); anim->texture = l_checkTexture(L, 3); anim->screen = l_checkSurface(L, 4); anim->rect = l_checkRect(L, 5); base = bta_get_base(anim->bta); SDL_LockSurface(anim->s); memcpy(anim->s->pixels, base->gfx->buf, base->gfx->size); SDL_UnlockSurface(anim->s); SDL_BlitSurface(anim->s, NULL, anim->screen, anim->rect); SDL_UpdateTexture(anim->texture, NULL, anim->screen->pixels, anim->screen->pitch); SDL_RenderCopy(anim->renderer, anim->texture, NULL, NULL); SDL_RenderPresent(anim->renderer); /* Create a timer for each loop */ for (index = 0; index < bta_getNumLoops(anim->bta); index++) { l_loop_t *loop; bta_cell_t *c; loop = (l_loop_t *)gl_list_get_at(anim->loopData, index); c = bta_cell_get(anim->bta, index, 0); loop->timer = SDL_AddTimer(c->delay, simpleCallback, loop); } return 0; }
/* * Print the list of completions in a set of columns. */ static void completion_print (gl_list_t l, size_t size) { size_t i, j, col, max, numcols; max = calculate_max_length (l, size) + 5; numcols = (get_window_ewidth (cur_wp) - 1) / max; bprintf ("Possible completions are:\n"); for (i = col = 0; i < MIN (size, gl_list_size (l)); i++) { char *s = (char *) gl_list_get_at (l, i); size_t len = strlen (s); if (col >= numcols) { col = 0; insert_newline (); } insert_nstring (s, len); for (j = max - len; j > 0; --j) insert_char_in_insert_mode (' '); ++col; } }
int main (int argc, char *argv[]) { gl_list_t list1, list2; set_program_name (argv[0]); /* Allow the user to provide a non-default random seed on the command line. */ if (argc > 1) srand (atoi (argv[1])); { size_t initial_size = RANDOM (50); const void **contents = (const void **) malloc (initial_size * sizeof (const void *)); size_t i; unsigned int repeat; for (i = 0; i < initial_size; i++) contents[i] = RANDOM_OBJECT (); /* Create list1. */ list1 = gl_list_create (GL_ARRAY_LIST, NULL, NULL, NULL, true, initial_size, contents); /* Create list2. */ list2 = gl_list_create_empty (GL_ARRAY_LIST, NULL, NULL, NULL, true); for (i = 0; i < initial_size; i++) gl_list_add_last (list2, contents[i]); check_equals (list1, list2); for (repeat = 0; repeat < 10000; repeat++) { unsigned int operation = RANDOM (16); switch (operation) { case 0: if (gl_list_size (list1) > 0) { size_t index = RANDOM (gl_list_size (list1)); const char *obj = RANDOM_OBJECT (); gl_list_node_t node1, node2; node1 = gl_list_set_at (list1, index, obj); ASSERT (gl_list_get_at (list1, index) == obj); ASSERT (gl_list_node_value (list1, node1) == obj); node2 = gl_list_set_at (list2, index, obj); ASSERT (gl_list_get_at (list2, index) == obj); ASSERT (gl_list_node_value (list2, node2) == obj); if (index > 0) { ASSERT (gl_list_node_value (list1, gl_list_previous_node (list1, node1)) == gl_list_get_at (list1, index - 1)); } if (index + 1 < gl_list_size (list1)) { ASSERT (gl_list_node_value (list1, gl_list_next_node (list1, node1)) == gl_list_get_at (list1, index + 1)); } } break; case 1: { const char *obj = RANDOM_OBJECT (); gl_list_node_t node1, node2; node1 = gl_list_search (list1, obj); node2 = gl_list_search (list2, obj); if (node1 == NULL) { ASSERT (node2 == NULL); } else { ASSERT (node2 != NULL); ASSERT (gl_list_node_value (list1, node1) == obj); ASSERT (gl_list_node_value (list2, node2) == obj); } } break; case 2: { const char *obj = RANDOM_OBJECT (); size_t index1, index2; index1 = gl_list_indexof (list1, obj); index2 = gl_list_indexof (list2, obj); if (index1 == (size_t)(-1)) { ASSERT (index2 == (size_t)(-1)); } else { ASSERT (index2 != (size_t)(-1)); ASSERT (gl_list_get_at (list1, index1) == obj); ASSERT (gl_list_get_at (list2, index2) == obj); ASSERT (index2 == index1); } } break; case 3: /* add 1 element */ { const char *obj = RANDOM_OBJECT (); gl_list_node_t node1, node2; node1 = gl_list_add_first (list1, obj); node2 = gl_list_add_first (list2, obj); ASSERT (gl_list_node_value (list1, node1) == obj); ASSERT (gl_list_node_value (list2, node2) == obj); ASSERT (gl_list_get_at (list1, 0) == obj); ASSERT (gl_list_get_at (list2, 0) == obj); } break; case 4: /* add 1 element */ { const char *obj = RANDOM_OBJECT (); gl_list_node_t node1, node2; node1 = gl_list_add_last (list1, obj); node2 = gl_list_add_last (list2, obj); ASSERT (gl_list_node_value (list1, node1) == obj); ASSERT (gl_list_node_value (list2, node2) == obj); ASSERT (gl_list_get_at (list1, gl_list_size (list1) - 1) == obj); ASSERT (gl_list_get_at (list2, gl_list_size (list2) - 1) == obj); } break; case 5: /* add 3 elements */ { const char *obj0 = RANDOM_OBJECT (); const char *obj1 = RANDOM_OBJECT (); const char *obj2 = RANDOM_OBJECT (); gl_list_node_t node1, node2; node1 = gl_list_add_first (list1, obj2); node1 = gl_list_add_before (list1, node1, obj0); node1 = gl_list_add_after (list1, node1, obj1); node2 = gl_list_add_first (list2, obj2); node2 = gl_list_add_before (list2, node2, obj0); node2 = gl_list_add_after (list2, node2, obj1); ASSERT (gl_list_node_value (list1, node1) == obj1); ASSERT (gl_list_node_value (list2, node2) == obj1); ASSERT (gl_list_get_at (list1, 0) == obj0); ASSERT (gl_list_get_at (list1, 1) == obj1); ASSERT (gl_list_get_at (list1, 2) == obj2); ASSERT (gl_list_get_at (list2, 0) == obj0); ASSERT (gl_list_get_at (list2, 1) == obj1); ASSERT (gl_list_get_at (list2, 2) == obj2); } break; case 6: /* add 1 element */ { size_t index = RANDOM (gl_list_size (list1) + 1); const char *obj = RANDOM_OBJECT (); gl_list_node_t node1, node2; node1 = gl_list_add_at (list1, index, obj); node2 = gl_list_add_at (list2, index, obj); ASSERT (gl_list_get_at (list1, index) == obj); ASSERT (gl_list_node_value (list1, node1) == obj); ASSERT (gl_list_get_at (list2, index) == obj); ASSERT (gl_list_node_value (list2, node2) == obj); if (index > 0) { ASSERT (gl_list_node_value (list1, gl_list_previous_node (list1, node1)) == gl_list_get_at (list1, index - 1)); } if (index + 1 < gl_list_size (list1)) { ASSERT (gl_list_node_value (list1, gl_list_next_node (list1, node1)) == gl_list_get_at (list1, index + 1)); } } break; case 7: case 8: /* remove 1 element */ if (gl_list_size (list1) > 0) { size_t n = gl_list_size (list1); const char *obj = gl_list_get_at (list1, RANDOM (n)); gl_list_node_t node1, node2; node1 = gl_list_search (list1, obj); node2 = gl_list_search (list2, obj); ASSERT (node1 != NULL); ASSERT (node2 != NULL); ASSERT (gl_list_remove_node (list1, node1)); ASSERT (gl_list_remove_node (list2, node2)); ASSERT (gl_list_size (list1) == n - 1); } break; case 9: case 10: /* remove 1 element */ if (gl_list_size (list1) > 0) { size_t n = gl_list_size (list1); size_t index = RANDOM (n); ASSERT (gl_list_remove_at (list1, index)); ASSERT (gl_list_remove_at (list2, index)); ASSERT (gl_list_size (list1) == n - 1); } break; case 11: case 12: /* remove 1 element */ if (gl_list_size (list1) > 0) { size_t n = gl_list_size (list1); const char *obj = gl_list_get_at (list1, RANDOM (n)); ASSERT (gl_list_remove (list1, obj)); ASSERT (gl_list_remove (list2, obj)); ASSERT (gl_list_size (list1) == n - 1); } break; case 13: if (gl_list_size (list1) > 0) { size_t n = gl_list_size (list1); const char *obj = "xyzzy"; ASSERT (!gl_list_remove (list1, obj)); ASSERT (!gl_list_remove (list2, obj)); ASSERT (gl_list_size (list1) == n); } break; case 14: { size_t n = gl_list_size (list1); gl_list_iterator_t iter1, iter2; const void *elt; iter1 = gl_list_iterator (list1); iter2 = gl_list_iterator (list2); for (i = 0; i < n; i++) { ASSERT (gl_list_iterator_next (&iter1, &elt, NULL)); ASSERT (gl_list_get_at (list1, i) == elt); ASSERT (gl_list_iterator_next (&iter2, &elt, NULL)); ASSERT (gl_list_get_at (list2, i) == elt); } ASSERT (!gl_list_iterator_next (&iter1, &elt, NULL)); ASSERT (!gl_list_iterator_next (&iter2, &elt, NULL)); gl_list_iterator_free (&iter1); gl_list_iterator_free (&iter2); } break; case 15: { size_t end = RANDOM (gl_list_size (list1) + 1); size_t start = RANDOM (end + 1); gl_list_iterator_t iter1, iter2; const void *elt; iter1 = gl_list_iterator_from_to (list1, start, end); iter2 = gl_list_iterator_from_to (list2, start, end); for (i = start; i < end; i++) { ASSERT (gl_list_iterator_next (&iter1, &elt, NULL)); ASSERT (gl_list_get_at (list1, i) == elt); ASSERT (gl_list_iterator_next (&iter2, &elt, NULL)); ASSERT (gl_list_get_at (list2, i) == elt); } ASSERT (!gl_list_iterator_next (&iter1, &elt, NULL)); ASSERT (!gl_list_iterator_next (&iter2, &elt, NULL)); gl_list_iterator_free (&iter1); gl_list_iterator_free (&iter2); } break; } check_equals (list1, list2); } gl_list_free (list1); gl_list_free (list2); free (contents); } return 0; }