fort.h

Go to the documentation of this file.

/*
libfort

MIT License

Copyright (c) 2017 - 2020 Seleznev Anton

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

#ifndef LIBFORT_H
#define LIBFORT_H

#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>

/*****************************************************************************
 *               VERSION
 *****************************************************************************/

#define LIBFORT_MAJOR_VERSION 0
#define LIBFORT_MINOR_VERSION 4
#define LIBFORT_REVISION 2
#define LIBFORT_VERSION_STR "0.4.2"


/*****************************************************************************
 *               Configuration
 *****************************************************************************/

#if !defined(FT_CONGIG_DISABLE_WCHAR)
#define FT_HAVE_WCHAR
#endif

#if !defined(FT_CONGIG_DISABLE_UTF8)
#define FT_HAVE_UTF8
#endif


/*****************************************************************************
 *               RETURN CODES
 *****************************************************************************/

#define FT_SUCCESS        0

#define FT_MEMORY_ERROR  -1

#define FT_EINVAL        -2

#define FT_INTERN_ERROR  -3

#define FT_GEN_ERROR     -4


#define FT_IS_SUCCESS(arg) ((arg) >= 0)
#define FT_IS_ERROR(arg) ((arg) < 0)




/*****************************************************************************
 *               Determine compiler
 *****************************************************************************/

#if defined(__clang__)
#define FT_CLANG_COMPILER
#elif defined(__GNUC__)
#define FT_GCC_COMPILER
#elif defined(_MSC_VER)
#define FT_MICROSOFT_COMPILER
#else
#define FT_UNDEFINED_COMPILER
#endif


/*****************************************************************************
 *               Declare inline
 *****************************************************************************/

#if defined(__cplusplus)
#define FT_INLINE inline
#else
#define FT_INLINE __inline
#endif /* if defined(__cplusplus) */


/*****************************************************************************
 *    C++ needs to know that types and declarations are C, not C++.
 *****************************************************************************/

#ifdef __cplusplus
# define FT_BEGIN_DECLS extern "C" {
# define FT_END_DECLS }
#else
# define FT_BEGIN_DECLS
# define FT_END_DECLS
#endif


/*****************************************************************************
 *               Helper macros
 *****************************************************************************/

#define FT_STR_2_CAT_(arg1, arg2) \
    arg1##arg2
#define FT_STR_2_CAT(arg1, arg2) \
    FT_STR_2_CAT_(arg1, arg2)

static FT_INLINE int ft_check_if_string_helper(const char *str)
{
    (void)str;
    return 0;
}

static FT_INLINE int ft_check_if_wstring_helper(const wchar_t *str)
{
    (void)str;
    return 0;
}

#define FT_NARGS_IMPL_(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,N,...) N
#define FT_EXPAND_(x) x
#define FT_PP_NARG_(...) \
    FT_EXPAND_(FT_NARGS_IMPL_(__VA_ARGS__,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))

#define FT_CHECK_IF_STR_32(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_31(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_31(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_30(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_30(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_29(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_29(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_28(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_28(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_27(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_27(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_26(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_26(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_25(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_25(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_24(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_24(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_23(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_23(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_22(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_22(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_21(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_21(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_20(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_20(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_19(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_19(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_18(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_18(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_17(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_17(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_16(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_16(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_15(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_15(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_14(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_14(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_13(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_13(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_12(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_12(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_11(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_11(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_10(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_10(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_9(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_9(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_8(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_8(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_7(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_7(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_6(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_6(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_5(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_5(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_4(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_4(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_3(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_3(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_2(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_2(checker,arg,...) (checker(arg),FT_EXPAND_(FT_CHECK_IF_STR_1(checker,__VA_ARGS__)))
#define FT_CHECK_IF_STR_1(checker,arg) (checker(arg))

#define FT_CHECK_IF_ARGS_ARE_STRINGS__(checker,func, ...) \
    FT_EXPAND_(func(checker,__VA_ARGS__))
#define FT_CHECK_IF_ARGS_ARE_STRINGS_(checker,basis, n, ...) \
    FT_CHECK_IF_ARGS_ARE_STRINGS__(checker,FT_STR_2_CAT_(basis, n), __VA_ARGS__)
