shithub: masto9

ref: 22b180670881db7c4850e7fd9786ffcb70498057
dir: /util.c/

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <thread.h>
#include <regexp.h>
#include <json.h>

#include "masto9.h"

void *
emalloc(ulong n)
{
	void *v;

	v = mallocz(n, 1);
	if(v == nil)
		sysfatal("malloc: %r");
	setmalloctag(v, getcallerpc(&n));
	return v;
}

void *
erealloc(void *p, ulong n)
{
	void *v;

	v = realloc(p, n);
	if(v == nil)
		sysfatal("realloc: %r");
	setmalloctag(v, getcallerpc(&p));
	return v;
}

char*
estrdup(char *s)
{
	s = strdup(s);
	if(s == nil)
		sysfatal("strdup: %r");
	setmalloctag(s, getcallerpc(&s));
	return s;
}

char *
concat(char *s1, char *s2)
{
  char *result;
  result = emalloc(strlen(s1) + strlen(s2) + 1); // +1 for the null-terminator

  strcpy(result, s1);
  strcat(result, s2);
  return result;
}

char*
esmprint(char *fmt, ...)
{
	char *s;
	va_list ap;

	va_start(ap, fmt);
	s = vsmprint(fmt, ap);
	va_end(ap);
	if(s == nil)
		sysfatal("smprint: %r");
	setmalloctag(s, getcallerpc(&fmt));
	return s;
}

char*
fslurp(int fd, int *nbuf)
{
	int n, sz, r;
	char *buf;

	n = 0;
	sz = 128;
	buf = emalloc(sz);
	while(1){
		r = read(fd, buf + n, sz - n);
		if(r == 0)
			break;
		if(r == -1)
			goto error;
		n += r;
		if(n == sz){
			sz += sz/2;
			buf = erealloc(buf, sz);
		}
	}
	buf[n] = 0;
	if(nbuf)
		*nbuf = n;
	return buf;
error:
	free(buf);
	return nil;
}

void
removesubstring(char *str, char *sub)
{
  int len = strlen(sub);

  while ((str = strstr(str, sub))) {
    memmove(str, str + len, strlen(str + len) + 1);
  }
}

void
removetag(char *str, char *tag)
{
  char *start = strstr(str, tag);

  while (start) {
    char *end = strchr(start, '>');

    if (end) {
      memmove(start, end + 1, strlen(end + 1) + 1);
    } else {
      *start = '\0';
      break;
    }

    start = strstr(start, tag);
  }
}

JSON *
getjsonkey(JSON *obj, char *key)
{
	JSON *value = jsonbyname(obj, key);
	if (value == nil)
		sysfatal("jsonbyname: key %s not found in %J", key, obj);
	return value;
}

FileAttachment *
readfile(char *filename)
{
    int fd, nread, size = 0, bufsize = 1024;
    FileAttachment *fa = emalloc(sizeof(FileAttachment));
    char *buf = malloc(bufsize);
    if (!buf)
        sysfatal("malloc failed");

    fd = open(filename, OREAD);
    if (fd < 0)
        sysfatal("open %s: %r", filename);

    while ((nread = read(fd, buf + size, bufsize - size)) > 0) {
        size += nread;
        if (size == bufsize) {
            bufsize *= 2;
            buf = realloc(buf, bufsize);
            if (!buf)
                sysfatal("realloc failed");
        }
    }
    close(fd);

    if (nread < 0)
        sysfatal("read %s: %r", filename);

    buf[size] = '\0';

    fa->buf = buf;
    fa->size = size;
    return fa;
}

char *
basename(char *path)
{
  char *base = strrchr(path, '/');
  return base ? base + 1 : path;
}