string-util.h

Go to the documentation of this file.

// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.
 
#ifndef MUPDF_FITZ_STRING_H
#define MUPDF_FITZ_STRING_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
 
/* The Unicode character used to incoming character whose value is
 * unknown or unrepresentable. */
#define FZ_REPLACEMENT_CHARACTER 0xFFFD


size_t fz_strnlen(const char *s, size_t maxlen);

char *fz_strsep(char **stringp, const char *delim);

size_t fz_strlcpy(char *dst, const char *src, size_t n);

size_t fz_strlcat(char *dst, const char *src, size_t n);

const char *fz_strstr(const char *haystack, const char *needle);

const char *fz_strstrcase(const char *haystack, const char *needle);

void *fz_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);

void fz_dirname(char *dir, const char *path, size_t dirsize);

const char *fz_basename(const char *path);

int fz_strverscmp(const char *s1, const char *s2);

char *fz_urldecode(char *url);

char *fz_decode_uri(fz_context *ctx, const char *s);

char *fz_decode_uri_component(fz_context *ctx, const char *s);

char *fz_encode_uri(fz_context *ctx, const char *s);

char *fz_encode_uri_component(fz_context *ctx, const char *s);

char *fz_encode_uri_pathname(fz_context *ctx, const char *s);

void fz_format_output_path(fz_context *ctx, char *path, size_t size, const char *fmt, int page);

char *fz_cleanname(char *name);

char *fz_cleanname_strdup(fz_context *ctx, const char *name);

char *fz_realpath(const char *path, char *resolved_path);

int fz_strcasecmp(const char *a, const char *b);

int fz_strncasecmp(const char *a, const char *b, size_t n);

enum { FZ_UTFMAX = 4 };

int fz_chartorune(int *rune, const char *str);

int fz_chartorunen(int *rune, const char *str, size_t n);

int fz_runetochar(char *str, int rune);

int fz_runelen(int rune);

int fz_runeidx(const char *str, const char *p);

const char *fz_runeptr(const char *str, int idx);

int fz_utflen(const char *s);
 
/*
    Convert a wchar string into a new heap allocated utf8 one.
*/
char *fz_utf8_from_wchar(fz_context *ctx, const wchar_t *s);
 
/*
    Convert a utf8 string into a new heap allocated wchar one.
*/
wchar_t *fz_wchar_from_utf8(fz_context *ctx, const char *path);
 

float fz_strtof(const char *s, char **es);
 
int fz_grisu(float f, char *s, int *exp);

int fz_is_page_range(fz_context *ctx, const char *s);
const char *fz_parse_page_range(fz_context *ctx, const char *s, int *a, int *b, int n);

int fz_tolower(int c);
int fz_toupper(int c);

 
static inline uint16_t fz_unpack_uint16(const uint8_t *p)
{
    return (uint16_t)p[0] << 8 | (uint16_t)p[1];
}
 
static inline uint16_t fz_unpack_uint16_le(const uint8_t *p)
{
    return (uint16_t)p[1] << 8 | (uint16_t)p[0];
}
 
static inline uint32_t fz_unpack_uint32(const uint8_t *p)
{
    return (uint32_t)p[0] << 24 | (uint32_t)p[1] << 16 | (uint32_t)p[2] << 8 | (uint32_t)p[3];
}
 
static inline uint32_t fz_unpack_uint32_le(const uint8_t *p)
{
    return (uint32_t)p[3] << 24 | (uint32_t)p[2] << 16 | (uint32_t)p[1] << 8 | (uint32_t)p[0];
}
 
static inline uint64_t fz_unpack_uint64(const uint8_t *p)
{
    return  (
        (uint64_t)p[0]<<56 | (uint64_t)p[1]<<48 | (uint64_t)p[2]<<40 | (uint64_t)p[3]<<32 |
        (uint64_t)p[4]<<24 | (uint64_t)p[5]<<16 | (uint64_t)p[6]<<8 | (uint64_t)p[7]
    );
}
 