#define FT_CHECK_IF_ARGS_ARE_STRINGS(...) \
    FT_CHECK_IF_ARGS_ARE_STRINGS_(ft_check_if_string_helper,FT_CHECK_IF_STR_,FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__)

#ifdef FT_HAVE_WCHAR
#define CHECK_IF_ARGS_ARE_WSTRINGS(...) \
    FT_CHECK_IF_ARGS_ARE_STRINGS_(ft_check_if_wstring_helper,FT_CHECK_IF_STR_,FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__)
#endif

/*****************************************************************************
 *               Attribute format for argument checking
 *****************************************************************************/

#if defined(FT_CLANG_COMPILER) || defined(FT_GCC_COMPILER)
#define FT_PRINTF_ATTRIBUTE_FORMAT(string_index, first_to_check) \
    __attribute__ ((format (printf, string_index, first_to_check)))
#else
#define FT_PRINTF_ATTRIBUTE_FORMAT(string_index, first_to_check)
#endif /* defined(FT_CLANG_COMPILER) || defined(FT_GCC_COMPILER) */


/*****************************************************************************
 *                   libfort API
 *****************************************************************************/

FT_BEGIN_DECLS

struct ft_table;

typedef struct ft_table ft_table_t;

ft_table_t *ft_create_table(void);

void ft_destroy_table(ft_table_t *table);

ft_table_t *ft_copy_table(ft_table_t *table);

int ft_ln(ft_table_t *table);

size_t ft_cur_row(const ft_table_t *table);

size_t ft_cur_col(const ft_table_t *table);

void ft_set_cur_cell(ft_table_t *table, size_t row, size_t col);

int ft_is_empty(const ft_table_t *table);

size_t ft_row_count(const ft_table_t *table);

int ft_erase_range(ft_table_t *table,
                   size_t top_left_row, size_t top_left_col,
                   size_t bottom_right_row, size_t bottom_right_col);

#if defined(FT_CLANG_COMPILER) || defined(FT_GCC_COMPILER)

int ft_printf(ft_table_t *table, const char *fmt, ...) FT_PRINTF_ATTRIBUTE_FORMAT(2, 3);

int ft_printf_ln(ft_table_t *table, const char *fmt, ...) FT_PRINTF_ATTRIBUTE_FORMAT(2, 3);

#else

int ft_printf_impl(ft_table_t *table, const char *fmt, ...) FT_PRINTF_ATTRIBUTE_FORMAT(2, 3);
int ft_printf_ln_impl(ft_table_t *table, const char *fmt, ...) FT_PRINTF_ATTRIBUTE_FORMAT(2, 3);

#define ft_printf(table, ...) \
    (( 0 ? fprintf(stderr, __VA_ARGS__) : 1), ft_printf_impl(table, __VA_ARGS__))
#define ft_printf_ln(table, ...) \
    (( 0 ? fprintf(stderr, __VA_ARGS__) : 1), ft_printf_ln_impl(table, __VA_ARGS__))

#endif

void ft_set_default_printf_field_separator(char separator);


#define ft_write(table, ...)\
    (0 ? FT_CHECK_IF_ARGS_ARE_STRINGS(__VA_ARGS__) : ft_nwrite(table, FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__))

#define ft_write_ln(table, ...)\
    (0 ? FT_CHECK_IF_ARGS_ARE_STRINGS(__VA_ARGS__) : ft_nwrite_ln(table, FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__))

int ft_nwrite(ft_table_t *table, size_t count, const char *cell_content, ...);

int ft_nwrite_ln(ft_table_t *table, size_t count, const char *cell_content, ...);



int ft_row_write(ft_table_t *table, size_t cols, const char *row_cells[]);

int ft_row_write_ln(ft_table_t *table, size_t cols, const char *row_cells[]);


int ft_table_write(ft_table_t *table, size_t rows, size_t cols, const char *table_cells[]);

int ft_table_write_ln(ft_table_t *table, size_t rows, size_t cols, const char *table_cells[]);


int ft_add_separator(ft_table_t *table);


const char *ft_to_string(const ft_table_t *table);







