admin/mlib
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor code

Browse Source
This commit is contained in:
Patrick Pelissier committed 2019-04-20 12:33:08 +02:00
1 parent c28597014f
commit 67a7a4762a
1 file changed
+90 -76
Download Patch File Download Diff File Expand all files Collapse all files
m-string.h
+90 -76
View File
@@ -126,6 +126,20 @@ string_capacity(const string_t s)
return string_int_stack_p(s) ? c_stack : c_heap;
}
static inline char*
stringi_get_str(const string_t v)
{
STRINGI_CONTRACT (v);
return v->ptr;
}
static inline const char*
string_get_cstr(const string_t v)
{
STRINGI_CONTRACT (v);
return v->ptr;
}
static inline void
string_init(string_t s)
{
@@ -184,7 +198,7 @@ string_get_char(const string_t v, size_t index)
{
STRINGI_CONTRACT (v);
M_ASSUME(index < string_size(v));
return v->ptr[index];
return string_get_cstr(v)[index];
}
static inline bool
@@ -195,7 +209,7 @@ string_empty_p(const string_t v)
}
// Size includes the final null char
static inline void
static inline char *
stringi_fit2size (string_t v, size_t size_alloc)
{
assert (size_alloc > 0);
@@ -209,7 +223,7 @@ stringi_fit2size (string_t v, size_t size_alloc)
M_MEMORY_FULL(sizeof (char) * alloc);
// NOTE: Return is broken...
abort();
return;
return NULL;
}
char *ptr = v->ptr;
ptr = string_int_stack_p(v) ? NULL : ptr;
@@ -218,7 +232,7 @@ stringi_fit2size (string_t v, size_t size_alloc)
M_MEMORY_FULL(sizeof (char) * alloc);
// NOTE: Return is broken...
abort();
return;
return NULL;
}
M_ASSUME(ptr != &v->u.stack.buffer[0]);
if (string_int_stack_p(v)) {
@@ -227,8 +241,10 @@ stringi_fit2size (string_t v, size_t size_alloc)
}
v->ptr = ptr;
v->u.heap.alloc = alloc;
return ptr;
}
assert(v->ptr != NULL);
return v->ptr;
}
static inline void
@@ -271,8 +287,8 @@ string_set_str(string_t v, const char str[])
STRINGI_CONTRACT (v);
M_ASSUME(str != NULL);
size_t size = strlen(str);
stringi_fit2size(v, size+1);
memcpy(v->ptr, str, size+1);
char *ptr = stringi_fit2size(v, size+1);
memcpy(ptr, str, size+1);
string_int_set_size(v, size);
STRINGI_CONTRACT (v);
}
@@ -284,20 +300,13 @@ string_set_strn(string_t v, const char str[], size_t n)
M_ASSUME(str != NULL);
size_t len = strlen(str);
size_t size = M_MIN (len, n);
stringi_fit2size(v, size+1);
memcpy(v->ptr, str, size);
v->ptr[size] = 0;
char *ptr = stringi_fit2size(v, size+1);
memcpy(ptr, str, size);
ptr[size] = 0;
string_int_set_size(v, size);
STRINGI_CONTRACT (v);
}
static inline const char*
string_get_cstr(const string_t v)
{
STRINGI_CONTRACT (v);
return v->ptr;
}
static inline void
string_set (string_t v1, const string_t v2)
{
@@ -305,8 +314,8 @@ string_set (string_t v1, const string_t v2)
STRINGI_CONTRACT (v2);
if (M_LIKELY (v1 != v2)) {
const size_t size = string_size(v2);
stringi_fit2size(v1, size+1);
memcpy(v1->ptr, v2->ptr, size+1);
char *ptr = stringi_fit2size(v1, size+1);
memcpy(ptr, string_get_cstr(v2), size+1);
string_int_set_size(v1, size);
}
STRINGI_CONTRACT (v1);
@@ -319,9 +328,9 @@ string_set_n(string_t v, const string_t ref, size_t offset, size_t length)
STRINGI_CONTRACT (ref);
assert (offset <= string_size(ref));
size_t size = M_MIN (string_size(ref) - offset, length);
stringi_fit2size(v, size+1);
memmove(v->ptr, ref->ptr + offset, size);
v->ptr[size] = 0;
char *ptr = stringi_fit2size(v, size+1);
memmove(ptr, string_get_cstr(ref) + offset, size);
ptr[size] = 0;
string_int_set_size(v, size);
STRINGI_CONTRACT (v);
}
@@ -382,9 +391,9 @@ string_push_back (string_t v, char c)
{
STRINGI_CONTRACT (v);
const size_t size = string_size(v);
stringi_fit2size(v, size+2);
v->ptr[size+0] = c;
v->ptr[size+1] = 0;
char *ptr = stringi_fit2size(v, size+2);
ptr[size+0] = c;
ptr[size+1] = 0;
string_int_set_size(v, size+1);
STRINGI_CONTRACT (v);
}
@@ -396,8 +405,8 @@ string_cat_str(string_t v, const char str[])
M_ASSUME (str != NULL);
const size_t old_size = string_size(v);
const size_t size = strlen(str);
stringi_fit2size(v, old_size + size + 1);
memcpy(&v->ptr[old_size], str, size + 1);
char *ptr = stringi_fit2size(v, old_size + size + 1);
memcpy(&ptr[old_size], str, size + 1);
string_int_set_size(v, old_size + size);
STRINGI_CONTRACT (v);
}
@@ -410,9 +419,9 @@ string_cat(string_t v, const string_t v2)
const size_t size = string_size(v2);
if (M_LIKELY (size > 0)) {
const size_t old_size = string_size(v);
stringi_fit2size(v, old_size + size + 1);
memcpy(&v->ptr[old_size], v2->ptr, size);
v->ptr[old_size + size] = 0;
char *ptr = stringi_fit2size(v, old_size + size + 1);
memcpy(&ptr[old_size], v2->ptr, size);
ptr[old_size + size] = 0;
string_int_set_size(v, old_size + size);
}
STRINGI_CONTRACT (v);
@@ -611,12 +620,12 @@ string_replace_str (string_t v, const char str1[], const char str2[], size_t sta
const size_t str2_l = strlen(str2);
const size_t size = string_size(v);
assert(size + 1 + str2_l > str1_l);
stringi_fit2size (v, size + str2_l - str1_l + 1);
char *ptr = stringi_fit2size (v, size + str2_l - str1_l + 1);
if (str1_l != str2_l) {
memmove(&v->ptr[i+str2_l], &v->ptr[i+str1_l], size - i - str1_l + 1);
memmove(&ptr[i+str2_l], &ptr[i+str1_l], size - i - str1_l + 1);
string_int_set_size(v, size + str2_l - str1_l);
}
memcpy (&v->ptr[i], str2, str2_l);
memcpy (&ptr[i], str2, str2_l);
STRINGI_CONTRACT (v);
}
return i;
@@ -639,12 +648,12 @@ string_replace_at (string_t v, size_t pos, size_t len, const char str2[])
const size_t str1_l = len;
const size_t str2_l = strlen(str2);
const size_t size = string_size(v);
stringi_fit2size (v, size + str2_l - str1_l + 1);
char *ptr = stringi_fit2size (v, size + str2_l - str1_l + 1);
if (str1_l != str2_l) {
memmove(&v->ptr[pos+str2_l], &v->ptr[pos+str1_l], size - pos - str1_l + 1);
memmove(&ptr[pos+str2_l], &ptr[pos+str1_l], size - pos - str1_l + 1);
string_int_set_size(v, size + str2_l - str1_l);
}
memcpy (&v->ptr[pos], str2, str2_l);
memcpy (&ptr[pos], str2, str2_l);
STRINGI_CONTRACT (v);
}
@@ -660,12 +669,12 @@ string_printf (string_t v, const char format[], ...)
size = vsnprintf (v->ptr, alloc, format, args);
if (size > 0 && ((size_t) size+1 >= alloc) ) {
// We have to realloc our string to fit the needed size
stringi_fit2size (v, (size_t) size + 1);
char *ptr = stringi_fit2size (v, (size_t) size + 1);
alloc = string_capacity(v);
// and redo the parsing.
va_end (args);
va_start (args, format);
alloc = string_capacity(v);
size = vsnprintf (v->ptr, alloc, format, args);
size = vsnprintf (ptr, alloc, format, args);
assert (size > 0 && (size_t)size < alloc);
}
if (size >= 0) {
@@ -684,17 +693,18 @@ string_cat_printf (string_t v, const char format[], ...)
va_list args;
int size;
size_t old_size = string_size(v);
size_t alloc = string_capacity(v);
char *ptr = stringi_get_str(v);
size_t alloc = string_capacity(v);
va_start (args, format);
size = vsnprintf (&v->ptr[old_size], alloc - old_size, format, args);
size = vsnprintf (&ptr[old_size], alloc - old_size, format, args);
if (size > 0 && (old_size+(size_t)size+1 >= alloc) ) {
// We have to realloc our string to fit the needed size
stringi_fit2size (v, old_size + (size_t) size + 1);
ptr = stringi_fit2size (v, old_size + (size_t) size + 1);
alloc = string_capacity(v);
// and redo the parsing.
va_end (args);
va_start (args, format);
size = vsnprintf (&v->ptr[old_size], alloc - old_size, format, args);
size = vsnprintf (&ptr[old_size], alloc - old_size, format, args);
assert (size >= 0);
}
if (size >= 0) {
@@ -702,7 +712,7 @@ string_cat_printf (string_t v, const char format[], ...)
} else {
// vsnprintf may have output some characters before returning an error.
// Undo this to have a clean state
v->ptr[old_size] = 0;
ptr[old_size] = 0;
}
va_end (args);
STRINGI_CONTRACT (v);
@@ -714,27 +724,27 @@ string_fgets(string_t v, FILE *f, string_fgets_t arg)
{
STRINGI_CONTRACT(v);
assert (f != NULL);
stringi_fit2size (v, 100);
char *ptr = stringi_fit2size (v, 100);
size_t size = 0;
size_t alloc = string_capacity(v);
v->ptr[0] = 0;
ptr[0] = 0;
bool retcode = false; /* Nothing has been read yet */
while (fgets(&v->ptr[size], alloc - size, f) != NULL) {
while (fgets(&ptr[size], alloc - size, f) != NULL) {
retcode = true; /* Something has been read */
size += strlen(&v->ptr[size]);
if (arg != STRING_READ_FILE && v->ptr[size-1] == '\n') {
size += strlen(&ptr[size]);
if (arg != STRING_READ_FILE && ptr[size-1] == '\n') {
if (arg == STRING_READ_PURE_LINE) {
size --;
v->ptr[size] = 0; /* Remove EOL */
ptr[size] = 0; /* Remove EOL */
}
string_int_set_size(v, size);
STRINGI_CONTRACT(v);
return retcode; /* Normal terminaison */
} else if (v->ptr[size-1] != '\n' && !feof(f)) {
} else if (ptr[size-1] != '\n' && !feof(f)) {
/* The string buffer is not big enough:
increase it and continue reading */
/* v cannot be stack alloc */
stringi_fit2size (v, alloc + alloc/2);
ptr = stringi_fit2size (v, alloc + alloc/2);
alloc = string_capacity(v);
}
}
@@ -763,7 +773,10 @@ string_fget_word (string_t v, const char separator[], FILE *f)
}
} while (strchr(separator, d) != NULL);
ungetc(d, f);
v->ptr[0] = 0;
size_t alloc = string_capacity(v);
char *ptr = stringi_get_str(v);
ptr[0] = 0;
/* NOTE: We generate a buffer which we give to scanf to parse the string,
that it is to say, we generate the format dynamically!
@@ -779,16 +792,16 @@ string_fget_word (string_t v, const char separator[], FILE *f)
(size_t) alloc-1-size, separator) > 0
&& fscanf(f, buffer, &v->ptr[size], &c) == 2) {
retcode = true;
size += strlen(&v->ptr[size]);
size += strlen(&ptr[size]);
if (strchr(separator, c) != NULL)
break;
/* Next char is not a separator: continue parsing */
string_int_set_size(v, size);
stringi_fit2size (v, alloc + alloc/2);
ptr = stringi_fit2size (v, alloc + alloc/2);
alloc = string_capacity(v);
assert (alloc > size + 1);
v->ptr[size++] = c;
v->ptr[size] = 0;
ptr[size++] = c;
ptr[size] = 0;
}
string_int_set_size(v, size);
STRINGI_CONTRACT(v);
@@ -830,7 +843,7 @@ string_hash(const string_t v)
{
STRINGI_CONTRACT (v);
// TODO: alignemnt incorrect if stack based & string_t is 32-bits aligned ?...
return m_core_hash(v->ptr, string_size(v));
return m_core_hash(string_get_cstr(v), string_size(v));
}
// Return true if c is a character from charac
@@ -848,18 +861,19 @@ static inline void
string_strim(string_t v, const char charac[])
{
STRINGI_CONTRACT (v);
char *b = v->ptr;
char *ptr = stringi_get_str(v);
char *b = ptr;
size_t size = string_size(v);
while (size > 0 && stringi_strim_char(b[size-1], charac))
size --;
if (size > 0) {
while (stringi_strim_char(*b, charac))
b++;
M_ASSUME (b >= v->ptr && size >= (size_t) (b - v->ptr) );
size -= (b - v->ptr);
memmove (v->ptr, b, size);
M_ASSUME (b >= ptr && size >= (size_t) (b - ptr) );
size -= (b - ptr);
memmove (ptr, b, size);
}
v->ptr[size] = 0;
ptr[size] = 0;
string_int_set_size(v, size);
STRINGI_CONTRACT (v);
}
@@ -891,10 +905,10 @@ string_get_str(string_t v, const string_t v2, bool append)
size_t size = append ? string_size(v) : 0;
size_t v2_size = string_size(v2);
size_t targetSize = size + v2_size + 3;
stringi_fit2size(v, targetSize);
v->ptr[size ++] = '"';
char *ptr = stringi_fit2size(v, targetSize);
ptr[size ++] = '"';
for(size_t i = 0 ; i < v2_size; i++) {
const char c = v2->ptr[i];
const char c = string_get_char(v2,i);
switch (c) {
case '\\':
case '"':
@@ -903,30 +917,30 @@ string_get_str(string_t v, const string_t v2, bool append)
case '\r':
// Special characters which can be displayed in a short form.
string_int_set_size(v, size);
stringi_fit2size(v, ++targetSize);
v->ptr[size ++] = '\\';
ptr = stringi_fit2size(v, ++targetSize);
ptr[size ++] = '\\';
// This string acts as a perfect hashmap which supposes an ASCII mapping
// and (c^(c>>5)) is the hash function
v->ptr[size ++] = " tn\" r\\"[(c ^ (c >>5)) & 0x07];
ptr[size ++] = " tn\" r\\"[(c ^ (c >>5)) & 0x07];
break;
default:
if (M_UNLIKELY (!isprint(c))) {
targetSize += 3;
string_int_set_size(v, size);
stringi_fit2size(v, targetSize);
ptr = stringi_fit2size(v, targetSize);
int d1 = c & 0x07, d2 = (c>>3) & 0x07, d3 = (c>>6) & 0x07;
v->ptr[size ++] = '\\';
v->ptr[size ++] = '0' + d3;
v->ptr[size ++] = '0' + d2;
v->ptr[size ++] = '0' + d1;
ptr[size ++] = '\\';
ptr[size ++] = '0' + d3;
ptr[size ++] = '0' + d2;
ptr[size ++] = '0' + d1;
} else {
v->ptr[size ++] = c;
ptr[size ++] = c;
}
break;
}
}
v->ptr[size ++] = '"';
v->ptr[size] = 0;
ptr[size ++] = '"';
ptr[size] = 0;
string_int_set_size(v, size);
assert (size <= targetSize);
STRINGI_CONTRACT (v);