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

[C] Refactoring

Browse Source
This commit is contained in:
seleznevae 2019-08-27 15:04:54 +03:00
parent e6710b9410
commit 5bfabee696
20 changed files with 1006 additions and 1048 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1000
lib/fort.c
View File

File diff suppressed because it is too large Load Diff

1
lib/fort.h
View File

@ -71,7 +71,6 @@ SOFTWARE.
/***************************************************************************** /*****************************************************************************
* RETURN CODES * RETURN CODES
*****************************************************************************/ *****************************************************************************/
typedef int fort_status_t;
#define FT_SUCCESS 0 #define FT_SUCCESS 0
#define FT_MEMORY_ERROR -1 #define FT_MEMORY_ERROR -1
#define FT_ERROR -2 #define FT_ERROR -2

64
src/cell.c
View File

@ -3,15 +3,15 @@
#include "string_buffer.h" #include "string_buffer.h"
#include <assert.h> #include <assert.h>
struct fort_cell { struct f_cell {
string_buffer_t *str_buffer; f_string_buffer_t *str_buffer;
enum CellType cell_type; enum f_cell_type cell_type;
}; };
FT_INTERNAL FT_INTERNAL
fort_cell_t *create_cell(void) f_cell_t *create_cell(void)
{ {
fort_cell_t *cell = (fort_cell_t *)F_CALLOC(sizeof(fort_cell_t), 1); f_cell_t *cell = (f_cell_t *)F_CALLOC(sizeof(f_cell_t), 1);
if (cell == NULL) if (cell == NULL)
return NULL; return NULL;
cell->str_buffer = create_string_buffer(DEFAULT_STR_BUF_SIZE, CHAR_BUF); cell->str_buffer = create_string_buffer(DEFAULT_STR_BUF_SIZE, CHAR_BUF);
@ -19,12 +19,12 @@ fort_cell_t *create_cell(void)
F_FREE(cell); F_FREE(cell);
return NULL; return NULL;
} }
cell->cell_type = CommonCell; cell->cell_type = COMMON_CELL;
return cell; return cell;
} }
FT_INTERNAL FT_INTERNAL
void destroy_cell(fort_cell_t *cell) void destroy_cell(f_cell_t *cell)
{ {
if (cell == NULL) if (cell == NULL)
return; return;
@ -33,11 +33,11 @@ void destroy_cell(fort_cell_t *cell)
} }
FT_INTERNAL FT_INTERNAL
fort_cell_t *copy_cell(fort_cell_t *cell) f_cell_t *copy_cell(f_cell_t *cell)
{ {
assert(cell); assert(cell);
fort_cell_t *result = create_cell(); f_cell_t *result = create_cell();
if (result == NULL) if (result == NULL)
return NULL; return NULL;
destroy_string_buffer(result->str_buffer); destroy_string_buffer(result->str_buffer);
@ -51,21 +51,21 @@ fort_cell_t *copy_cell(fort_cell_t *cell)
} }
FT_INTERNAL FT_INTERNAL
void set_cell_type(fort_cell_t *cell, enum CellType type) void set_cell_type(f_cell_t *cell, enum f_cell_type type)
{ {
assert(cell); assert(cell);
cell->cell_type = type; cell->cell_type = type;
} }
FT_INTERNAL FT_INTERNAL
enum CellType get_cell_type(const fort_cell_t *cell) enum f_cell_type get_cell_type(const f_cell_t *cell)
{ {
assert(cell); assert(cell);
return cell->cell_type; return cell->cell_type;
} }
FT_INTERNAL FT_INTERNAL
size_t hint_width_cell(const fort_cell_t *cell, const context_t *context, enum request_geom_type geom) size_t hint_width_cell(const f_cell_t *cell, const f_context_t *context, enum f_geometry_type geom)
{ {
/* todo: /* todo:
* At the moment min width includes paddings. Maybe it is better that min width weren't include * At the moment min width includes paddings. Maybe it is better that min width weren't include
@ -75,17 +75,17 @@ size_t hint_width_cell(const fort_cell_t *cell, const context_t *context, enum r
assert(cell); assert(cell);
assert(context); assert(context);
fort_table_properties_t *properties = context->table_properties; f_table_properties_t *properties = context->table_properties;
size_t row = context->row; size_t row = context->row;
size_t column = context->column; size_t column = context->column;
size_t padding_left = get_cell_property_value_hierarcial(properties, row, column, FT_CPROP_LEFT_PADDING); size_t padding_left = get_cell_property_hierarchically(properties, row, column, FT_CPROP_LEFT_PADDING);
size_t padding_right = get_cell_property_value_hierarcial(properties, row, column, FT_CPROP_RIGHT_PADDING); size_t padding_right = get_cell_property_hierarchically(properties, row, column, FT_CPROP_RIGHT_PADDING);
size_t result = padding_left + padding_right; size_t result = padding_left + padding_right;
if (cell->str_buffer && cell->str_buffer->str.data) { if (cell->str_buffer && cell->str_buffer->str.data) {
result += buffer_text_visible_width(cell->str_buffer); result += buffer_text_visible_width(cell->str_buffer);
} }
result = MAX(result, (size_t)get_cell_property_value_hierarcial(properties, row, column, FT_CPROP_MIN_WIDTH)); result = MAX(result, (size_t)get_cell_property_hierarchically(properties, row, column, FT_CPROP_MIN_WIDTH));
if (geom == INTERN_REPR_GEOMETRY) { if (geom == INTERN_REPR_GEOMETRY) {
char cell_style_tag[TEXT_STYLE_TAG_MAX_SIZE]; char cell_style_tag[TEXT_STYLE_TAG_MAX_SIZE];
@ -109,17 +109,17 @@ size_t hint_width_cell(const fort_cell_t *cell, const context_t *context, enum r
} }
FT_INTERNAL FT_INTERNAL
size_t hint_height_cell(const fort_cell_t *cell, const context_t *context) size_t hint_height_cell(const f_cell_t *cell, const f_context_t *context)
{ {
assert(cell); assert(cell);
assert(context); assert(context);
fort_table_properties_t *properties = context->table_properties; f_table_properties_t *properties = context->table_properties;
size_t row = context->row; size_t row = context->row;
size_t column = context->column; size_t column = context->column;
size_t padding_top = get_cell_property_value_hierarcial(properties, row, column, FT_CPROP_TOP_PADDING); size_t padding_top = get_cell_property_hierarchically(properties, row, column, FT_CPROP_TOP_PADDING);
size_t padding_bottom = get_cell_property_value_hierarcial(properties, row, column, FT_CPROP_BOTTOM_PADDING); size_t padding_bottom = get_cell_property_hierarchically(properties, row, column, FT_CPROP_BOTTOM_PADDING);
size_t empty_string_height = get_cell_property_value_hierarcial(properties, row, column, FT_CPROP_EMPTY_STR_HEIGHT); size_t empty_string_height = get_cell_property_hierarchically(properties, row, column, FT_CPROP_EMPTY_STR_HEIGHT);
size_t result = padding_top + padding_bottom; size_t result = padding_top + padding_bottom;
if (cell->str_buffer && cell->str_buffer->str.data) { if (cell->str_buffer && cell->str_buffer->str.data) {
@ -131,19 +131,19 @@ size_t hint_height_cell(const fort_cell_t *cell, const context_t *context)
FT_INTERNAL FT_INTERNAL
int cell_printf(fort_cell_t *cell, size_t row, conv_context_t *cntx, size_t vis_width) int cell_printf(f_cell_t *cell, size_t row, f_conv_context_t *cntx, size_t vis_width)
{ {
const context_t *context = cntx->cntx; const f_context_t *context = cntx->cntx;
size_t buf_len = vis_width; size_t buf_len = vis_width;
if (cell == NULL || (vis_width < hint_width_cell(cell, context, VISIBLE_GEOMETRY))) { if (cell == NULL || (vis_width < hint_width_cell(cell, context, VISIBLE_GEOMETRY))) {
return -1; return -1;
} }
fort_table_properties_t *properties = context->table_properties; f_table_properties_t *properties = context->table_properties;
unsigned int padding_top = get_cell_property_value_hierarcial(properties, context->row, context->column, FT_CPROP_TOP_PADDING); unsigned int padding_top = get_cell_property_hierarchically(properties, context->row, context->column, FT_CPROP_TOP_PADDING);
unsigned int padding_left = get_cell_property_value_hierarcial(properties, context->row, context->column, FT_CPROP_LEFT_PADDING); unsigned int padding_left = get_cell_property_hierarchically(properties, context->row, context->column, FT_CPROP_LEFT_PADDING);
unsigned int padding_right = get_cell_property_value_hierarcial(properties, context->row, context->column, FT_CPROP_RIGHT_PADDING); unsigned int padding_right = get_cell_property_hierarchically(properties, context->row, context->column, FT_CPROP_RIGHT_PADDING);
size_t written = 0; size_t written = 0;
size_t invisible_written = 0; size_t invisible_written = 0;
@ -224,7 +224,7 @@ clear:
} }
FT_INTERNAL FT_INTERNAL
fort_status_t fill_cell_from_string(fort_cell_t *cell, const char *str) f_status fill_cell_from_string(f_cell_t *cell, const char *str)
{ {
assert(str); assert(str);
assert(cell); assert(cell);
@ -234,7 +234,7 @@ fort_status_t fill_cell_from_string(fort_cell_t *cell, const char *str)
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
fort_status_t fill_cell_from_wstring(fort_cell_t *cell, const wchar_t *str) f_status fill_cell_from_wstring(f_cell_t *cell, const wchar_t *str)
{ {
assert(str); assert(str);
assert(cell); assert(cell);
@ -245,7 +245,7 @@ fort_status_t fill_cell_from_wstring(fort_cell_t *cell, const wchar_t *str)
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
static static
fort_status_t fill_cell_from_u8string(fort_cell_t *cell, const void *str) f_status fill_cell_from_u8string(f_cell_t *cell, const void *str)
{ {
assert(str); assert(str);
assert(cell); assert(cell);
@ -254,7 +254,7 @@ fort_status_t fill_cell_from_u8string(fort_cell_t *cell, const void *str)
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */
FT_INTERNAL FT_INTERNAL
string_buffer_t *cell_get_string_buffer(fort_cell_t *cell) f_string_buffer_t *cell_get_string_buffer(f_cell_t *cell)
{ {
assert(cell); assert(cell);
assert(cell->str_buffer); assert(cell->str_buffer);
@ -262,7 +262,7 @@ string_buffer_t *cell_get_string_buffer(fort_cell_t *cell)
} }
FT_INTERNAL FT_INTERNAL
fort_status_t fill_cell_from_buffer(fort_cell_t *cell, const struct string_buffer *buffer) f_status fill_cell_from_buffer(f_cell_t *cell, const f_string_buffer_t *buffer)
{ {
assert(cell); assert(cell);
assert(buffer); assert(buffer);

24
src/cell.h
View File

@ -4,41 +4,41 @@
#include "fort_utils.h" #include "fort_utils.h"
FT_INTERNAL FT_INTERNAL
fort_cell_t *create_cell(void); f_cell_t *create_cell(void);
FT_INTERNAL FT_INTERNAL
void destroy_cell(fort_cell_t *cell); void destroy_cell(f_cell_t *cell);
FT_INTERNAL FT_INTERNAL
fort_cell_t *copy_cell(fort_cell_t *cell); f_cell_t *copy_cell(f_cell_t *cell);
FT_INTERNAL FT_INTERNAL
size_t hint_width_cell(const fort_cell_t *cell, const context_t *context, enum request_geom_type geom); size_t hint_width_cell(const f_cell_t *cell, const f_context_t *context, enum f_geometry_type geom);
FT_INTERNAL FT_INTERNAL
size_t hint_height_cell(const fort_cell_t *cell, const context_t *context); size_t hint_height_cell(const f_cell_t *cell, const f_context_t *context);
FT_INTERNAL FT_INTERNAL
void set_cell_type(fort_cell_t *cell, enum CellType type); void set_cell_type(f_cell_t *cell, enum f_cell_type type);
FT_INTERNAL FT_INTERNAL
enum CellType get_cell_type(const fort_cell_t *cell); enum f_cell_type get_cell_type(const f_cell_t *cell);
FT_INTERNAL FT_INTERNAL
int cell_printf(fort_cell_t *cell, size_t row, conv_context_t *cntx, size_t cod_width); int cell_printf(f_cell_t *cell, size_t row, f_conv_context_t *cntx, size_t cod_width);
FT_INTERNAL FT_INTERNAL
fort_status_t fill_cell_from_string(fort_cell_t *cell, const char *str); f_status fill_cell_from_string(f_cell_t *cell, const char *str);
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
fort_status_t fill_cell_from_wstring(fort_cell_t *cell, const wchar_t *str); f_status fill_cell_from_wstring(f_cell_t *cell, const wchar_t *str);
#endif #endif
FT_INTERNAL FT_INTERNAL
fort_status_t fill_cell_from_buffer(fort_cell_t *cell, const struct string_buffer *buf); f_status fill_cell_from_buffer(f_cell_t *cell, const f_string_buffer_t *buf);
FT_INTERNAL FT_INTERNAL
string_buffer_t *cell_get_string_buffer(fort_cell_t *cell); f_string_buffer_t *cell_get_string_buffer(f_cell_t *cell);
#endif /* CELL_H */ #endif /* CELL_H */

1
src/fort.h
View File

@ -71,7 +71,6 @@ SOFTWARE.
/***************************************************************************** /*****************************************************************************
* RETURN CODES * RETURN CODES
*****************************************************************************/ *****************************************************************************/
typedef int fort_status_t;
#define FT_SUCCESS 0 #define FT_SUCCESS 0
#define FT_MEMORY_ERROR -1 #define FT_MEMORY_ERROR -1
#define FT_ERROR -2 #define FT_ERROR -2

79
src/fort_impl.c
View File

@ -47,12 +47,12 @@ ft_table_t *ft_create_table(void)
if (result == NULL) if (result == NULL)
return NULL; return NULL;
result->rows = create_vector(sizeof(fort_row_t *), DEFAULT_VECTOR_CAPACITY); result->rows = create_vector(sizeof(f_row_t *), DEFAULT_VECTOR_CAPACITY);
if (result->rows == NULL) { if (result->rows == NULL) {
F_FREE(result); F_FREE(result);
return NULL; return NULL;
} }
result->separators = create_vector(sizeof(separator_t *), DEFAULT_VECTOR_CAPACITY); result->separators = create_vector(sizeof(f_separator_t *), DEFAULT_VECTOR_CAPACITY);
if (result->separators == NULL) { if (result->separators == NULL) {
destroy_vector(result->rows); destroy_vector(result->rows);
F_FREE(result); F_FREE(result);
@ -76,14 +76,14 @@ void ft_destroy_table(ft_table_t *table)
if (table->rows) { if (table->rows) {
size_t row_n = vector_size(table->rows); size_t row_n = vector_size(table->rows);
for (i = 0; i < row_n; ++i) { for (i = 0; i < row_n; ++i) {
destroy_row(*(fort_row_t **)vector_at(table->rows, i)); destroy_row(*(f_row_t **)vector_at(table->rows, i));
} }
destroy_vector(table->rows); destroy_vector(table->rows);
} }
if (table->separators) { if (table->separators) {
size_t row_n = vector_size(table->separators); size_t row_n = vector_size(table->separators);
for (i = 0; i < row_n; ++i) { for (i = 0; i < row_n; ++i) {
destroy_separator(*(separator_t **)vector_at(table->separators, i)); destroy_separator(*(f_separator_t **)vector_at(table->separators, i));
} }
destroy_vector(table->separators); destroy_vector(table->separators);
} }
@ -104,8 +104,8 @@ ft_table_t *ft_copy_table(ft_table_t *table)
size_t i = 0; size_t i = 0;
size_t rows_n = vector_size(table->rows); size_t rows_n = vector_size(table->rows);
for (i = 0; i < rows_n; ++i) { for (i = 0; i < rows_n; ++i) {
fort_row_t *row = *(fort_row_t **)vector_at(table->rows, i); f_row_t *row = *(f_row_t **)vector_at(table->rows, i);
fort_row_t *new_row = copy_row(row); f_row_t *new_row = copy_row(row);
if (new_row == NULL) { if (new_row == NULL) {
ft_destroy_table(result); ft_destroy_table(result);
return NULL; return NULL;
@ -115,8 +115,8 @@ ft_table_t *ft_copy_table(ft_table_t *table)
size_t sep_sz = vector_size(table->separators); size_t sep_sz = vector_size(table->separators);
for (i = 0; i < sep_sz; ++i) { for (i = 0; i < sep_sz; ++i) {
separator_t *sep = *(separator_t **)vector_at(table->separators, i); f_separator_t *sep = *(f_separator_t **)vector_at(table->separators, i);
separator_t *new_sep = copy_separator(sep); f_separator_t *new_sep = copy_separator(sep);
if (new_sep == NULL) { if (new_sep == NULL) {
ft_destroy_table(result); ft_destroy_table(result);
return NULL; return NULL;
@ -165,7 +165,7 @@ void ft_set_cur_cell(ft_table_t *table, size_t row, size_t col)
table->cur_col = col; table->cur_col = col;
} }
static int ft_row_printf_impl_(ft_table_t *table, size_t row, const struct ft_string *fmt, va_list *va) static int ft_row_printf_impl_(ft_table_t *table, size_t row, const struct f_string_view *fmt, va_list *va)
{ {
size_t i = 0; size_t i = 0;
size_t new_cols = 0; size_t new_cols = 0;
@ -173,18 +173,18 @@ static int ft_row_printf_impl_(ft_table_t *table, size_t row, const struct ft_st
if (table == NULL) if (table == NULL)
return -1; return -1;
fort_row_t *new_row = create_row_from_fmt_string(fmt, va); f_row_t *new_row = create_row_from_fmt_string(fmt, va);
if (new_row == NULL) { if (new_row == NULL) {
return -1; return -1;
} }
fort_row_t **cur_row_p = NULL; f_row_t **cur_row_p = NULL;
size_t sz = vector_size(table->rows); size_t sz = vector_size(table->rows);
if (row >= sz) { if (row >= sz) {
size_t push_n = row - sz + 1; size_t push_n = row - sz + 1;
for (i = 0; i < push_n; ++i) { for (i = 0; i < push_n; ++i) {
fort_row_t *padding_row = create_row(); f_row_t *padding_row = create_row();
if (padding_row == NULL) if (padding_row == NULL)
goto clear; goto clear;
@ -197,7 +197,7 @@ static int ft_row_printf_impl_(ft_table_t *table, size_t row, const struct ft_st
/* todo: clearing pushed items in case of error ?? */ /* todo: clearing pushed items in case of error ?? */
new_cols = columns_in_row(new_row); new_cols = columns_in_row(new_row);
cur_row_p = (fort_row_t **)vector_at(table->rows, row); cur_row_p = (f_row_t **)vector_at(table->rows, row);
swap_row(*cur_row_p, new_row, table->cur_col); swap_row(*cur_row_p, new_row, table->cur_col);
table->cur_col += new_cols; table->cur_col += new_cols;
@ -225,7 +225,7 @@ int FT_PRINTF(ft_table_t *table, const char *fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
struct ft_string fmt_str; struct f_string_view fmt_str;
fmt_str.type = CHAR_BUF; fmt_str.type = CHAR_BUF;
fmt_str.u.cstr = fmt; fmt_str.u.cstr = fmt;
int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va); int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
@ -239,7 +239,7 @@ int FT_PRINTF_LN(ft_table_t *table, const char *fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
struct ft_string fmt_str; struct f_string_view fmt_str;
fmt_str.type = CHAR_BUF; fmt_str.type = CHAR_BUF;
fmt_str.u.cstr = fmt; fmt_str.u.cstr = fmt;
int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va); int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
@ -260,7 +260,7 @@ int ft_wprintf(ft_table_t *table, const wchar_t *fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
struct ft_string fmt_str; struct f_string_view fmt_str;
fmt_str.type = W_CHAR_BUF; fmt_str.type = W_CHAR_BUF;
fmt_str.u.wstr = fmt; fmt_str.u.wstr = fmt;
int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va); int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
@ -274,7 +274,7 @@ int ft_wprintf_ln(ft_table_t *table, const wchar_t *fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
struct ft_string fmt_str; struct f_string_view fmt_str;
fmt_str.type = W_CHAR_BUF; fmt_str.type = W_CHAR_BUF;
fmt_str.u.wstr = fmt; fmt_str.u.wstr = fmt;
int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va); int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
@ -292,10 +292,10 @@ void ft_set_default_printf_field_separator(char separator)
g_col_separator = separator; g_col_separator = separator;
} }
static int ft_write_impl_(ft_table_t *table, const ft_string_t *cell_content) static int ft_write_impl_(ft_table_t *table, const f_string_view_t *cell_content)
{ {
assert(table); assert(table);
string_buffer_t *buf = get_cur_str_buffer_and_create_if_not_exists(table); f_string_buffer_t *buf = get_cur_str_buffer_and_create_if_not_exists(table);
if (buf == NULL) if (buf == NULL)
return FT_ERROR; return FT_ERROR;
@ -325,7 +325,7 @@ static int ft_write_impl_(ft_table_t *table, const ft_string_t *cell_content)
static int ft_write_impl(ft_table_t *table, const char *cell_content) static int ft_write_impl(ft_table_t *table, const char *cell_content)
{ {
ft_string_t content; f_string_view_t content;
content.type = CHAR_BUF; content.type = CHAR_BUF;
content.u.cstr = cell_content; content.u.cstr = cell_content;
return ft_write_impl_(table, &content); return ft_write_impl_(table, &content);
@ -334,7 +334,7 @@ static int ft_write_impl(ft_table_t *table, const char *cell_content)
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
static int ft_u8write_impl(ft_table_t *table, const void *cell_content) static int ft_u8write_impl(ft_table_t *table, const void *cell_content)
{ {
ft_string_t content; f_string_view_t content;
content.type = UTF8_BUF; content.type = UTF8_BUF;
content.u.u8str = cell_content; content.u.u8str = cell_content;
return ft_write_impl_(table, &content); return ft_write_impl_(table, &content);
@ -344,7 +344,7 @@ static int ft_u8write_impl(ft_table_t *table, const void *cell_content)
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
static int ft_wwrite_impl(ft_table_t *table, const wchar_t *cell_content) static int ft_wwrite_impl(ft_table_t *table, const wchar_t *cell_content)
{ {
ft_string_t content; f_string_view_t content;
content.type = W_CHAR_BUF; content.type = W_CHAR_BUF;
content.u.wstr = cell_content; content.u.wstr = cell_content;
return ft_write_impl_(table, &content); return ft_write_impl_(table, &content);
@ -572,7 +572,7 @@ static
const char *empty_str_arr[] = {"", (const char *)L"", ""}; const char *empty_str_arr[] = {"", (const char *)L"", ""};
static static
const void *ft_to_string_impl(const ft_table_t *table, enum str_buf_type b_type) const void *ft_to_string_impl(const ft_table_t *table, enum f_string_type b_type)
{ {
assert(table); assert(table);
@ -618,15 +618,14 @@ const void *ft_to_string_impl(const ft_table_t *table, enum str_buf_type b_type)
int tmp = 0; int tmp = 0;
size_t i = 0; size_t i = 0;
context_t context; f_context_t context;
context.table_properties = (table->properties ? table->properties : &g_table_properties); context.table_properties = (table->properties ? table->properties : &g_table_properties);
fort_row_t *prev_row = NULL; f_row_t *prev_row = NULL;
fort_row_t *cur_row = NULL; f_row_t *cur_row = NULL;
separator_t *cur_sep = NULL; f_separator_t *cur_sep = NULL;
size_t sep_size = vector_size(table->separators); size_t sep_size = vector_size(table->separators);
conv_context_t cntx; f_conv_context_t cntx;
cntx.buf_origin = buffer;
cntx.u.buf = buffer; cntx.u.buf = buffer;
cntx.raw_avail = string_buffer_raw_capacity(table->conv_buffer); cntx.raw_avail = string_buffer_raw_capacity(table->conv_buffer);
cntx.cntx = &context; cntx.cntx = &context;
@ -639,18 +638,18 @@ const void *ft_to_string_impl(const ft_table_t *table, enum str_buf_type b_type)
} }
for (i = 0; i < rows; ++i) { for (i = 0; i < rows; ++i) {
cur_sep = (i < sep_size) ? (*(separator_t **)vector_at(table->separators, i)) : NULL; cur_sep = (i < sep_size) ? (*(f_separator_t **)vector_at(table->separators, i)) : NULL;
cur_row = *(fort_row_t **)vector_at(table->rows, i); cur_row = *(f_row_t **)vector_at(table->rows, i);
enum HorSeparatorPos separatorPos = (i == 0) ? TopSeparator : InsideSeparator; enum f_hor_separator_pos separatorPos = (i == 0) ? TOP_SEPARATOR : INSIDE_SEPARATOR;
context.row = i; context.row = i;
FT_CHECK(print_row_separator(&cntx, col_vis_width_arr, cols, prev_row, cur_row, separatorPos, cur_sep)); FT_CHECK(print_row_separator(&cntx, col_vis_width_arr, cols, prev_row, cur_row, separatorPos, cur_sep));
FT_CHECK(snprintf_row(cur_row, &cntx, col_vis_width_arr, cols, row_vis_height_arr[i])); FT_CHECK(snprintf_row(cur_row, &cntx, col_vis_width_arr, cols, row_vis_height_arr[i]));
prev_row = cur_row; prev_row = cur_row;
} }
cur_row = NULL; cur_row = NULL;
cur_sep = (i < sep_size) ? (*(separator_t **)vector_at(table->separators, i)) : NULL; cur_sep = (i < sep_size) ? (*(f_separator_t **)vector_at(table->separators, i)) : NULL;
context.row = i; context.row = i;
FT_CHECK(print_row_separator(&cntx, col_vis_width_arr, cols, prev_row, cur_row, BottomSeparator, cur_sep)); FT_CHECK(print_row_separator(&cntx, col_vis_width_arr, cols, prev_row, cur_row, BOTTOM_SEPARATOR, cur_sep));
/* Print bottom margin */ /* Print bottom margin */
for (i = 0; i < context.table_properties->entire_table_properties.bottom_margin; ++i) { for (i = 0; i < context.table_properties->entire_table_properties.bottom_margin; ++i) {
@ -685,7 +684,7 @@ int ft_add_separator(ft_table_t *table)
assert(table->separators); assert(table->separators);
while (vector_size(table->separators) <= table->cur_row) { while (vector_size(table->separators) <= table->cur_row) {
separator_t *sep_p = create_separator(F_FALSE); f_separator_t *sep_p = create_separator(F_FALSE);
if (sep_p == NULL) if (sep_p == NULL)
return FT_MEMORY_ERROR; return FT_MEMORY_ERROR;
int status = vector_push(table->separators, &sep_p); int status = vector_push(table->separators, &sep_p);
@ -693,7 +692,7 @@ int ft_add_separator(ft_table_t *table)
return status; return status;
} }
separator_t **sep_p = (separator_t **)vector_at(table->separators, table->cur_row); f_separator_t **sep_p = (f_separator_t **)vector_at(table->separators, table->cur_row);
if (*sep_p == NULL) if (*sep_p == NULL)
*sep_p = create_separator(F_TRUE); *sep_p = create_separator(F_TRUE);
else else
@ -748,7 +747,7 @@ const struct ft_border_style *const FT_BOLD_STYLE = &built_in_external_styles[1
const struct ft_border_style *const FT_BOLD2_STYLE = &built_in_external_styles[13]; const struct ft_border_style *const FT_BOLD2_STYLE = &built_in_external_styles[13];
const struct ft_border_style *const FT_FRAME_STYLE = &built_in_external_styles[14]; const struct ft_border_style *const FT_FRAME_STYLE = &built_in_external_styles[14];
static void set_border_props_for_props(fort_table_properties_t *properties, const struct ft_border_style *style) static void set_border_props_for_props(f_table_properties_t *properties, const struct ft_border_style *style)
{ {
if (style >= built_in_external_styles && style < (built_in_external_styles + BUILT_IN_STYLES_SZ)) { if (style >= built_in_external_styles && style < (built_in_external_styles + BUILT_IN_STYLES_SZ)) {
size_t pos = (size_t)(style - built_in_external_styles); size_t pos = (size_t)(style - built_in_external_styles);
@ -889,7 +888,7 @@ int ft_set_cell_span(ft_table_t *table, size_t row, size_t col, size_t hor_span)
if (row == FT_CUR_COLUMN) if (row == FT_CUR_COLUMN)
col = table->cur_col; col = table->cur_col;
fort_row_t *row_p = get_row_and_create_if_not_exists(table, row); f_row_t *row_p = get_row_and_create_if_not_exists(table, row);
if (row_p == NULL) if (row_p == NULL)
return FT_ERROR; return FT_ERROR;
@ -955,7 +954,7 @@ int ft_u8printf(ft_table_t *table, const char *fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
struct ft_string fmt_str; struct f_string_view fmt_str;
fmt_str.type = UTF8_BUF; fmt_str.type = UTF8_BUF;
fmt_str.u.cstr = fmt; fmt_str.u.cstr = fmt;
int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va); int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);
@ -970,7 +969,7 @@ int ft_u8printf_ln(ft_table_t *table, const char *fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
struct ft_string fmt_str; struct f_string_view fmt_str;
fmt_str.type = UTF8_BUF; fmt_str.type = UTF8_BUF;
fmt_str.u.cstr = fmt; fmt_str.u.cstr = fmt;
int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va); int result = ft_row_printf_impl_(table, table->cur_row, &fmt_str, &va);

40
src/fort_utils.c
View File

@ -138,8 +138,8 @@ wchar_t *fort_wcsdup(const wchar_t *str)
#endif #endif
FT_INTERNAL static
size_t number_of_columns_in_format_string(const char *fmt) size_t columns_number_in_fmt_string(const char *fmt)
{ {
size_t separator_counter = 0; size_t separator_counter = 0;
const char *pos = fmt; const char *pos = fmt;
@ -154,10 +154,9 @@ size_t number_of_columns_in_format_string(const char *fmt)
return separator_counter + 1; return separator_counter + 1;
} }
#if defined(FT_HAVE_WCHAR) #if defined(FT_HAVE_WCHAR)
FT_INTERNAL static
size_t number_of_columns_in_format_wstring(const wchar_t *fmt) size_t columns_number_in_fmt_wstring(const wchar_t *fmt)
{ {
size_t separator_counter = 0; size_t separator_counter = 0;
const wchar_t *pos = fmt; const wchar_t *pos = fmt;
@ -173,10 +172,9 @@ size_t number_of_columns_in_format_wstring(const wchar_t *fmt)
} }
#endif #endif
#if defined(FT_HAVE_UTF8) #if defined(FT_HAVE_UTF8)
FT_INTERNAL static
size_t number_of_columns_in_format_u8string(const void *fmt) size_t columns_number_in_fmt_u8string(const void *fmt)
{ {
size_t separator_counter = 0; size_t separator_counter = 0;
const char *pos = (const char *)fmt; const char *pos = (const char *)fmt;
@ -193,18 +191,18 @@ size_t number_of_columns_in_format_u8string(const void *fmt)
#endif #endif
FT_INTERNAL FT_INTERNAL
size_t number_of_columns_in_format_string2(const struct ft_string *fmt) size_t number_of_columns_in_format_string(const f_string_view_t *fmt)
{ {
switch (fmt->type) { switch (fmt->type) {
case CHAR_BUF: case CHAR_BUF:
return number_of_columns_in_format_string(fmt->u.cstr); return columns_number_in_fmt_string(fmt->u.cstr);
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
case W_CHAR_BUF: case W_CHAR_BUF:
return number_of_columns_in_format_wstring(fmt->u.wstr); return columns_number_in_fmt_wstring(fmt->u.wstr);
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
case UTF8_BUF: case UTF8_BUF:
return number_of_columns_in_format_u8string(fmt->u.u8str); return columns_number_in_fmt_u8string(fmt->u.u8str);
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */
default: default:
assert(0); assert(0);
@ -213,18 +211,18 @@ size_t number_of_columns_in_format_string2(const struct ft_string *fmt)
} }
FT_INTERNAL FT_INTERNAL
size_t number_of_columns_in_format_buffer(const string_buffer_t *fmt) size_t number_of_columns_in_format_buffer(const f_string_buffer_t *fmt)
{ {
switch (fmt->type) { switch (fmt->type) {
case CHAR_BUF: case CHAR_BUF:
return number_of_columns_in_format_string(fmt->str.cstr); return columns_number_in_fmt_string(fmt->str.cstr);
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
case W_CHAR_BUF: case W_CHAR_BUF:
return number_of_columns_in_format_wstring(fmt->str.wstr); return columns_number_in_fmt_wstring(fmt->str.wstr);
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
case UTF8_BUF: case UTF8_BUF:
return number_of_columns_in_format_u8string(fmt->str.u8str); return columns_number_in_fmt_u8string(fmt->str.u8str);
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */
default: default:
assert(0); assert(0);
@ -263,7 +261,7 @@ int snprint_n_strings_impl(char *buf, size_t length, size_t n, const char *str)
} }
static static
int snprint_n_strings(conv_context_t *cntx, size_t n, const char *str) int snprint_n_strings(f_conv_context_t *cntx, size_t n, const char *str)
{ {
int w = snprint_n_strings_impl(cntx->u.buf, cntx->raw_avail, n, str); int w = snprint_n_strings_impl(cntx->u.buf, cntx->raw_avail, n, str);
if (w >= 0) { if (w >= 0) {
@ -285,7 +283,7 @@ int u8nprint_n_strings(void *buf, size_t length, size_t n, const void *str);
FT_INTERNAL FT_INTERNAL
int print_n_strings(conv_context_t *cntx, size_t n, const char *str) int print_n_strings(f_conv_context_t *cntx, size_t n, const char *str)
{ {
int cod_w; int cod_w;
int raw_written; int raw_written;
@ -326,7 +324,7 @@ int print_n_strings(conv_context_t *cntx, size_t n, const char *str)
} }
FT_INTERNAL FT_INTERNAL
int ft_nprint(conv_context_t *cntx, const char *str, size_t strlen) int ft_nprint(f_conv_context_t *cntx, const char *str, size_t strlen)
{ {
if (cntx->raw_avail + 1/* for 0 */ < strlen) if (cntx->raw_avail + 1/* for 0 */ < strlen)
return -1; return -1;
@ -339,7 +337,7 @@ int ft_nprint(conv_context_t *cntx, const char *str, size_t strlen)
} }
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
int ft_nwprint(conv_context_t *cntx, const wchar_t *str, size_t strlen) int ft_nwprint(f_conv_context_t *cntx, const wchar_t *str, size_t strlen)
{ {
if (cntx->raw_avail + 1/* for 0 */ < strlen) if (cntx->raw_avail + 1/* for 0 */ < strlen)
return -1; return -1;
@ -359,7 +357,7 @@ int ft_nwprint(conv_context_t *cntx, const wchar_t *str, size_t strlen)
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
FT_INTERNAL FT_INTERNAL
int ft_nu8print(conv_context_t *cntx, const void *beg, const void *end) int ft_nu8print(f_conv_context_t *cntx, const void *beg, const void *end)
{ {
const char *bc = (const char *)beg; const char *bc = (const char *)beg;
const char *ec = (const char *)end; const char *ec = (const char *)end;

126
src/fort_utils.h
View File

@ -46,18 +46,38 @@ extern char g_col_separator;
#define FT_NEWLINE "\n" #define FT_NEWLINE "\n"
#define FT_SPACE " " #define FT_SPACE " "
enum get_policy { /*****************************************************************************
* DEFAULT_SIZES
* ***************************************************************************/
#define DEFAULT_STR_BUF_SIZE 1024
#define DEFAULT_VECTOR_CAPACITY 10
/*****************************************************************************
* DATA TYPES
* ***************************************************************************/
enum f_get_policy {
CREATE_ON_NULL, CREATE_ON_NULL,
DONT_CREATE_ON_NULL DONT_CREATE_ON_NULL
}; };
enum f_bool {
enum ft_bool {
F_FALSE = 0, F_FALSE = 0,
F_TRUE = 1 F_TRUE = 1
}; };
enum str_buf_type { enum f_cell_type {
COMMON_CELL,
GROUP_MASTER_CELL,
GROUP_SLAVE_CELL
};
enum f_geometry_type {
VISIBLE_GEOMETRY,
INTERN_REPR_GEOMETRY
};
enum f_string_type {
CHAR_BUF, CHAR_BUF,
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
W_CHAR_BUF, W_CHAR_BUF,
@ -67,7 +87,7 @@ enum str_buf_type {
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
}; };
struct ft_string { struct f_string_view {
union { union {
const char *cstr; const char *cstr;
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
@ -78,9 +98,9 @@ struct ft_string {
#endif #endif
const void *data; const void *data;
} u; } u;
enum str_buf_type type; enum f_string_type type;
}; };
typedef struct ft_string ft_string_t; typedef struct f_string_view f_string_view_t;
#define FT_STR_2_CAT_(arg1, arg2) \ #define FT_STR_2_CAT_(arg1, arg2) \
@ -93,65 +113,49 @@ typedef struct ft_string ft_string_t;
#define UNIQUE_NAME(prefix) \ #define UNIQUE_NAME(prefix) \
UNIQUE_NAME_(prefix) UNIQUE_NAME_(prefix)
typedef int f_status;
/*****************************************************************************
* DEFAULT_SIZES
* ***************************************************************************/
#define DEFAULT_STR_BUF_SIZE 1024
#define DEFAULT_VECTOR_CAPACITY 10
struct fort_table_properties;
struct fort_column_properties; struct f_table_properties;
struct fort_row; struct f_row;
struct vector; struct f_vector;
struct fort_cell; struct f_cell;
struct string_buffer; struct f_string_buffer;
struct separator { struct f_separator {
int enabled; int enabled;
}; };
typedef struct fort_table_properties fort_table_properties_t; typedef struct f_table_properties f_table_properties_t;
struct fort_context { typedef struct f_vector f_vector_t;
fort_table_properties_t *table_properties; typedef struct f_cell f_cell_t;
typedef struct f_string_buffer f_string_buffer_t;
typedef struct f_row f_row_t;
typedef struct f_separator f_separator_t;
struct f_context {
f_table_properties_t *table_properties;
size_t row; size_t row;
size_t column; size_t column;
}; };
typedef struct fort_context context_t; typedef struct f_context f_context_t;
typedef struct fort_column_properties fort_column_properties_t;
typedef struct vector vector_t;
typedef struct fort_cell fort_cell_t;
typedef struct string_buffer string_buffer_t;
typedef struct fort_row fort_row_t;
/*typedef struct ft_table ft_table_t;*/
typedef struct separator separator_t;
enum CellType { struct f_conv_context {
CommonCell,
GroupMasterCell,
GroupSlaveCell
};
enum request_geom_type {
VISIBLE_GEOMETRY,
INTERN_REPR_GEOMETRY
};
struct conv_context {
char *buf_origin;
union { union {
char *buf; char *buf;
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
wchar_t *wbuf; wchar_t *wbuf;
#endif
#ifdef FT_HAVE_UTF8
const void *u8str;
#endif #endif
} u; } u;
size_t raw_avail; size_t raw_avail;
struct fort_context *cntx; struct f_context *cntx;
enum str_buf_type b_type; enum f_string_type b_type;
}; };
typedef struct conv_context conv_context_t; typedef struct f_conv_context f_conv_context_t;
/***************************************************************************** /*****************************************************************************
@ -169,36 +173,34 @@ void set_memory_funcs(void *(*f_malloc)(size_t size), void (*f_free)(void *ptr))
FT_INTERNAL FT_INTERNAL
char *fort_strdup(const char *str); char *fort_strdup(const char *str);
FT_INTERNAL
size_t number_of_columns_in_format_string(const char *fmt);
FT_INTERNAL FT_INTERNAL
size_t number_of_columns_in_format_string2(const struct ft_string *fmt); size_t number_of_columns_in_format_string(const f_string_view_t *fmt);
FT_INTERNAL
size_t number_of_columns_in_format_buffer(const f_string_buffer_t *fmt);
#if defined(FT_HAVE_WCHAR) #if defined(FT_HAVE_WCHAR)
FT_INTERNAL FT_INTERNAL
wchar_t *fort_wcsdup(const wchar_t *str); wchar_t *fort_wcsdup(const wchar_t *str);
FT_INTERNAL
size_t number_of_columns_in_format_wstring(const wchar_t *fmt);
#endif #endif
FT_INTERNAL
size_t number_of_columns_in_format_buffer(const string_buffer_t *fmt);
FT_INTERNAL
int print_n_strings(conv_context_t *cntx, size_t n, const char *str);
FT_INTERNAL FT_INTERNAL
int ft_nprint(conv_context_t *cntx, const char *str, size_t strlen); int print_n_strings(f_conv_context_t *cntx, size_t n, const char *str);
FT_INTERNAL
int ft_nprint(f_conv_context_t *cntx, const char *str, size_t strlen);
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
int ft_nwprint(conv_context_t *cntx, const wchar_t *str, size_t strlen); int ft_nwprint(f_conv_context_t *cntx, const wchar_t *str, size_t strlen);
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
FT_INTERNAL FT_INTERNAL
int ft_nu8print(conv_context_t *cntx, const void *beg, const void *end); int ft_nu8print(f_conv_context_t *cntx, const void *beg, const void *end);
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */

100
src/properties.c
View File

@ -62,14 +62,14 @@ static const size_t n_fg_colors = sizeof(fg_colors) / sizeof(fg_colors[0]);
static const size_t n_bg_colors = sizeof(bg_colors) / sizeof(bg_colors[0]); static const size_t n_bg_colors = sizeof(bg_colors) / sizeof(bg_colors[0]);
static const size_t n_styles = sizeof(text_styles) / sizeof(text_styles[0]); static const size_t n_styles = sizeof(text_styles) / sizeof(text_styles[0]);
void get_style_tag_for_cell(const fort_table_properties_t *props, void get_style_tag_for_cell(const f_table_properties_t *props,
size_t row, size_t col, char *style_tag, size_t sz) size_t row, size_t col, char *style_tag, size_t sz)
{ {
(void)sz; (void)sz;
size_t i = 0; size_t i = 0;
unsigned bg_color_number = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CELL_BG_COLOR); unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_BG_COLOR);
unsigned text_style = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CELL_TEXT_STYLE); unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_TEXT_STYLE);
style_tag[0] = '\0'; style_tag[0] = '\0';
@ -98,14 +98,14 @@ error:
return; return;
} }
void get_reset_style_tag_for_cell(const fort_table_properties_t *props, void get_reset_style_tag_for_cell(const f_table_properties_t *props,
size_t row, size_t col, char *reset_style_tag, size_t sz) size_t row, size_t col, char *reset_style_tag, size_t sz)
{ {
(void)sz; (void)sz;
size_t i = 0; size_t i = 0;
unsigned bg_color_number = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CELL_BG_COLOR); unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_BG_COLOR);
unsigned text_style = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CELL_TEXT_STYLE); unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CELL_TEXT_STYLE);
reset_style_tag[0] = '\0'; reset_style_tag[0] = '\0';
@ -142,15 +142,15 @@ error:
} }
void get_style_tag_for_content(const fort_table_properties_t *props, void get_style_tag_for_content(const f_table_properties_t *props,
size_t row, size_t col, char *style_tag, size_t sz) size_t row, size_t col, char *style_tag, size_t sz)
{ {
(void)sz; (void)sz;
size_t i = 0; size_t i = 0;
unsigned text_style = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CONT_TEXT_STYLE); unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_TEXT_STYLE);
unsigned fg_color_number = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CONT_FG_COLOR); unsigned fg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_FG_COLOR);
unsigned bg_color_number = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CONT_BG_COLOR); unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_BG_COLOR);
style_tag[0] = '\0'; style_tag[0] = '\0';
@ -186,16 +186,16 @@ error:
return; return;
} }
void get_reset_style_tag_for_content(const fort_table_properties_t *props, void get_reset_style_tag_for_content(const f_table_properties_t *props,
size_t row, size_t col, char *reset_style_tag, size_t sz) size_t row, size_t col, char *reset_style_tag, size_t sz)
{ {
(void)sz; (void)sz;
size_t i = 0; size_t i = 0;
size_t len = 0; size_t len = 0;
unsigned text_style = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CONT_TEXT_STYLE); unsigned text_style = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_TEXT_STYLE);
unsigned fg_color_number = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CONT_FG_COLOR); unsigned fg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_FG_COLOR);
unsigned bg_color_number = get_cell_property_value_hierarcial(props, row, col, FT_CPROP_CONT_BG_COLOR); unsigned bg_color_number = get_cell_property_hierarchically(props, row, col, FT_CPROP_CONT_BG_COLOR);
reset_style_tag[0] = '\0'; reset_style_tag[0] = '\0';
@ -241,7 +241,7 @@ error:
} }
static struct fort_cell_props g_default_cell_properties = { static struct f_cell_props g_default_cell_properties = {
FT_ANY_ROW, /* cell_row */ FT_ANY_ROW, /* cell_row */
FT_ANY_COLUMN, /* cell_col */ FT_ANY_COLUMN, /* cell_col */
@ -267,7 +267,7 @@ static struct fort_cell_props g_default_cell_properties = {
FT_TSTYLE_DEFAULT, /* content_text_style */ FT_TSTYLE_DEFAULT, /* content_text_style */
}; };
static int get_prop_value_if_exists_otherwise_default(const struct fort_cell_props *cell_opts, uint32_t property) static int get_prop_value_if_exists_otherwise_default(const struct f_cell_props *cell_opts, uint32_t property)
{ {
if (cell_opts == NULL || !PROP_IS_SET(cell_opts->properties_flags, property)) { if (cell_opts == NULL || !PROP_IS_SET(cell_opts->properties_flags, property)) {
cell_opts = &g_default_cell_properties; cell_opts = &g_default_cell_properties;
@ -308,15 +308,15 @@ static int get_prop_value_if_exists_otherwise_default(const struct fort_cell_pro
FT_INTERNAL FT_INTERNAL
fort_cell_prop_container_t *create_cell_prop_container(void) f_cell_prop_container_t *create_cell_prop_container(void)
{ {
fort_cell_prop_container_t *ret = create_vector(sizeof(fort_cell_props_t), DEFAULT_VECTOR_CAPACITY); f_cell_prop_container_t *ret = create_vector(sizeof(f_cell_props_t), DEFAULT_VECTOR_CAPACITY);
return ret; return ret;
} }
FT_INTERNAL FT_INTERNAL
void destroy_cell_prop_container(fort_cell_prop_container_t *cont) void destroy_cell_prop_container(f_cell_prop_container_t *cont)
{ {
if (cont) if (cont)
destroy_vector(cont); destroy_vector(cont);
@ -324,13 +324,13 @@ void destroy_cell_prop_container(fort_cell_prop_container_t *cont)
FT_INTERNAL FT_INTERNAL
const fort_cell_props_t *cget_cell_prop(const fort_cell_prop_container_t *cont, size_t row, size_t col) const f_cell_props_t *cget_cell_prop(const f_cell_prop_container_t *cont, size_t row, size_t col)
{ {
assert(cont); assert(cont);
size_t sz = vector_size(cont); size_t sz = vector_size(cont);
size_t i = 0; size_t i = 0;
for (i = 0; i < sz; ++i) { for (i = 0; i < sz; ++i) {
const fort_cell_props_t *opt = (const fort_cell_props_t *)vector_at_c(cont, i); const f_cell_props_t *opt = (const f_cell_props_t *)vector_at_c(cont, i);
if (opt->cell_row == row && opt->cell_col == col) if (opt->cell_row == row && opt->cell_col == col)
return opt; return opt;
} }
@ -339,27 +339,27 @@ const fort_cell_props_t *cget_cell_prop(const fort_cell_prop_container_t *cont,
FT_INTERNAL FT_INTERNAL
fort_cell_props_t *get_cell_prop_and_create_if_not_exists(fort_cell_prop_container_t *cont, size_t row, size_t col) f_cell_props_t *get_cell_prop_and_create_if_not_exists(f_cell_prop_container_t *cont, size_t row, size_t col)
{ {
assert(cont); assert(cont);
size_t sz = vector_size(cont); size_t sz = vector_size(cont);
size_t i = 0; size_t i = 0;
for (i = 0; i < sz; ++i) { for (i = 0; i < sz; ++i) {
fort_cell_props_t *opt = (fort_cell_props_t *)vector_at(cont, i); f_cell_props_t *opt = (f_cell_props_t *)vector_at(cont, i);
if (opt->cell_row == row && opt->cell_col == col) if (opt->cell_row == row && opt->cell_col == col)
return opt; return opt;
} }
fort_cell_props_t opt; f_cell_props_t opt;
if (row == FT_ANY_ROW && col == FT_ANY_COLUMN) if (row == FT_ANY_ROW && col == FT_ANY_COLUMN)
memcpy(&opt, &g_default_cell_properties, sizeof(fort_cell_props_t)); memcpy(&opt, &g_default_cell_properties, sizeof(f_cell_props_t));
else else
memset(&opt, 0, sizeof(fort_cell_props_t)); memset(&opt, 0, sizeof(f_cell_props_t));
opt.cell_row = row; opt.cell_row = row;
opt.cell_col = col; opt.cell_col = col;
if (FT_IS_SUCCESS(vector_push(cont, &opt))) { if (FT_IS_SUCCESS(vector_push(cont, &opt))) {
return (fort_cell_props_t *)vector_at(cont, sz); return (f_cell_props_t *)vector_at(cont, sz);
} }
return NULL; return NULL;
@ -367,12 +367,12 @@ fort_cell_props_t *get_cell_prop_and_create_if_not_exists(fort_cell_prop_contain
FT_INTERNAL FT_INTERNAL
int get_cell_property_value_hierarcial(const fort_table_properties_t *propertiess, size_t row, size_t column, uint32_t property) int get_cell_property_hierarchically(const f_table_properties_t *propertiess, size_t row, size_t column, uint32_t property)
{ {
assert(propertiess); assert(propertiess);
size_t row_origin = row; size_t row_origin = row;
const fort_cell_props_t *opt = NULL; const f_cell_props_t *opt = NULL;
if (propertiess->cell_properties != NULL) { if (propertiess->cell_properties != NULL) {
while (1) { while (1) {
opt = cget_cell_prop(propertiess->cell_properties, row, column); opt = cget_cell_prop(propertiess->cell_properties, row, column);
@ -401,7 +401,7 @@ int get_cell_property_value_hierarcial(const fort_table_properties_t *properties
} }
static fort_status_t set_cell_property_impl(fort_cell_props_t *opt, uint32_t property, int value) static f_status set_cell_property_impl(f_cell_props_t *opt, uint32_t property, int value)
{ {
assert(opt); assert(opt);
@ -458,9 +458,9 @@ fort_fail:
FT_INTERNAL FT_INTERNAL
fort_status_t set_cell_property(fort_cell_prop_container_t *cont, size_t row, size_t col, uint32_t property, int value) f_status set_cell_property(f_cell_prop_container_t *cont, size_t row, size_t col, uint32_t property, int value)
{ {
fort_cell_props_t *opt = get_cell_prop_and_create_if_not_exists(cont, row, col); f_cell_props_t *opt = get_cell_prop_and_create_if_not_exists(cont, row, col);
if (opt == NULL) if (opt == NULL)
return FT_ERROR; return FT_ERROR;
@ -479,7 +479,7 @@ fort_status_t set_cell_property(fort_cell_prop_container_t *cont, size_t row, si
FT_INTERNAL FT_INTERNAL
fort_status_t set_default_cell_property(uint32_t property, int value) f_status set_default_cell_property(uint32_t property, int value)
{ {
return set_cell_property_impl(&g_default_cell_properties, property, value); return set_cell_property_impl(&g_default_cell_properties, property, value);
} }
@ -876,7 +876,7 @@ fort_entire_table_properties_t g_entire_table_properties = {
0, /* bottom_margin */ 0, /* bottom_margin */
}; };
static fort_status_t set_entire_table_property_internal(fort_entire_table_properties_t *properties, uint32_t property, int value) static f_status set_entire_table_property_internal(fort_entire_table_properties_t *properties, uint32_t property, int value)
{ {
assert(properties); assert(properties);
CHECK_NOT_NEGATIVE(value); CHECK_NOT_NEGATIVE(value);
@ -899,7 +899,7 @@ fort_fail:
FT_INTERNAL FT_INTERNAL
fort_status_t set_entire_table_property(fort_table_properties_t *table_properties, uint32_t property, int value) f_status set_entire_table_property(f_table_properties_t *table_properties, uint32_t property, int value)
{ {
assert(table_properties); assert(table_properties);
return set_entire_table_property_internal(&table_properties->entire_table_properties, property, value); return set_entire_table_property_internal(&table_properties->entire_table_properties, property, value);
@ -907,34 +907,34 @@ fort_status_t set_entire_table_property(fort_table_properties_t *table_propertie
FT_INTERNAL FT_INTERNAL
fort_status_t set_default_entire_table_property(uint32_t property, int value) f_status set_default_entire_table_property(uint32_t property, int value)
{ {
return set_entire_table_property_internal(&g_entire_table_properties, property, value); return set_entire_table_property_internal(&g_entire_table_properties, property, value);
} }
FT_INTERNAL FT_INTERNAL
size_t max_border_elem_strlen(struct fort_table_properties *properties) size_t max_border_elem_strlen(struct f_table_properties *properties)
{ {
assert(properties); assert(properties);
size_t result = 1; size_t result = 1;
int i = 0; int i = 0;
for (i = 0; i < BorderItemPosSize; ++i) { for (i = 0; i < BORDER_ITEM_POS_SIZE; ++i) {
result = MAX(result, strlen(properties->border_style.border_chars[i])); result = MAX(result, strlen(properties->border_style.border_chars[i]));
} }
for (i = 0; i < BorderItemPosSize; ++i) { for (i = 0; i < BORDER_ITEM_POS_SIZE; ++i) {
result = MAX(result, strlen(properties->border_style.header_border_chars[i])); result = MAX(result, strlen(properties->border_style.header_border_chars[i]));
} }
for (i = 0; i < SepratorItemPosSize; ++i) { for (i = 0; i < SEPARATOR_ITEM_POS_SIZE; ++i) {
result = MAX(result, strlen(properties->border_style.separator_chars[i])); result = MAX(result, strlen(properties->border_style.separator_chars[i]));
} }
return result; return result;
} }
fort_table_properties_t g_table_properties = { f_table_properties_t g_table_properties = {
/* border_style */ /* border_style */
BASIC_STYLE, BASIC_STYLE,
NULL, /* cell_properties */ NULL, /* cell_properties */
@ -949,13 +949,13 @@ fort_table_properties_t g_table_properties = {
FT_INTERNAL FT_INTERNAL
fort_table_properties_t *create_table_properties(void) f_table_properties_t *create_table_properties(void)
{ {
fort_table_properties_t *properties = (fort_table_properties_t *)F_CALLOC(sizeof(fort_table_properties_t), 1); f_table_properties_t *properties = (f_table_properties_t *)F_CALLOC(sizeof(f_table_properties_t), 1);
if (properties == NULL) { if (properties == NULL) {
return NULL; return NULL;
} }
memcpy(properties, &g_table_properties, sizeof(fort_table_properties_t)); memcpy(properties, &g_table_properties, sizeof(f_table_properties_t));
properties->cell_properties = create_cell_prop_container(); properties->cell_properties = create_cell_prop_container();
if (properties->cell_properties == NULL) { if (properties->cell_properties == NULL) {
destroy_table_properties(properties); destroy_table_properties(properties);
@ -966,7 +966,7 @@ fort_table_properties_t *create_table_properties(void)
} }
FT_INTERNAL FT_INTERNAL
void destroy_table_properties(fort_table_properties_t *properties) void destroy_table_properties(f_table_properties_t *properties)
{ {
if (properties == NULL) if (properties == NULL)
return; return;
@ -978,16 +978,16 @@ void destroy_table_properties(fort_table_properties_t *properties)
} }
static static
fort_cell_prop_container_t *copy_cell_properties(fort_cell_prop_container_t *cont) f_cell_prop_container_t *copy_cell_properties(f_cell_prop_container_t *cont)
{ {
fort_cell_prop_container_t *result = create_cell_prop_container(); f_cell_prop_container_t *result = create_cell_prop_container();
if (result == NULL) if (result == NULL)
return NULL; return NULL;
size_t i = 0; size_t i = 0;
size_t sz = vector_size(cont); size_t sz = vector_size(cont);
for (i = 0; i < sz; ++i) { for (i = 0; i < sz; ++i) {
fort_cell_props_t *opt = (fort_cell_props_t *)vector_at(cont, i); f_cell_props_t *opt = (f_cell_props_t *)vector_at(cont, i);
if (FT_IS_ERROR(vector_push(result, opt))) { if (FT_IS_ERROR(vector_push(result, opt))) {
destroy_cell_prop_container(result); destroy_cell_prop_container(result);
return NULL; return NULL;
@ -997,9 +997,9 @@ fort_cell_prop_container_t *copy_cell_properties(fort_cell_prop_container_t *con
} }
FT_INTERNAL FT_INTERNAL
fort_table_properties_t *copy_table_properties(const fort_table_properties_t *properties) f_table_properties_t *copy_table_properties(const f_table_properties_t *properties)
{ {
fort_table_properties_t *new_opt = create_table_properties(); f_table_properties_t *new_opt = create_table_properties();
if (new_opt == NULL) if (new_opt == NULL)
return NULL; return NULL;

74
src/properties.h
View File

@ -12,23 +12,23 @@
#define TEXT_STYLE_TAG_MAX_SIZE (64 * 2) #define TEXT_STYLE_TAG_MAX_SIZE (64 * 2)
FT_INTERNAL FT_INTERNAL
void get_style_tag_for_cell(const fort_table_properties_t *props, void get_style_tag_for_cell(const f_table_properties_t *props,
size_t row, size_t col, char *style_tag, size_t sz); size_t row, size_t col, char *style_tag, size_t sz);
FT_INTERNAL FT_INTERNAL
void get_reset_style_tag_for_cell(const fort_table_properties_t *props, void get_reset_style_tag_for_cell(const f_table_properties_t *props,
size_t row, size_t col, char *style_tag, size_t sz); size_t row, size_t col, char *style_tag, size_t sz);
FT_INTERNAL FT_INTERNAL
void get_style_tag_for_content(const fort_table_properties_t *props, void get_style_tag_for_content(const f_table_properties_t *props,
size_t row, size_t col, char *style_tag, size_t sz); size_t row, size_t col, char *style_tag, size_t sz);
FT_INTERNAL FT_INTERNAL
void get_reset_style_tag_for_content(const fort_table_properties_t *props, void get_reset_style_tag_for_content(const f_table_properties_t *props,
size_t row, size_t col, char *style_tag, size_t sz); size_t row, size_t col, char *style_tag, size_t sz);
struct fort_cell_props { struct f_cell_props {
size_t cell_row; size_t cell_row;
size_t cell_col; size_t cell_col;
uint32_t properties_flags; uint32_t properties_flags;
@ -48,29 +48,29 @@ struct fort_cell_props {
enum ft_text_style content_text_style; enum ft_text_style content_text_style;
}; };
typedef struct fort_cell_props fort_cell_props_t; typedef struct f_cell_props f_cell_props_t;
typedef vector_t fort_cell_prop_container_t; typedef f_vector_t f_cell_prop_container_t;
FT_INTERNAL FT_INTERNAL
fort_cell_prop_container_t *create_cell_prop_container(void); f_cell_prop_container_t *create_cell_prop_container(void);
FT_INTERNAL FT_INTERNAL
void destroy_cell_prop_container(fort_cell_prop_container_t *cont); void destroy_cell_prop_container(f_cell_prop_container_t *cont);
FT_INTERNAL FT_INTERNAL
const fort_cell_props_t *cget_cell_prop(const fort_cell_prop_container_t *cont, size_t row, size_t col); const f_cell_props_t *cget_cell_prop(const f_cell_prop_container_t *cont, size_t row, size_t col);
FT_INTERNAL FT_INTERNAL
fort_cell_props_t *get_cell_prop_and_create_if_not_exists(fort_cell_prop_container_t *cont, size_t row, size_t col); f_cell_props_t *get_cell_prop_and_create_if_not_exists(f_cell_prop_container_t *cont, size_t row, size_t col);
FT_INTERNAL FT_INTERNAL
fort_status_t set_cell_property(fort_cell_prop_container_t *cont, size_t row, size_t col, uint32_t property, int value); f_status set_cell_property(f_cell_prop_container_t *cont, size_t row, size_t col, uint32_t property, int value);
FT_INTERNAL FT_INTERNAL
int get_cell_property_value_hierarcial(const fort_table_properties_t *properties, size_t row, size_t column, uint32_t property); int get_cell_property_hierarchically(const f_table_properties_t *properties, size_t row, size_t column, uint32_t property);
FT_INTERNAL FT_INTERNAL
fort_status_t set_default_cell_property(uint32_t property, int value); f_status set_default_cell_property(uint32_t property, int value);
/* TABLE BORDER DESСRIPTION /* TABLE BORDER DESСRIPTION
@ -95,20 +95,20 @@ fort_status_t set_default_cell_property(uint32_t property, int value);
/* HORIZONTAL SEPARATOR DESCRIPTION /* HORIZONTAL SEPARATOR DESCRIPTION
* *
* *
* TL TT TT TT TV TT TT TT TV TT TT TT TR <----- TopSeparator * TL TT TT TT TV TT TT TT TV TT TT TT TR <----- TOP_SEPARATOR
* LL IV IV RR * LL IV IV RR
* LH IH IH IH II IH IH IH II IH IH IH RH <----- InsideSeparator * LH IH IH IH II IH IH IH II IH IH IH RH <----- INSIDE_SEPARATOR
* LL IV IV RR * LL IV IV RR
* BL BB BB BB BV BB BB BB BV BB BB BB BR <----- BottomSeparator * BL BB BB BB BV BB BB BB BV BB BB BB BR <----- BOTTOM_SEPARATOR
*/ */
enum HorSeparatorPos { enum f_hor_separator_pos {
TopSeparator, TOP_SEPARATOR,
InsideSeparator, INSIDE_SEPARATOR,
BottomSeparator BOTTOM_SEPARATOR
}; };
enum BorderItemPos { enum f_border_item_pos {
TL_bip = 0, TL_bip = 0,
TT_bip = 1, TT_bip = 1,
TV_bip = 2, TV_bip = 2,
@ -133,11 +133,11 @@ enum BorderItemPos {
RI_bip = 17, RI_bip = 17,
BI_bip = 18, BI_bip = 18,
BorderItemPosSize BORDER_ITEM_POS_SIZE
}; };
enum SeparatorItemPos { enum f_separator_item_pos {
LH_sip = 0, LH_sip = 0,
IH_sip = 1, IH_sip = 1,
II_sip = 2, II_sip = 2,
@ -146,14 +146,14 @@ enum SeparatorItemPos {
TI_sip = 4, TI_sip = 4,
BI_sip = 5, BI_sip = 5,
SepratorItemPosSize SEPARATOR_ITEM_POS_SIZE
}; };
struct fort_border_style { struct fort_border_style {
const char *border_chars[BorderItemPosSize]; const char *border_chars[BORDER_ITEM_POS_SIZE];
const char *header_border_chars[BorderItemPosSize]; const char *header_border_chars[BORDER_ITEM_POS_SIZE];
const char *separator_chars[SepratorItemPosSize]; const char *separator_chars[SEPARATOR_ITEM_POS_SIZE];
}; };
extern struct fort_border_style FORT_BASIC_STYLE; extern struct fort_border_style FORT_BASIC_STYLE;
extern struct fort_border_style FORT_BASIC2_STYLE; extern struct fort_border_style FORT_BASIC2_STYLE;
@ -182,28 +182,28 @@ typedef struct fort_entire_table_properties fort_entire_table_properties_t;
extern fort_entire_table_properties_t g_entire_table_properties; extern fort_entire_table_properties_t g_entire_table_properties;
FT_INTERNAL FT_INTERNAL
fort_status_t set_entire_table_property(fort_table_properties_t *table_properties, uint32_t property, int value); f_status set_entire_table_property(f_table_properties_t *table_properties, uint32_t property, int value);
FT_INTERNAL FT_INTERNAL
fort_status_t set_default_entire_table_property(uint32_t property, int value); f_status set_default_entire_table_property(uint32_t property, int value);
struct fort_table_properties { struct f_table_properties {
struct fort_border_style border_style; struct fort_border_style border_style;
fort_cell_prop_container_t *cell_properties; f_cell_prop_container_t *cell_properties;
fort_entire_table_properties_t entire_table_properties; fort_entire_table_properties_t entire_table_properties;
}; };
extern fort_table_properties_t g_table_properties; extern f_table_properties_t g_table_properties;
FT_INTERNAL FT_INTERNAL
size_t max_border_elem_strlen(struct fort_table_properties *); size_t max_border_elem_strlen(struct f_table_properties *);
FT_INTERNAL FT_INTERNAL
fort_table_properties_t *create_table_properties(void); f_table_properties_t *create_table_properties(void);
FT_INTERNAL FT_INTERNAL
void destroy_table_properties(fort_table_properties_t *properties); void destroy_table_properties(f_table_properties_t *properties);
FT_INTERNAL FT_INTERNAL
fort_table_properties_t *copy_table_properties(const fort_table_properties_t *property); f_table_properties_t *copy_table_properties(const f_table_properties_t *property);
#endif /* PROPERTIES_H */ #endif /* PROPERTIES_H */

180
src/row.c
View File

@ -6,18 +6,18 @@
#include "vector.h" #include "vector.h"
struct fort_row { struct f_row {
vector_t *cells; f_vector_t *cells;
}; };
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row(void) f_row_t *create_row(void)
{ {
fort_row_t *row = (fort_row_t *)F_CALLOC(1, sizeof(fort_row_t)); f_row_t *row = (f_row_t *)F_CALLOC(1, sizeof(f_row_t));
if (row == NULL) if (row == NULL)
return NULL; return NULL;
row->cells = create_vector(sizeof(fort_cell_t *), DEFAULT_VECTOR_CAPACITY); row->cells = create_vector(sizeof(f_cell_t *), DEFAULT_VECTOR_CAPACITY);
if (row->cells == NULL) { if (row->cells == NULL) {
F_FREE(row); F_FREE(row);
return NULL; return NULL;
@ -26,7 +26,7 @@ fort_row_t *create_row(void)
} }
FT_INTERNAL FT_INTERNAL
void destroy_row(fort_row_t *row) void destroy_row(f_row_t *row)
{ {
if (row == NULL) if (row == NULL)
return; return;
@ -35,7 +35,7 @@ void destroy_row(fort_row_t *row)
size_t i = 0; size_t i = 0;
size_t cells_n = vector_size(row->cells); size_t cells_n = vector_size(row->cells);
for (i = 0; i < cells_n; ++i) { for (i = 0; i < cells_n; ++i) {
fort_cell_t *cell = *(fort_cell_t **)vector_at(row->cells, i); f_cell_t *cell = *(f_cell_t **)vector_at(row->cells, i);
destroy_cell(cell); destroy_cell(cell);
} }
destroy_vector(row->cells); destroy_vector(row->cells);
@ -45,18 +45,18 @@ void destroy_row(fort_row_t *row)
} }
FT_INTERNAL FT_INTERNAL
fort_row_t *copy_row(fort_row_t *row) f_row_t *copy_row(f_row_t *row)
{ {
assert(row); assert(row);
fort_row_t *result = create_row(); f_row_t *result = create_row();
if (result == NULL) if (result == NULL)
return NULL; return NULL;
size_t i = 0; size_t i = 0;
size_t cols_n = vector_size(row->cells); size_t cols_n = vector_size(row->cells);
for (i = 0; i < cols_n; ++i) { for (i = 0; i < cols_n; ++i) {
fort_cell_t *cell = *(fort_cell_t **)vector_at(row->cells, i); f_cell_t *cell = *(f_cell_t **)vector_at(row->cells, i);
fort_cell_t *new_cell = copy_cell(cell); f_cell_t *new_cell = copy_cell(cell);
if (new_cell == NULL) { if (new_cell == NULL) {
destroy_row(result); destroy_row(result);
return NULL; return NULL;
@ -68,7 +68,7 @@ fort_row_t *copy_row(fort_row_t *row)
} }
FT_INTERNAL FT_INTERNAL
size_t columns_in_row(const fort_row_t *row) size_t columns_in_row(const f_row_t *row)
{ {
if (row == NULL || row->cells == NULL) if (row == NULL || row->cells == NULL)
return 0; return 0;
@ -78,7 +78,7 @@ size_t columns_in_row(const fort_row_t *row)
static static
fort_cell_t *get_cell_impl(fort_row_t *row, size_t col, enum get_policy policy) f_cell_t *get_cell_impl(f_row_t *row, size_t col, enum f_get_policy policy)
{ {
if (row == NULL || row->cells == NULL) { if (row == NULL || row->cells == NULL) {
return NULL; return NULL;
@ -87,12 +87,12 @@ fort_cell_t *get_cell_impl(fort_row_t *row, size_t col, enum get_policy policy)
switch (policy) { switch (policy) {
case DONT_CREATE_ON_NULL: case DONT_CREATE_ON_NULL:
if (col < columns_in_row(row)) { if (col < columns_in_row(row)) {
return *(fort_cell_t **)vector_at(row->cells, col); return *(f_cell_t **)vector_at(row->cells, col);
} }
return NULL; return NULL;
case CREATE_ON_NULL: case CREATE_ON_NULL:
while (col >= columns_in_row(row)) { while (col >= columns_in_row(row)) {
fort_cell_t *new_cell = create_cell(); f_cell_t *new_cell = create_cell();
if (new_cell == NULL) if (new_cell == NULL)
return NULL; return NULL;
if (FT_IS_ERROR(vector_push(row->cells, &new_cell))) { if (FT_IS_ERROR(vector_push(row->cells, &new_cell))) {
@ -100,7 +100,7 @@ fort_cell_t *get_cell_impl(fort_row_t *row, size_t col, enum get_policy policy)
return NULL; return NULL;
} }
} }
return *(fort_cell_t **)vector_at(row->cells, col); return *(f_cell_t **)vector_at(row->cells, col);
} }
assert(0 && "Shouldn't be here!"); assert(0 && "Shouldn't be here!");
@ -109,37 +109,37 @@ fort_cell_t *get_cell_impl(fort_row_t *row, size_t col, enum get_policy policy)
FT_INTERNAL FT_INTERNAL
fort_cell_t *get_cell(fort_row_t *row, size_t col) f_cell_t *get_cell(f_row_t *row, size_t col)
{ {
return get_cell_impl(row, col, DONT_CREATE_ON_NULL); return get_cell_impl(row, col, DONT_CREATE_ON_NULL);
} }
FT_INTERNAL FT_INTERNAL
const fort_cell_t *get_cell_c(const fort_row_t *row, size_t col) const f_cell_t *get_cell_c(const f_row_t *row, size_t col)
{ {
return get_cell((fort_row_t *)row, col); return get_cell((f_row_t *)row, col);
} }
FT_INTERNAL FT_INTERNAL
fort_cell_t *get_cell_and_create_if_not_exists(fort_row_t *row, size_t col) f_cell_t *get_cell_and_create_if_not_exists(f_row_t *row, size_t col)
{ {
return get_cell_impl(row, col, CREATE_ON_NULL); return get_cell_impl(row, col, CREATE_ON_NULL);
} }
FT_INTERNAL FT_INTERNAL
fort_status_t swap_row(fort_row_t *cur_row, fort_row_t *ins_row, size_t pos) f_status swap_row(f_row_t *cur_row, f_row_t *ins_row, size_t pos)
{ {
assert(cur_row); assert(cur_row);
assert(ins_row); assert(ins_row);
size_t cur_sz = vector_size(cur_row->cells); size_t cur_sz = vector_size(cur_row->cells);
if (cur_sz == 0 && pos == 0) { if (cur_sz == 0 && pos == 0) {
fort_row_t tmp; f_row_t tmp;
memcpy(&tmp, cur_row, sizeof(fort_row_t)); memcpy(&tmp, cur_row, sizeof(f_row_t));
memcpy(cur_row, ins_row, sizeof(fort_row_t)); memcpy(cur_row, ins_row, sizeof(f_row_t));
memcpy(ins_row, &tmp, sizeof(fort_row_t)); memcpy(ins_row, &tmp, sizeof(f_row_t));
return FT_SUCCESS; return FT_SUCCESS;
} }
@ -148,21 +148,21 @@ fort_status_t swap_row(fort_row_t *cur_row, fort_row_t *ins_row, size_t pos)
FT_INTERNAL FT_INTERNAL
size_t group_cell_number(const fort_row_t *row, size_t master_cell_col) size_t group_cell_number(const f_row_t *row, size_t master_cell_col)
{ {
assert(row); assert(row);
const fort_cell_t *master_cell = get_cell_c(row, master_cell_col); const f_cell_t *master_cell = get_cell_c(row, master_cell_col);
if (master_cell == NULL) if (master_cell == NULL)
return 0; return 0;
if (get_cell_type(master_cell) != GroupMasterCell) if (get_cell_type(master_cell) != GROUP_MASTER_CELL)
return 1; return 1;
size_t total_cols = vector_size(row->cells); size_t total_cols = vector_size(row->cells);
size_t slave_col = master_cell_col + 1; size_t slave_col = master_cell_col + 1;
while (slave_col < total_cols) { while (slave_col < total_cols) {
const fort_cell_t *cell = get_cell_c(row, slave_col); const f_cell_t *cell = get_cell_c(row, slave_col);
if (cell && get_cell_type(cell) == GroupSlaveCell) { if (cell && get_cell_type(cell) == GROUP_SLAVE_CELL) {
++slave_col; ++slave_col;
} else { } else {
break; break;
@ -173,17 +173,17 @@ size_t group_cell_number(const fort_row_t *row, size_t master_cell_col)
FT_INTERNAL FT_INTERNAL
int get_row_cell_types(const fort_row_t *row, enum CellType *types, size_t types_sz) int get_row_cell_types(const f_row_t *row, enum f_cell_type *types, size_t types_sz)
{ {
assert(row); assert(row);
assert(types); assert(types);
size_t i = 0; size_t i = 0;
for (i = 0; i < types_sz; ++i) { for (i = 0; i < types_sz; ++i) {
const fort_cell_t *cell = get_cell_c(row, i); const f_cell_t *cell = get_cell_c(row, i);
if (cell) { if (cell) {
types[i] = get_cell_type(cell); types[i] = get_cell_type(cell);
} else { } else {
types[i] = CommonCell; types[i] = COMMON_CELL;
} }
} }
return FT_SUCCESS; return FT_SUCCESS;
@ -191,27 +191,27 @@ int get_row_cell_types(const fort_row_t *row, enum CellType *types, size_t types
FT_INTERNAL FT_INTERNAL
fort_status_t row_set_cell_span(fort_row_t *row, size_t cell_column, size_t hor_span) f_status row_set_cell_span(f_row_t *row, size_t cell_column, size_t hor_span)
{ {
assert(row); assert(row);
if (hor_span < 2) if (hor_span < 2)
return FT_EINVAL; return FT_EINVAL;
fort_cell_t *main_cell = get_cell_and_create_if_not_exists(row, cell_column); f_cell_t *main_cell = get_cell_and_create_if_not_exists(row, cell_column);
if (main_cell == NULL) { if (main_cell == NULL) {
return FT_ERROR; return FT_ERROR;
} }
set_cell_type(main_cell, GroupMasterCell); set_cell_type(main_cell, GROUP_MASTER_CELL);
--hor_span; --hor_span;
++cell_column; ++cell_column;
while (hor_span) { while (hor_span) {
fort_cell_t *slave_cell = get_cell_and_create_if_not_exists(row, cell_column); f_cell_t *slave_cell = get_cell_and_create_if_not_exists(row, cell_column);
if (slave_cell == NULL) { if (slave_cell == NULL) {
return FT_ERROR; return FT_ERROR;
} }
set_cell_type(slave_cell, GroupSlaveCell); set_cell_type(slave_cell, GROUP_SLAVE_CELL);
--hor_span; --hor_span;
++cell_column; ++cell_column;
} }
@ -220,45 +220,45 @@ fort_status_t row_set_cell_span(fort_row_t *row, size_t cell_column, size_t hor_
} }
static static
int print_row_separator_impl(conv_context_t *cntx, int print_row_separator_impl(f_conv_context_t *cntx,
const size_t *col_width_arr, size_t cols, const size_t *col_width_arr, size_t cols,
const fort_row_t *upper_row, const fort_row_t *lower_row, const f_row_t *upper_row, const f_row_t *lower_row,
enum HorSeparatorPos separatorPos, enum f_hor_separator_pos separatorPos,
const separator_t *sep) const f_separator_t *sep)
{ {
assert(cntx); assert(cntx);
int status = FT_ERROR; int status = FT_ERROR;
const context_t *context = cntx->cntx; const f_context_t *context = cntx->cntx;
/* Get cell types /* Get cell types
* *
* Regions above top row and below bottom row areconsidered full of virtual * Regions above top row and below bottom row areconsidered full of virtual
* GroupSlaveCell cells * GROUP_SLAVE_CELL cells
*/ */
enum CellType *top_row_types = (enum CellType *)F_MALLOC(sizeof(enum CellType) * cols * 2); enum f_cell_type *top_row_types = (enum f_cell_type *)F_MALLOC(sizeof(enum f_cell_type) * cols * 2);
if (top_row_types == NULL) { if (top_row_types == NULL) {
return FT_MEMORY_ERROR; return FT_MEMORY_ERROR;
} }
enum CellType *bottom_row_types = top_row_types + cols; enum f_cell_type *bottom_row_types = top_row_types + cols;
if (upper_row) { if (upper_row) {
get_row_cell_types(upper_row, top_row_types, cols); get_row_cell_types(upper_row, top_row_types, cols);
} else { } else {
size_t i = 0; size_t i = 0;
for (i = 0; i < cols; ++i) for (i = 0; i < cols; ++i)
top_row_types[i] = GroupSlaveCell; top_row_types[i] = GROUP_SLAVE_CELL;
} }
if (lower_row) { if (lower_row) {
get_row_cell_types(lower_row, bottom_row_types, cols); get_row_cell_types(lower_row, bottom_row_types, cols);
} else { } else {
size_t i = 0; size_t i = 0;
for (i = 0; i < cols; ++i) for (i = 0; i < cols; ++i)
bottom_row_types[i] = GroupSlaveCell; bottom_row_types[i] = GROUP_SLAVE_CELL;
} }
fort_table_properties_t *properties = context->table_properties; f_table_properties_t *properties = context->table_properties;
fort_entire_table_properties_t *entire_tprops = &properties->entire_table_properties; fort_entire_table_properties_t *entire_tprops = &properties->entire_table_properties;
size_t written = 0; size_t written = 0;
@ -266,11 +266,11 @@ int print_row_separator_impl(conv_context_t *cntx,
enum ft_row_type lower_row_type = FT_ROW_COMMON; enum ft_row_type lower_row_type = FT_ROW_COMMON;
if (lower_row != NULL) { if (lower_row != NULL) {
lower_row_type = (enum ft_row_type)get_cell_property_value_hierarcial(properties, context->row, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE); lower_row_type = (enum ft_row_type)get_cell_property_hierarchically(properties, context->row, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE);
} }
enum ft_row_type upper_row_type = FT_ROW_COMMON; enum ft_row_type upper_row_type = FT_ROW_COMMON;
if (upper_row != NULL) { if (upper_row != NULL) {
upper_row_type = (enum ft_row_type)get_cell_property_value_hierarcial(properties, context->row - 1, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE); upper_row_type = (enum ft_row_type)get_cell_property_hierarchically(properties, context->row - 1, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE);
} }
/* Row separator anatomy /* Row separator anatomy
@ -289,8 +289,8 @@ int print_row_separator_impl(conv_context_t *cntx,
struct fort_border_style *border_style = &properties->border_style; struct fort_border_style *border_style = &properties->border_style;
typedef const char *(*border_chars_point_t)[BorderItemPosSize]; typedef const char *(*border_chars_point_t)[BORDER_ITEM_POS_SIZE];
const char *(*border_chars)[BorderItemPosSize] = NULL; const char *(*border_chars)[BORDER_ITEM_POS_SIZE] = NULL;
border_chars = (border_chars_point_t)&border_style->border_chars; border_chars = (border_chars_point_t)&border_style->border_chars;
if (upper_row_type == FT_ROW_HEADER || lower_row_type == FT_ROW_HEADER) { if (upper_row_type == FT_ROW_HEADER || lower_row_type == FT_ROW_HEADER) {
border_chars = (border_chars_point_t)&border_style->header_border_chars; border_chars = (border_chars_point_t)&border_style->header_border_chars;
@ -315,7 +315,7 @@ int print_row_separator_impl(conv_context_t *cntx,
} }
} else { } else {
switch (separatorPos) { switch (separatorPos) {
case TopSeparator: case TOP_SEPARATOR:
L = &(*border_chars)[TL_bip]; L = &(*border_chars)[TL_bip];
I = &(*border_chars)[TT_bip]; I = &(*border_chars)[TT_bip];
IV = &(*border_chars)[TV_bip]; IV = &(*border_chars)[TV_bip];
@ -325,7 +325,7 @@ int print_row_separator_impl(conv_context_t *cntx,
IB = &(*border_chars)[TV_bip]; IB = &(*border_chars)[TV_bip];
II = &(*border_chars)[TT_bip]; II = &(*border_chars)[TT_bip];
break; break;
case InsideSeparator: case INSIDE_SEPARATOR:
L = &(*border_chars)[LH_bip]; L = &(*border_chars)[LH_bip];
I = &(*border_chars)[IH_bip]; I = &(*border_chars)[IH_bip];
IV = &(*border_chars)[II_bip]; IV = &(*border_chars)[II_bip];
@ -335,7 +335,7 @@ int print_row_separator_impl(conv_context_t *cntx,
IB = &(*border_chars)[BI_bip]; IB = &(*border_chars)[BI_bip];
II = &(*border_chars)[IH_bip]; II = &(*border_chars)[IH_bip];
break; break;
case BottomSeparator: case BOTTOM_SEPARATOR:
L = &(*border_chars)[BL_bip]; L = &(*border_chars)[BL_bip];
I = &(*border_chars)[BB_bip]; I = &(*border_chars)[BB_bip];
IV = &(*border_chars)[BV_bip]; IV = &(*border_chars)[BV_bip];
@ -368,12 +368,12 @@ int print_row_separator_impl(conv_context_t *cntx,
if (i == 0) { if (i == 0) {
CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *L)); CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *L));
} else { } else {
if ((top_row_types[i] == CommonCell || top_row_types[i] == GroupMasterCell) if ((top_row_types[i] == COMMON_CELL || top_row_types[i] == GROUP_MASTER_CELL)
&& (bottom_row_types[i] == CommonCell || bottom_row_types[i] == GroupMasterCell)) { && (bottom_row_types[i] == COMMON_CELL || bottom_row_types[i] == GROUP_MASTER_CELL)) {
CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *IV)); CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *IV));
} else if (top_row_types[i] == GroupSlaveCell && bottom_row_types[i] == GroupSlaveCell) { } else if (top_row_types[i] == GROUP_SLAVE_CELL && bottom_row_types[i] == GROUP_SLAVE_CELL) {
CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *II)); CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *II));
} else if (top_row_types[i] == GroupSlaveCell) { } else if (top_row_types[i] == GROUP_SLAVE_CELL) {
CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *IT)); CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *IT));
} else { } else {
CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *IB)); CHCK_RSLT_ADD_TO_WRITTEN(print_n_strings(cntx, 1, *IB));
@ -396,22 +396,22 @@ clear:
} }
FT_INTERNAL FT_INTERNAL
int print_row_separator(conv_context_t *cntx, int print_row_separator(f_conv_context_t *cntx,
const size_t *col_width_arr, size_t cols, const size_t *col_width_arr, size_t cols,
const fort_row_t *upper_row, const fort_row_t *lower_row, const f_row_t *upper_row, const f_row_t *lower_row,
enum HorSeparatorPos separatorPos, const separator_t *sep) enum f_hor_separator_pos separatorPos, const f_separator_t *sep)
{ {
return print_row_separator_impl(cntx, col_width_arr, cols, upper_row, lower_row, return print_row_separator_impl(cntx, col_width_arr, cols, upper_row, lower_row,
separatorPos, sep); separatorPos, sep);
} }
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_string(const char *str) f_row_t *create_row_from_string(const char *str)
{ {
typedef char char_type; typedef char char_type;
char_type *(*strdup_)(const char_type * str) = F_STRDUP; char_type *(*strdup_)(const char_type * str) = F_STRDUP;
const char_type zero_char = '\0'; const char_type zero_char = '\0';
fort_status_t (*fill_cell_from_string_)(fort_cell_t *cell, const char *str) = fill_cell_from_string; f_status(*fill_cell_from_string_)(f_cell_t *cell, const char *str) = fill_cell_from_string;
const char_type *const zero_string = ""; const char_type *const zero_string = "";
#define STRCHR strchr #define STRCHR strchr
@ -419,7 +419,7 @@ fort_row_t *create_row_from_string(const char *str)
char_type *base_pos = NULL; char_type *base_pos = NULL;
size_t number_of_separators = 0; size_t number_of_separators = 0;
fort_row_t *row = create_row(); f_row_t *row = create_row();
if (row == NULL) if (row == NULL)
return NULL; return NULL;
@ -441,7 +441,7 @@ fort_row_t *create_row_from_string(const char *str)
number_of_separators++; number_of_separators++;
} }
fort_cell_t *cell = create_cell(); f_cell_t *cell = create_cell();
if (cell == NULL) if (cell == NULL)
goto clear; goto clear;
@ -464,7 +464,7 @@ fort_row_t *create_row_from_string(const char *str)
/* special case if in format string last cell is empty */ /* special case if in format string last cell is empty */
while (vector_size(row->cells) < (number_of_separators + 1)) { while (vector_size(row->cells) < (number_of_separators + 1)) {
fort_cell_t *cell = create_cell(); f_cell_t *cell = create_cell();
if (cell == NULL) if (cell == NULL)
goto clear; goto clear;
@ -495,12 +495,12 @@ clear:
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_wstring(const wchar_t *str) f_row_t *create_row_from_wstring(const wchar_t *str)
{ {
typedef wchar_t char_type; typedef wchar_t char_type;
char_type *(*strdup_)(const char_type * str) = F_WCSDUP; char_type *(*strdup_)(const char_type * str) = F_WCSDUP;
const char_type zero_char = L'\0'; const char_type zero_char = L'\0';
fort_status_t (*fill_cell_from_string_)(fort_cell_t *cell, const wchar_t *str) = fill_cell_from_wstring; f_status(*fill_cell_from_string_)(f_cell_t *cell, const wchar_t *str) = fill_cell_from_wstring;
const char_type *const zero_string = L""; const char_type *const zero_string = L"";
#define STRCHR wcschr #define STRCHR wcschr
@ -508,7 +508,7 @@ fort_row_t *create_row_from_wstring(const wchar_t *str)
char_type *base_pos = NULL; char_type *base_pos = NULL;
size_t number_of_separators = 0; size_t number_of_separators = 0;
fort_row_t *row = create_row(); f_row_t *row = create_row();
if (row == NULL) if (row == NULL)
return NULL; return NULL;
@ -530,7 +530,7 @@ fort_row_t *create_row_from_wstring(const wchar_t *str)
number_of_separators++; number_of_separators++;
} }
fort_cell_t *cell = create_cell(); f_cell_t *cell = create_cell();
if (cell == NULL) if (cell == NULL)
goto clear; goto clear;
@ -553,7 +553,7 @@ fort_row_t *create_row_from_wstring(const wchar_t *str)
/* special case if in format string last cell is empty */ /* special case if in format string last cell is empty */
while (vector_size(row->cells) < (number_of_separators + 1)) { while (vector_size(row->cells) < (number_of_separators + 1)) {
fort_cell_t *cell = create_cell(); f_cell_t *cell = create_cell();
if (cell == NULL) if (cell == NULL)
goto clear; goto clear;
@ -582,7 +582,7 @@ clear:
#endif #endif
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_buffer(const string_buffer_t *buffer) f_row_t *create_row_from_buffer(const f_string_buffer_t *buffer)
{ {
switch (buffer->type) { switch (buffer->type) {
case CHAR_BUF: case CHAR_BUF:
@ -602,7 +602,7 @@ fort_row_t *create_row_from_buffer(const string_buffer_t *buffer)
} }
static int static int
vsnprintf_buffer(string_buffer_t *buffer, const struct ft_string *fmt, vsnprintf_buffer(f_string_buffer_t *buffer, const struct f_string_view *fmt,
va_list *va) va_list *va)
{ {
/* Disable compiler diagnostic (format string is not a string literal) */ /* Disable compiler diagnostic (format string is not a string literal) */
@ -639,13 +639,13 @@ vsnprintf_buffer(string_buffer_t *buffer, const struct ft_string *fmt,
} }
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_fmt_string(const struct ft_string *fmt, va_list *va_args) f_row_t *create_row_from_fmt_string(const struct f_string_view *fmt, va_list *va_args)
{ {
string_buffer_t *buffer = create_string_buffer(DEFAULT_STR_BUF_SIZE, fmt->type); f_string_buffer_t *buffer = create_string_buffer(DEFAULT_STR_BUF_SIZE, fmt->type);
if (buffer == NULL) if (buffer == NULL)
return NULL; return NULL;
size_t cols_origin = number_of_columns_in_format_string2(fmt); size_t cols_origin = number_of_columns_in_format_string(fmt);
size_t cols = 0; size_t cols = 0;
while (1) { while (1) {
@ -668,7 +668,7 @@ fort_row_t *create_row_from_fmt_string(const struct ft_string *fmt, va_list *va
cols = number_of_columns_in_format_buffer(buffer); cols = number_of_columns_in_format_buffer(buffer);
if (cols == cols_origin) { if (cols == cols_origin) {
fort_row_t *row = create_row_from_buffer(buffer); f_row_t *row = create_row_from_buffer(buffer);
if (row == NULL) { if (row == NULL) {
goto clear; goto clear;
} }
@ -678,18 +678,18 @@ fort_row_t *create_row_from_fmt_string(const struct ft_string *fmt, va_list *va
} }
if (cols_origin == 1) { if (cols_origin == 1) {
fort_row_t *row = create_row(); f_row_t *row = create_row();
if (row == NULL) { if (row == NULL) {
goto clear; goto clear;
} }
fort_cell_t *cell = get_cell_and_create_if_not_exists(row, 0); f_cell_t *cell = get_cell_and_create_if_not_exists(row, 0);
if (cell == NULL) { if (cell == NULL) {
destroy_row(row); destroy_row(row);
goto clear; goto clear;
} }
fort_status_t result = fill_cell_from_buffer(cell, buffer); f_status result = fill_cell_from_buffer(cell, buffer);
if (FT_IS_ERROR(result)) { if (FT_IS_ERROR(result)) {
destroy_row(row); destroy_row(row);
goto clear; goto clear;
@ -711,10 +711,10 @@ clear:
FT_INTERNAL FT_INTERNAL
int snprintf_row(const fort_row_t *row, conv_context_t *cntx, size_t *col_width_arr, size_t col_width_arr_sz, int snprintf_row(const f_row_t *row, f_conv_context_t *cntx, size_t *col_width_arr, size_t col_width_arr_sz,
size_t row_height) size_t row_height)
{ {
const context_t *context = cntx->cntx; const f_context_t *context = cntx->cntx;
assert(context); assert(context);
if (row == NULL) if (row == NULL)
@ -728,11 +728,11 @@ int snprintf_row(const fort_row_t *row, conv_context_t *cntx, size_t *col_width_
* *
* L data IV data IV data R * L data IV data IV data R
*/ */
fort_table_properties_t *properties = context->table_properties; f_table_properties_t *properties = context->table_properties;
typedef const char *(*border_chars_point_t)[BorderItemPosSize]; typedef const char *(*border_chars_point_t)[BORDER_ITEM_POS_SIZE];
enum ft_row_type row_type = (enum ft_row_type)get_cell_property_value_hierarcial(properties, context->row, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE); enum ft_row_type row_type = (enum ft_row_type)get_cell_property_hierarchically(properties, context->row, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE);
const char *(*bord_chars)[BorderItemPosSize] = (row_type == FT_ROW_HEADER) const char *(*bord_chars)[BORDER_ITEM_POS_SIZE] = (row_type == FT_ROW_HEADER)
? (border_chars_point_t)(&properties->border_style.header_border_chars) ? (border_chars_point_t)(&properties->border_style.header_border_chars)
: (border_chars_point_t)(&properties->border_style.border_chars); : (border_chars_point_t)(&properties->border_style.border_chars);
const char **L = &(*bord_chars)[LL_bip]; const char **L = &(*bord_chars)[LL_bip];
@ -753,8 +753,8 @@ int snprintf_row(const fort_row_t *row, conv_context_t *cntx, size_t *col_width_
size_t j = 0; size_t j = 0;
while (j < col_width_arr_sz) { while (j < col_width_arr_sz) {
if (j < cols_in_row) { if (j < cols_in_row) {
((context_t *)context)->column = j; ((f_context_t *)context)->column = j;
fort_cell_t *cell = *(fort_cell_t **)vector_at(row->cells, j); f_cell_t *cell = *(f_cell_t **)vector_at(row->cells, j);
size_t cell_vis_width = 0; size_t cell_vis_width = 0;
size_t group_slave_sz = group_cell_number(row, j); size_t group_slave_sz = group_cell_number(row, j);

36
src/row.h
View File

@ -10,57 +10,57 @@
#endif #endif
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row(void); f_row_t *create_row(void);
FT_INTERNAL FT_INTERNAL
void destroy_row(fort_row_t *row); void destroy_row(f_row_t *row);
FT_INTERNAL FT_INTERNAL
fort_row_t *copy_row(fort_row_t *row); f_row_t *copy_row(f_row_t *row);
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_string(const char *str); f_row_t *create_row_from_string(const char *str);
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_fmt_string(const struct ft_string *fmt, va_list *va_args); f_row_t *create_row_from_fmt_string(const struct f_string_view *fmt, va_list *va_args);
FT_INTERNAL FT_INTERNAL
size_t columns_in_row(const fort_row_t *row); size_t columns_in_row(const f_row_t *row);
FT_INTERNAL FT_INTERNAL
fort_cell_t *get_cell(fort_row_t *row, size_t col); f_cell_t *get_cell(f_row_t *row, size_t col);
FT_INTERNAL FT_INTERNAL
const fort_cell_t *get_cell_c(const fort_row_t *row, size_t col); const f_cell_t *get_cell_c(const f_row_t *row, size_t col);
FT_INTERNAL FT_INTERNAL
fort_cell_t *get_cell_and_create_if_not_exists(fort_row_t *row, size_t col); f_cell_t *get_cell_and_create_if_not_exists(f_row_t *row, size_t col);
FT_INTERNAL FT_INTERNAL
fort_status_t swap_row(fort_row_t *cur_row, fort_row_t *ins_row, size_t pos); f_status swap_row(f_row_t *cur_row, f_row_t *ins_row, size_t pos);
FT_INTERNAL FT_INTERNAL
size_t group_cell_number(const fort_row_t *row, size_t master_cell_col); size_t group_cell_number(const f_row_t *row, size_t master_cell_col);
FT_INTERNAL FT_INTERNAL
int get_row_cell_types(const fort_row_t *row, enum CellType *types, size_t types_sz); int get_row_cell_types(const f_row_t *row, enum f_cell_type *types, size_t types_sz);
FT_INTERNAL FT_INTERNAL
fort_status_t row_set_cell_span(fort_row_t *row, size_t cell_column, size_t hor_span); f_status row_set_cell_span(f_row_t *row, size_t cell_column, size_t hor_span);
FT_INTERNAL FT_INTERNAL
int print_row_separator(conv_context_t *cntx, int print_row_separator(f_conv_context_t *cntx,
const size_t *col_width_arr, size_t cols, const size_t *col_width_arr, size_t cols,
const fort_row_t *upper_row, const fort_row_t *lower_row, const f_row_t *upper_row, const f_row_t *lower_row,
enum HorSeparatorPos separatorPos, const separator_t *sep); enum f_hor_separator_pos separatorPos, const f_separator_t *sep);
FT_INTERNAL FT_INTERNAL
int snprintf_row(const fort_row_t *row, conv_context_t *cntx, size_t *col_width_arr, size_t col_width_arr_sz, int snprintf_row(const f_row_t *row, f_conv_context_t *cntx, size_t *col_width_arr, size_t col_width_arr_sz,
size_t row_height); size_t row_height);
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
fort_row_t *create_row_from_wstring(const wchar_t *str); f_row_t *create_row_from_wstring(const wchar_t *str);
#endif #endif

46
src/string_buffer.c
View File

@ -26,7 +26,7 @@ static ptrdiff_t wcs_iter_width(const wchar_t *beg, const wchar_t *end)
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
static size_t buf_str_len(const string_buffer_t *buf) static size_t buf_str_len(const f_string_buffer_t *buf)
{ {
assert(buf); assert(buf);
@ -247,7 +247,7 @@ void utf8_n_substring(const void *str, utf8_int32_t ch_separator, size_t n, cons
FT_INTERNAL FT_INTERNAL
string_buffer_t *create_string_buffer(size_t n_chars, enum str_buf_type type) f_string_buffer_t *create_string_buffer(size_t n_chars, enum f_string_type type)
{ {
size_t char_sz = 0; size_t char_sz = 0;
switch (type) { switch (type) {
@ -267,7 +267,7 @@ string_buffer_t *create_string_buffer(size_t n_chars, enum str_buf_type type)
} }
size_t sz = n_chars * char_sz; size_t sz = n_chars * char_sz;
string_buffer_t *result = (string_buffer_t *)F_MALLOC(sizeof(string_buffer_t)); f_string_buffer_t *result = (f_string_buffer_t *)F_MALLOC(sizeof(f_string_buffer_t));
if (result == NULL) if (result == NULL)
return NULL; return NULL;
result->str.data = F_MALLOC(sz); result->str.data = F_MALLOC(sz);
@ -301,7 +301,7 @@ string_buffer_t *create_string_buffer(size_t n_chars, enum str_buf_type type)
FT_INTERNAL FT_INTERNAL
void destroy_string_buffer(string_buffer_t *buffer) void destroy_string_buffer(f_string_buffer_t *buffer)
{ {
if (buffer == NULL) if (buffer == NULL)
return; return;
@ -311,10 +311,10 @@ void destroy_string_buffer(string_buffer_t *buffer)
} }
FT_INTERNAL FT_INTERNAL
string_buffer_t *copy_string_buffer(const string_buffer_t *buffer) f_string_buffer_t *copy_string_buffer(const f_string_buffer_t *buffer)
{ {
assert(buffer); assert(buffer);
string_buffer_t *result = create_string_buffer(buffer->data_sz, buffer->type); f_string_buffer_t *result = create_string_buffer(buffer->data_sz, buffer->type);
if (result == NULL) if (result == NULL)
return NULL; return NULL;
switch (buffer->type) { switch (buffer->type) {
@ -340,7 +340,7 @@ string_buffer_t *copy_string_buffer(const string_buffer_t *buffer)
} }
FT_INTERNAL FT_INTERNAL
fort_status_t realloc_string_buffer_without_copy(string_buffer_t *buffer) f_status realloc_string_buffer_without_copy(f_string_buffer_t *buffer)
{ {
assert(buffer); assert(buffer);
char *new_str = (char *)F_MALLOC(buffer->data_sz * 2); char *new_str = (char *)F_MALLOC(buffer->data_sz * 2);
@ -355,7 +355,7 @@ fort_status_t realloc_string_buffer_without_copy(string_buffer_t *buffer)
FT_INTERNAL FT_INTERNAL
fort_status_t fill_buffer_from_string(string_buffer_t *buffer, const char *str) f_status fill_buffer_from_string(f_string_buffer_t *buffer, const char *str)
{ {
assert(buffer); assert(buffer);
assert(str); assert(str);
@ -374,7 +374,7 @@ fort_status_t fill_buffer_from_string(string_buffer_t *buffer, const char *str)
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
fort_status_t fill_buffer_from_wstring(string_buffer_t *buffer, const wchar_t *str) f_status fill_buffer_from_wstring(f_string_buffer_t *buffer, const wchar_t *str)
{ {
assert(buffer); assert(buffer);
assert(str); assert(str);
@ -393,7 +393,7 @@ fort_status_t fill_buffer_from_wstring(string_buffer_t *buffer, const wchar_t *s
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
FT_INTERNAL FT_INTERNAL
fort_status_t fill_buffer_from_u8string(string_buffer_t *buffer, const void *str) f_status fill_buffer_from_u8string(f_string_buffer_t *buffer, const void *str)
{ {
assert(buffer); assert(buffer);
assert(str); assert(str);
@ -411,7 +411,7 @@ fort_status_t fill_buffer_from_u8string(string_buffer_t *buffer, const void *str
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */
FT_INTERNAL FT_INTERNAL
size_t buffer_text_visible_height(const string_buffer_t *buffer) size_t buffer_text_visible_height(const f_string_buffer_t *buffer)
{ {
if (buffer == NULL || buffer->str.data == NULL || buf_str_len(buffer) == 0) { if (buffer == NULL || buffer->str.data == NULL || buf_str_len(buffer) == 0) {
return 0; return 0;
@ -432,13 +432,13 @@ size_t buffer_text_visible_height(const string_buffer_t *buffer)
} }
FT_INTERNAL FT_INTERNAL
size_t string_buffer_cod_width_capacity(const string_buffer_t *buffer) size_t string_buffer_cod_width_capacity(const f_string_buffer_t *buffer)
{ {
return string_buffer_width_capacity(buffer); return string_buffer_width_capacity(buffer);
} }
FT_INTERNAL FT_INTERNAL
size_t string_buffer_raw_capacity(const string_buffer_t *buffer) size_t string_buffer_raw_capacity(const f_string_buffer_t *buffer)
{ {
return buffer->data_sz; return buffer->data_sz;
} }
@ -461,7 +461,7 @@ size_t ut8_width(const void *beg, const void *end)
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
FT_INTERNAL FT_INTERNAL
size_t buffer_text_visible_width(const string_buffer_t *buffer) size_t buffer_text_visible_width(const f_string_buffer_t *buffer)
{ {
size_t max_length = 0; size_t max_length = 0;
if (buffer->type == CHAR_BUF) { if (buffer->type == CHAR_BUF) {
@ -515,7 +515,7 @@ size_t buffer_text_visible_width(const string_buffer_t *buffer)
static void static void
buffer_substring(const string_buffer_t *buffer, size_t buffer_row, const void **begin, const void **end, ptrdiff_t *str_it_width) buffer_substring(const f_string_buffer_t *buffer, size_t buffer_row, const void **begin, const void **end, ptrdiff_t *str_it_width)
{ {
switch (buffer->type) { switch (buffer->type) {
case CHAR_BUF: case CHAR_BUF:
@ -544,7 +544,7 @@ buffer_substring(const string_buffer_t *buffer, size_t buffer_row, const void **
static int static int
buffer_print_range(conv_context_t *cntx, const void *beg, const void *end) buffer_print_range(f_conv_context_t *cntx, const void *beg, const void *end)
{ {
size_t len; size_t len;
switch (cntx->b_type) { switch (cntx->b_type) {
@ -568,11 +568,11 @@ buffer_print_range(conv_context_t *cntx, const void *beg, const void *end)
FT_INTERNAL FT_INTERNAL
int buffer_printf(string_buffer_t *buffer, size_t buffer_row, conv_context_t *cntx, size_t vis_width, int buffer_printf(f_string_buffer_t *buffer, size_t buffer_row, f_conv_context_t *cntx, size_t vis_width,
const char *content_style_tag, const char *reset_content_style_tag) const char *content_style_tag, const char *reset_content_style_tag)
{ {
const context_t *context = cntx->cntx; const f_context_t *context = cntx->cntx;
fort_table_properties_t *props = context->table_properties; f_table_properties_t *props = context->table_properties;
size_t row = context->row; size_t row = context->row;
size_t column = context->column; size_t column = context->column;
@ -587,7 +587,7 @@ int buffer_printf(string_buffer_t *buffer, size_t buffer_row, conv_context_t *cn
size_t left = 0; size_t left = 0;
size_t right = 0; size_t right = 0;
switch (get_cell_property_value_hierarcial(props, row, column, FT_CPROP_TEXT_ALIGN)) { switch (get_cell_property_hierarchically(props, row, column, FT_CPROP_TEXT_ALIGN)) {
case FT_ALIGNED_LEFT: case FT_ALIGNED_LEFT:
left = 0; left = 0;
right = (vis_width) - content_width; right = (vis_width) - content_width;
@ -631,7 +631,7 @@ clear:
} }
FT_INTERNAL FT_INTERNAL
size_t string_buffer_width_capacity(const string_buffer_t *buffer) size_t string_buffer_width_capacity(const f_string_buffer_t *buffer)
{ {
assert(buffer); assert(buffer);
switch (buffer->type) { switch (buffer->type) {
@ -653,14 +653,14 @@ size_t string_buffer_width_capacity(const string_buffer_t *buffer)
FT_INTERNAL FT_INTERNAL
void *buffer_get_data(string_buffer_t *buffer) void *buffer_get_data(f_string_buffer_t *buffer)
{ {
assert(buffer); assert(buffer);
return buffer->str.data; return buffer->str.data;
} }
FT_INTERNAL FT_INTERNAL
int buffer_check_align(string_buffer_t *buffer) int buffer_check_align(f_string_buffer_t *buffer)
{ {
assert(buffer); assert(buffer);
assert(buffer->str.data); assert(buffer->str.data);

34
src/string_buffer.h
View File

@ -8,7 +8,7 @@
* STRING BUFFER * STRING BUFFER
* ***************************************************************************/ * ***************************************************************************/
struct string_buffer { struct f_string_buffer {
union { union {
char *cstr; char *cstr;
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
@ -20,57 +20,57 @@ struct string_buffer {
void *data; void *data;
} str; } str;
size_t data_sz; size_t data_sz;
enum str_buf_type type; enum f_string_type type;
}; };
FT_INTERNAL FT_INTERNAL
string_buffer_t *create_string_buffer(size_t number_of_chars, enum str_buf_type type); f_string_buffer_t *create_string_buffer(size_t number_of_chars, enum f_string_type type);
FT_INTERNAL FT_INTERNAL
void destroy_string_buffer(string_buffer_t *buffer); void destroy_string_buffer(f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
string_buffer_t *copy_string_buffer(const string_buffer_t *buffer); f_string_buffer_t *copy_string_buffer(const f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
fort_status_t realloc_string_buffer_without_copy(string_buffer_t *buffer); f_status realloc_string_buffer_without_copy(f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
fort_status_t fill_buffer_from_string(string_buffer_t *buffer, const char *str); f_status fill_buffer_from_string(f_string_buffer_t *buffer, const char *str);
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
FT_INTERNAL FT_INTERNAL
fort_status_t fill_buffer_from_wstring(string_buffer_t *buffer, const wchar_t *str); f_status fill_buffer_from_wstring(f_string_buffer_t *buffer, const wchar_t *str);
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
FT_INTERNAL FT_INTERNAL
fort_status_t fill_buffer_from_u8string(string_buffer_t *buffer, const void *str); f_status fill_buffer_from_u8string(f_string_buffer_t *buffer, const void *str);
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */
FT_INTERNAL FT_INTERNAL
size_t buffer_text_visible_width(const string_buffer_t *buffer); size_t buffer_text_visible_width(const f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
size_t buffer_text_visible_height(const string_buffer_t *buffer); size_t buffer_text_visible_height(const f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
size_t string_buffer_cod_width_capacity(const string_buffer_t *buffer); size_t string_buffer_cod_width_capacity(const f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
size_t string_buffer_raw_capacity(const string_buffer_t *buffer); size_t string_buffer_raw_capacity(const f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
size_t string_buffer_width_capacity(const string_buffer_t *buffer); size_t string_buffer_width_capacity(const f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
void *buffer_get_data(string_buffer_t *buffer); void *buffer_get_data(f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
int buffer_check_align(string_buffer_t *buffer); int buffer_check_align(f_string_buffer_t *buffer);
FT_INTERNAL FT_INTERNAL
int buffer_printf(string_buffer_t *buffer, size_t buffer_row, conv_context_t *cntx, size_t cod_width, int buffer_printf(f_string_buffer_t *buffer, size_t buffer_row, f_conv_context_t *cntx, size_t cod_width,
const char *content_style_tag, const char *reset_content_style_tag); const char *content_style_tag, const char *reset_content_style_tag);
#endif /* STRING_BUFFER_H */ #endif /* STRING_BUFFER_H */

100
src/table.c
View File

@ -5,9 +5,9 @@
#include "row.h" #include "row.h"
FT_INTERNAL FT_INTERNAL
separator_t *create_separator(int enabled) f_separator_t *create_separator(int enabled)
{ {
separator_t *res = (separator_t *)F_CALLOC(1, sizeof(separator_t)); f_separator_t *res = (f_separator_t *)F_CALLOC(1, sizeof(f_separator_t));
if (res == NULL) if (res == NULL)
return NULL; return NULL;
res->enabled = enabled; res->enabled = enabled;
@ -16,14 +16,14 @@ separator_t *create_separator(int enabled)
FT_INTERNAL FT_INTERNAL
void destroy_separator(separator_t *sep) void destroy_separator(f_separator_t *sep)
{ {
F_FREE(sep); F_FREE(sep);
} }
FT_INTERNAL FT_INTERNAL
separator_t *copy_separator(separator_t *sep) f_separator_t *copy_separator(f_separator_t *sep)
{ {
assert(sep); assert(sep);
return create_separator(sep->enabled); return create_separator(sep->enabled);
@ -31,7 +31,7 @@ separator_t *copy_separator(separator_t *sep)
static static
fort_row_t *get_row_impl(ft_table_t *table, size_t row, enum get_policy policy) f_row_t *get_row_impl(ft_table_t *table, size_t row, enum f_get_policy policy)
{ {
if (table == NULL || table->rows == NULL) { if (table == NULL || table->rows == NULL) {
return NULL; return NULL;
@ -40,12 +40,12 @@ fort_row_t *get_row_impl(ft_table_t *table, size_t row, enum get_policy policy)
switch (policy) { switch (policy) {
case DONT_CREATE_ON_NULL: case DONT_CREATE_ON_NULL:
if (row < vector_size(table->rows)) { if (row < vector_size(table->rows)) {
return *(fort_row_t **)vector_at(table->rows, row); return *(f_row_t **)vector_at(table->rows, row);
} }
return NULL; return NULL;
case CREATE_ON_NULL: case CREATE_ON_NULL:
while (row >= vector_size(table->rows)) { while (row >= vector_size(table->rows)) {
fort_row_t *new_row = create_row(); f_row_t *new_row = create_row();
if (new_row == NULL) if (new_row == NULL)
return NULL; return NULL;
if (FT_IS_ERROR(vector_push(table->rows, &new_row))) { if (FT_IS_ERROR(vector_push(table->rows, &new_row))) {
@ -53,7 +53,7 @@ fort_row_t *get_row_impl(ft_table_t *table, size_t row, enum get_policy policy)
return NULL; return NULL;
} }
} }
return *(fort_row_t **)vector_at(table->rows, row); return *(f_row_t **)vector_at(table->rows, row);
} }
assert(0 && "Shouldn't be here!"); assert(0 && "Shouldn't be here!");
@ -62,35 +62,35 @@ fort_row_t *get_row_impl(ft_table_t *table, size_t row, enum get_policy policy)
FT_INTERNAL FT_INTERNAL
fort_row_t *get_row(ft_table_t *table, size_t row) f_row_t *get_row(ft_table_t *table, size_t row)
{ {
return get_row_impl(table, row, DONT_CREATE_ON_NULL); return get_row_impl(table, row, DONT_CREATE_ON_NULL);
} }
FT_INTERNAL FT_INTERNAL
const fort_row_t *get_row_c(const ft_table_t *table, size_t row) const f_row_t *get_row_c(const ft_table_t *table, size_t row)
{ {
return get_row((ft_table_t *)table, row); return get_row((ft_table_t *)table, row);
} }
FT_INTERNAL FT_INTERNAL
fort_row_t *get_row_and_create_if_not_exists(ft_table_t *table, size_t row) f_row_t *get_row_and_create_if_not_exists(ft_table_t *table, size_t row)
{ {
return get_row_impl(table, row, CREATE_ON_NULL); return get_row_impl(table, row, CREATE_ON_NULL);
} }
FT_INTERNAL FT_INTERNAL
string_buffer_t *get_cur_str_buffer_and_create_if_not_exists(ft_table_t *table) f_string_buffer_t *get_cur_str_buffer_and_create_if_not_exists(ft_table_t *table)
{ {
assert(table); assert(table);
fort_row_t *row = get_row_and_create_if_not_exists(table, table->cur_row); f_row_t *row = get_row_and_create_if_not_exists(table, table->cur_row);
if (row == NULL) if (row == NULL)
return NULL; return NULL;
fort_cell_t *cell = get_cell_and_create_if_not_exists(row, table->cur_col); f_cell_t *cell = get_cell_and_create_if_not_exists(row, table->cur_col);
if (cell == NULL) if (cell == NULL)
return NULL; return NULL;
@ -102,24 +102,15 @@ string_buffer_t *get_cur_str_buffer_and_create_if_not_exists(ft_table_t *table)
* Returns number of cells (rows * cols) * Returns number of cells (rows * cols)
*/ */
FT_INTERNAL FT_INTERNAL
fort_status_t get_table_sizes(const ft_table_t *table, size_t *rows, size_t *cols) f_status get_table_sizes(const ft_table_t *table, size_t *rows, size_t *cols)
{ {
*rows = 0; *rows = 0;
*cols = 0; *cols = 0;
if (table && table->rows) { if (table && table->rows) {
*rows = vector_size(table->rows); *rows = vector_size(table->rows);
/*
fort_row_t *row = NULL;
FOR_EACH(fort_row_t *, row, table->rows) {
(void)i0;
size_t cols_in_row = columns_in_row(row);
if (cols_in_row > *cols)
*cols = cols_in_row;
}
*/
size_t row_index = 0; size_t row_index = 0;
for (row_index = 0; row_index < vector_size(table->rows); ++row_index) { for (row_index = 0; row_index < vector_size(table->rows); ++row_index) {
fort_row_t *row = *(fort_row_t **)vector_at(table->rows, row_index); f_row_t *row = *(f_row_t **)vector_at(table->rows, row_index);
size_t cols_in_row = columns_in_row(row); size_t cols_in_row = columns_in_row(row);
if (cols_in_row > *cols) if (cols_in_row > *cols)
*cols = cols_in_row; *cols = cols_in_row;
@ -130,25 +121,23 @@ fort_status_t get_table_sizes(const ft_table_t *table, size_t *rows, size_t *col
FT_INTERNAL FT_INTERNAL
fort_status_t table_rows_and_cols_geometry(const ft_table_t *table, f_status table_rows_and_cols_geometry(const ft_table_t *table,
size_t **col_width_arr_p, size_t *col_width_arr_sz, size_t **col_width_arr_p, size_t *col_width_arr_sz,
size_t **row_height_arr_p, size_t *row_height_arr_sz, size_t **row_height_arr_p, size_t *row_height_arr_sz,
enum request_geom_type geom) enum f_geometry_type geom)
{ {
if (table == NULL) { if (table == NULL) {
return FT_ERROR; return FT_ERROR;
} }
size_t cols = 0; size_t cols = 0;
size_t rows = 0; size_t rows = 0;
int status = get_table_sizes(table, &rows, &cols); int status = get_table_sizes(table, &rows, &cols);
if (FT_IS_ERROR(status)) if (FT_IS_ERROR(status))
return status; return status;
size_t *col_width_arr = (size_t *)F_CALLOC(sizeof(size_t), cols); size_t *col_width_arr = (size_t *)F_CALLOC(cols, sizeof(size_t));
size_t *row_height_arr = (size_t *)F_CALLOC(sizeof(size_t), rows); size_t *row_height_arr = (size_t *)F_CALLOC(rows, sizeof(size_t));
if (col_width_arr == NULL || row_height_arr == NULL) { if (col_width_arr == NULL || row_height_arr == NULL) {
F_FREE(col_width_arr); F_FREE(col_width_arr);
F_FREE(row_height_arr); F_FREE(row_height_arr);
@ -156,35 +145,35 @@ fort_status_t table_rows_and_cols_geometry(const ft_table_t *table,
} }
int combined_cells_found = 0; int combined_cells_found = 0;
context_t context; f_context_t context;
context.table_properties = (table->properties ? table->properties : &g_table_properties); context.table_properties = (table->properties ? table->properties : &g_table_properties);
size_t col = 0; size_t col = 0;
for (col = 0; col < cols; ++col) { for (col = 0; col < cols; ++col) {
col_width_arr[col] = 0; col_width_arr[col] = 0;
size_t row = 0; size_t row = 0;
for (row = 0; row < rows; ++row) { for (row = 0; row < rows; ++row) {
const fort_row_t *row_p = get_row_c(table, row); const f_row_t *row_p = get_row_c(table, row);
const fort_cell_t *cell = get_cell_c(row_p, col); const f_cell_t *cell = get_cell_c(row_p, col);
context.column = col; context.column = col;
context.row = row; context.row = row;
if (cell) { if (cell) {
switch (get_cell_type(cell)) { switch (get_cell_type(cell)) {
case CommonCell: case COMMON_CELL:
col_width_arr[col] = MAX(col_width_arr[col], hint_width_cell(cell, &context, geom)); col_width_arr[col] = MAX(col_width_arr[col], hint_width_cell(cell, &context, geom));
break; break;
case GroupMasterCell: case GROUP_MASTER_CELL:
combined_cells_found = 1; combined_cells_found = 1;
break; break;
case GroupSlaveCell: case GROUP_SLAVE_CELL:
; /* Do nothing */ ; /* Do nothing */
break; break;
} }
row_height_arr[row] = MAX(row_height_arr[row], hint_height_cell(cell, &context)); row_height_arr[row] = MAX(row_height_arr[row], hint_height_cell(cell, &context));
} else { } else {
size_t cell_empty_string_height = get_cell_property_value_hierarcial(context.table_properties, context.row, context.column, FT_CPROP_EMPTY_STR_HEIGHT); size_t cell_empty_string_height = get_cell_property_hierarchically(context.table_properties, context.row, context.column, FT_CPROP_EMPTY_STR_HEIGHT);
if (cell_empty_string_height) { if (cell_empty_string_height) {
size_t cell_top_padding = get_cell_property_value_hierarcial(context.table_properties, context.row, context.column, FT_CPROP_TOP_PADDING); size_t cell_top_padding = get_cell_property_hierarchically(context.table_properties, context.row, context.column, FT_CPROP_TOP_PADDING);
size_t cell_bottom_padding = get_cell_property_value_hierarcial(context.table_properties, context.row, context.column, FT_CPROP_BOTTOM_PADDING); size_t cell_bottom_padding = get_cell_property_hierarchically(context.table_properties, context.row, context.column, FT_CPROP_BOTTOM_PADDING);
row_height_arr[row] = MAX(row_height_arr[row], cell_empty_string_height + cell_top_padding + cell_bottom_padding); row_height_arr[row] = MAX(row_height_arr[row], cell_empty_string_height + cell_top_padding + cell_bottom_padding);
} }
} }
@ -195,12 +184,12 @@ fort_status_t table_rows_and_cols_geometry(const ft_table_t *table,
for (col = 0; col < cols; ++col) { for (col = 0; col < cols; ++col) {
size_t row = 0; size_t row = 0;
for (row = 0; row < rows; ++row) { for (row = 0; row < rows; ++row) {
const fort_row_t *row_p = get_row_c(table, row); const f_row_t *row_p = get_row_c(table, row);
const fort_cell_t *cell = get_cell_c(row_p, col); const f_cell_t *cell = get_cell_c(row_p, col);
context.column = col; context.column = col;
context.row = row; context.row = row;
if (cell) { if (cell) {
if (get_cell_type(cell) == GroupMasterCell) { if (get_cell_type(cell) == GROUP_MASTER_CELL) {
size_t hint_width = hint_width_cell(cell, &context, geom); size_t hint_width = hint_width_cell(cell, &context, geom);
size_t slave_col = col + group_cell_number(row_p, col); size_t slave_col = col + group_cell_number(row_p, col);
size_t cur_adj_col = col; size_t cur_adj_col = col;
@ -224,9 +213,10 @@ fort_status_t table_rows_and_cols_geometry(const ft_table_t *table,
} }
} }
/* todo: Maybe it is better to move min width checking to a particular cell width checking. /* todo: Maybe it is better to move min width checking to a particular cell
* At the moment min width includes paddings. Maybe it is better that min width weren't include * width checking. At the moment min width includes paddings. Maybe it is
* paddings but be min width of the cell content without padding * better that min width weren't include paddings but be min width of the
* cell content without padding
*/ */
/* /*
if (table->properties) { if (table->properties) {
@ -248,7 +238,7 @@ fort_status_t table_rows_and_cols_geometry(const ft_table_t *table,
* Returns geometry in characters * Returns geometry in characters
*/ */
FT_INTERNAL FT_INTERNAL
fort_status_t table_geometry(const ft_table_t *table, size_t *height, size_t *width) f_status table_geometry(const ft_table_t *table, size_t *height, size_t *width)
{ {
if (table == NULL) if (table == NULL)
return FT_ERROR; return FT_ERROR;
@ -278,24 +268,24 @@ fort_status_t table_geometry(const ft_table_t *table, size_t *height, size_t *wi
F_FREE(col_width_arr); F_FREE(col_width_arr);
F_FREE(row_height_arr); F_FREE(row_height_arr);
if (table->properties) { f_table_properties_t *properties = table->properties;
*height += table->properties->entire_table_properties.top_margin; if (properties) {
*height += table->properties->entire_table_properties.bottom_margin; *height += properties->entire_table_properties.top_margin;
*width += table->properties->entire_table_properties.left_margin; *height += properties->entire_table_properties.bottom_margin;
*width += table->properties->entire_table_properties.right_margin; *width += properties->entire_table_properties.left_margin;
*width += properties->entire_table_properties.right_margin;
} }
/* Take into account that border elements can be more than one byte long */ /* Take into account that border elements can be more than one byte long */
fort_table_properties_t *table_properties = table->properties ? table->properties : &g_table_properties; f_table_properties_t *table_properties = properties ? properties : &g_table_properties;
size_t max_border_elem_len = max_border_elem_strlen(table_properties); size_t max_border_elem_len = max_border_elem_strlen(table_properties);
*width *= max_border_elem_len; *width *= max_border_elem_len;
return FT_SUCCESS; return FT_SUCCESS;
} }
FT_INTERNAL FT_INTERNAL
fort_status_t table_internal_codepoints_geometry(const ft_table_t *table, size_t *height, size_t *width) f_status table_internal_codepoints_geometry(const ft_table_t *table, size_t *height, size_t *width)
{ {
return table_geometry(table, height, width); return table_geometry(table, height, width);
} }

32
src/table.h
View File

@ -4,53 +4,53 @@
#include "fort_utils.h" #include "fort_utils.h"
struct ft_table { struct ft_table {
vector_t *rows; f_vector_t *rows;
fort_table_properties_t *properties; f_table_properties_t *properties;
string_buffer_t *conv_buffer; f_string_buffer_t *conv_buffer;
size_t cur_row; size_t cur_row;
size_t cur_col; size_t cur_col;
vector_t *separators; f_vector_t *separators;
}; };
FT_INTERNAL FT_INTERNAL
separator_t *create_separator(int enabled); f_separator_t *create_separator(int enabled);
FT_INTERNAL FT_INTERNAL
void destroy_separator(separator_t *sep); void destroy_separator(f_separator_t *sep);
FT_INTERNAL FT_INTERNAL
separator_t *copy_separator(separator_t *sep); f_separator_t *copy_separator(f_separator_t *sep);
FT_INTERNAL FT_INTERNAL
fort_status_t get_table_sizes(const ft_table_t *table, size_t *rows, size_t *cols); f_status get_table_sizes(const ft_table_t *table, size_t *rows, size_t *cols);
FT_INTERNAL FT_INTERNAL
fort_row_t *get_row(ft_table_t *table, size_t row); f_row_t *get_row(ft_table_t *table, size_t row);
FT_INTERNAL FT_INTERNAL
const fort_row_t *get_row_c(const ft_table_t *table, size_t row); const f_row_t *get_row_c(const ft_table_t *table, size_t row);
FT_INTERNAL FT_INTERNAL
fort_row_t *get_row_and_create_if_not_exists(ft_table_t *table, size_t row); f_row_t *get_row_and_create_if_not_exists(ft_table_t *table, size_t row);
FT_INTERNAL FT_INTERNAL
string_buffer_t *get_cur_str_buffer_and_create_if_not_exists(ft_table_t *table); f_string_buffer_t *get_cur_str_buffer_and_create_if_not_exists(ft_table_t *table);
FT_INTERNAL FT_INTERNAL
fort_status_t table_rows_and_cols_geometry(const ft_table_t *table, f_status table_rows_and_cols_geometry(const ft_table_t *table,
size_t **col_width_arr_p, size_t *col_width_arr_sz, size_t **col_width_arr_p, size_t *col_width_arr_sz,
size_t **row_height_arr_p, size_t *row_height_arr_sz, size_t **row_height_arr_p, size_t *row_height_arr_sz,
enum request_geom_type geom); enum f_geometry_type geom);
FT_INTERNAL FT_INTERNAL
fort_status_t table_geometry(const ft_table_t *table, size_t *height, size_t *width); f_status table_geometry(const ft_table_t *table, size_t *height, size_t *width);
/* /*
* Returns geometry in codepoints(characters) (include codepoints of invisible * Returns geometry in codepoints(characters) (include codepoints of invisible
* elements: e.g. styles tags). * elements: e.g. styles tags).
*/ */
FT_INTERNAL FT_INTERNAL
fort_status_t table_internal_codepoints_geometry(const ft_table_t *table, size_t *height, size_t *width); f_status table_internal_codepoints_geometry(const ft_table_t *table, size_t *height, size_t *width);
#endif /* TABLE_H */ #endif /* TABLE_H */

32
src/vector.c
View File

@ -2,7 +2,7 @@
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
struct vector { struct f_vector {
size_t m_size; size_t m_size;
void *m_data; void *m_data;
size_t m_capacity; size_t m_capacity;
@ -10,7 +10,7 @@ struct vector {
}; };
static int vector_reallocate_(vector_t *vector, size_t new_capacity) static int vector_reallocate_(f_vector_t *vector, size_t new_capacity)
{ {
assert(vector); assert(vector);
assert(new_capacity > vector->m_capacity); assert(new_capacity > vector->m_capacity);
@ -24,9 +24,9 @@ static int vector_reallocate_(vector_t *vector, size_t new_capacity)
FT_INTERNAL FT_INTERNAL
vector_t *create_vector(size_t item_size, size_t capacity) f_vector_t *create_vector(size_t item_size, size_t capacity)
{ {
vector_t *vector = (vector_t *)F_MALLOC(sizeof(vector_t)); f_vector_t *vector = (f_vector_t *)F_MALLOC(sizeof(f_vector_t));
if (vector == NULL) { if (vector == NULL) {
return NULL; return NULL;
} }
@ -47,7 +47,7 @@ vector_t *create_vector(size_t item_size, size_t capacity)
FT_INTERNAL FT_INTERNAL
void destroy_vector(vector_t *vector) void destroy_vector(f_vector_t *vector)
{ {
assert(vector); assert(vector);
F_FREE(vector->m_data); F_FREE(vector->m_data);
@ -56,7 +56,7 @@ void destroy_vector(vector_t *vector)
FT_INTERNAL FT_INTERNAL
size_t vector_size(const vector_t *vector) size_t vector_size(const f_vector_t *vector)
{ {
assert(vector); assert(vector);
return vector->m_size; return vector->m_size;
@ -64,7 +64,7 @@ size_t vector_size(const vector_t *vector)
FT_INTERNAL FT_INTERNAL
size_t vector_capacity(const vector_t *vector) size_t vector_capacity(const f_vector_t *vector)
{ {
assert(vector); assert(vector);
return vector->m_capacity; return vector->m_capacity;
@ -72,7 +72,7 @@ size_t vector_capacity(const vector_t *vector)
FT_INTERNAL FT_INTERNAL
int vector_push(vector_t *vector, const void *item) int vector_push(f_vector_t *vector, const void *item)
{ {
assert(vector); assert(vector);
assert(item); assert(item);
@ -93,7 +93,7 @@ int vector_push(vector_t *vector, const void *item)
FT_INTERNAL FT_INTERNAL
const void *vector_at_c(const vector_t *vector, size_t index) const void *vector_at_c(const f_vector_t *vector, size_t index)
{ {
if (index >= vector->m_size) if (index >= vector->m_size)
return NULL; return NULL;
@ -103,7 +103,7 @@ const void *vector_at_c(const vector_t *vector, size_t index)
FT_INTERNAL FT_INTERNAL
void *vector_at(vector_t *vector, size_t index) void *vector_at(f_vector_t *vector, size_t index)
{ {
if (index >= vector->m_size) if (index >= vector->m_size)
return NULL; return NULL;
@ -113,7 +113,7 @@ void *vector_at(vector_t *vector, size_t index)
FT_INTERNAL FT_INTERNAL
fort_status_t vector_swap(vector_t *cur_vec, vector_t *mv_vec, size_t pos) f_status vector_swap(f_vector_t *cur_vec, f_vector_t *mv_vec, size_t pos)
{ {
assert(cur_vec); assert(cur_vec);
assert(mv_vec); assert(mv_vec);
@ -169,12 +169,12 @@ fort_status_t vector_swap(vector_t *cur_vec, vector_t *mv_vec, size_t pos)
#ifdef FT_TEST_BUILD #ifdef FT_TEST_BUILD
vector_t *copy_vector(vector_t *v) f_vector_t *copy_vector(f_vector_t *v)
{ {
if (v == NULL) if (v == NULL)
return NULL; return NULL;
vector_t *new_vector = create_vector(v->m_item_size, v->m_capacity); f_vector_t *new_vector = create_vector(v->m_item_size, v->m_capacity);
if (new_vector == NULL) if (new_vector == NULL)
return NULL; return NULL;
@ -184,7 +184,7 @@ vector_t *copy_vector(vector_t *v)
return new_vector; return new_vector;
} }
size_t vector_index_of(const vector_t *vector, const void *item) size_t vector_index_of(const f_vector_t *vector, const void *item)
{ {
assert(vector); assert(vector);
assert(item); assert(item);
@ -200,7 +200,7 @@ size_t vector_index_of(const vector_t *vector, const void *item)
} }
int vector_erase(vector_t *vector, size_t index) int vector_erase(f_vector_t *vector, size_t index)
{ {
assert(vector); assert(vector);
@ -215,7 +215,7 @@ int vector_erase(vector_t *vector, size_t index)
} }
void vector_clear(vector_t *vector) void vector_clear(f_vector_t *vector)
{ {
vector->m_size = 0; vector->m_size = 0;
} }

33
src/vector.h
View File

@ -7,44 +7,35 @@
#define INVALID_VEC_INDEX ((size_t) -1) #define INVALID_VEC_INDEX ((size_t) -1)
FT_INTERNAL FT_INTERNAL
vector_t *create_vector(size_t item_size, size_t capacity); f_vector_t *create_vector(size_t item_size, size_t capacity);
FT_INTERNAL FT_INTERNAL
void destroy_vector(vector_t *); void destroy_vector(f_vector_t *);
FT_INTERNAL FT_INTERNAL
size_t vector_size(const vector_t *); size_t vector_size(const f_vector_t *);
FT_INTERNAL FT_INTERNAL
size_t vector_capacity(const vector_t *); size_t vector_capacity(const f_vector_t *);
FT_INTERNAL FT_INTERNAL
int vector_push(vector_t *, const void *item); int vector_push(f_vector_t *, const void *item);
FT_INTERNAL FT_INTERNAL
const void *vector_at_c(const vector_t *vector, size_t index); const void *vector_at_c(const f_vector_t *vector, size_t index);
FT_INTERNAL FT_INTERNAL
void *vector_at(vector_t *, size_t index); void *vector_at(f_vector_t *, size_t index);
FT_INTERNAL FT_INTERNAL
fort_status_t vector_swap(vector_t *cur_vec, vector_t *mv_vec, size_t pos); f_status vector_swap(f_vector_t *cur_vec, f_vector_t *mv_vec, size_t pos);
/*
#define FOR_EACH_(type, item, vector, index_name) \
size_t index_name = 0; \
for (index_name = 0; (index_name < vector_size(vector)) ? ((item = *(type*)vector_at(vector, index_name)), 1) : 0; ++index_name)
#define FOR_EACH(type, item, vector) \
FOR_EACH_(type, item, vector, UNIQUE_NAME(i))
*/
#ifdef FT_TEST_BUILD #ifdef FT_TEST_BUILD
vector_t *copy_vector(vector_t *); f_vector_t *copy_vector(f_vector_t *);
size_t vector_index_of(const vector_t *, const void *item); size_t vector_index_of(const f_vector_t *, const void *item);
int vector_erase(vector_t *, size_t index); int vector_erase(f_vector_t *, size_t index);
void vector_clear(vector_t *); void vector_clear(f_vector_t *);
#endif #endif
#endif /* VECTOR_H */ #endif /* VECTOR_H */

30
tests/wb_tests/test_string_buffer.c
View File

@ -19,7 +19,7 @@ const wchar_t *wstr_n_substring_beg(const wchar_t *str, wchar_t ch_separator, si
const void *utf8_n_substring_beg(const void *str, utf8_int32_t ch_separator, size_t n); const void *utf8_n_substring_beg(const void *str, utf8_int32_t ch_separator, size_t n);
#endif #endif
fort_status_t str_n_substring(const char *str, char ch_separator, size_t n, const char **begin, const char **end); f_status str_n_substring(const char *str, char ch_separator, size_t n, const char **begin, const char **end);
void wstr_n_substring(const wchar_t *str, wchar_t ch_separator, size_t n, const wchar_t **begin, const wchar_t **end); void wstr_n_substring(const wchar_t *str, wchar_t ch_separator, size_t n, const wchar_t **begin, const wchar_t **end);
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
void utf8_n_substring(const void *str, utf8_int32_t ch_separator, size_t n, const void **begin, const void **end); void utf8_n_substring(const void *str, utf8_int32_t ch_separator, size_t n, const void **begin, const void **end);
@ -351,7 +351,7 @@ void test_str_n_substring(void)
void test_buffer_text_visible_width(void) void test_buffer_text_visible_width(void)
{ {
string_buffer_t *buffer = create_string_buffer(200, CHAR_BUF); f_string_buffer_t *buffer = create_string_buffer(200, CHAR_BUF);
buffer->type = CHAR_BUF; buffer->type = CHAR_BUF;
char *old_value = buffer->str.cstr; char *old_value = buffer->str.cstr;
@ -477,7 +477,7 @@ void test_buffer_text_visible_width(void)
void test_buffer_text_visible_height(void) void test_buffer_text_visible_height(void)
{ {
string_buffer_t *buffer = create_string_buffer(200, CHAR_BUF); f_string_buffer_t *buffer = create_string_buffer(200, CHAR_BUF);
buffer->type = CHAR_BUF; buffer->type = CHAR_BUF;
char *old_value = buffer->str.cstr; char *old_value = buffer->str.cstr;
@ -606,41 +606,41 @@ static void test_print_n_strings_(const char *str, size_t n)
{ {
int sz = n * strlen(str); int sz = n * strlen(str);
{ {
string_buffer_t *buffer = create_string_buffer(200, CHAR_BUF); f_string_buffer_t *buffer = create_string_buffer(200, CHAR_BUF);
conv_context_t cntx; const char *origin = (char *)buffer_get_data(buffer);
f_conv_context_t cntx;
cntx.u.buf = (char *)buffer_get_data(buffer); cntx.u.buf = (char *)buffer_get_data(buffer);
cntx.buf_origin = (char *)buffer_get_data(buffer);
cntx.raw_avail = 200; cntx.raw_avail = 200;
cntx.b_type = CHAR_BUF; cntx.b_type = CHAR_BUF;
assert_true(print_n_strings(&cntx, n, str) == sz); assert_true(print_n_strings(&cntx, n, str) == sz);
assert_true(cntx.u.buf - cntx.buf_origin == (ptrdiff_t)sz); assert_true(cntx.u.buf - origin == (ptrdiff_t)sz);
destroy_string_buffer(buffer); destroy_string_buffer(buffer);
} }
#ifdef FT_HAVE_WCHAR #ifdef FT_HAVE_WCHAR
{ {
string_buffer_t *buffer = create_string_buffer(200, W_CHAR_BUF); f_string_buffer_t *buffer = create_string_buffer(200, W_CHAR_BUF);
conv_context_t cntx; const char *origin = (char *)buffer_get_data(buffer);
f_conv_context_t cntx;
cntx.u.buf = (char *)buffer_get_data(buffer); cntx.u.buf = (char *)buffer_get_data(buffer);
cntx.buf_origin = (char *)buffer_get_data(buffer);
cntx.raw_avail = 200; cntx.raw_avail = 200;
cntx.b_type = W_CHAR_BUF; cntx.b_type = W_CHAR_BUF;
assert_true(print_n_strings(&cntx, n, str) == /*sizeof(wchar_t) **/ sz); assert_true(print_n_strings(&cntx, n, str) == /*sizeof(wchar_t) **/ sz);
assert_true(cntx.u.buf - cntx.buf_origin == (ptrdiff_t)sizeof(wchar_t) * sz); assert_true(cntx.u.buf - origin == (ptrdiff_t)sizeof(wchar_t) * sz);
destroy_string_buffer(buffer); destroy_string_buffer(buffer);
} }
#endif /* FT_HAVE_WCHAR */ #endif /* FT_HAVE_WCHAR */
#ifdef FT_HAVE_UTF8 #ifdef FT_HAVE_UTF8
{ {
string_buffer_t *buffer = create_string_buffer(200, UTF8_BUF); f_string_buffer_t *buffer = create_string_buffer(200, UTF8_BUF);
conv_context_t cntx; const char *origin = (char *)buffer_get_data(buffer);
f_conv_context_t cntx;
cntx.u.buf = (char *)buffer_get_data(buffer); cntx.u.buf = (char *)buffer_get_data(buffer);
cntx.buf_origin = (char *)buffer_get_data(buffer);
cntx.raw_avail = 200; cntx.raw_avail = 200;
cntx.b_type = UTF8_BUF; cntx.b_type = UTF8_BUF;
assert_true(print_n_strings(&cntx, n, str) == sz); assert_true(print_n_strings(&cntx, n, str) == sz);
assert_true(cntx.u.buf - cntx.buf_origin == (ptrdiff_t)sz); assert_true(cntx.u.buf - origin == (ptrdiff_t)sz);
destroy_string_buffer(buffer); destroy_string_buffer(buffer);
} }
#endif /* FT_HAVE_UTF8 */ #endif /* FT_HAVE_UTF8 */

6
tests/wb_tests/test_vector.c
View File

@ -8,7 +8,7 @@ void test_vector_basic(void)
typedef short item_t; typedef short item_t;
const size_t init_capacity = 10; const size_t init_capacity = 10;
vector_t *vector = create_vector(sizeof(item_t), init_capacity); f_vector_t *vector = create_vector(sizeof(item_t), init_capacity);
assert_true(vector != NULL); assert_true(vector != NULL);
assert_true(vector_size(vector) == 0); assert_true(vector_size(vector) == 0);
@ -94,7 +94,7 @@ void test_vector_basic(void)
vector_push(vector, &item); vector_push(vector, &item);
} }
vector_t *mv_vector = create_vector(sizeof(item_t), 5); f_vector_t *mv_vector = create_vector(sizeof(item_t), 5);
assert_true(mv_vector != NULL); assert_true(mv_vector != NULL);
for (i = 0; i < 5; ++i) { for (i = 0; i < 5; ++i) {
item_t item = (item_t)i * 2; item_t item = (item_t)i * 2;
@ -130,7 +130,7 @@ void test_vector_stress(void)
typedef short item_t; typedef short item_t;
const size_t init_capacity = 10; const size_t init_capacity = 10;
vector_t *vector = create_vector(sizeof(item_t), init_capacity); f_vector_t *vector = create_vector(sizeof(item_t), init_capacity);
assert_true(vector != NULL); assert_true(vector != NULL);
assert_true(vector_size(vector) == 0); assert_true(vector_size(vector) == 0);