struct ft_border_chars {
    const char *top_border_ch;
    const char *separator_ch;
    const char *bottom_border_ch;
    const char *side_border_ch;
    const char *out_intersect_ch;
    const char *in_intersect_ch;
};

struct ft_border_style {
    struct ft_border_chars border_chs;
    struct ft_border_chars header_border_chs;
    const char *hor_separator_char;
};

extern const struct ft_border_style *const FT_BASIC_STYLE;
extern const struct ft_border_style *const FT_BASIC2_STYLE;
extern const struct ft_border_style *const FT_SIMPLE_STYLE;
extern const struct ft_border_style *const FT_PLAIN_STYLE;
extern const struct ft_border_style *const FT_DOT_STYLE;
extern const struct ft_border_style *const FT_EMPTY_STYLE;
extern const struct ft_border_style *const FT_EMPTY2_STYLE;
extern const struct ft_border_style *const FT_SOLID_STYLE;
extern const struct ft_border_style *const FT_SOLID_ROUND_STYLE;
extern const struct ft_border_style *const FT_NICE_STYLE;
extern const struct ft_border_style *const FT_DOUBLE_STYLE;
extern const struct ft_border_style *const FT_DOUBLE2_STYLE;
extern const struct ft_border_style *const FT_BOLD_STYLE;
extern const struct ft_border_style *const FT_BOLD2_STYLE;
extern const struct ft_border_style *const FT_FRAME_STYLE;
int ft_set_default_border_style(const struct ft_border_style *style);

int ft_set_border_style(ft_table_t *table, const struct ft_border_style *style);



#define FT_ANY_COLUMN (UINT_MAX)     
#define FT_CUR_COLUMN (UINT_MAX - 1) 
#define FT_ANY_ROW    (UINT_MAX)     
#define FT_CUR_ROW    (UINT_MAX - 1) 
#define FT_MAX_ROW_INDEX (UINT_MAX - 2)
#define FT_MAX_COL_INDEX (UINT_MAX - 2)


#define FT_CPROP_MIN_WIDTH        (0x01U << 0) 
#define FT_CPROP_TEXT_ALIGN       (0x01U << 1) 
#define FT_CPROP_TOP_PADDING      (0x01U << 2) 
#define FT_CPROP_BOTTOM_PADDING   (0x01U << 3) 
#define FT_CPROP_LEFT_PADDING     (0x01U << 4) 
#define FT_CPROP_RIGHT_PADDING    (0x01U << 5) 
#define FT_CPROP_EMPTY_STR_HEIGHT (0x01U << 6) 
#define FT_CPROP_ROW_TYPE         (0x01U << 7) 
#define FT_CPROP_CONT_FG_COLOR    (0x01U << 8) 
#define FT_CPROP_CELL_BG_COLOR    (0x01U << 9) 
#define FT_CPROP_CONT_BG_COLOR    (0x01U << 10) 
#define FT_CPROP_CELL_TEXT_STYLE  (0x01U << 11) 
#define FT_CPROP_CONT_TEXT_STYLE  (0x01U << 12) 
enum ft_color {
    FT_COLOR_DEFAULT        = 0,  
    FT_COLOR_BLACK          = 1,  
    FT_COLOR_RED            = 2,  
    FT_COLOR_GREEN          = 3,  
    FT_COLOR_YELLOW         = 4,  
    FT_COLOR_BLUE           = 5,  
    FT_COLOR_MAGENTA        = 6,  
    FT_COLOR_CYAN           = 7,  
    FT_COLOR_LIGHT_GRAY     = 8,  
    FT_COLOR_DARK_GRAY      = 9,  
    FT_COLOR_LIGHT_RED      = 10, 
    FT_COLOR_LIGHT_GREEN    = 11, 
    FT_COLOR_LIGHT_YELLOW   = 12, 
    FT_COLOR_LIGHT_BLUE     = 13, 
    FT_COLOR_LIGHT_MAGENTA  = 15, 
    FT_COLOR_LIGHT_CYAN     = 16, 
    FT_COLOR_LIGHT_WHYTE    = 17  
};

