common.h

/* ----------------------------------------------------------------------------
  Copyright (c) 2021, Daan Leijen
  This is free software; you can redistribute it and/or modify it
  under the terms of the MIT License. A copy of the license can be
  found in the "LICENSE" file at the root of this distribution.
-----------------------------------------------------------------------------*/

#pragma once
#ifndef IC_COMMON_H
#define IC_COMMON_H

//-------------------------------------------------------------
// Headers and defines
//-------------------------------------------------------------

#include <sys/types.h>  // ssize_t
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
#include "../include/isocline.h"  // ic_malloc_fun_t, ic_color_t etc.

# ifdef __cplusplus
#  define ic_extern_c   extern "C"
# else
#  define ic_extern_c
# endif

#if defined(IC_SEPARATE_OBJS)
#  define ic_public     ic_extern_c 
# if defined(__GNUC__) // includes clang and icc      
#  define ic_private    __attribute__((visibility("hidden")))
# else
#  define ic_private  
# endif
#else
# define ic_private     static
# define ic_public      ic_extern_c
#endif

#define ic_unused(x)    (void)(x)


//-------------------------------------------------------------
// ssize_t
//-------------------------------------------------------------

#if defined(_MSC_VER)
typedef intptr_t ssize_t;
#endif

#define ssizeof(tp)   (ssize_t)(sizeof(tp))
static inline size_t  to_size_t(ssize_t sz) { return (sz >= 0 ? (size_t)sz : 0); }
static inline ssize_t to_ssize_t(size_t sz) { return (sz <= SIZE_MAX/2 ? (ssize_t)sz : 0); }

ic_private void    ic_memmove(void* dest, const void* src, ssize_t n);
ic_private void    ic_memcpy(void* dest, const void* src, ssize_t n);
ic_private void    ic_memset(void* dest, uint8_t value, ssize_t n);
ic_private bool    ic_memnmove(void* dest, ssize_t dest_size, const void* src, ssize_t n);

ic_private ssize_t ic_strlen(const char* s);
ic_private bool    ic_strcpy(char* dest, ssize_t dest_size /* including 0 */, const char* src);
ic_private bool    ic_strncpy(char* dest, ssize_t dest_size /* including 0 */, const char* src, ssize_t n);

ic_private bool    ic_contains(const char* big, const char* s);
ic_private bool    ic_icontains(const char* big, const char* s);
ic_private char    ic_tolower(char c);
ic_private void    ic_str_tolower(char* s);
ic_private int     ic_stricmp(const char* s1, const char* s2);
ic_private int     ic_strnicmp(const char* s1, const char* s2, ssize_t n);



//---------------------------------------------------------------------
// Unicode
//
// We use "qutf-8" (quite like utf-8) encoding and decoding. 
// Internally we always use valid utf-8. If we encounter invalid
// utf-8 bytes (or bytes >= 0x80 from any other encoding) we encode
// these as special code points in the "raw plane" (0xEE000 - 0xEE0FF).
// When decoding we are then able to restore such raw bytes as-is.
// See <https://github.com/koka-lang/koka/blob/master/kklib/include/kklib/string.h>
//---------------------------------------------------------------------

typedef uint32_t  unicode_t;

ic_private void      unicode_to_qutf8(unicode_t u, uint8_t buf[5]);
ic_private unicode_t unicode_from_qutf8(const uint8_t* s, ssize_t len, ssize_t* nread); // validating

ic_private unicode_t unicode_from_raw(uint8_t c);
ic_private bool      unicode_is_raw(unicode_t u, uint8_t* c);

ic_private bool      utf8_is_cont(uint8_t c);


//-------------------------------------------------------------
// Colors
//-------------------------------------------------------------

// A color is either RGB or an ANSI code.
// (RGB colors have bit 24 set to distinguish them from the ANSI color palette colors.)
// (Isocline will automatically convert from RGB on terminals that do not support full colors)
typedef uint32_t ic_color_t;

// Create a color from a 24-bit color value.
ic_private ic_color_t ic_rgb(uint32_t hex);

// Create a color from a 8-bit red/green/blue components.
// The value of each component is capped between 0 and 255.
ic_private ic_color_t ic_rgbx(ssize_t r, ssize_t g, ssize_t b);

#define IC_COLOR_NONE     (0)
#define IC_RGB(rgb)       (0x1000000 | (uint32_t)(rgb)) // ic_rgb(rgb)  // define to it can be used as a constant

// ANSI colors.
// The actual colors used is usually determined by the terminal theme
// See <https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit>
#define IC_ANSI_BLACK     (30)
#define IC_ANSI_MAROON    (31)
#define IC_ANSI_GREEN     (32)
#define IC_ANSI_OLIVE     (33)
#define IC_ANSI_NAVY      (34)
#define IC_ANSI_PURPLE    (35)
#define IC_ANSI_TEAL      (36)
#define IC_ANSI_SILVER    (37)
#define IC_ANSI_DEFAULT   (39)

#define IC_ANSI_GRAY      (90)
#define IC_ANSI_RED       (91)
#define IC_ANSI_LIME      (92)
#define IC_ANSI_YELLOW    (93)
#define IC_ANSI_BLUE      (94)
#define IC_ANSI_FUCHSIA   (95)
#define IC_ANSI_AQUA      (96)
#define IC_ANSI_WHITE     (97)

#define IC_ANSI_DARKGRAY  IC_ANSI_GRAY
#define IC_ANSI_LIGHTGRAY IC_ANSI_SILVER
#define IC_ANSI_MAGENTA   IC_ANSI_FUCHSIA
#define IC_ANSI_CYAN      IC_ANSI_AQUA



//-------------------------------------------------------------
// Debug
//-------------------------------------------------------------

#if defined(IC_NO_DEBUG_MSG) 
#define debug_msg(fmt,...)   (void)(0)
#else
ic_private void debug_msg( const char* fmt, ... );
#endif


//-------------------------------------------------------------
// Abstract environment
//-------------------------------------------------------------
struct ic_env_s;
typedef struct ic_env_s ic_env_t;


//-------------------------------------------------------------
// Allocation
//-------------------------------------------------------------

typedef struct alloc_s {
  ic_malloc_fun_t*  malloc;
  ic_realloc_fun_t* realloc;
  ic_free_fun_t*    free;
} alloc_t;


ic_private void* mem_malloc( alloc_t* mem, ssize_t sz );
ic_private void* mem_zalloc( alloc_t* mem, ssize_t sz );
ic_private void* mem_realloc( alloc_t* mem, void* p, ssize_t newsz );
ic_private void  mem_free( alloc_t* mem, const void* p );
ic_private char* mem_strdup( alloc_t* mem, const char* s);
ic_private char* mem_strndup( alloc_t* mem, const char* s, ssize_t n);

#define mem_zalloc_tp(mem,tp)        (tp*)mem_zalloc(mem,ssizeof(tp))
#define mem_malloc_tp_n(mem,tp,n)    (tp*)mem_malloc(mem,(n)*ssizeof(tp))
#define mem_zalloc_tp_n(mem,tp,n)    (tp*)mem_zalloc(mem,(n)*ssizeof(tp))
#define mem_realloc_tp(mem,tp,p,n)   (tp*)mem_realloc(mem,p,(n)*ssizeof(tp))


#endif // IC_COMMON_H