/*
* Various utilities
*
* Copyright
* (C) 1992 Joseph H. Allen
* (C) 2001 Marek 'Marx' Grac
*
* This file is part of JOE (Joe's Own Editor)
*/
/* JOE's version of zero-terminated string (z-string) functions.
In older versions of JOE we had these because the library versions were slow.
In older versions of JOE we had these because we globally used "unsigned char *" strings.
Now we have them for ptrdiff_t lengths (instead of size_t), to avoid mixed signed / unsigned warnings. */
/* These are exactly the same as the library versions: for consistent naming */
#define zstr(a, b) strstr((a), (b))
#define zchr(s, c) strchr((s), (c))
#define zrchr(s, c) strrchr((s), (c))
#define zcat(a, b) strcat((a), (b))
#define zdup(s) strdup(s)
#define zcpy(a, b) strcpy((a), (b))
#define zcmp(a, b) strcmp((a), (b))
#define zlen(s) (ptrdiff_t)strlen(s)
/* Case insensitive compare, but only for ASCII */
int zicmp(const char *a, const char *b);
/* String compare for ctags file strings */
int zmcmp(const char *a, const char *b);
/* Same strncmp */
int zncmp(const char *a, const char *b, ptrdiff_t len);
/* Same as memcpy */
void *mcpy(void *a, const void *b, ptrdiff_t len);
/* Same as strncpy */
char *zncpy(char *a, const char *b, ptrdiff_t len);
/* Like strncpy, but string always ends up zero-terminated */
char *zlcpy(char *a, ptrdiff_t siz, const char *b);
/* Like strncat, but result is always zero-terminated */
char *zlcat(char *a, ptrdiff_t siz, const char *b);
/* Functions which support zero-terminated strings of ints */
ptrdiff_t Zlen(const int *s);
int Zcmp(const int *a, const int *b);
int *Zlcpy(int *a, ptrdiff_t siz, const int *b);
int *Zdup(const int *s);
char *Ztoutf8(char *a, ptrdiff_t len, const int *b);
char *Ztoz(char *a, ptrdiff_t len, const int *b);
/*
* Functions which return minimum/maximum of two numbers
*/
unsigned int uns_min(unsigned int a, unsigned int b);
signed int int_min(signed int a, int signed b);
signed long long_max(signed long a, signed long b);
signed long long_min(signed long a, signed long b);
off_t off_max(off_t a, off_t b);
off_t off_min(off_t a, off_t b);
ptrdiff_t diff_max(ptrdiff_t a, ptrdiff_t b);
ptrdiff_t diff_min(ptrdiff_t a, ptrdiff_t b);
/* Versions of 'read' and 'write' which automatically retry when interrupted */
ptrdiff_t joe_read(int fd, void *buf, ptrdiff_t siz);
ptrdiff_t joe_write(int fd, const void *buf, ptrdiff_t siz);
int joe_ioctl(int fd, unsigned long req, void *ptr);
/* wrappers to *alloc routines */
void *joe_malloc(ptrdiff_t size);
char *joe_strdup(char *ptr);
void *joe_calloc(ptrdiff_t nmemb, ptrdiff_t size);
void *joe_realloc(void *ptr, ptrdiff_t size);
void joe_free(void *ptr);
#ifndef HAVE_SIGHANDLER_T
typedef RETSIGTYPE (*sighandler_t)(int);
#endif
#ifdef NEED_TO_REINSTALL_SIGNAL
#define REINSTALL_SIGHANDLER(sig, handler) joe_set_signal(sig, handler)
#else
#define REINSTALL_SIGHANDLER(sig, handler) do {} while(0)
#endif
/* wrapper to hide signal interface differrencies */
int joe_set_signal(int signum, sighandler_t handler);
/* Simple parsers */
int parse_ws(const char * *p,int cmt);
int parse_ident(const char * *p,char **buf);
int parse_kw(const char **p,const char *kw);
int parse_tows(const char **p,char **buf);
int parse_field(const char **p,const char *field);
int parse_char(const char **p,char c);
int parse_int(const char **p,int *buf);
int parse_diff(const char **p,ptrdiff_t *buf);
int parse_off_t(const char **p,off_t *buf);
off_t ztoo(const char *s);
off_t zhtoo(const char *s);
long ztol(const char *s);
long zhtol(const char *s);
ptrdiff_t ztodiff(const char *s);
ptrdiff_t zhtodiff(const char *s);
int ztoi(const char *s);
int zhtoi(const char *s);
ptrdiff_t parse_string(const char **p,char **dst);
ptrdiff_t parse_Zstring(const char **p,int *dst, ptrdiff_t len);
int parse_range(const char **p,int *first,int *second);
int parse_class(const char **p, struct interval **array, ptrdiff_t *size);
void emit_string(FILE *f,const char *s,ptrdiff_t len);
void jsort(void *base, ptrdiff_t num, ptrdiff_t size, int (*compar)(const void *a, const void *b));
off_t oabs(off_t);
