lib.h

Go to the documentation of this file.

/* lib/lib.h
 *
 * General library stuff.
 *
 */
#ifndef LIB_H_
#define LIB_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ----- Includes ----- */
 
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include "list.h"
#include "log.h" // This may appear unused but it is used in the macros
 
/* ----- Macros ----- */

#define try(a) do { \
        if ((a) < 0) { \
            log(FATAL, "%s:%s:%d %s\n", __FILE__, __func__, __LINE__, strerror(errno)); \
            exit (EXIT_FAILURE); \
        } \
    } while(0)
 

#define exists(a) do { \
        if ((a) == NULL) { \
            log(FATAL, "%s:%s:%d Null pointer encountered, %s\n", __FILE__, __func__, __LINE__, strerror(errno)); \
            exit (EXIT_FAILURE); \
        } \
    } while(0)

#define TODO do { \
    log(ERROR, "%s:%s:%d Not yet implemented\n", __FILE__, __func__, __LINE__); \
    exit(EXIT_FAILURE); \
} while(0)

#define expect(cond, ...) do { \
    if (!(cond)) { \
        fprintf(stderr, __VA_ARGS__); \
        exit(EXIT_FAILURE); \
    } \
} while (0)

#define KB4 0x1000

#define CHUNK_SIZE 0x400
 
 
/* ----- Types ----- */

typedef uint8_t Byte;

typedef const char* Str;

typedef struct {
    Str str;  
    size_t len;  
} SafeStr;

Byte* copy(Byte* src, size_t nbytes);

typedef struct {
    size_t len;  
    Byte* buf;   
} Buffer;
 
DefList(Buffer)
 

typedef struct {
    FILE* fptr;             
    size_t position;        
    size_t size;            
    size_t len;             
    Byte buf[CHUNK_SIZE]; 
} LazyBuffer;
 
/* ----- Functions ----- */

bool mkdir_p(SafeStr fpath, mode_t mode);

LazyBuffer open(Str fpath);

LazyBuffer next_chunk(LazyBuffer b);

Buffer Buffer_serialize(Buffer buf);

Buffer Buffer_deserialize(Buffer buf);

Buffer ListBuffer_serialize(ListBuffer list);

ListBuffer ListBuffer_deserialize(Buffer buf);

Buffer to_buffer(const void* thing, size_t nbytes);

Buffer uint8_t_serialize(uint8_t n);

uint8_t uint8_t_deserialize(Buffer buf);

Buffer uint16_t_serialize(uint16_t n);

uint16_t uint16_t_deserialize(Buffer buf);

Buffer uint32_t_serialize(uint32_t n);

uint32_t uint32_t_deserialize(Buffer buf);

Buffer atob(Str str);

Buffer validate_str(Buffer str, size_t max_len);

Buffer bufcpy(Buffer in);

size_t safe_strlen(Str str, size_t max_len);

void Buffer_deinit(Buffer kod);

void Buffer_write(Buffer buf, FILE* f);

Buffer Buffer_read(FILE* f);

Buffer SafeStr_serialize(SafeStr str);

SafeStr SafeStr_deserialize(Buffer buf);

Buffer size_t_serialize(size_t a);

size_t size_t_deserialize(Buffer buf);

Buffer concat(Buffer fst, Buffer snd);

bool Str_eq(Str lhs, Str rhs);

SafeStr atoss(Str str);

size_t min(size_t l, size_t r);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIB_H_