src/ebisp/repl_runtime.c
src/ebisp/std.h
src/ebisp/std.c
+ src/system/stacktrace.h
+ src/system/stacktrace.c
)
add_executable(nothing_test
src/ebisp/builtins.c
src/system/log.c
src/system/nth_alloc.h
src/system/nth_alloc.c
+ src/system/stacktrace.h
+ src/system/stacktrace.c
)
target_link_libraries(nothing ${SDL2_LIBRARY} ${SDL2_MIXER_LIBRARY} m)
target_link_libraries(nothing_test ${SDL2_LIBRARY} ${SDL2_MIXER_LIBRARY} m)
-#include <assert.h>
+#include "system/stacktrace.h"
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
static bool equal_atoms(struct Atom *atom1, struct Atom *atom2)
{
- assert(atom1);
- assert(atom2);
+ trace_assert(atom1);
+ trace_assert(atom2);
if (atom1->type != atom2->type) {
return false;
static bool equal_cons(struct Cons *cons1, struct Cons *cons2)
{
- assert(cons1);
- assert(cons2);
+ trace_assert(cons1);
+ trace_assert(cons2);
return equal(cons1->car, cons2->car) && equal(cons1->cdr, cons2->cdr);
}
bool is_special(const char *name)
{
- assert(name);
+ trace_assert(name);
size_t n = sizeof(specials) / sizeof(const char*);
for (size_t i = 0; i < n; ++i) {
static struct Expr
list_rec(Gc *gc, const char *format, va_list args)
{
- assert(gc);
- assert(format);
+ trace_assert(gc);
+ trace_assert(format);
if (*format == 0) {
return NIL(gc);
default: {
fprintf(stderr, "Wrong format parameter: %c\n", *format);
- assert(0);
+ trace_assert(0);
}
}
}
-#include <assert.h>
+#include "system/stacktrace.h"
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
void print_atom_as_sexpr(FILE *stream, struct Atom *atom)
{
- assert(atom);
+ trace_assert(atom);
switch (atom->type) {
case ATOM_SYMBOL:
void print_cons_as_sexpr(FILE *stream, struct Cons *head)
{
- assert(head);
+ trace_assert(head);
struct Cons *cons = head;
static int atom_as_sexpr(struct Atom *atom, char *output, size_t n)
{
- assert(atom);
- assert(output);
+ trace_assert(atom);
+ trace_assert(output);
switch (atom->type) {
case ATOM_SYMBOL:
static int cons_as_sexpr(struct Cons *head, char *output, size_t n)
{
- assert(head);
- assert(output);
+ trace_assert(head);
+ trace_assert(output);
/* TODO(#378): cons_as_sexpr does not handle encoding errors of snprintf */
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static int compare_exprs(const void *a, const void *b)
{
- assert(a);
- assert(b);
+ trace_assert(a);
+ trace_assert(b);
const long int ptr_a = value_of_expr(*(const struct Expr *)a);
const long int ptr_b = value_of_expr(*(const struct Expr *)b);
void destroy_gc(Gc *gc)
{
- assert(gc);
+ trace_assert(gc);
for (size_t i = 0; i < gc->size; ++i) {
destroy_expr(gc->exprs[i]);
int gc_add_expr(Gc *gc, struct Expr expr)
{
- assert(gc);
+ trace_assert(gc);
if (gc->size >= gc->capacity) {
const size_t new_capacity = gc->capacity * 2;
static long int gc_find_expr(Gc *gc, struct Expr expr)
{
- assert(gc);
+ trace_assert(gc);
(void) expr;
struct Expr *result =
static void gc_traverse_expr(Gc *gc, struct Expr root)
{
- assert(gc);
- assert(root.type != EXPR_VOID);
+ trace_assert(gc);
+ trace_assert(root.type != EXPR_VOID);
const long int root_index = gc_find_expr(gc, root);
/* TODO(#578): gc_traverse_expr just crashes when we try to collect already collected root */
if (root_index < 0) {
fprintf(stderr, "GC tried to collect something that was not registered\n");
print_expr_as_sexpr(stderr, root);
fprintf(stderr, "\n");
- assert(root_index >= 0);
+ trace_assert(root_index >= 0);
}
if (gc->visited[root_index]) {
void gc_collect(Gc *gc, struct Expr root)
{
- assert(gc);
+ trace_assert(gc);
(void) root;
/* Sort gc->exprs O(nlogn) */
-#include <assert.h>
+#include "system/stacktrace.h"
#include <math.h>
#include <string.h>
#include <stdarg.h>
struct EvalResult eval_block(Gc *gc, struct Scope *scope, struct Expr block)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
if (!list_p(block)) {
return wrong_argument_type(gc, "listp", block);
car(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr xs = NIL(gc);
-#include <assert.h>
+#include "system/stacktrace.h"
#include <ctype.h>
#include <errno.h>
#include <stdint.h>
struct ParseResult read_expr_from_string(Gc *gc, const char *str)
{
- assert(gc);
- assert(str);
+ trace_assert(gc);
+ trace_assert(str);
return parse_expr(gc, next_token(str));
}
struct ParseResult read_all_exprs_from_string(Gc *gc, const char *str)
{
- assert(gc);
- assert(str);
+ trace_assert(gc);
+ trace_assert(str);
struct Token current_token = next_token(str);
struct ParseResult parse_result = parse_expr(gc, current_token);
struct ParseResult read_expr_from_file(Gc *gc, const char *filename)
{
- assert(filename);
+ trace_assert(filename);
Lt *lt = create_lt();
if (lt == NULL) {
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdbool.h>
#include "gc.h"
-#include <assert.h>
+#include "system/stacktrace.h"
#include "scope.h"
#include "interpreter.h"
static struct EvalResult gc_inspect_adapter(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) param;
(void) args;
static struct EvalResult quit(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) args;
(void) param;
static struct EvalResult get_scope(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) param;
(void) args;
static struct EvalResult print(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) param;
const char *s = NULL;
-#include <assert.h>
+#include "system/stacktrace.h"
#include "./scope.h"
static struct Expr get_scope_value_impl(struct Expr scope, struct Expr name)
void push_scope_frame(Gc *gc, struct Scope *scope, struct Expr vars, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr frame = NIL(gc);
void pop_scope_frame(Gc *gc, struct Scope *scope)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
if (!nil_p(scope->expr)) {
scope->expr = scope->expr.cons->cdr;
-#include <assert.h>
+#include "system/stacktrace.h"
#include <string.h>
#include "ebisp/gc.h"
quasiquote(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr expr = void_expr();
struct EvalResult result = match_list(gc, "e", args, &expr);
unquote(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) args;
return eval_failure(STRING(gc, "Using unquote outside of quasiquote."));
static struct EvalResult
greaterThan(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) param;
long int x1 = 0;
static struct EvalResult
list_op(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) param;
return eval_success(args);
plus_op(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
long int result = 0L;
assoc_op(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr key = NIL(gc);
struct Expr alist = NIL(gc);
set(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
const char *name = NULL;
struct Expr value = void_expr();
quote(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr expr = void_expr();
struct EvalResult result = match_list(gc, "e", args, &expr);
begin(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr block = void_expr();
struct EvalResult result = match_list(gc, "*", args, &block);
defun(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr name = void_expr();
struct Expr args_list = void_expr();
when(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr condition = void_expr();
struct Expr body = void_expr();
lambda_op(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
(void) param;
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
struct Expr args_list = void_expr();
struct Expr body = void_expr();
+#include <stdio.h>
#include <stdbool.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <ctype.h>
#include <stdlib.h>
static const char *skip_whitespace(const char *str)
{
- assert(str);
+ trace_assert(str);
while(*str != 0 && isspace(*str)) {
str++;
static const char *next_quote(const char *str)
{
- assert(str);
+ trace_assert(str);
while(*str != 0 && *str != '"') {
str++;
static const char *skip_until_newline(const char *str)
{
- assert(str);
+ trace_assert(str);
while(*str != 0 && *str != '\n') {
str++;
static const char *next_non_symbol(const char *str)
{
- assert(str);
+ trace_assert(str);
while(*str != 0 && is_symbol_char(*str)) {
str++;
struct Token next_token(const char *str)
{
- assert(str);
+ trace_assert(str);
str = skip_whitespace(str);
if (*str == 0) {
#include <SDL2/SDL.h>
#include <SDL2/SDL_mixer.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include "game.h"
size_t sound_sample_files_count,
SDL_Renderer *renderer)
{
- assert(level_file_path);
+ trace_assert(level_file_path);
Lt *const lt = create_lt();
if (lt == NULL) {
void destroy_game(Game *game)
{
- assert(game);
+ trace_assert(game);
RETURN_LT0(game->lt);
}
int game_render(const Game *game)
{
- assert(game);
+ trace_assert(game);
if (game->state == GAME_STATE_QUIT) {
return 0;
int game_update(Game *game, float delta_time)
{
- assert(game);
- assert(delta_time > 0.0f);
+ trace_assert(game);
+ trace_assert(delta_time > 0.0f);
if (game->state == GAME_STATE_QUIT) {
return 0;
static int game_event_pause(Game *game, const SDL_Event *event)
{
- assert(game);
- assert(event);
+ trace_assert(game);
+ trace_assert(event);
switch (event->type) {
case SDL_QUIT:
static int game_event_running(Game *game, const SDL_Event *event)
{
- assert(game);
- assert(event);
+ trace_assert(game);
+ trace_assert(event);
switch (event->type) {
case SDL_QUIT:
int game_event(Game *game, const SDL_Event *event)
{
- assert(game);
- assert(event);
+ trace_assert(game);
+ trace_assert(event);
switch (game->state) {
case GAME_STATE_RUNNING:
const Uint8 *const keyboard_state,
SDL_Joystick *the_stick_of_joy)
{
- assert(game);
- assert(keyboard_state);
+ trace_assert(game);
+ trace_assert(keyboard_state);
if (game->state == GAME_STATE_QUIT ||
game->state == GAME_STATE_PAUSE ||
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <math.h>
#include <stdbool.h>
void destroy_camera(Camera *camera)
{
- assert(camera);
+ trace_assert(camera);
free(camera);
}
Rect rect,
Color color)
{
- assert(camera);
+ trace_assert(camera);
SDL_Rect view_port;
SDL_RenderGetViewport(camera->renderer, &view_port);
Rect rect,
Color color)
{
- assert(camera);
+ trace_assert(camera);
SDL_Rect view_port;
SDL_RenderGetViewport(camera->renderer, &view_port);
Triangle t,
Color color)
{
- assert(camera);
+ trace_assert(camera);
SDL_Rect view_port;
SDL_RenderGetViewport(camera->renderer, &view_port);
Triangle t,
Color color)
{
- assert(camera);
+ trace_assert(camera);
SDL_Rect view_port;
SDL_RenderGetViewport(camera->renderer, &view_port);
const char *text,
Vec position)
{
- assert(camera);
- assert(text);
+ trace_assert(camera);
+ trace_assert(text);
if (!camera->debug_mode) {
return 0;
void camera_center_at(Camera *camera, Point position)
{
- assert(camera);
+ trace_assert(camera);
camera->position = position;
}
void camera_toggle_debug_mode(Camera *camera)
{
- assert(camera);
+ trace_assert(camera);
camera->debug_mode = !camera->debug_mode;
}
void camera_disable_debug_mode(Camera *camera)
{
- assert(camera);
+ trace_assert(camera);
camera->debug_mode = 0;
}
void camera_toggle_blackwhite_mode(Camera *camera)
{
- assert(camera);
+ trace_assert(camera);
camera->blackwhite_mode = !camera->blackwhite_mode;
}
Rect camera_view_port(const Camera *camera)
{
- assert(camera);
+ trace_assert(camera);
SDL_Rect view_port;
SDL_RenderGetViewport(camera->renderer, &view_port);
Vec position,
const char *text)
{
- assert(camera);
- assert(text);
+ trace_assert(camera);
+ trace_assert(text);
SDL_Rect view_port;
SDL_RenderGetViewport(camera->renderer, &view_port);
Rect rect,
Color c)
{
- assert(camera);
+ trace_assert(camera);
if (!camera->debug_mode) {
return 0;
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include "color.h"
#include "game/camera.h"
Level *create_level_from_file(const char *file_name)
{
- assert(file_name);
+ trace_assert(file_name);
Lt *const lt = create_lt();
if (lt == NULL) {
void destroy_level(Level *level)
{
- assert(level);
+ trace_assert(level);
RETURN_LT0(level->lt);
}
int level_render(const Level *level, Camera *camera)
{
- assert(level);
+ trace_assert(level);
if (background_render(level->background, camera) < 0) {
return -1;
int level_update(Level *level, float delta_time)
{
- assert(level);
- assert(delta_time > 0);
+ trace_assert(level);
+ trace_assert(delta_time > 0);
physical_world_apply_gravity(level->physical_world);
boxes_float_in_lava(level->boxes, level->lava);
int level_event(Level *level, const SDL_Event *event)
{
- assert(level);
- assert(event);
+ trace_assert(level);
+ trace_assert(event);
switch (event->type) {
case SDL_KEYDOWN:
const Uint8 *const keyboard_state,
SDL_Joystick *the_stick_of_joy)
{
- assert(level);
- assert(keyboard_state);
+ trace_assert(level);
+ trace_assert(keyboard_state);
(void) the_stick_of_joy;
if (keyboard_state[SDL_SCANCODE_A]) {
Rigid_rect *level_rigid_rect(Level *level,
const char *rigid_rect_id)
{
- assert(level);
- assert(rigid_rect_id);
+ trace_assert(level);
+ trace_assert(rigid_rect_id);
Rigid_rect *rigid_rect = player_rigid_rect(level->player,
rigid_rect_id);
void level_hide_label(Level *level, const char *label_id)
{
- assert(level);
- assert(label_id);
+ trace_assert(level);
+ trace_assert(label_id);
labels_hide(level->labels, label_id);
}
-#include <assert.h>
+#include "system/stacktrace.h"
#include "game/level/background.h"
#include "math/rand.h"
void destroy_background(Background *background)
{
- assert(background);
+ trace_assert(background);
RETURN_LT0(background->lt);
}
int background_render(const Background *background,
Camera *camera)
{
- assert(background);
- assert(camera);
+ trace_assert(background);
+ trace_assert(camera);
if (camera_clear_background(
camera,
static void chunk_of_point(Point p, int *x, int *y)
{
- assert(x);
- assert(y);
+ trace_assert(x);
+ trace_assert(y);
*x = (int) (p.x / BACKGROUND_CHUNK_WIDTH);
*y = (int) (p.y / BACKGROUND_CHUNK_HEIGHT);
}
-#include <assert.h>
+#include "system/stacktrace.h"
#include "game/level/boxes.h"
#include "game/level/physical_world.h"
Boxes *create_boxes_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *lt = create_lt();
void destroy_boxes(Boxes *boxes)
{
- assert(boxes);
+ trace_assert(boxes);
RETURN_LT0(boxes->lt);
}
int boxes_render(Boxes *boxes, Camera *camera)
{
- assert(boxes);
- assert(camera);
+ trace_assert(boxes);
+ trace_assert(camera);
for (size_t i = 0; i < boxes->count; ++i) {
if (rigid_rect_render(boxes->bodies[i], camera) < 0) {
int boxes_update(Boxes *boxes,
float delta_time)
{
- assert(boxes);
- assert(delta_time);
+ trace_assert(boxes);
+ trace_assert(delta_time);
for (size_t i = 0; i < boxes->count; ++i) {
if (rigid_rect_update(boxes->bodies[i], delta_time) < 0) {
int boxes_add_to_physical_world(const Boxes *boxes,
Physical_world *physical_world)
{
- assert(boxes);
- assert(physical_world);
+ trace_assert(boxes);
+ trace_assert(physical_world);
for (size_t i = 0; i < boxes->count; ++i) {
if (physical_world_add_solid(
void boxes_float_in_lava(Boxes *boxes, Lava *lava)
{
- assert(boxes);
- assert(lava);
+ trace_assert(boxes);
+ trace_assert(lava);
for (size_t i = 0; i < boxes->count; ++i) {
lava_float_rigid_rect(lava, boxes->bodies[i]);
Rigid_rect *boxes_rigid_rect(Boxes *boxes, const char *id)
{
- assert(boxes);
- assert(id);
+ trace_assert(boxes);
+ trace_assert(id);
for (size_t i = 0; i < boxes->count; ++i) {
if (rigid_rect_has_id(boxes->bodies[i], id)) {
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <math.h>
#include "goals.h"
Goals *create_goals_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *const lt = create_lt();
if (lt == NULL) {
void destroy_goals(Goals *goals)
{
- assert(goals);
+ trace_assert(goals);
RETURN_LT0(goals->lt);
}
size_t goal_index,
Camera *camera)
{
- assert(goals);
- assert(camera);
+ trace_assert(goals);
+ trace_assert(camera);
const Point position = vec_sum(
goals->points[goal_index],
int goals_render(const Goals *goals,
Camera *camera)
{
- assert(goals);
- assert(camera);
+ trace_assert(goals);
+ trace_assert(camera);
for (size_t i = 0; i < goals->count; ++i) {
if (!goals_is_goal_hidden(goals, i)) {
void goals_update(Goals *goals,
float delta_time)
{
- assert(goals);
- assert(delta_time > 0.0f);
+ trace_assert(goals);
+ trace_assert(delta_time > 0.0f);
goals->angle = fmodf(goals->angle + 2.0f * delta_time, 2.0f * PI);
}
void goals_checkpoint(const Goals *goals,
Player *player)
{
- assert(goals);
- assert(player);
+ trace_assert(goals);
+ trace_assert(player);
for (size_t i = 0; i < goals->count; ++i) {
if (goals->cue_states[i] == CUE_STATE_HIT_NOTHING) {
void goals_hide(Goals *goals, const char *id)
{
- assert(goals);
- assert(id);
+ trace_assert(goals);
+ trace_assert(id);
for (size_t i = 0; i < goals->count; ++i) {
if (strcmp(id, goals->ids[i]) == 0) {
void goals_show(Goals *goals, const char *id)
{
- assert(goals);
- assert(id);
+ trace_assert(goals);
+ trace_assert(id);
for (size_t i = 0; i < goals->count; ++i) {
if (strcmp(id, goals->ids[i]) == 0) {
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdbool.h>
#include "game/camera.h"
Labels *create_labels_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *const lt = create_lt();
if (lt == NULL) {
void destroy_labels(Labels *label)
{
- assert(label);
+ trace_assert(label);
RETURN_LT0(label->lt);
}
int labels_render(const Labels *label,
Camera *camera)
{
- assert(label);
- assert(camera);
+ trace_assert(label);
+ trace_assert(camera);
for (size_t i = 0; i < label->count; ++i) {
/* Easing */
void labels_update(Labels *label,
float delta_time)
{
- assert(label);
+ trace_assert(label);
(void) delta_time;
for (size_t i = 0; i < label->count; ++i) {
void labels_enter_camera_event(Labels *labels,
const Camera *camera)
{
- assert(labels);
- assert(camera);
+ trace_assert(labels);
+ trace_assert(camera);
for (size_t i = 0; i < labels->count; ++i) {
const int became_visible = camera_is_text_visible(
void labels_hide(Labels *labels,
const char *label_id)
{
- assert(labels);
- assert(label_id);
+ trace_assert(labels);
+ trace_assert(label_id);
for (size_t i = 0; i < labels->count; ++i) {
if (strcmp(labels->ids[i], label_id) == 0 && labels->states[i] != LABEL_STATE_HIDDEN) {
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include "color.h"
Lava *create_lava_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *lt = create_lt();
if (lt == NULL) {
void destroy_lava(Lava *lava)
{
- assert(lava);
+ trace_assert(lava);
RETURN_LT0(lava->lt);
}
int lava_render(const Lava *lava,
Camera *camera)
{
- assert(lava);
- assert(camera);
+ trace_assert(lava);
+ trace_assert(camera);
for (size_t i = 0; i < lava->rects_count; ++i) {
if (wavy_rect_render(lava->rects[i], camera) < 0) {
int lava_update(Lava *lava, float delta_time)
{
- assert(lava);
+ trace_assert(lava);
for (size_t i = 0; i < lava->rects_count; ++i) {
if (wavy_rect_update(lava->rects[i], delta_time) < 0) {
bool lava_overlaps_rect(const Lava *lava,
Rect rect)
{
- assert(lava);
+ trace_assert(lava);
for (size_t i = 0; i < lava->rects_count; ++i) {
if (rects_overlap(wavy_rect_hitbox(lava->rects[i]), rect)) {
void lava_float_rigid_rect(Lava *lava, Rigid_rect *object)
{
- assert(lava);
+ trace_assert(lava);
const Rect object_hitbox = rigid_rect_hitbox(object);
for (size_t i = 0; i < lava->rects_count; ++i) {
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
Wavy_rect *create_wavy_rect_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
char color_name[7];
Rect rect;
void destroy_wavy_rect(Wavy_rect *wavy_rect)
{
- assert(wavy_rect);
+ trace_assert(wavy_rect);
RETURN_LT0(wavy_rect->lt);
}
int wavy_rect_render(const Wavy_rect *wavy_rect,
Camera *camera)
{
- assert(wavy_rect);
- assert(camera);
+ trace_assert(wavy_rect);
+ trace_assert(camera);
srand(42);
for (float wave_scanner = 0;
int wavy_rect_update(Wavy_rect *wavy_rect,
float delta_time)
{
- assert(wavy_rect);
+ trace_assert(wavy_rect);
wavy_rect->angle = fmodf(wavy_rect->angle + 2.0f * delta_time, 2 * PI);
return 0;
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdlib.h>
#include "game/level/platforms.h"
void destroy_physical_world(Physical_world *physical_world)
{
- assert(physical_world);
+ trace_assert(physical_world);
RETURN_LT0(physical_world->lt);
}
void physical_world_collide_solids(Physical_world *physical_world,
Platforms *platforms)
{
- assert(physical_world);
+ trace_assert(physical_world);
for (size_t i = 0; i < physical_world->size; ++i) {
solid_collide_with_solid(
int physical_world_add_solid(Physical_world *physical_world,
Solid_ref solid)
{
- assert(physical_world);
+ trace_assert(physical_world);
if (physical_world->size >= physical_world->capacity) {
const size_t new_capacity = physical_world->capacity * 2;
void physical_world_clean(Physical_world *physical_world)
{
- assert(physical_world);
+ trace_assert(physical_world);
physical_world->size = 0;
}
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Platforms *create_platforms_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *const lt = create_lt();
if (lt == NULL) {
void destroy_platforms(Platforms *platforms)
{
- assert(platforms);
+ trace_assert(platforms);
RETURN_LT0(platforms->lt);
}
int platforms_save_to_file(const Platforms *platforms,
const char *filename)
{
- assert(platforms);
- assert(filename);
+ trace_assert(platforms);
+ trace_assert(filename);
Lt *const lt = create_lt();
if (lt == NULL) {
Rect object,
int sides[RECT_SIDE_N])
{
- assert(platforms);
+ trace_assert(platforms);
for (size_t i = 0; i < platforms->rects_size; ++i) {
rect_object_impact(object, platforms->rects[i], sides);
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
Player *create_player_from_line_stream(LineStream *line_stream, Level *level)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *lt = create_lt();
int player_render(const Player * player,
Camera *camera)
{
- assert(player);
- assert(camera);
+ trace_assert(player);
+ trace_assert(camera);
switch (player->state) {
case PLAYER_STATE_ALIVE:
void player_update(Player *player,
float delta_time)
{
- assert(player);
+ trace_assert(player);
switch (player->state) {
case PLAYER_STATE_ALIVE: {
void player_move_left(Player *player)
{
- assert(player);
+ trace_assert(player);
rigid_rect_move(player->alive_body, vec(-PLAYER_SPEED, 0.0f));
}
void player_move_right(Player *player)
{
- assert(player);
+ trace_assert(player);
rigid_rect_move(player->alive_body, vec(PLAYER_SPEED, 0.0f));
}
void player_stop(Player *player)
{
- assert(player);
+ trace_assert(player);
rigid_rect_move(player->alive_body, vec(0.0f, 0.0f));
}
void player_jump(Player *player)
{
- assert(player);
+ trace_assert(player);
if (player->jump_threshold < PLAYER_MAX_JUMP_THRESHOLD) {
rigid_rect_transform_velocity(player->alive_body,
make_mat3x3(1.0f, 0.0f, 0.0f,
void player_die(Player *player)
{
- assert(player);
+ trace_assert(player);
if (player->state == PLAYER_STATE_ALIVE) {
const Rect hitbox =
void player_focus_camera(Player *player,
Camera *camera)
{
- assert(player);
- assert(camera);
+ trace_assert(player);
+ trace_assert(camera);
const Rect player_hitbox = rigid_rect_hitbox(player->alive_body);
void player_hide_goals(const Player *player,
Goals *goals)
{
- assert(player);
- assert(goals);
+ trace_assert(player);
+ trace_assert(goals);
goals_hide_from_player(goals, rigid_rect_hitbox(player->alive_body));
}
Rigid_rect *player_rigid_rect(Player *player, const char *id)
{
- assert(player);
- assert(id);
+ trace_assert(player);
+ trace_assert(id);
if (player->state == PLAYER_STATE_ALIVE) {
if (rigid_rect_has_id(player->alive_body, id)) {
bool player_overlaps_rect(const Player *player,
Rect rect)
{
- assert(player);
+ trace_assert(player);
return player->state == PLAYER_STATE_ALIVE
&& rects_overlap(
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include "dying_rect.h"
#include "math/rand.h"
void destroy_dying_rect(Dying_rect *dying_rect)
{
- assert(dying_rect);
+ trace_assert(dying_rect);
RETURN_LT0(dying_rect->lt);
}
int dying_rect_render(const Dying_rect *dying_rect,
Camera *camera)
{
- assert(dying_rect);
- assert(camera);
+ trace_assert(dying_rect);
+ trace_assert(camera);
for (size_t i = 0; i < DYING_RECT_PIECE_COUNT; ++i) {
Color color = dying_rect->color;
int dying_rect_update(Dying_rect *dying_rect,
float delta_time)
{
- assert(dying_rect);
- assert(delta_time > 0.0f);
+ trace_assert(dying_rect);
+ trace_assert(delta_time > 0.0f);
if (dying_rect_is_dead(dying_rect)) {
return 0;
int dying_rect_is_dead(const Dying_rect *dying_rect)
{
- assert(dying_rect);
+ trace_assert(dying_rect);
return dying_rect->time_passed >= dying_rect->duration;
}
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <string.h>
Rigid_rect *create_rigid_rect(Rect rect, Color color, const char *id)
{
- assert(id);
+ trace_assert(id);
Lt *lt = create_lt();
Rigid_rect *create_rigid_rect_from_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
char color[7];
Rect rect;
int rigid_rect_update(Rigid_rect * rigid_rect,
float delta_time)
{
- assert(rigid_rect);
+ trace_assert(rigid_rect);
rigid_rect->touches_ground = 0;
void rigid_rect_collide_with_solid(Rigid_rect * rigid_rect,
Solid_ref solid)
{
- assert(rigid_rect);
- assert(rigid_rect != solid.ptr);
+ trace_assert(rigid_rect);
+ trace_assert(rigid_rect != solid.ptr);
int sides[RECT_SIDE_N] = { 0, 0, 0, 0 };
bool rigid_rect_has_id(Rigid_rect *rigid_rect,
const char *id)
{
- assert(rigid_rect);
- assert(id);
+ trace_assert(rigid_rect);
+ trace_assert(id);
return strcmp(rigid_rect->id, id) == 0;
}
-#include <assert.h>
+#include "system/stacktrace.h"
#include "ebisp/gc.h"
#include "ebisp/interpreter.h"
Regions *create_regions_from_line_stream(LineStream *line_stream, Level *level)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *lt = create_lt();
if (lt == NULL) {
void destroy_regions(Regions *regions)
{
- assert(regions);
+ trace_assert(regions);
RETURN_LT0(regions->lt);
}
void regions_player_enter(Regions *regions, Player *player)
{
- assert(regions);
- assert(player);
+ trace_assert(regions);
+ trace_assert(player);
for (size_t i = 0; i < regions->count; ++i) {
if (regions->states[i] == RS_PLAYER_OUTSIDE &&
void regions_player_leave(Regions *regions, Player *player)
{
- assert(regions);
- assert(player);
+ trace_assert(regions);
+ trace_assert(player);
for (size_t i = 0; i < regions->count; ++i) {
if (regions->states[i] == RS_PLAYER_INSIDE &&
int regions_render(Regions *regions, Camera *camera)
{
- assert(regions);
- assert(camera);
+ trace_assert(regions);
+ trace_assert(camera);
for (size_t i = 0; i < regions->count; ++i) {
if (camera_render_debug_rect(
-#include <assert.h>
+#include "system/stacktrace.h"
#include "ebisp/gc.h"
#include "ebisp/interpreter.h"
Script *create_script_from_line_stream(LineStream *line_stream, Level *level)
{
- assert(line_stream);
+ trace_assert(line_stream);
Lt *lt = create_lt();
if (lt == NULL) {
void destroy_script(Script *script)
{
- assert(script);
+ trace_assert(script);
RETURN_LT0(script->lt);
}
int script_eval(Script *script, const char *source_code)
{
- assert(script);
- assert(source_code);
+ trace_assert(script);
+ trace_assert(source_code);
struct ParseResult parse_result = read_expr_from_string(
script->gc,
-#include <assert.h>
+#include "system/stacktrace.h"
#include "ebisp/gc.h"
#include "ebisp/interpreter.h"
static struct EvalResult
hide_goal(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(param);
- assert(gc);
- assert(scope);
+ trace_assert(param);
+ trace_assert(gc);
+ trace_assert(scope);
Level * const level = (Level*)param;
char * goal_id = NULL;
static struct EvalResult
show_goal(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(param);
- assert(gc);
- assert(scope);
+ trace_assert(param);
+ trace_assert(gc);
+ trace_assert(scope);
Level * const level = (Level*)param;
const char *goal_id = NULL;
static struct EvalResult
rect_apply_force(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
- assert(param);
+ trace_assert(gc);
+ trace_assert(scope);
+ trace_assert(param);
Level *level = (Level*) param;
static struct EvalResult
hide_label(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(param);
- assert(gc);
- assert(scope);
+ trace_assert(param);
+ trace_assert(gc);
+ trace_assert(scope);
Level *level = (Level*) param;
const char *label_id = NULL;
#include <SDL2/SDL.h>
#include <SDL2/SDL_mixer.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
Sound_samples *create_sound_samples(const char *sample_files[],
size_t sample_files_count)
{
- assert(sample_files);
- assert(sample_files_count > 0);
+ trace_assert(sample_files);
+ trace_assert(sample_files_count > 0);
Lt *lt = create_lt();
if (lt == NULL) {
void destroy_sound_samples(Sound_samples *sound_samples)
{
- assert(sound_samples);
+ trace_assert(sound_samples);
RETURN_LT0(sound_samples->lt);
}
size_t sound_index,
int loops)
{
- assert(sound_samples);
+ trace_assert(sound_samples);
if (sound_index < sound_samples->samples_count) {
const int free_channel = mix_get_free_channel();
int sound_samples_toggle_pause(Sound_samples *sound_samples)
{
- assert(sound_samples);
+ trace_assert(sound_samples);
if (sound_samples->paused) {
Mix_Resume(-1);
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <string.h>
Sprite_font *create_sprite_font_from_file(const char *bmp_file_path,
SDL_Renderer *renderer)
{
- assert(bmp_file_path);
- assert(renderer);
+ trace_assert(bmp_file_path);
+ trace_assert(renderer);
Lt * const lt = create_lt();
if (lt == NULL) {
void destroy_sprite_font(Sprite_font *sprite_font)
{
- assert(sprite_font);
+ trace_assert(sprite_font);
RETURN_LT0(sprite_font->lt);
}
static SDL_Rect sprite_font_char_rect(const Sprite_font *sprite_font, char x)
{
- assert(sprite_font);
+ trace_assert(sprite_font);
if (32 <= x && x <= 126) {
const SDL_Rect rect = {
Color color,
const char *text)
{
- assert(sprite_font);
- assert(renderer);
- assert(text);
+ trace_assert(sprite_font);
+ trace_assert(renderer);
+ trace_assert(text);
const SDL_Color sdl_color = color_for_sdl(color);
Vec size,
const char *text)
{
- assert(sprite_font);
- assert(text);
+ trace_assert(sprite_font);
+ trace_assert(text);
return rect(
position.x, position.y,
size.x * FONT_CHAR_WIDTH * (float) strlen(text),
-#include <assert.h>
+#include "system/stacktrace.h"
#include <math.h>
#include "point.h"
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include <math.h>
#include <string.h>
void rect_object_impact(Rect object, Rect obstacle, int *sides)
{
- assert(sides);
+ trace_assert(sides);
Rect int_area = rects_overlap_area(object, obstacle);
#include <SDL2/SDL.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include "renderer.h"
#include "system/lt.h"
int draw_triangle(SDL_Renderer *render,
Triangle t)
{
- assert(render);
+ trace_assert(render);
if (SDL_RenderDrawLine(render,
(int) roundf(t.p1.x),
static int fill_bottom_flat_triangle(SDL_Renderer *render,
Triangle t)
{
- assert(render);
+ trace_assert(render);
const float invslope1 = (t.p2.x - t.p1.x) / (t.p2.y - t.p1.y);
const float invslope2 = (t.p3.x - t.p1.x) / (t.p3.y - t.p1.y);
static int fill_top_flat_triangle(SDL_Renderer *render,
Triangle t)
{
- assert(render);
+ trace_assert(render);
const float invslope1 = (t.p3.x - t.p1.x) / (t.p3.y - t.p1.y);
const float invslope2 = (t.p3.x - t.p2.x) / (t.p3.y - t.p2.y);
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include "str.h"
#include "system/nth_alloc.h"
char *string_append(char *prefix, const char *suffix)
{
- assert(suffix);
+ trace_assert(suffix);
if (prefix == NULL) {
return string_duplicate(suffix, NULL);
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
const char *mode,
size_t capacity)
{
- assert(filename);
- assert(mode);
+ trace_assert(filename);
+ trace_assert(mode);
Lt *lt = create_lt();
if (lt == NULL) {
void destroy_line_stream(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
RETURN_LT0(line_stream->lt);
}
const char *line_stream_next(LineStream *line_stream)
{
- assert(line_stream);
+ trace_assert(line_stream);
return fgets(line_stream->buffer,
(int) line_stream->capacity,
line_stream->stream);
-#include <assert.h>
+#include "system/stacktrace.h"
#include "ebisp/gc.h"
#include "ebisp/scope.h"
static struct EvalResult
print(void *param, Gc *gc, struct Scope *scope, struct Expr args)
{
- assert(gc);
- assert(scope);
+ trace_assert(gc);
+ trace_assert(scope);
(void) param;
const char *s = NULL;
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
void destroy_lt(Lt *lt)
{
- assert(lt);
+ trace_assert(lt);
while (lt->size-- > 0) {
if (lt->frames[lt->size]) {
void *lt_push(Lt *lt, void *resource, Lt_destroy resource_destroy)
{
- assert(lt);
- assert(resource_destroy);
- assert(lt != resource);
+ trace_assert(lt);
+ trace_assert(resource_destroy);
+ trace_assert(lt != resource);
if (resource == NULL) {
return NULL;
void* lt_reset(Lt *lt, void *old_resource, void *new_resource)
{
- assert(lt);
- assert(old_resource);
- assert(new_resource);
- assert(old_resource != new_resource);
+ trace_assert(lt);
+ trace_assert(old_resource);
+ trace_assert(new_resource);
+ trace_assert(old_resource != new_resource);
for (size_t i = 0; i < lt->size; ++i) {
if (lt->frames[i] && lt_slot_contains_resource(lt->frames[i], old_resource)) {
void *lt_release(Lt *lt, void *resource)
{
- assert(lt);
- assert(resource);
+ trace_assert(lt);
+ trace_assert(resource);
for (size_t i = 0; i < lt->size; ++i) {
if (lt->frames[i] && lt_slot_contains_resource(lt->frames[i], resource)) {
void *lt_replace(Lt *lt, void *old_resource, void *new_resource)
{
- assert(lt);
- assert(old_resource);
- assert(new_resource);
+ trace_assert(lt);
+ trace_assert(old_resource);
+ trace_assert(new_resource);
for (size_t i = 0; i < lt->size; ++i) {
if (lt->frames[i] && lt_slot_contains_resource(lt->frames[i], old_resource)) {
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdio.h>
#include <stdlib.h>
Lt_slot *create_lt_slot(void *resource, Lt_destroy resource_destroy)
{
- assert(resource);
- assert(resource_destroy);
+ trace_assert(resource);
+ trace_assert(resource_destroy);
Lt_slot *lt_slot = nth_alloc(sizeof(Lt_slot));
if (lt_slot == NULL) {
void *release_lt_slot(Lt_slot *lt_slot)
{
- assert(lt_slot);
+ trace_assert(lt_slot);
void *resource = lt_slot->resource;
free(lt_slot);
void destroy_lt_slot(Lt_slot *lt_slot)
{
- assert(lt_slot);
+ trace_assert(lt_slot);
lt_slot->resource_destroy(lt_slot->resource);
free(lt_slot);
void lt_slot_reset_resource(Lt_slot *lt_slot, void *resource)
{
- assert(lt_slot);
- assert(resource);
+ trace_assert(lt_slot);
+ trace_assert(resource);
lt_slot->resource_destroy(lt_slot->resource);
lt_slot->resource = resource;
void lt_slot_replace_resource(Lt_slot *lt_slot, void *resource)
{
- assert(lt_slot);
- assert(resource);
+ trace_assert(lt_slot);
+ trace_assert(resource);
lt_slot->resource = resource;
}
int lt_slot_contains_resource(const Lt_slot *lt_slot, void *resource)
{
- assert(lt_slot);
- assert(resource);
+ trace_assert(lt_slot);
+ trace_assert(resource);
return lt_slot->resource == resource;
}
-#include <assert.h>
+#include "system/stacktrace.h"
#include "ebisp/gc.h"
#include "ebisp/interpreter.h"
void destroy_console(Console *console)
{
- assert(console);
+ trace_assert(console);
RETURN_LT0(console->lt);
}
int console_update(Console *console, float delta_time)
{
- assert(console);
+ trace_assert(console);
if (console->a < 1.0f) {
console->a += 1.0f / SLIDE_DOWN_TIME * delta_time;
void console_slide_down(Console *console)
{
- assert(console);
+ trace_assert(console);
console->a = 0.0f;
}
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdlib.h>
#include <SDL2/SDL.h>
void destroy_console_log(Console_Log *console_log)
{
- assert(console_log);
+ trace_assert(console_log);
for (size_t i = 0; i < console_log->capacity; ++i) {
if (console_log->buffer[i]) {
free(console_log->buffer[i]);
SDL_Renderer *renderer,
Point position)
{
- assert(console_log);
- assert(renderer);
+ trace_assert(console_log);
+ trace_assert(renderer);
(void) position;
for (size_t i = 0; i < console_log->capacity; ++i) {
int console_log_push_line(Console_Log *console_log, const char *line, Color color)
{
- assert(console_log);
- assert(line);
+ trace_assert(console_log);
+ trace_assert(line);
const size_t next_cursor = (console_log->cursor + 1) % console_log->capacity;
-#include <assert.h>
+#include "system/stacktrace.h"
#include <stdbool.h>
#include "edit_field.h"
Vec font_size,
Color font_color)
{
- assert(font);
+ trace_assert(font);
Lt *lt = create_lt();
void destroy_edit_field(Edit_field *edit_field)
{
- assert(edit_field);
+ trace_assert(edit_field);
RETURN_LT0(edit_field->lt);
}
SDL_Renderer *renderer,
Point position)
{
- assert(edit_field);
- assert(renderer);
+ trace_assert(edit_field);
+ trace_assert(renderer);
const float cursor_y_overflow = 10.0f;
const float cursor_width = 2.0f;
int edit_field_handle_event(Edit_field *edit_field,
const SDL_Event *event)
{
- assert(edit_field);
- assert(event);
+ trace_assert(edit_field);
+ trace_assert(event);
switch (event->type) {
case SDL_KEYDOWN:
const char *edit_field_as_text(const Edit_field *edit_field)
{
- assert(edit_field);
+ trace_assert(edit_field);
return edit_field->buffer;
}
static void edit_field_right(Edit_field *edit_field)
{
- assert(edit_field);
+ trace_assert(edit_field);
if (edit_field->cursor < edit_field->buffer_size) {
edit_field->cursor++;
}
static void edit_field_backspace(Edit_field *edit_field)
{
- assert(edit_field);
+ trace_assert(edit_field);
if (edit_field->cursor == 0) {
return;
static void edit_field_delete(Edit_field *edit_field)
{
- assert(edit_field);
+ trace_assert(edit_field);
if (edit_field->cursor >= edit_field->buffer_size) {
return;
static void edit_field_insert_char(Edit_field *edit_field, char c)
{
- assert(edit_field);
+ trace_assert(edit_field);
if (edit_field->buffer_size >= BUFFER_CAPACITY) {
return;
void edit_field_clean(Edit_field *edit_field)
{
- assert(edit_field);
+ trace_assert(edit_field);
edit_field->cursor = 0;
edit_field->buffer_size = 0;
void edit_field_replace(Edit_field *edit_field, const char *text)
{
- assert(edit_field);
+ trace_assert(edit_field);
edit_field_clean(edit_field);
#include <stdio.h>
#include <stdlib.h>
-#include <assert.h>
+#include "system/stacktrace.h"
#include "history.h"
#include "str.h"
void destroy_history(History *history)
{
- assert(history);
+ trace_assert(history);
for (size_t i = 0; i < history->capacity; ++i) {
if (history->buffer[i] != NULL) {
int history_push(History *history, const char *command)
{
- assert(history);
- assert(command);
+ trace_assert(history);
+ trace_assert(command);
const size_t next_begin = (history->begin + 1) % history->capacity;
const char *history_current(History *history)
{
- assert(history);
+ trace_assert(history);
return history->buffer[history->cursor];
}
void history_prev(History *history)
{
- assert(history);
+ trace_assert(history);
if (history->cursor == 0) {
history->cursor = history->capacity - 1;
} else {
void history_next(History *history)
{
- assert(history);
+ trace_assert(history);
history->cursor = (history->cursor + 1) % history->capacity;
}
projects / nothing.git / commitdiff