3rd-party/libfort
1
0
Fork 0
Code Releases Activity

[A] Appveyour integration

Browse Source 
- [A] Appveyour integration
- [D] Deleted cmocka
- [F] Fixed c++ warnings
This commit is contained in:
seleznevae
2018-03-17 21:53:38 +03:00
parent c84a6d55bc
commit 57673718cd
106 changed files with 222 additions and 13701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/cell.c
View File

@@ -7,6 +7,7 @@
* CELL
* ***************************************************************************/
struct fort_cell
{
string_buffer_t *str_buffer;
@@ -15,7 +16,7 @@ struct fort_cell
fort_cell_t * create_cell()
{
fort_cell_t *cell = F_CALLOC(sizeof(fort_cell_t), 1);
fort_cell_t *cell = (fort_cell_t *)F_CALLOC(sizeof(fort_cell_t), 1);
if (cell == NULL)
return NULL;
cell->str_buffer = create_string_buffer(DEFAULT_STR_BUF_SIZE, CharBuf);
@@ -49,7 +50,7 @@ int hint_width_cell(const fort_cell_t *cell, const context_t *context)
int cell_padding_left = get_cell_opt_value_hierarcial(context->table_options, context->row, context->column, FT_OPT_LEFT_PADDING);
int cell_padding_right = get_cell_opt_value_hierarcial(context->table_options, context->row, context->column, FT_OPT_RIGHT_PADDING);
int result = cell_padding_left + cell_padding_right;
if (cell->str_buffer && cell->str_buffer->data) {
if (cell->str_buffer && cell->str_buffer->str.data) {
result += buffer_text_width(cell->str_buffer);
}
result = MAX(result, get_cell_opt_value_hierarcial(context->table_options, context->row, context->column, FT_OPT_MIN_WIDTH));
@@ -64,7 +65,7 @@ int hint_height_cell(const fort_cell_t *cell, const context_t *context)
int cell_padding_bottom = get_cell_opt_value_hierarcial(context->table_options, context->row, context->column, FT_OPT_BOTTOM_PADDING);
int cell_empty_string_height = get_cell_opt_value_hierarcial(context->table_options, context->row, context->column, FT_OPT_EMPTY_STR_HEIGHT);
int result = cell_padding_top + cell_padding_bottom;
if (cell->str_buffer && cell->str_buffer->data) {
if (cell->str_buffer && cell->str_buffer->str.data) {
size_t text_height = buffer_text_height(cell->str_buffer);
result += text_height == 0 ? cell_empty_string_height : text_height;
}
@@ -185,3 +186,4 @@ string_buffer_t *cell_get_string_buffer(fort_cell_t *cell)
assert(cell->str_buffer);
return cell->str_buffer;
}

26
src/fort.c
View File

@@ -49,7 +49,7 @@ SOFTWARE.
FTABLE * ft_create_table(void)
{
FTABLE *result = F_CALLOC(1, sizeof(FTABLE));
FTABLE *result = (FTABLE *)F_CALLOC(1, sizeof(FTABLE));
if (result == NULL)
return NULL;
@@ -109,6 +109,7 @@ void ft_ln(FTABLE *FT_RESTRICT table)
static int ft_row_printf_impl(FTABLE *FT_RESTRICT table, size_t row, const char* FT_RESTRICT fmt, va_list *va)
{
size_t i = 0;
size_t new_cols = 0;
if (table == NULL)
return -1;
@@ -124,12 +125,12 @@ static int ft_row_printf_impl(FTABLE *FT_RESTRICT table, size_t row, const char*
if (row >= sz) {
size_t push_n = row - sz + 1;
for (i = 0; i < push_n; ++i) {
fort_row_t *new_row = create_row();
if (new_row == NULL)
fort_row_t *padding_row = create_row();
if (padding_row == NULL)
goto clear;
if (IS_ERROR(vector_push(table->rows, &new_row))) {
destroy_row(new_row);
if (IS_ERROR(vector_push(table->rows, &padding_row))) {
destroy_row(padding_row);
goto clear;
}
}
@@ -141,7 +142,7 @@ static int ft_row_printf_impl(FTABLE *FT_RESTRICT table, size_t row, const char*
destroy_row(*cur_row_p);
*cur_row_p = new_row;
size_t new_cols = columns_in_row(new_row);
new_cols = columns_in_row(new_row);
table->cur_col += new_cols;
return new_cols;
@@ -359,6 +360,7 @@ int ft_row_write_ln(FTABLE *FT_RESTRICT table, size_t cols, const char* FT_RESTR
#if !defined(__cplusplus) && !defined(FT_MICROSOFT_COMPILER)
int ft_s_table_write(FTABLE *FT_RESTRICT table, size_t rows, size_t cols, const char* FT_RESTRICT table_cells[rows][cols])
{
@@ -412,7 +414,7 @@ int ft_table_write_ln(FTABLE *FT_RESTRICT table, size_t rows, size_t cols, const
}
return status;
}
#endif
@@ -468,7 +470,7 @@ const char* ft_to_string(const FTABLE *FT_RESTRICT table)
return NULL;
}
}
char_type *buffer = buffer_get_data(table->conv_buffer);
char_type *buffer = (char_type *)buffer_get_data(table->conv_buffer);
size_t cols = 0;
@@ -562,7 +564,7 @@ const wchar_t* ft_to_wstring(const FTABLE *FT_RESTRICT table)
return NULL;
}
}
char_type *buffer = buffer_get_data(table->conv_buffer);
char_type *buffer = (char_type *)buffer_get_data(table->conv_buffer);
size_t cols = 0;
@@ -618,7 +620,11 @@ clear:
/*
* TMP
*/
static int dummy_function() __attribute__ ((unused));
static int dummy_function()
#if defined(FT_CLANG_COMPILER) || defined(FT_GCC_COMPILER)
__attribute__ ((unused))
#endif
;
static int dummy_function()
{

14
src/options.c
View File

@@ -64,7 +64,7 @@ fort_column_options_t g_column_options =
RightAligned, /* align */
};
fort_column_options_t create_column_options()
fort_column_options_t create_column_options(void)
{
fort_column_options_t result;
memset(&result, '\0', sizeof(result));
@@ -73,9 +73,9 @@ fort_column_options_t create_column_options()
}
#define DEFAULT_CELL_OPTION {FT_ROW_UNSPEC, FT_COLUMN_UNSPEC, 0, 0, 0}
//#define DEFAULT_CELL_OPTION {FT_ROW_UNSPEC, FT_COLUMN_UNSPEC, 0, 0, 0}
fort_cell_opt_container_t *create_cell_opt_container()
fort_cell_opt_container_t *create_cell_opt_container(void)
{
fort_cell_opt_container_t *ret = create_vector(sizeof(fort_cell_options_t), DEFAULT_VECTOR_CAPACITY);
return ret;
@@ -111,7 +111,7 @@ fort_cell_options_t* get_cell_opt_and_create_if_not_exists(fort_cell_opt_contain
if (opt->cell_row == row && opt->cell_col == col)
return opt;
}
fort_cell_options_t opt = DEFAULT_CELL_OPTION;
fort_cell_options_t opt = g_default_cell_option;// DEFAULT_CELL_OPTION;
opt.cell_row = row;
opt.cell_col = col;
if (IS_SUCCESS(vector_push(cont, &opt))) {
@@ -160,7 +160,7 @@ static fort_status_t set_cell_option_impl(fort_cell_options_t *opt, uint32_t opt
if (OPTION_IS_SET(option, FT_OPT_MIN_WIDTH)) {
opt->col_min_width = value;
} else if (OPTION_IS_SET(option, FT_OPT_TEXT_ALIGN)) {
opt->align = value;
opt->align = (enum TextAlignment)value;
} else if (OPTION_IS_SET(option, FT_OPT_TOP_PADDING)) {
opt->cell_padding_top = value;
} else if (OPTION_IS_SET(option, FT_OPT_BOTTOM_PADDING)) {
@@ -172,7 +172,7 @@ static fort_status_t set_cell_option_impl(fort_cell_options_t *opt, uint32_t opt
} else if (OPTION_IS_SET(option, FT_OPT_EMPTY_STR_HEIGHT)) {
opt->cell_empty_string_height = value;
} else if (OPTION_IS_SET(option, FT_OPT_ROW_TYPE)) {
opt->row_type = value;
opt->row_type = (enum RowType)value;
}
return F_SUCCESS;
@@ -330,7 +330,7 @@ fort_table_options_t g_table_options = {
fort_table_options_t* create_table_options()
{
fort_table_options_t* options = F_CALLOC(sizeof(fort_table_options_t), 1);
fort_table_options_t* options = (fort_table_options_t*)F_CALLOC(sizeof(fort_table_options_t), 1);
if (options == NULL) {
return NULL;
}

4
src/options.h
View File

@@ -27,7 +27,7 @@ struct fort_column_options
typedef struct fort_column_options fort_column_options_t;
extern fort_column_options_t g_column_options;
fort_column_options_t create_column_options();
fort_column_options_t create_column_options(void);
@@ -73,7 +73,7 @@ typedef struct fort_cell_options fort_cell_options_t;
typedef vector_t fort_cell_opt_container_t;
fort_cell_opt_container_t *create_cell_opt_container();
fort_cell_opt_container_t *create_cell_opt_container(void);
void destroy_cell_opt_container(fort_cell_opt_container_t *cont);
const fort_cell_options_t* cget_cell_opt(const fort_cell_opt_container_t *cont, unsigned row, unsigned col);
fort_cell_options_t* get_cell_opt_and_create_if_not_exists(fort_cell_opt_container_t *cont, unsigned row, unsigned col);

31
src/row.c
View File

@@ -15,7 +15,7 @@ struct fort_row
fort_row_t * create_row()
{
fort_row_t * row = F_CALLOC(sizeof(fort_row_t), 1);
fort_row_t * row = (fort_row_t *)F_CALLOC(sizeof(fort_row_t), 1);
if (row == NULL)
return NULL;
row->cells = create_vector(sizeof(fort_cell_t*), DEFAULT_VECTOR_CAPACITY);
@@ -137,11 +137,11 @@ int print_row_separator(char *buffer, size_t buffer_sz,
enum RowType lower_row_type = Common;
if (lower_row != NULL) {
lower_row_type = get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
lower_row_type = (enum RowType)get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
}
enum RowType upper_row_type = Common;
if (upper_row != NULL) {
upper_row_type = get_cell_opt_value_hierarcial(context->table_options, context->row-1, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
upper_row_type = (enum RowType)get_cell_opt_value_hierarcial(context->table_options, context->row-1, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
}
@@ -244,11 +244,11 @@ int wprint_row_separator(wchar_t *buffer, size_t buffer_sz,
enum RowType lower_row_type = Common;
if (lower_row != NULL) {
lower_row_type = get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
lower_row_type = (enum RowType)get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
}
enum RowType upper_row_type = Common;
if (upper_row != NULL) {
upper_row_type = get_cell_opt_value_hierarcial(context->table_options, context->row-1, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
upper_row_type = (enum RowType)get_cell_opt_value_hierarcial(context->table_options, context->row-1, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
}
/* Row separator anatomy
@@ -327,6 +327,10 @@ clear:
fort_row_t* create_row_from_string(const char *str)
{
char *pos = NULL;
char *base_pos = NULL;
int number_of_separators = 0;
fort_row_t * row = create_row();
if (row == NULL)
return NULL;
@@ -338,9 +342,9 @@ fort_row_t* create_row_from_string(const char *str)
if (str_copy == NULL)
goto clear;
char *pos = str_copy;
char *base_pos = str_copy;
int number_of_separators = 0;
pos = str_copy;
base_pos = str_copy;
number_of_separators = 0;
while (*pos) {
pos = strchr(pos, FORT_COL_SEPARATOR);
if (pos != NULL) {
@@ -410,11 +414,12 @@ fort_row_t* create_row_from_fmt_string(const char* FT_RESTRICT fmt, va_list *va_
return NULL;
int cols_origin = number_of_columns_in_format_string(fmt);
int cols = 0;
while (1) {
va_list va;
va_copy(va, *va_args);
int virtual_sz = vsnprintf(buffer->cstr, string_buffer_capacity(buffer)/*buffer->str_sz*/, fmt, va);
int virtual_sz = vsnprintf(buffer->str.cstr, string_buffer_capacity(buffer)/*buffer->str_sz*/, fmt, va);
va_end(va);
/* If error encountered */
if (virtual_sz == -1)
@@ -429,10 +434,10 @@ fort_row_t* create_row_from_fmt_string(const char* FT_RESTRICT fmt, va_list *va_
goto clear;
}
int cols = number_of_columns_in_format_string(buffer->cstr);
cols = number_of_columns_in_format_string(buffer->str.cstr);
if (cols == cols_origin) {
fort_row_t *row = create_row_from_string(buffer->cstr);
fort_row_t *row = create_row_from_string(buffer->str.cstr);
if (row == NULL) {
goto clear;
}
@@ -473,7 +478,7 @@ int snprintf_row(const fort_row_t *row, char *buffer, size_t buf_sz, size_t *col
*/
typedef const char (*border_chars_point_t)[BorderItemPosSize];
enum RowType row_type = get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
enum RowType row_type = (enum RowType)get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
const char (*bord_chars)[BorderItemPosSize] = (row_type == Header)
? (border_chars_point_t) (&context->table_options->border_style.header_border_chars)
: (border_chars_point_t) (&context->table_options->border_style.border_chars);
@@ -532,7 +537,7 @@ int wsnprintf_row(const fort_row_t *row, wchar_t *buffer, size_t buf_sz, size_t
*/
typedef const char (*border_chars_point_t)[BorderItemPosSize];
enum RowType row_type = get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
enum RowType row_type = (enum RowType)get_cell_opt_value_hierarcial(context->table_options, context->row, FT_ANY_COLUMN, FT_OPT_ROW_TYPE);
const char (*bord_chars)[BorderItemPosSize] = (row_type)
? (border_chars_point_t) (&context->table_options->border_style.header_border_chars)
: (border_chars_point_t) (&context->table_options->border_style.border_chars);

46
src/string_buffer.c
View File

@@ -11,9 +11,9 @@ static size_t buf_str_len(const string_buffer_t*buf)
{
assert(buf);
if (buf->type == CharBuf) {
return strlen(buf->cstr);
return strlen(buf->str.cstr);
} else {
return wcslen(buf->wstr);
return wcslen(buf->str.wstr);
}
}
@@ -132,8 +132,8 @@ string_buffer_t* create_string_buffer(size_t number_of_chars, enum str_buf_type
string_buffer_t *result = (string_buffer_t *)F_MALLOC(sizeof(string_buffer_t));
if (result == NULL)
return NULL;
result->data = F_MALLOC(sz);
if (result->data == NULL) {
result->str.data = F_MALLOC(sz);
if (result->str.data == NULL) {
F_FREE(result);
return NULL;
}
@@ -147,8 +147,8 @@ void destroy_string_buffer(string_buffer_t *buffer)
{
if (buffer == NULL)
return;
F_FREE(buffer->data);
buffer->data = NULL;
F_FREE(buffer->str.data);
buffer->str.data = NULL;
F_FREE(buffer);
}
@@ -159,8 +159,8 @@ fort_status_t realloc_string_buffer_without_copy(string_buffer_t *buffer)
if (new_str == NULL) {
return F_MEMORY_ERROR;
}
F_FREE(buffer->data);
buffer->data = new_str;
F_FREE(buffer->str.data);
buffer->str.data = new_str;
buffer->data_sz *= 2;
return F_SUCCESS;
}
@@ -181,8 +181,8 @@ fort_status_t fill_buffer_from_string(string_buffer_t *buffer, const char *str)
return status;
}
}
F_FREE(buffer->data);
buffer->cstr = copy;
F_FREE(buffer->str.data);
buffer->str.cstr = copy;
buffer->type = CharBuf;
return F_SUCCESS;
@@ -204,8 +204,8 @@ fort_status_t fill_buffer_from_wstring(string_buffer_t *buffer, const wchar_t *s
return status;
}
}
F_FREE(buffer->data);
buffer->wstr = copy;
F_FREE(buffer->str.data);
buffer->str.wstr = copy;
buffer->type = WCharBuf;
return F_SUCCESS;
@@ -215,13 +215,13 @@ fort_status_t fill_buffer_from_wstring(string_buffer_t *buffer, const wchar_t *s
size_t buffer_text_height(string_buffer_t *buffer)
{
if (buffer == NULL || buffer->data == NULL || buf_str_len(buffer) == 0) {
if (buffer == NULL || buffer->str.data == NULL || buf_str_len(buffer) == 0) {
return 0;
}
if (buffer->type == CharBuf)
return 1 + strchr_count(buffer->cstr, '\n');
return 1 + strchr_count(buffer->str.cstr, '\n');
else
return 1 + wstrchr_count(buffer->wstr, L'\n');
return 1 + wstrchr_count(buffer->str.wstr, L'\n');
}
size_t buffer_text_width(string_buffer_t *buffer)
@@ -232,18 +232,18 @@ size_t buffer_text_width(string_buffer_t *buffer)
while (1) {
const char *beg = NULL;
const char *end = NULL;
str_n_substring(buffer->cstr, '\n', n, &beg, &end);
str_n_substring(buffer->str.cstr, '\n', n, &beg, &end);
if (beg == NULL || end == NULL)
return max_length;
max_length = MAX(max_length, (end - beg));
max_length = MAX(max_length, (size_t)(end - beg));
++n;
}
} else {
while (1) {
const wchar_t *beg = NULL;
const wchar_t *end = NULL;
wstr_n_substring(buffer->wstr, L'\n', n, &beg, &end);
wstr_n_substring(buffer->str.wstr, L'\n', n, &beg, &end);
if (beg == NULL || end == NULL)
return max_length;
@@ -263,11 +263,11 @@ int buffer_printf(string_buffer_t *buffer, size_t buffer_row, size_t table_colum
#define SPACE_CHAR ' '
#define SNPRINTF_FMT_STR "%*s"
#define SNPRINTF snprintf
#define BUFFER_STR cstr
#define BUFFER_STR str.cstr
#define SNPRINT_N_CHARS snprint_n_chars
#define STR_N_SUBSTRING str_n_substring
if (buffer == NULL || buffer->data == NULL
if (buffer == NULL || buffer->str.data == NULL
|| buffer_row >= buffer_text_height(buffer) || buf_len == 0) {
return -1;
}
@@ -345,11 +345,11 @@ int buffer_wprintf(string_buffer_t *buffer, size_t buffer_row, size_t table_colu
#define SPACE_CHAR L' '
#define SNPRINTF_FMT_STR L"%*ls"
#define SNPRINTF swprintf
#define BUFFER_STR wstr
#define BUFFER_STR str.wstr
#define SNPRINT_N_CHARS wsnprint_n_chars
#define STR_N_SUBSTRING wstr_n_substring
if (buffer == NULL || buffer->data == NULL
if (buffer == NULL || buffer->str.data == NULL
|| buffer_row >= buffer_text_height(buffer) || buf_len == 0) {
return -1;
}
@@ -430,5 +430,5 @@ size_t string_buffer_capacity(const string_buffer_t *buffer)
void *buffer_get_data(string_buffer_t *buffer)
{
assert(buffer);
return buffer->data;
return buffer->str.data;
}

2
src/string_buffer.h
View File

@@ -21,7 +21,7 @@ struct string_buffer
char *cstr;
wchar_t *wstr;
void *data;
};
}str;
size_t data_sz;
enum str_buf_type type;
};

4
src/table.c
View File

@@ -104,8 +104,8 @@ fort_status_t table_rows_and_cols_geometry(const FTABLE *table,
if (IS_ERROR(status))
return status;
size_t *col_width_arr = F_CALLOC(sizeof(size_t), cols);
size_t *row_height_arr = F_CALLOC(sizeof(size_t), rows);
size_t *col_width_arr = (size_t *)F_CALLOC(sizeof(size_t), cols);
size_t *row_height_arr = (size_t *)F_CALLOC(sizeof(size_t), rows);
if (col_width_arr == NULL || row_height_arr == NULL) {
F_FREE(col_width_arr);
F_FREE(row_height_arr);

2
src/table.h
View File

@@ -19,7 +19,7 @@ struct fort_table
static FT_INLINE
separator_t *create_separator(int enabled)
{
separator_t *res = F_CALLOC(1, sizeof(separator_t));
separator_t *res = (separator_t *)F_CALLOC(1, sizeof(separator_t));
if (res == NULL)
return NULL;
res->enabled = enabled;

15
src/vector.c
View File

@@ -1,5 +1,6 @@
#include "vector.h"
#include <assert.h>
#include <string.h>
/*****************************************************************************
* VECTOR IMPLEMENTATIONS
@@ -29,7 +30,7 @@ static int vector_reallocate_(vector_t *vector, size_t new_capacity)
vector_t* create_vector(size_t item_size, size_t capacity)
{
vector_t *vector = malloc(sizeof(vector_t));
vector_t *vector = (vector_t *)malloc(sizeof(vector_t));
if (vector == NULL) {
SYS_LOG_ERROR("Failed to allocate memory for asock vector");
return NULL;
@@ -97,7 +98,7 @@ size_t vector_index_of(const vector_t* vector, const void *item)
size_t i = 0;
for (i = 0; i < vector->m_size; ++i) {
void *data_pos = vector->m_data + i * vector->m_item_size;
void *data_pos = (char*)vector->m_data + i * vector->m_item_size;
if (memcmp(data_pos, item, vector->m_item_size) == 0) {
return i;
}
@@ -120,7 +121,7 @@ int vector_push (vector_t* vector, const void* item)
}
ptrdiff_t deviation = vector->m_size * vector->m_item_size;
memcpy(vector->m_data + deviation, item, vector->m_item_size);
memcpy((char*)vector->m_data + deviation, item, vector->m_item_size);
++(vector->m_size);
@@ -135,8 +136,8 @@ int vector_erase(vector_t *vector, size_t index)
if (vector->m_size == 0 || index >= vector->m_size)
return F_ERROR;
memmove(vector->m_data + vector->m_item_size * index,
vector->m_data + vector->m_item_size * (index + 1),
memmove((char*)vector->m_data + vector->m_item_size * index,
(char*)vector->m_data + vector->m_item_size * (index + 1),
(vector->m_size - 1 - index) * vector->m_item_size);
vector->m_size--;
return F_SUCCESS;
@@ -153,7 +154,7 @@ const void *vector_at_c(const vector_t *vector, size_t index)
if (index >= vector->m_size)
return NULL;
return vector->m_data + index * vector->m_item_size;
return (char*)vector->m_data + index * vector->m_item_size;
}
@@ -162,7 +163,7 @@ void *vector_at(vector_t *vector, size_t index)
if (index >= vector->m_size)
return NULL;
return vector->m_data + index * vector->m_item_size;
return (char*)vector->m_data + index * vector->m_item_size;
}