Timerix/kerep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

StringBuilder rewrote

Browse Source
This commit is contained in:
Timerix22 2022-04-20 19:25:19 +03:00
parent 2434a126da
commit 0309f0a3d0
9 changed files with 138 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
DtsodParser/DtsodV24_deserialize.c
View File

@ -3,8 +3,6 @@
#define ARR_BC 64
#define ARR_BL 1024
#define STRB_BC 64
#define STRB_BL 1024
typedef struct DeserializeSharedData{
@ -105,7 +103,7 @@ Maybe __ReadName(DeserializeSharedData* shared){
safethrow_wrongchar(c,;);
return SUCCESS(UniPtr(CharPtr,NULL));
case ':':
return SUCCESS(UniPtr(CharPtr,string_cpToCptr(nameStr)));
return SUCCESS(UniPtr(CharPtr,string_extract(nameStr)));
case '$':
if(nameStr.length!=0)
safethrow_wrongchar(c,;);
@ -130,19 +128,18 @@ Maybe __ReadValue(DeserializeSharedData* shared);
Maybe __ReadString(DeserializeSharedData* shared){
char c;
bool prevIsBackslash=false;
StringBuilder* b=StringBuilder_create(STRB_BC,STRB_BL);
StringBuilder* b=StringBuilder_create();
while ((c=*++text)){
if(c=='"') {
if(prevIsBackslash) {
// replacing <\"> with <">
StringBuilder_pop(b);
StringBuilder_rmchar(b);
StringBuilder_append_char(b,c);
prevIsBackslash=false;
}
else {
char* str=StringBuilder_build(b);
StringBuilder_free(b);
char* str=StringBuilder_build(b).ptr;
return SUCCESS(UniPtr(CharPtr,str));
}
}
@ -188,7 +185,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
break;
// Float64
case 'f': {
char* _c=string_cpToCptr(str);
char* _c=string_extract(str);
Unitype rez=Uni(Float64,strtod(_c,NULL));
free(_c);
return SUCCESS(rez);
@ -196,7 +193,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
// UInt64
case 'u': {
uint64 lu=0;
char* _c=string_cpToCptr(str);
char* _c=string_extract(str);
if(sscanf(_c,"%lu",&lu)!=1){
char err[64];
IFWIN(
@ -212,7 +209,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
int64 li=0;
char* _c=string_cpToCptr(str);
char* _c=string_extract(str);
if(sscanf(_c,"%li",&li)!=1){
char err[64];
IFWIN(

14
DtsodParser/DtsodV24_serialize.c
View File

@ -1,9 +1,6 @@
#include "DtsodV24.h"
#include "../String/StringBuilder.h"
// 65536 max length!
#define STRB_BC 64
#define STRB_BL 1024
typedef struct SerializeSharedData{
StringBuilder* sh_builder;
@ -35,7 +32,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
addc('u');
break;
case Float64:
StringBuilder_append_double(b,u.Float64);
StringBuilder_append_float64(b,u.Float64);
addc('f');
break;
case CharPtr:
@ -64,7 +61,7 @@ Maybe __AppendValue(SerializeSharedData* shared, Unitype u){
try(AppendValue(e),__,;);
addc(',');
}));
StringBuilder_pop(b);
StringBuilder_rmchar(b);
addc('\n');
tabs--;
AppendTabs();
@ -106,9 +103,8 @@ Maybe __serialize(StringBuilder* _b, uint8 _tabs, Hashtable* dtsod){
}
Maybe DtsodV24_serialize(Hashtable* dtsod){
StringBuilder* sb=StringBuilder_create(STRB_BC,STRB_BL);
try(__serialize(sb,0,dtsod),__, StringBuilder_free((sb)));
char* str=StringBuilder_build(sb);
StringBuilder_free((sb));
StringBuilder* sb=StringBuilder_create();
try(__serialize(sb,0,dtsod),__, StringBuilder_free(sb));
char* str=StringBuilder_build(sb).ptr;
return SUCCESS(UniPtr(CharPtr, str));
}

119
String/StringBuilder.c
View File

@ -1,42 +1,109 @@
#include "StringBuilder.h"
StringBuilder* StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length){
return Autoarr_create(int8,max_blocks_count,max_block_length);
define_Autoarr(string)
#define MAXLENGTH 32768
#define BL_C 32
#define BL_L 1024
void complete_buf(StringBuilder* b){
if(!b->compl_bufs)
b->compl_bufs=Autoarr_create(string,BL_C,BL_L);
uint32 len=Autoarr_length(b->curr_buf);
if(!len) return;
string str={.length=len, .ptr=malloc(len)};
uint32 i=0;
Autoarr_foreach(b->curr_buf, c, ({
str.ptr[i++]=c;
}));
Autoarr_add(b->compl_bufs,str);
Autoarr_free(b->curr_buf);
b->curr_buf=Autoarr_create(int8,BL_C,BL_L);
}
void try_complete_buf(StringBuilder* b){
if(b->curr_buf->blocks_count==BL_C)
complete_buf(b);
}
StringBuilder* StringBuilder_create(){
StringBuilder* b=malloc(sizeof(StringBuilder));
b->compl_bufs=NULL;
b->curr_buf=Autoarr_create(int8,BL_C,BL_L);
return b;
}
void StringBuilder_free(StringBuilder* b){
Autoarr_free(b);
if(b->compl_bufs) Autoarr_free(b->compl_bufs);
Autoarr_free(b->curr_buf);
free(b);
}
void StringBuilder_pop(StringBuilder* b){
Autoarr_pop(b);
string StringBuilder_build(StringBuilder* b){
complete_buf(b);
uint32 len=0;
Autoarr_foreach(b->compl_bufs, cs, ({
len+=cs.length;
}));
string str= { .length=len, .ptr=malloc(len+1) };
str.ptr[len]='\0';
uint32 i=0;
Autoarr_foreach(b->compl_bufs, cs, ({
for(uint32 n=0;n<cs.length;n++)
str.ptr[i++]=cs.ptr[n];
free(cs.ptr);
}));
StringBuilder_free(b);
return str;
}
void StringBuilder_rmchar(StringBuilder* b){
if(b->curr_buf->block_length!=0)
Autoarr_pop(b->curr_buf)
else {
if(!b->compl_bufs) throw(ERR_NULLPTR);
string* lastcb=Autoarr_getptr(b->compl_bufs, (Autoarr_length(b->compl_bufs)-1));
lastcb->length--;
}
}
void StringBuilder_append_char(StringBuilder* b, char c){
Autoarr_add(b,c);
try_complete_buf(b);
Autoarr_add(b->curr_buf,c);
}
void StringBuilder_append_string(StringBuilder* b, string s){
complete_buf(b);
Autoarr_add(b->compl_bufs, string_copy(s));
}
void StringBuilder_append_cptr(StringBuilder* b, char* s){
char c;
while((c=*s++))
Autoarr_add(b,c);
string str={
.ptr=s,
.length=cptr_length(s)
};
StringBuilder_append_string(b,str);
}
void StringBuilder_append_string(StringBuilder* b, string s){
while(s.length>0){
Autoarr_add(b,*s.ptr++);
s.length--;
}
void curr_buf_add_string(StringBuilder* b, string s){
for(uint32 i=0; i<s.length; i++)
Autoarr_add(b->curr_buf,s.ptr[i]);
}
void StringBuilder_append_int64(StringBuilder* b, int64 a){
try_complete_buf(b);
uint8 i=0;
if(a==0){
Autoarr_add(b,'0');
Autoarr_add(b->curr_buf,'0');
return;
}
else if(a<0){
Autoarr_add(b,'-');
Autoarr_add(b->curr_buf,'-');
a=-a;
}
char buf[24];
@ -45,14 +112,15 @@ void StringBuilder_append_int64(StringBuilder* b, int64 a){
a/=10;
}
string rev=string_reverse((string){buf,i});
StringBuilder_append_string(b,rev);
curr_buf_add_string(b,rev);
free(rev.ptr);
}
void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
try_complete_buf(b);
uint8 i=0;
if(a==0){
Autoarr_add(b,'0');
Autoarr_add(b->curr_buf,'0');
return;
}
char buf[24];
@ -61,24 +129,17 @@ void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
a/=10;
}
string rev=string_reverse((string){buf,i});
StringBuilder_append_string(b,rev);
curr_buf_add_string(b,rev);
free(rev.ptr);
}
void StringBuilder_append_double(StringBuilder* b, double a){
void StringBuilder_append_float64(StringBuilder* b, double a){
try_complete_buf(b);
char buf[32];
IFWIN(
sprintf_s(buf,32,"%lf",a),
sprintf(buf,"%lf",a)
);
StringBuilder_append_cptr(b,buf);
}
char* StringBuilder_build(StringBuilder* b){
uint32 len=Autoarr_length(b);
char* str=malloc(len+1);
str[len]=0;
for(uint32 i=0;i<len;i++)
str[i]=Autoarr_get(b,i);
return str;
curr_buf_add_string(b, (string){.ptr=buf, .length=cptr_length(buf)});
}

20
String/StringBuilder.h
View File

@ -7,18 +7,28 @@ extern "C" {
#include "../Autoarr/Autoarr.h"
#include "../String/string.h"
typedef Autoarr(int8) StringBuilder;
declare_Autoarr(string)
StringBuilder* StringBuilder_create(uint16 max_blocks_count, uint16 max_block_length);
typedef struct StringBuilder{
Autoarr(string)* compl_bufs;
Autoarr(int8)* curr_buf;
} StringBuilder;
StringBuilder* StringBuilder_create(void);
void StringBuilder_free(StringBuilder* b);
void StringBuilder_pop(StringBuilder* b);
// Joins all strings from compl_bufs.
// Returns zero-terminated string.
// No need to call string_extract()!
// Frees StringBuilder.
string StringBuilder_build(StringBuilder* b);
// removes last char
void StringBuilder_rmchar(StringBuilder* b);
void StringBuilder_append_char(StringBuilder* b, char c);
void StringBuilder_append_cptr(StringBuilder* b, char* s);
void StringBuilder_append_string(StringBuilder* b, string s);
void StringBuilder_append_int64(StringBuilder* b, int64 a);
void StringBuilder_append_uint64(StringBuilder* b, uint64 a);
void StringBuilder_append_double(StringBuilder* b, double a);
char* StringBuilder_build(StringBuilder* b);
void StringBuilder_append_float64(StringBuilder* b, double a);
#if __cplusplus
}

20
String/string.c
View File

@ -1,7 +1,7 @@
#include "../String/string.h"
// copies str content to new char pointer value (adding '\0' at the end)
char* string_cpToCptr(string str){
char* string_extract(string str){
if(str.length==0) return NULL;
char* cptr=malloc(str.length*sizeof(char)+1);
cptr[str.length]=0;
@ -10,15 +10,15 @@ char* string_cpToCptr(string str){
return cptr;
}
// copies cptr content (excluding '\0' at the end) to new string
string string_cpFromCharPtr(char* cptr){
if(!cptr) return stringNull;
string str;
str.length=cptr_length(cptr)-1;
str.ptr=malloc(str.length);
for(uint32 i=0;i<str.length;i++)
str.ptr[i]=cptr[i];
return str;
// copies src.ptr content to new string
string string_copy(string src){
if(!src.ptr) return src;
string nstr;
nstr.length=src.length;
nstr.ptr=malloc(nstr.length);
for(uint32 i=0;i<nstr.length;i++)
nstr.ptr[i]=src.ptr[i];
return nstr;
}
// compares two strings, NullPtr-friendly

6
String/string.h
View File

@ -16,10 +16,10 @@ typedef struct string{
static const string stringNull={NULL,0};
// copies str content to new char pointer value (adding '\0' at the end)
char* string_cpToCptr(string str);
char* string_extract(string str);
// copies cptr content (excluding '\0' at the end) to new string
string string_cpFromCharPtr(char* cptr);
// copies src.ptr content to new string
string string_copy(string src);
// compares two strings, NullPtr-friendly
bool string_compare(string str0, string str1);

6
base/cptr.c
View File

@ -1,16 +1,16 @@
#include "base.h"
// returns length of string (including \0)
// returns length of char buffer (without \0)
uint32 cptr_length(char* str){
uint32 len=0;
while(*(str++)) len++;
return ++len;
return len;
}
// allocates new char[] and copies src there
char* cptr_copy(char* src){
uint32 len=cptr_length(src);
char* dst=malloc(len*sizeof(char));
char* dst=malloc(len+1);
while(len-->0)
dst[len]=src[len];
return dst;

2
base/cptr.h
View File

@ -6,7 +6,7 @@ extern "C" {
#include "types.h"
// returns length of string (including \0)
// returns length of char buffer (without \0)
uint32 cptr_length(char* str);
// allocates new char[] and copies src there

10
tests/test_string.c
View File

@ -5,12 +5,10 @@ void test_string(){
optime(__func__,1,({
printf("\e[96m-------------[test_string]-------------\n");
char c[]="0123456789abcdef";
string s=string_cpFromCharPtr(c);
printf("\e[92m\"%s\" \e[94m-> string_cpFromCharPtr()\n",c);
if(s.length!=16) throw("string created with incorrect length");
char* p=string_cpToCptr(s);
printf("\e[94mstring_cpToCptr() -> \e[92m\"%s\"\n",p);
string s={.ptr=c, .length=cptr_length(c)};
if(s.length!=sizeof(c)-1) throw("string created with incorrect length");
char* p=string_extract(s);
printf("\e[94mstring_extract() -> \e[92m\"%s\"\n",p);
free(p);
free(s.ptr);
}));
}