all: improve const-correctness

9 files changed, 76 insertions, 76 deletions

diff --git a/libass/ass.c b/libass/ass.c
index 51fa201..66d9719 100644
--- a/libass/ass.c
+++ b/libass/ass.c
@@ -301,14 +301,14 @@ static inline void advance_token_pos(const char **const str,
     *end   = *start;
     while (**end != '\0' && **end != ',') ++*end;
     *str = *end + (**end == ',');
-    rskip_spaces((char**)end, (char*)*start);
+    rskip_spaces(end, *start);
 }
 
 static char *next_token(char **str)
 {
     char *p;
     char *start;
-    skip_spaces(str);
+    skip_spaces((const char **)str);
     if (**str == '\0') {
         return 0;
     }
@@ -583,8 +583,8 @@ static bool format_line_compare(const char *fmt1, const char *fmt2)
         const char *tk1_start, *tk2_start;
         const char *tk1_end, *tk2_end;
 
-        skip_spaces((char**)&fmt1);
-        skip_spaces((char**)&fmt2);
+        skip_spaces(&fmt1);
+        skip_spaces(&fmt2);
         if (!*fmt1 || !*fmt2)
             break;
 
@@ -628,7 +628,7 @@ static int process_styles_line(ASS_Track *track, char *str)
 {
     int ret = 0;
     if (!strncmp(str, "Format:", 7)) {
-        char *p = str + 7;
+        const char *p = str + 7;
         skip_spaces(&p);
         free(track->style_format);
         track->style_format = strdup(p);
@@ -642,7 +642,7 @@ static int process_styles_line(ASS_Track *track, char *str)
             custom_format_line_compatibility(track, p, ssa_style_format);
     } else if (!strncmp(str, "Style:", 6)) {
         char *p = str + 6;
-        skip_spaces(&p);
+        skip_spaces((const char**)&p);
         ret = process_style(track, p);
     }
     return ret;
@@ -768,7 +768,7 @@ static bool detect_legacy_conv_subs(ASS_Track *track)
 static int process_events_line(ASS_Track *track, char *str)
 {
     if (!strncmp(str, "Format:", 7)) {
-        char *p = str + 7;
+        const char *p = str + 7;
         skip_spaces(&p);
         free(track->event_format);
         track->event_format = strdup(p);
@@ -802,7 +802,7 @@ static int process_events_line(ASS_Track *track, char *str)
         }
 
         str += 9;
-        skip_spaces(&str);
+        skip_spaces((const char**)&str);
 
         eid = ass_alloc_event(track);
         if (eid < 0)
@@ -889,7 +889,7 @@ static int process_fonts_line(ASS_Track *track, char *str)
     size_t len;
 
     if (!strncmp(str, "fontname:", 9)) {
-        char *p = str + 9;
+        const char *p = str + 9;
         skip_spaces(&p);
         if (track->parser_priv->fontname) {
             decode_font(track);
@@ -937,7 +937,7 @@ mem_fail:
 */
 static int process_line(ASS_Track *track, char *str)
 {
-    skip_spaces(&str);
+    skip_spaces((const char**)&str);
     if (!ass_strncasecmp(str, "[Script Info]", 13)) {
         track->parser_priv->state = PST_INFO;
     } else if (!ass_strncasecmp(str, "[V4 Styles]", 11)) {
@@ -1228,7 +1228,7 @@ out:
  * \param bufsize out: file size
  * \return pointer to file contents. Caller is responsible for its deallocation.
  */
-char *read_file(ASS_Library *library, char *fname, size_t *bufsize)
+char *read_file(ASS_Library *library, const char *fname, size_t *bufsize)
 {
     int res;
     long sz;
diff --git a/libass/ass_drawing.c b/libass/ass_drawing.c
index c7f99b7..356b9df 100644
--- a/libass/ass_drawing.c
+++ b/libass/ass_drawing.c
@@ -51,7 +51,7 @@ static bool token_check_values(ASS_DrawingToken *token, int i, int type)
  */
 static ASS_DrawingToken *drawing_tokenize(const char *str)
 {
-    char *p = (char *) str;
+    const char *p = str;
     int type = -1, is_set = 0;
     double val;
     ASS_Vector point = {0, 0};
diff --git a/libass/ass_library.h b/libass/ass_library.h
index 674e06c..1df0d39 100644
--- a/libass/ass_library.h
+++ b/libass/ass_library.h
@@ -38,6 +38,6 @@ struct ass_library {
     void *msg_callback_data;
 };
 
-char *read_file(struct ass_library *library, char *fname, size_t *bufsize);
+char *read_file(struct ass_library *library, const char *fname, size_t *bufsize);
 
 #endif                          /* LIBASS_LIBRARY_H */
diff --git a/libass/ass_parse.c b/libass/ass_parse.c
index 8ba39c8..2cecb0f 100644
--- a/libass/ass_parse.c
+++ b/libass/ass_parse.c
@@ -33,7 +33,7 @@
 #define NBSP 0xa0   // unicode non-breaking space character
 
 struct arg {
-    char *start, *end;
+    const char *start, *end;
 };
 
 static inline int argtoi(struct arg arg)
@@ -57,7 +57,7 @@ static inline double argtod(struct arg arg)
     return value;
 }
 
-static inline void push_arg(struct arg *args, int *nargs, char *start, char *end)
+static inline void push_arg(struct arg *args, int *nargs, const char *start, const char *end)
 {
     if (*nargs <= MAX_VALID_NARGS) {
         rskip_spaces(&end, start);
@@ -72,9 +72,9 @@ static inline void push_arg(struct arg *args, int *nargs, char *start, char *end
  * \brief Check if starting part of (*p) matches sample.
  * If true, shift p to the first symbol after the matching part.
  */
-static inline int mystrcmp(char **p, const char *sample)
+static inline int mystrcmp(const char **p, const char *sample)
 {
-    char *p2;
+    const char *p2;
     for (p2 = *p; *sample != 0 && *p2 == *sample; p2++, sample++)
         ;
     if (*sample == 0) {
@@ -246,10 +246,10 @@ static bool parse_vector_clip(ASS_Renderer *render_priv,
  *            of a number of spaces immediately preceding '}' or ')'
  * \param pwr multiplier for some tag effects (comes from \t tags)
  */
-char *parse_tags(ASS_Renderer *render_priv, char *p, char *end, double pwr,
-                 bool nested)
+const char *parse_tags(ASS_Renderer *render_priv, const char *p, const char *end,
+                       double pwr, bool nested)
 {
-    for (char *q; p < end; p = q) {
+    for (const char *q; p < end; p = q) {
         while (*p != '\\' && p != end)
             ++p;
         if (*p != '\\')
@@ -264,7 +264,7 @@ char *parse_tags(ASS_Renderer *render_priv, char *p, char *end, double pwr,
         if (q == p)
             continue;
 
-        char *name_end = q;
+        const char *name_end = q;
 
         // Store one extra element to be able to detect excess arguments
         struct arg args[MAX_VALID_NARGS + 1];
@@ -286,7 +286,7 @@ char *parse_tags(ASS_Renderer *render_priv, char *p, char *end, double pwr,
                 // the last comma, through the backslash and all the way
                 // to the end of the argument string into a single argument.
 
-                char *r = q;
+                const char *r = q;
                 while (*r != ',' && *r != '\\' && *r != ')' && r != end)
                     ++r;
 
@@ -517,7 +517,7 @@ char *parse_tags(ASS_Renderer *render_priv, char *p, char *end, double pwr,
                 render_priv->state.frz =
                     render_priv->state.style->Angle;
         } else if (tag("fn")) {
-            char *start = args->start;
+            const char *start = args->start;
             if (nargs && strncmp(start, "0", args->end - start)) {
                 skip_spaces(&start);
                 render_priv->state.family.str = start;
@@ -1043,9 +1043,9 @@ void process_karaoke_effects(ASS_Renderer *render_priv)
  * \return ucs4 code of the next char
  * On return str points to the unparsed part of the string
  */
-unsigned get_next_char(ASS_Renderer *render_priv, char **str)
+unsigned get_next_char(ASS_Renderer *render_priv, const char **str)
 {
-    char *p = *str;
+    const char *p = *str;
     unsigned chr;
     if (*p == '\t') {
         ++p;
@@ -1076,14 +1076,14 @@ unsigned get_next_char(ASS_Renderer *render_priv, char **str)
             return '}';
         }
     }
-    chr = ass_utf8_get_char((char **) &p);
+    chr = ass_utf8_get_char(&p);
     *str = p;
     return chr;
 }
 
 // Return 1 if the event contains tags that will apply overrides the selective
 // style override code should not touch. Return 0 otherwise.
-int event_has_hard_overrides(char *str)
+int event_has_hard_overrides(const char *str)
 {
     // look for \pos and \move tags inside {...}
     // mirrors get_next_char, but is faster and doesn't change any global state
@@ -1094,7 +1094,7 @@ int event_has_hard_overrides(char *str)
             str++;
             while (*str && *str != '}') {
                 if (*str == '\\') {
-                    char *p = str + 1;
+                    const char *p = str + 1;
                     if (mystrcmp(&p, "pos") || mystrcmp(&p, "move") ||
                         mystrcmp(&p, "clip") || mystrcmp(&p, "iclip") ||
                         mystrcmp(&p, "org") || mystrcmp(&p, "pbo") ||
diff --git a/libass/ass_parse.h b/libass/ass_parse.h
index bf72b78..3dafe45 100644
--- a/libass/ass_parse.h
+++ b/libass/ass_parse.h
@@ -30,10 +30,10 @@ void update_font(ASS_Renderer *render_priv);
 double ensure_font_size(ASS_Renderer *priv, double size);
 void apply_transition_effects(ASS_Renderer *render_priv, ASS_Event *event);
 void process_karaoke_effects(ASS_Renderer *render_priv);
-unsigned get_next_char(ASS_Renderer *render_priv, char **str);
-char *parse_tags(ASS_Renderer *render_priv, char *p, char *end, double pwr,
-                 bool nested);
-int event_has_hard_overrides(char *str);
+unsigned get_next_char(ASS_Renderer *render_priv, const char **str);
+const char *parse_tags(ASS_Renderer *render_priv, const char *p, const char *end,
+                       double pwr, bool nested);
+int event_has_hard_overrides(const char *str);
 extern void change_alpha(uint32_t *var, int32_t new, double pwr);
 extern uint32_t mult_alpha(uint32_t a, uint32_t b);
 
diff --git a/libass/ass_render.c b/libass/ass_render.c
index 0bf6676..e856c0d 100644
--- a/libass/ass_render.c
+++ b/libass/ass_render.c
@@ -1914,7 +1914,7 @@ static bool parse_events(ASS_Renderer *render_priv, ASS_Event *event)
 {
     TextInfo *text_info = &render_priv->text_info;
 
-    char *p = event->Text, *q;
+    const char *p = event->Text, *q;
 
     // Event parsing.
     while (true) {
diff --git a/libass/ass_strtod.c b/libass/ass_strtod.c
index 47302a8..782ba7e 100644
--- a/libass/ass_strtod.c
+++ b/libass/ass_strtod.c
@@ -89,7 +89,7 @@ ass_strtod(
                              * The "E" may actually be an "e".  E and X
                              * may both be omitted (but not just one).
                              */
-    char **endPtr           /* If non-NULL, store terminating character's
+    const char **endPtr     /* If non-NULL, store terminating character's
                              * address here. */
     )
 {
diff --git a/libass/ass_utils.c b/libass/ass_utils.c
index 65b6f74..885374d 100644
--- a/libass/ass_utils.c
+++ b/libass/ass_utils.c
@@ -150,26 +150,26 @@ void *ass_try_realloc_array(void *ptr, size_t nmemb, size_t size)
     }
 }
 
-void skip_spaces(char **str)
+void skip_spaces(const char **str)
 {
-    char *p = *str;
+    const char *p = *str;
     while ((*p == ' ') || (*p == '\t'))
         ++p;
     *str = p;
 }
 
-void rskip_spaces(char **str, char *limit)
+void rskip_spaces(const char **str, const char *limit)
 {
-    char *p = *str;
+    const char *p = *str;
     while ((p > limit) && ((p[-1] == ' ') || (p[-1] == '\t')))
         --p;
     *str = p;
 }
 
-static int read_digits(char **str, unsigned base, uint32_t *res)
+static int read_digits(const char **str, unsigned base, uint32_t *res)
 {
-    char *p = *str;
-    char *start = p;
+    const char *p = *str;
+    const char *start = p;
     uint32_t val = 0;
 
     while (1) {
@@ -196,7 +196,7 @@ static int read_digits(char **str, unsigned base, uint32_t *res)
  * Follows the rules for strtoul but reduces the number modulo 2**32
  * instead of saturating it to 2**32 - 1.
  */
-static int mystrtou32_modulo(char **p, unsigned base, uint32_t *res)
+static int mystrtou32_modulo(const char **p, unsigned base, uint32_t *res)
 {
     // This emulates scanf with %d or %x format as it works on
     // Windows, because that's what is used by VSFilter. In practice,
@@ -205,7 +205,7 @@ static int mystrtou32_modulo(char **p, unsigned base, uint32_t *res)
 
     // Unlike scanf and like strtoul, produce 0 for invalid inputs.
 
-    char *start = *p;
+    const char *start = *p;
     int sign = 1;
 
     skip_spaces(p);
@@ -227,7 +227,7 @@ static int mystrtou32_modulo(char **p, unsigned base, uint32_t *res)
     }
 }
 
-int32_t parse_alpha_tag(char *str)
+int32_t parse_alpha_tag(const char *str)
 {
     int32_t alpha = 0;
 
@@ -238,7 +238,7 @@ int32_t parse_alpha_tag(char *str)
     return alpha;
 }
 
-uint32_t parse_color_tag(char *str)
+uint32_t parse_color_tag(const char *str)
 {
     int32_t color = 0;
 
@@ -249,7 +249,7 @@ uint32_t parse_color_tag(char *str)
     return ass_bswap32((uint32_t) color);
 }
 
-uint32_t parse_color_header(char *str)
+uint32_t parse_color_header(const char *str)
 {
     uint32_t color = 0;
     unsigned base;
@@ -265,19 +265,19 @@ uint32_t parse_color_header(char *str)
 }
 
 // Return a boolean value for a string
-char parse_bool(char *str)
+char parse_bool(const char *str)
 {
     skip_spaces(&str);
     return !ass_strncasecmp(str, "yes", 3) || strtol(str, NULL, 10) > 0;
 }
 
-int parse_ycbcr_matrix(char *str)
+int parse_ycbcr_matrix(const char *str)
 {
     skip_spaces(&str);
     if (*str == '\0')
         return YCBCR_DEFAULT;
 
-    char *end = str + strlen(str);
+    const char *end = str + strlen(str);
     rskip_spaces(&end, str);
 
     // Trim a local copy of the input that we know is safe to
@@ -339,7 +339,7 @@ void ass_msg(ASS_Library *priv, int lvl, const char *fmt, ...)
     va_end(va);
 }
 
-unsigned ass_utf8_get_char(char **str)
+unsigned ass_utf8_get_char(const char **str)
 {
     uint8_t *strp = (uint8_t *) * str;
     unsigned c = *strp++;
@@ -407,7 +407,7 @@ unsigned ass_utf8_put_char(char *dest, uint32_t ch)
  *            (will be set to the start of the next code point)
  * \return the code point
  */
-static uint32_t ass_read_utf16be(uint8_t **src, size_t bytes)
+static uint32_t ass_read_utf16be(const uint8_t **src, size_t bytes)
 {
     if (bytes < 2)
         goto too_short;
@@ -440,9 +440,9 @@ too_short:
     return 0xFFFD;
 }
 
-void ass_utf16be_to_utf8(char *dst, size_t dst_size, uint8_t *src, size_t src_size)
+void ass_utf16be_to_utf8(char *dst, size_t dst_size, const uint8_t *src, size_t src_size)
 {
-    uint8_t *end = src + src_size;
+    const uint8_t *end = src + src_size;
 
     if (!dst_size)
         return;
@@ -467,7 +467,7 @@ void ass_utf16be_to_utf8(char *dst, size_t dst_size, uint8_t *src, size_t src_si
  * Returns 0 if no styles found => expects at least 1 style.
  * Parsing code always adds "Default" style in the beginning.
  */
-int lookup_style(ASS_Track *track, char *name)
+int lookup_style(ASS_Track *track, const char *name)
 {
     int i;
     // '*' seem to mean literally nothing;
@@ -497,7 +497,7 @@ int lookup_style(ASS_Track *track, char *name)
  * \return style in track->styles
  * Returns NULL if no style has the given name.
  */
-ASS_Style *lookup_style_strict(ASS_Track *track, char *name, size_t len)
+ASS_Style *lookup_style_strict(ASS_Track *track, const char *name, size_t len)
 {
     int i;
     for (i = track->n_styles - 1; i >= 0; --i) {
diff --git a/libass/ass_utils.h b/libass/ass_utils.h
index 4789179..c75c3fc 100644
--- a/libass/ass_utils.h
+++ b/libass/ass_utils.h
@@ -93,28 +93,28 @@ void *ass_try_realloc_array(void *ptr, size_t nmemb, size_t size);
 #define ASS_REALLOC_ARRAY(ptr, count) \
     (errno = 0, (ptr) = ass_try_realloc_array(ptr, count, sizeof(*ptr)), !errno)
 
-void skip_spaces(char **str);
-void rskip_spaces(char **str, char *limit);
-int32_t parse_alpha_tag(char *str);
-uint32_t parse_color_tag(char *str);
-uint32_t parse_color_header(char *str);
-char parse_bool(char *str);
-int parse_ycbcr_matrix(char *str);
+void skip_spaces(const char **str);
+void rskip_spaces(const char **str, const char *limit);
+int32_t parse_alpha_tag(const char *str);
+uint32_t parse_color_tag(const char *str);
+uint32_t parse_color_header(const char *str);
+char parse_bool(const char *str);
+int parse_ycbcr_matrix(const char *str);
 int numpad2align(int val);
-unsigned ass_utf8_get_char(char **str);
+unsigned ass_utf8_get_char(const char **str);
 unsigned ass_utf8_put_char(char *dest, uint32_t ch);
-void ass_utf16be_to_utf8(char *dst, size_t dst_size, uint8_t *src, size_t src_size);
+void ass_utf16be_to_utf8(char *dst, size_t dst_size, const uint8_t *src, size_t src_size);
 #if defined(__MINGW32__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
     __attribute__ ((format (gnu_printf, 3, 4)))
 #elif defined(__GNUC__)
     __attribute__ ((format (printf, 3, 4)))
 #endif
 void ass_msg(ASS_Library *priv, int lvl, const char *fmt, ...);
-int lookup_style(ASS_Track *track, char *name);
-ASS_Style *lookup_style_strict(ASS_Track *track, char *name, size_t len);
+int lookup_style(ASS_Track *track, const char *name);
+ASS_Style *lookup_style_strict(ASS_Track *track, const char *name, size_t len);
 
 /* defined in ass_strtod.c */
-double ass_strtod(const char *string, char **endPtr);
+double ass_strtod(const char *string, const char **endPtr);
 
 static inline size_t ass_align(size_t alignment, size_t s)
 {
@@ -204,33 +204,33 @@ static inline uint32_t fnv_32a_buf(const void *buf, size_t len, uint32_t hval)
     return hval;
 }
 
-static inline int mystrtoi(char **p, int *res)
+static inline int mystrtoi(const char** p, int *res)
 {
-    char *start = *p;
+    const char *start = *p;
     double temp_res = ass_strtod(*p, p);
     *res = (int) (temp_res + (temp_res > 0 ? 0.5 : -0.5));
     return *p != start;
 }
 
-static inline int mystrtoll(char **p, long long *res)
+static inline int mystrtoll(const char** p, long long *res)
 {
-    char *start = *p;
+    const char *start = *p;
     double temp_res = ass_strtod(*p, p);
     *res = (long long) (temp_res + (temp_res > 0 ? 0.5 : -0.5));
     return *p != start;
 }
 
-static inline int mystrtod(char **p, double *res)
+static inline int mystrtod(const char ** p, double *res)
 {
-    char *start = *p;
+    const char *start = *p;
     *res = ass_strtod(*p, p);
     return *p != start;
 }
 
-static inline int mystrtoi32(char **p, int base, int32_t *res)
+static inline int mystrtoi32(const char** p, int base, int32_t *res)
 {
-    char *start = *p;
-    long long temp_res = strtoll(*p, p, base);
+    const char *start = *p;
+    long long temp_res = strtoll(*p, (char**)p, base);
     *res = FFMINMAX(temp_res, INT32_MIN, INT32_MAX);
     return *p != start;
 }