enum ft_text_style {
    FT_TSTYLE_DEFAULT    = (1U << 0), 
    FT_TSTYLE_BOLD       = (1U << 1), 
    FT_TSTYLE_DIM        = (1U << 2), 
    FT_TSTYLE_ITALIC     = (1U << 3), 
    FT_TSTYLE_UNDERLINED = (1U << 4), 
    FT_TSTYLE_BLINK      = (1U << 5), 
    FT_TSTYLE_INVERTED   = (1U << 6), 
    FT_TSTYLE_HIDDEN     = (1U << 7)  
};


enum ft_text_alignment {
    FT_ALIGNED_LEFT = 0,     
    FT_ALIGNED_CENTER,       
    FT_ALIGNED_RIGHT         
};

enum ft_row_type {
    FT_ROW_COMMON = 0,      
    FT_ROW_HEADER           
};

int ft_set_default_cell_prop(uint32_t property, int value);

int ft_set_cell_prop(ft_table_t *table, size_t row, size_t col, uint32_t property, int value);


#define FT_TPROP_LEFT_MARGIN     (0x01U << 0)
#define FT_TPROP_TOP_MARGIN      (0x01U << 1)
#define FT_TPROP_RIGHT_MARGIN    (0x01U << 2)
#define FT_TPROP_BOTTOM_MARGIN   (0x01U << 3)
#define FT_TPROP_ADDING_STRATEGY (0x01U << 4)

enum ft_adding_strategy {
    FT_STRATEGY_REPLACE = 0,  
    FT_STRATEGY_INSERT        
};


int ft_set_default_tbl_prop(uint32_t property, int value);

int ft_set_tbl_prop(ft_table_t *table, uint32_t property, int value);


int ft_set_cell_span(ft_table_t *table, size_t row, size_t col, size_t hor_span);


void ft_set_memory_funcs(void *(*f_malloc)(size_t size), void (*f_free)(void *ptr));


const char *ft_strerror(int error_code);



#ifdef FT_HAVE_WCHAR


int ft_wprintf(ft_table_t *table, const wchar_t *fmt, ...);
int ft_wprintf_ln(ft_table_t *table, const wchar_t *fmt, ...);


#define ft_wwrite(table, ...)\
    (0 ? CHECK_IF_ARGS_ARE_WSTRINGS(__VA_ARGS__) : ft_nwwrite(table, FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__))
#define ft_wwrite_ln(table, ...)\
    (0 ? CHECK_IF_ARGS_ARE_WSTRINGS(__VA_ARGS__) : ft_nwwrite_ln(table, FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__))
int ft_nwwrite(ft_table_t *table, size_t n, const wchar_t *cell_content, ...);
int ft_nwwrite_ln(ft_table_t *table, size_t n, const wchar_t *cell_content, ...);

int ft_row_wwrite(ft_table_t *table, size_t cols, const wchar_t *row_cells[]);
int ft_row_wwrite_ln(ft_table_t *table, size_t cols, const wchar_t *row_cells[]);

int ft_table_wwrite(ft_table_t *table, size_t rows, size_t cols, const wchar_t *table_cells[]);
int ft_table_wwrite_ln(ft_table_t *table, size_t rows, size_t cols, const wchar_t *table_cells[]);

const wchar_t *ft_to_wstring(const ft_table_t *table);
#endif



#ifdef FT_HAVE_UTF8
#define ft_u8write(table, ...)\
    (ft_u8nwrite(table, FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__))
#define ft_u8write_ln(table, ...)\
    (ft_u8nwrite_ln(table, FT_PP_NARG_(__VA_ARGS__), __VA_ARGS__))
int ft_u8nwrite(ft_table_t *table, size_t n, const void *cell_content, ...);
int ft_u8nwrite_ln(ft_table_t *table, size_t n, const void *cell_content, ...);

int ft_u8printf(ft_table_t *table, const char *fmt, ...) FT_PRINTF_ATTRIBUTE_FORMAT(2, 3);
int ft_u8printf_ln(ft_table_t *table, const char *fmt, ...) FT_PRINTF_ATTRIBUTE_FORMAT(2, 3);

const void *ft_to_u8string(const ft_table_t *table);

void ft_set_u8strwid_func(int (*u8strwid)(const void *beg, const void *end, size_t *width));

#endif /* FT_HAVE_UTF8 */


FT_END_DECLS

#endif /* LIBFORT_H */