Declare pointers as const when possible

Author: jserv

include/twin_private.h

@@ -327,9 +327,6 @@ twin_argb32_t *_twin_fetch_argb32(twin_pixmap_t *pixmap,
 /*
  * Geometry helper functions
  */
-twin_dfixed_t _twin_distance_to_point_squared(twin_spoint_t *a,
-                                              twin_spoint_t *b);
-
 twin_dfixed_t _twin_distance_to_line_squared(twin_spoint_t *p,
                                              twin_spoint_t *p1,
                                              twin_spoint_t *p2);

src/convolve.c

@@ -10,8 +10,8 @@
  * Find the point in path which is furthest left of the line
  */
 static int _twin_path_leftpoint(twin_path_t *path,
-                                twin_spoint_t *p1,
-                                twin_spoint_t *p2)
+                                const twin_spoint_t *p1,
+                                const twin_spoint_t *p2)
 {
     twin_spoint_t *points = path->points;
     int best = 0;
@@ -36,10 +36,10 @@ static int _twin_path_leftpoint(twin_path_t *path,
     return best;
 }
 
-static int _around_order(twin_spoint_t *a1,
-                         twin_spoint_t *a2,
-                         twin_spoint_t *b1,
-                         twin_spoint_t *b2)
+static int _around_order(const twin_spoint_t *a1,
+                         const twin_spoint_t *a2,
+                         const twin_spoint_t *b1,
+                         const twin_spoint_t *b2)
 {
     twin_dfixed_t adx = (a2->x - a1->x);
     twin_dfixed_t ady = (a2->y - a1->y);

src/font.c

@@ -26,7 +26,7 @@ typedef struct _twin_text_info {
 } twin_text_info_t;
 
 static void _twin_text_compute_info(twin_path_t *path,
-                                    twin_font_t *font,
+                                    const twin_font_t *font,
                                     twin_text_info_t *info)
 {
     twin_spoint_t origin = _twin_path_current_spoint(path);
@@ -175,7 +175,7 @@ static void _twin_text_compute_snap(twin_text_info_t *info,
         info->snap_y[s] = FY(snap[s], info);
 }
 
-static twin_path_t *_twin_text_compute_pen(twin_text_info_t *info)
+static twin_path_t *_twin_text_compute_pen(const twin_text_info_t *info)
 {
     twin_path_t *pen = twin_path_create();
 
@@ -184,7 +184,7 @@ static twin_path_t *_twin_text_compute_pen(twin_text_info_t *info)
     return pen;
 }
 
-static twin_fixed_t _twin_snap(twin_fixed_t v, twin_fixed_t *snap, int n)
+static twin_fixed_t _twin_snap(twin_fixed_t v, const twin_fixed_t *snap, int n)
 {
     for (int s = 0; s < n - 1; s++) {
         if (snap[s] <= v && v <= snap[s + 1]) {
@@ -309,7 +309,7 @@ void twin_text_metrics_ucs4(twin_path_t *path,
     m->font_descent = font_descent + margin_y;
 }
 
-static const signed char *twin_glyph_draw(twin_font_t *font,
+static const signed char *twin_glyph_draw(const twin_font_t *font,
                                           const signed char *b)
 {
     if (font->type == TWIN_FONT_TYPE_STROKE)

src/geom.c

@@ -6,8 +6,8 @@
 
 #include "twin_private.h"
 
-twin_dfixed_t _twin_distance_to_point_squared(twin_spoint_t *a,
-                                              twin_spoint_t *b)
+static twin_dfixed_t _twin_distance_to_point_squared(const twin_spoint_t *a,
+                                                     const twin_spoint_t *b)
 {
     twin_dfixed_t dx = (b->x - a->x);
     twin_dfixed_t dy = (b->y - a->y);

src/hull.c

@@ -21,17 +21,17 @@ typedef struct _twin_hull {
 } twin_hull_t;
 
 static void _twin_slope_init(twin_slope_t *slope,
-                             twin_spoint_t *a,
-                             twin_spoint_t *b)
+                             const twin_spoint_t *a,
+                             const twin_spoint_t *b)
 {
     slope->dx = b->x - a->x;
     slope->dy = b->y - a->y;
 }
 
-static twin_hull_t *_twin_hull_create(twin_path_t *path, int *nhull)
+static twin_hull_t *_twin_hull_create(const twin_path_t *path, int *nhull)
 {
     int n = path->npoints;
-    twin_spoint_t *p = path->points;
+    const twin_spoint_t *p = path->points;
     twin_hull_t *hull;
 
     int e = 0;
@@ -77,12 +77,10 @@ static twin_hull_t *_twin_hull_create(twin_path_t *path, int *nhull)
    == 0 => a equal to be
    >  0 => a more positive than b
 */
-static int _twin_slope_compare(twin_slope_t *a, twin_slope_t *b)
+static int _twin_slope_compare(const twin_slope_t *a, const twin_slope_t *b)
 {
-    twin_dfixed_t diff;
-
-    diff = ((twin_dfixed_t) a->dy * (twin_dfixed_t) b->dx -
-            (twin_dfixed_t) b->dy * (twin_dfixed_t) a->dx);
+    twin_dfixed_t diff = ((twin_dfixed_t) a->dy * (twin_dfixed_t) b->dx -
+                          (twin_dfixed_t) b->dy * (twin_dfixed_t) a->dx);
 
     if (diff > 0)
         return 1;
@@ -125,7 +123,7 @@ static int _twin_hull_vertex_compare(const void *av, const void *bv)
     return ret;
 }
 
-static int _twin_hull_prev_valid(twin_hull_t *hull,
+static int _twin_hull_prev_valid(const twin_hull_t *hull,
                                  int maybe_unused num_hull,
                                  int index)
 {
@@ -137,7 +135,9 @@ static int _twin_hull_prev_valid(twin_hull_t *hull,
     return index;
 }
 
-static int _twin_hull_next_valid(twin_hull_t *hull, int num_hull, int index)
+static int _twin_hull_next_valid(const twin_hull_t *hull,
+                                 int num_hull,
+                                 int index)
 {
     do {
         index = (index + 1) % num_hull;
@@ -180,7 +180,7 @@ static void _twin_hull_eliminate_concave(twin_hull_t *hull, int num_hull)
 /*
  * Convert the hull structure back to a simple path
  */
-static twin_path_t *_twin_hull_to_path(twin_hull_t *hull, int num_hull)
+static twin_path_t *_twin_hull_to_path(const twin_hull_t *hull, int num_hull)
 {
     twin_path_t *path = twin_path_create();
 

src/screen.c

@@ -307,7 +307,8 @@ static void twin_screen_update_cursor(twin_screen_t *screen,
 }
 #endif /* CONFIG_CURSOR */
 
-static void _twin_adj_mouse_evt(twin_event_t *event, twin_pixmap_t *pixmap)
+static void _twin_adj_mouse_evt(twin_event_t *event,
+                                const twin_pixmap_t *pixmap)
 {
     event->u.pointer.x = event->u.pointer.screen_x - pixmap->x;
     event->u.pointer.y = event->u.pointer.screen_y - pixmap->y;

src/spline.c

@@ -15,8 +15,8 @@ typedef struct _twin_spline {
  * The shift factor determines the position between 'a' and 'b'.
  * The result is stored in 'result'.
  */
-static void _lerp(twin_spoint_t *a,
-                  twin_spoint_t *b,
+static void _lerp(const twin_spoint_t *a,
+                  const twin_spoint_t *b,
                   int shift,
                   twin_spoint_t *result)
 {

src/timeout.c

@@ -24,8 +24,8 @@ static twin_time_t start;
 
 static twin_order_t _twin_timeout_order(twin_queue_t *a, twin_queue_t *b)
 {
-    twin_timeout_t *at = (twin_timeout_t *) a;
-    twin_timeout_t *bt = (twin_timeout_t *) b;
+    const twin_timeout_t *at = (twin_timeout_t *) a;
+    const twin_timeout_t *bt = (twin_timeout_t *) b;
 
     if (twin_time_compare(at->time, <, bt->time))
         return TWIN_BEFORE;
@@ -85,7 +85,7 @@ void twin_clear_timeout(twin_timeout_t *timeout)
 twin_time_t _twin_timeout_delay(void)
 {
     if (head) {
-        twin_timeout_t *thead = (twin_timeout_t *) head;
+        const twin_timeout_t *thead = (twin_timeout_t *) head;
         twin_time_t now = twin_now();
         if (twin_time_compare(now, >=, thead->time))
             return 0;

src/work.c

@@ -12,8 +12,7 @@ static twin_queue_t *head;
 
 static twin_order_t _twin_work_order(twin_queue_t *a, twin_queue_t *b)
 {
-    twin_work_t *aw = (twin_work_t *) a;
-    twin_work_t *bw = (twin_work_t *) b;
+    const twin_work_t *aw = (twin_work_t *) a, *bw = (twin_work_t *) b;
 
     if (aw->priority < bw->priority)
         return TWIN_BEFORE;