ziggi/cworker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

at work

Browse Source
This commit is contained in:
Oleg Borodin
2023-09-04 22:12:47 +02:00
parent 00b5cb548a
commit c31faa5c9b
11 changed files with 310 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
clib/Makefile.am
View File

@@ -1,5 +1,5 @@
AUTOMAKE_OPTIONS = foreign no-dependencies no-installinfo
AUTOMAKE_OPTIONS = foreign no-dependencies no-installinfo
SUFFIXES = .c .o
AM_CFLAGS = -Wall

2
clib/Makefile.in
View File

@@ -377,7 +377,7 @@ target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = foreign no-dependencies no-installinfo
AUTOMAKE_OPTIONS = foreign no-dependencies no-installinfo
SUFFIXES = .c .o
AM_CFLAGS = -Wall
AM_LDFLAGS = -pthread

148
clib/jblock.c
View File

@@ -23,6 +23,13 @@ void jblock_init(jblock_t* jb) {
jb->kvarr = malloc(sizeof(jkeyval_t) * INIT_CAPA);
}
jblock_t* new_jblock() {
jblock_t* jb = malloc(sizeof(jblock_t));
if (jb == NULL) return NULL;
jblock_init(jb);
return jb;
}
static void* jblock_checkalloc(jblock_t* jb) {
if (jb->kvsize == jb->kvcapa) {
size_t newsize = jb->kvcapa * 2;
@@ -161,19 +168,44 @@ void jblock_outjson(jblock_t* jb, char** res) {
void jblock_destroy(jblock_t* jb) {
if (jb == NULL) return;
for (int i = 0; i < jb->kvsize; i++) {
free(jb->kvarr[i].key);
switch (jb->kvarr[i].type) {
case JKVTYPE_BLK: {
jblock_destroy(jb->kvarr[i].blk);
break;
}
//case JKVTYPE_BLKARR: {
// break;
//}
case JKVTYPE_STR: {
free(jb->kvarr[i].str);
break;
}
case JKVTYPE_INTARR: {
//free(jb->kvarr[i].numarr);
break;
}
case JKVTYPE_BOOLARR: {
//free(jb->kvarr[i].flagarr);
break;
}
case JKVTYPE_FLTARR: {
//free(jb->kvarr[i].fltarr);
break;
}
}
free(jb->kvarr[i].key);
}
jb->kvsize = 0;
jb->kvcapa = 0;
jb->kvarr = NULL;
}
void jblock_free(jblock_t* jb) {
jblock_destroy(jb);
free(jb);
}
/* String container */
static void* jstring_init(jstring_t* str) {
str->data = malloc(INIT_CAPA + 1);
if (str->data == NULL) return NULL;
@@ -188,7 +220,7 @@ static void* jstring_append(jstring_t* str, char* add) {
size_t addsize = strlen(add);
size_t newsize = str->size + addsize;
if (newsize > str->capa) {
char* newstr = malloc(newsize + 1);
char* newstr = realloc(str->data, newsize + 1);
if (newstr == NULL) return NULL;
}
strcpy(&(str->data[str->size]), add);
@@ -202,6 +234,118 @@ static char* jstring_getref(jstring_t* str) {
return str->data;
}
/* Integer array */
jintarr_t* new_jintarr(void) {
jintarr_t* arr = malloc(sizeof(jintarr_t));
if (arr == NULL) return NULL;
if (jintarr_init(arr) == NULL) {
jintarr_free(arr);
return NULL;
}
return arr;
}
void* jintarr_init(jintarr_t* array) {
array->data = malloc(INIT_CAPA * sizeof(int64_t));
if (array->data == NULL) return NULL;
memset(array->data, 0, INIT_CAPA);
array->capa = INIT_CAPA;
array->size = 0;
return array->data;
}
void* jintarr_append(jintarr_t* array, int64_t add) {
if (array->size + 1 > array->capa) {
size_t newcapa = (array->capa * 10) / 6 ;
int64_t* newarray = realloc(array->data, newcapa);
if (newarray == NULL) return NULL;
array->capa = newcapa;
array->data = newarray;
}
array->data[array->size++] = add;
return array->data;
}
int64_t* jintarr_getref(jintarr_t* array) {
return array->data;
}
void jintarr_destroy(jintarr_t* array) {
if (array == NULL) return;
free(array->data);
}
void jintarr_free(jintarr_t* array) {
jintarr_destroy(array);
free(array->data);
}
/* Float array */
void* jfltarr_init(jfltarr_t* array) {
array->data = malloc(INIT_CAPA * sizeof(double));
if (array->data == NULL) return NULL;
memset(array->data, 0, INIT_CAPA);
array->capa = INIT_CAPA;
array->size = 0;
return array->data;
}
void* jfltarr_append(jfltarr_t* array, double add) {
if (array->size + 1 > array->capa) {
size_t newcapa = (array->capa * 10) / 6 ;
double* newarray = realloc(array->data, newcapa);
if (newarray == NULL) return NULL;
array->capa = newcapa;
array->data = newarray;
}
array->data[array->size++] = add;
return array->data;
}
double* jfltarr_getref(jfltarr_t* array) {
return array->data;
}
void jfltarr_destroy(jfltarr_t* array) {
if (array == NULL) return;
free(array->data);
}
/* Bool array */
void* jboolarr_init(jboolarr_t* array) {
array->data = malloc(INIT_CAPA * sizeof(bool));
if (array->data == NULL) return NULL;
memset(array->data, 0, INIT_CAPA);
array->capa = INIT_CAPA;
array->size = 0;
return array->data;
}
void* jboolarr_append(jboolarr_t* array, bool add) {
if (array->size + 1 > array->capa) {
size_t newcapa = (array->capa * 10) / 6 ;
bool* newarray = realloc(array->data, newcapa);
if (newarray == NULL) return NULL;
array->capa = newcapa;
array->data = newarray;
}
array->data[array->size++] = add;
return array->data;
}
bool* jboolarr_getref(jboolarr_t* array) {
return array->data;
}
void jboolarr_destroy(jboolarr_t* array) {
if (array == NULL) return;
free(array->data);
}
/* Tools */
static char* strcopy(char* src) {
size_t srcsize = strlen(src) + 1;
char* dst = malloc(srcsize);

84
clib/jblock.h
View File

@@ -5,56 +5,106 @@
#include <stdint.h>
#include <stdbool.h>
typedef struct {
char* data;
int capa;
int size;
} jstring_t;
typedef struct {
int64_t* data;
int capa;
int size;
} jintarr_t;
typedef struct {
bool* data;
int capa;
int size;
} jboolarr_t;
typedef struct {
double* data;
int capa;
int size;
} jfltarr_t;
typedef struct jblock jblock_t;
typedef struct {
char* key;
int type;
union {
int64_t num;
bool flag;
char* str;
double flt;
int64_t* numarr;
char** strarr;
double* fltarr;
bool* flagarr;
int64_t num;
bool flag;
char* str;
double flt;
jintarr_t numarr;
jfltarr_t fltarr;
jboolarr_t flagarr;
jblock_t* blk;
jblock_t* blkarr;
char** strarr;
};
int arrsize;
int arrcapa;
} jkeyval_t;
typedef struct {
struct jblock {
jkeyval_t* kvarr;
int kvsize;
int kvcapa;
} jblock_t;
};
#define JKVTYPE_INT 0x01
#define JKVTYPE_STR 0x02
#define JKVTYPE_BOOL 0x03
#define JKVTYPE_FLT 0x04
#define JKVTYPE_BLK 0x05
#define JKVTYPE_INTARR 0x11
#define JKVTYPE_STRARR 0x12
#define JKVTYPE_BOOLARR 0x13
#define JKVTYPE_FLTARR 0x14
#define JKVTYPE_BLKARR 0x15
#define JB_MALLOCERR -1
#define JB_KEYEXISTS -2
jblock_t* new_jblock();
void jblock_init(jblock_t* block);
void jblock_outjson(jblock_t* block, char** res);
void jblock_destroy(jblock_t* block);
void jblock_free(jblock_t* jb);
void jblock_init(jblock_t* kv);
void jblock_outjson(jblock_t* kv, char** res);
void jblock_destroy(jblock_t* kv);
int jblock_addint(jblock_t* block, char* key, int64_t val);
int jblock_addfloat(jblock_t* block, char* key, double val);
int jblock_addstr(jblock_t* block, char* key, char* val);
int jblock_addbool(jblock_t* block, char* key, bool val);
jintarr_t* new_jintarr(void);
void* jintarr_init(jintarr_t* array);
void* jintarr_append(jintarr_t* array, int64_t add);
int64_t* jintarr_getref(jintarr_t* array);
void jintarr_destroy(jintarr_t* array);
void jintarr_free(jintarr_t* array);
jfltarr_t* new_jfltarr(void);
void* jfltarr_init(jfltarr_t* array);
void* jfltarr_append(jfltarr_t* array, double add);
double* jfltarr_getref(jfltarr_t* array);
void jfltarr_destroy(jfltarr_t* array);
void jfltarr_free(jfltarr_t* array);
jboolarr_t* new_jboolarr(void);
void* jboolarr_init(jboolarr_t* array);
void* jboolarr_append(jboolarr_t* array, bool add);
bool* jboolarr_getref(jboolarr_t* array);
void jboolarr_destroy(jboolarr_t* array);
void jboolarr_free(jboolarr_t* array);
int jblock_addint(jblock_t* kv, char* key, int64_t val);
int jblock_addfloat(jblock_t* kv, char* key, double val);
int jblock_addstr(jblock_t* kv, char* key, char* val);
int jblock_addbool(jblock_t* kv, char* key, bool val);
#endif

49
clib/jblock_test.c
View File

@@ -12,25 +12,54 @@
void test01(void) {
jblock_t jb;
jblock_t* jb = new_jblock();
jblock_init(&jb);
jblock_addint(&jb, "id1", 12345);
jblock_addstr(&jb, "id2", "qwerty");
jblock_addbool(&jb, "b1", true);
jblock_addbool(&jb, "b2", false);
jblock_addfloat(&jb, "f1", (double)123e1);
jblock_init(jb);
jblock_addint(jb, "id1", 12345);
jblock_addstr(jb, "id2", "qwerty");
jblock_addbool(jb, "b1", true);
jblock_addbool(jb, "b2", false);
jblock_addfloat(jb, "f1", (double)123e1);
char* jsonstr = NULL;
jblock_outjson(&jb, &jsonstr);
jblock_destroy(&jb);
jblock_outjson(jb, &jsonstr);
jblock_free(jb);
printf("%s\n", jsonstr);
free(jsonstr);
}
void test02(void) {
jintarr_t* arr = new_jintarr();
jintarr_init(arr);
for (int64_t i = 0; i < 1024 + 1; i++) {
jintarr_append(arr, i);
}
printf("size: %d capa: %d\n", arr->size, arr->capa);
printf("last: %ld\n", arr->data[arr->size - 1]);
jintarr_free(arr);
}
void test03(void) {
jfltarr_t arr;
jfltarr_init(&arr);
for (int64_t i = 0; i < 1024 + 1; i++) {
jfltarr_append(&arr, i);
}
printf("size: %d capa: %d\n", arr.size, arr.capa);
printf("last: %f\n", arr.data[arr.size - 1]);
jfltarr_destroy(&arr);
}
int main(void) {
test01();
//test01();
test02();
test03();
return 0;
}

52
clib/jlexer.c
View File

@@ -10,25 +10,27 @@
#include <rcache.h>
#include <jlexer.h>
#define JLEXCONT_UNDEF 0
#define JLEXCONT_WORD 1
#define JLEXCONT_BLOCKB 2
#define JLEXCONT_BLOCKE 3
#define JLEXCONT_SEPAR 4
#define JLEXCONT_NUM 5
#define JLEXCONT_UNKNOW 6
#define JLEXCONT_END 9
#define JLEXCONT_UNDEF 0x00
#define JLEXCONT_WORD 0x01
#define JLEXCONT_BLOCKB 0x02
#define JLEXCONT_BLOCKE 0x03
#define JLEXCONT_SEPAR 0x04
#define JLEXCONT_NUM 0x05
#define JLEXCONT_UNKNOW 0x06
#define JLEXCONT_END 0x99
#define JLEXTYPE_UNDEF 0
#define JLEXTYPE_BLOCKB 1
#define JLEXTYPE_BLOCKE 2
#define JLEXTYPE_WORDL 3
#define JLEXTYPE_SPACE 4
#define JLEXTYPE_SEPAR 5
#define JLEXTYPE_NUM 6
#define JLEXTYPE_COMMA 7
#define JLEXTYPE_CHAR 8
#define JLEXTYPE_EOF 9
#define JLEXTYPE_UNDEF 0x00
#define JLEXTYPE_BLOCKB 0x01
#define JLEXTYPE_BLOCKE 0x02
#define JLEXTYPE_WORDL 0x03
#define JLEXTYPE_SPACE 0x04
#define JLEXTYPE_SEPAR 0x05
#define JLEXTYPE_NUM 0x06
#define JLEXTYPE_COMMA 0x07
#define JLEXTYPE_CHAR 0x08
#define JLEXTYPE_ARRB 0x11
#define JLEXTYPE_ARRE 0x12
#define JLEXTYPE_EOF 0x99
static int get_ltype(char letter) {
@@ -39,6 +41,10 @@ static int get_ltype(char letter) {
return JLEXTYPE_BLOCKB;
case '}':
return JLEXTYPE_BLOCKE;
case '[':
return JLEXTYPE_ARRB;
case ']':
return JLEXTYPE_ARRE;
case '"':
return JLEXTYPE_WORDL;
case ' ':
@@ -113,6 +119,16 @@ int jlexer_gettoken(jlexer_t * lexer, char* token) {
lexer->context = JLEXCONT_UNDEF;
return JLEXTOK_BLOCKE;
}
case JLEXTYPE_ARRB:{
strcpy(token, "ARR BEGIN");
lexer->context = JLEXCONT_UNDEF;
return JLEXTOK_ARRB;
}
case JLEXTYPE_ARRE:{
strcpy(token, "ARR END");
lexer->context = JLEXCONT_UNDEF;
return JLEXTOK_ARRE;
}
case JLEXTYPE_SEPAR:{
strcpy(token, "IS");
lexer->context = JLEXCONT_UNDEF;

22
clib/jlexer.h
View File

@@ -16,16 +16,18 @@ typedef struct {
#define JLEXTOK_BLOCKB 1
#define JLEXTOK_BLOCKE 2
#define JLEXTOK_SPACE 4
#define JLEXTOK_SEPAR 3
#define JLEXTOK_UNDEF 4
#define JLEXTOK_WORD 5
#define JLEXTOK_NUMB 6
#define JLEXTOK_UNKNOW 7
#define JLEXTOK_NEXT 8
#define JLEXTOK_END 9
#define JLEXTOK_BLOCKB 0x01
#define JLEXTOK_BLOCKE 0x02
#define JLEXTOK_SPACE 0x04
#define JLEXTOK_SEPAR 0x03
#define JLEXTOK_UNDEF 0x04
#define JLEXTOK_WORD 0x05
#define JLEXTOK_NUMB 0x06
#define JLEXTOK_UNKNOW 0x07
#define JLEXTOK_NEXT 0x08
#define JLEXTOK_ARRB 0x10
#define JLEXTOK_ARRE 0x11
#define JLEXTOK_END 0x99

4
clib/jlexer_test.c
View File

@@ -32,9 +32,9 @@ int main(void) {
int type = 0;
while ((type = jlexer_gettoken(&lexer, token)) != JLEXTOK_END) {
printf("%d: %s\n", type, token);
printf("%02x: %s\n", type, token);
}
printf("%d: %s\n", type, token);
printf("%02x: %s\n", type, token);
rcache_destroy(&cache);

3
clib/jparser.c
View File

@@ -31,6 +31,7 @@ void jparser_init(jparser_t * parser, jlexer_t * lexer) {
#define MAX_TOKEN_SIZE 1024
int jparser_parse(jparser_t * parser) {
jlexer_t* lex = parser->lexer;
char token[MAX_TOKEN_SIZE];
@@ -40,7 +41,7 @@ int jparser_parse(jparser_t * parser) {
char* key = "";
while ((type = jlexer_gettoken(lex, token)) != JLEXTOK_END) {
//printf("pos %d %d: %s\n", pos, type, token);
printf("pos %d tok 0x%02x: %s\n", pos, type, token);
switch (pos) {
// POS 0
case 0:{

7
clib/jparser.h
View File

@@ -23,9 +23,10 @@ typedef struct {
jlexer_t* lexer;
} jparser_t;
#define JVALTYPE_STR 1
#define JVALTYPE_NUM 2
#define JVALTYPE_BOOL 3
#define JVALTYPE_STR 0x01
#define JVALTYPE_NUM 0x02
#define JVALTYPE_BOOL 0x03
#define JVALTYPE_BLK 0x04
void jparser_init(jparser_t* parser, jlexer_t* lexer);

4
clib/jparser_test.c
View File

@@ -40,14 +40,14 @@ int main(void) {
int64_t id = 0;
if (jparser_bind(&parser, JVALTYPE_NUM, "id", (void *)&id) < 0) {
log_error("cannot bind variable\n");
log_error("cannot bind id variable\n");
return 1;
}
char* name = "";
if (jparser_bind(&parser, JVALTYPE_STR, "name", (void *)&name) < 0) {
log_error("cannot bind variable\n");
log_error("cannot bind name variable\n");
}
printf("id = %ld\n", id);