static inline uint64_t fz_unpack_uint64_le(const uint8_t *p)
{
    return (
        (uint64_t)p[7]<<56 | (uint64_t)p[6]<<48 | (uint64_t)p[5]<<40 | (uint64_t)p[4]<<32 |
        (uint64_t)p[3]<<24 | (uint64_t)p[2]<<16 | (uint64_t)p[1]<<8 | (uint64_t)p[0]
    );
}
 
static inline int16_t fz_unpack_int16(const uint8_t *p) { return fz_unpack_uint16(p); }
static inline int16_t fz_unpack_int16_le(const uint8_t *p) { return fz_unpack_uint16_le(p); }
static inline int32_t fz_unpack_int32(const uint8_t *p) { return fz_unpack_uint32(p); }
static inline int32_t fz_unpack_int32_le(const uint8_t *p) { return fz_unpack_uint32_le(p); }
static inline int64_t fz_unpack_int64(const uint8_t *p) { return fz_unpack_uint64(p); }
static inline int64_t fz_unpack_int64_le(const uint8_t *p) { return fz_unpack_uint64_le(p); }
 
static inline float fz_unpack_float(const uint8_t *p)
{
    uint32_t u = fz_unpack_uint32(p);
    float x;
    memcpy(&x, &u, sizeof x);
    return x;
}
 
static inline float fz_unpack_float_le(const uint8_t *p)
{
    uint32_t u = fz_unpack_uint32_le(p);
    float x;
    memcpy(&x, &u, sizeof x);
    return x;
}
 
static inline double fz_unpack_double(const uint8_t *p)
{
    uint64_t u = fz_unpack_uint64(p);
    double x;
    memcpy(&x, &u, sizeof x);
    return x;
}
 
static inline double fz_unpack_double_le(const uint8_t *p)
{
    uint64_t u = fz_unpack_uint64_le(p);
    double x;
    memcpy(&x, &u, sizeof x);
    return x;
}
 
static inline void fz_pack_uint16(uint8_t *p, uint16_t x)
{
    p[0] = x >> 8;
    p[1] = x;
}
 
static inline void fz_pack_uint32(uint8_t *p, uint32_t x)
{
    p[0] = x >> 24;
    p[1] = x >> 16;
    p[2] = x >> 8;
    p[3] = x;
}
 
static inline void fz_pack_uint64(uint8_t *p, uint64_t x)
{
    p[0] = x >> 56;
    p[1] = x >> 48;
    p[2] = x >> 40;
    p[3] = x >> 32;
    p[4] = x >> 24;
    p[5] = x >> 16;
    p[6] = x >> 8;
    p[7] = x;
}
 
static inline void fz_pack_uint16_le(uint8_t *p, uint16_t x)
{
    p[0] = x;
    p[1] = x >> 8;
}
 
static inline void fz_pack_uint32_le(uint8_t *p, uint32_t x)
{
    p[0] = x;
    p[1] = x >> 8;
    p[2] = x >> 16;
    p[3] = x >> 24;
}
 
static inline void fz_pack_uint64_le(uint8_t *p, uint64_t x)
{
    p[0] = x;
    p[1] = x >> 8;
    p[2] = x >> 16;
    p[3] = x >> 24;
    p[4] = x >> 32;
    p[5] = x >> 40;
    p[6] = x >> 48;
    p[7] = x >> 56;
}
 
static inline void fz_pack_float(uint8_t *p, float x)
{
    uint32_t u;
    memcpy(&u, &x, sizeof u);
    fz_pack_uint32(p, u);
}
 
static inline void fz_pack_double(uint8_t *p, double x)
{
    uint64_t u;
    memcpy(&u, &x, sizeof u);
    fz_pack_uint64(p, u);
}
 
static inline void fz_pack_float_le(uint8_t *p, float x)
{
    uint32_t u;
    memcpy(&u, &x, sizeof u);
    fz_pack_uint32_le(p, u);
}
 
static inline void fz_pack_double_le(uint8_t *p, double x)
{
    uint64_t u;
    memcpy(&u, &x, sizeof u);
    fz_pack_uint64_le(p, u);
}
 
#endif