From fc578f6e48669aa01f10c97de2233fde0e654a46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9E=D0=BB=D0=B5=D0=B3=20=D0=91=D0=BE=D1=80=D0=BE=D0=B4?= =?UTF-8?q?=D0=B8=D0=BD?= Date: Thu, 16 Oct 2025 00:08:17 +0200 Subject: [PATCH] indent --- libxtools/bstream.c | 134 ++++++------ libxtools/bstream.h | 8 +- libxtools/bstream_test.c | 54 ++--- libxtools/clcomp.c | 143 ++++++------- libxtools/clcomp.h | 10 +- libxtools/clcomp_test.c | 6 +- libxtools/clconfig.c | 33 +-- libxtools/clconfig.h | 20 +- libxtools/clconfig_test.c | 42 ++-- libxtools/cllexer.c | 206 +++++++++---------- libxtools/cllexer.h | 16 +- libxtools/cllexer_test.c | 10 +- libxtools/massert.c | 6 +- libxtools/massert.h | 2 +- libxtools/tccomp.c | 162 +++++++-------- libxtools/tccomp.h | 18 +- libxtools/tccomp_test.c | 73 +++---- libxtools/tclexer.c | 415 +++++++++++++++++++------------------- libxtools/tclexer.h | 12 +- libxtools/tclexer_test.c | 31 +-- libxtools/tconfig.c | 38 ++-- libxtools/tconfig.h | 18 +- libxtools/tconfig_test.c | 39 ++-- libxtools/vmapper.c | 290 +++++++++++++------------- libxtools/vmapper.h | 40 ++-- libxtools/vmapper_test.c | 47 ++--- 26 files changed, 968 insertions(+), 905 deletions(-) diff --git a/libxtools/bstream.c b/libxtools/bstream.c index 52fede6..919ce32 100644 --- a/libxtools/bstream.c +++ b/libxtools/bstream.c @@ -14,106 +14,114 @@ #define STREAM_INITCAPA 128 -bstream_t* bstream_init(bstream_t* stream) { - stream->data = malloc(STREAM_INITCAPA); - stream->wpos = 0; - stream->rpos = 0; - stream->capa = STREAM_INITCAPA; - return stream; +bstream_t* bstream_init(bstream_t * stream) { + stream->data = malloc(STREAM_INITCAPA); + stream->wpos = 0; + stream->rpos = 0; + stream->capa = STREAM_INITCAPA; + return stream; } bstream_t* new_bstream() { - bstream_t* stream = malloc(sizeof(bstream_t)); - if (stream == NULL) return NULL; - stream->data = malloc(STREAM_INITCAPA); - stream->wpos = 0; - stream->rpos = 0; - stream->capa = STREAM_INITCAPA; - return stream; + bstream_t* stream = malloc(sizeof(bstream_t)); + + if (stream == NULL) + return NULL; + stream->data = malloc(STREAM_INITCAPA); + stream->wpos = 0; + stream->rpos = 0; + stream->capa = STREAM_INITCAPA; + return stream; } size_t bstream_dump(bstream_t * stream) { - for (size_t i = 0; i < stream->wpos; i++) { - printf("%c", stream->data[i]); - } - return stream->wpos; + for (size_t i = 0; i < stream->wpos; i++) { + printf("%c", stream->data[i]); + } + return stream->wpos; } ssize_t bstream_write(bstream_t * stream, void* buf, size_t size) { - if ((stream->wpos + size) > stream->capa) { - size_t newcapa = stream->capa * 2; - stream->data = realloc(stream->data, (size_t)newcapa); - stream->capa = newcapa; - } - if (buf != NULL) { - memcpy(&(stream->data[stream->wpos]), buf, (size_t)size); - } - stream->wpos += size; - return (ssize_t)size; + if ((stream->wpos + size) > stream->capa) { + size_t newcapa = stream->capa * 2; + + stream->data = realloc(stream->data, (size_t)newcapa); + stream->capa = newcapa; + } + if (buf != NULL) { + memcpy(&(stream->data[stream->wpos]), buf, (size_t)size); + } + stream->wpos += size; + return (ssize_t) size; } ssize_t bstream_read(bstream_t * stream, void* buf, size_t size) { - size_t unread = stream->wpos - stream->rpos; - if (size > unread) { - size = unread; - } - if (buf != NULL) { - memcpy(buf, &(stream->data[stream->rpos]), size); - } - stream->rpos += size; - return (ssize_t)size; + size_t unread = stream->wpos - stream->rpos; + + if (size > unread) { + size = unread; + } + if (buf != NULL) { + memcpy(buf, &(stream->data[stream->rpos]), size); + } + stream->rpos += size; + return (ssize_t) size; } #define RBUF_SIZE 64 ssize_t bstream_fread(bstream_t * stream, char* filename) { - int fd = open(filename, O_RDONLY); - if (fd < 0) return (ssize_t)-1; + int fd = open(filename, O_RDONLY); - char buf[RBUF_SIZE]; - size_t size = 0; - size_t rsize = 0; - while ((size = (size_t)read(fd, buf, RBUF_SIZE)) > 0) { - if ((stream->wpos + size) > stream->capa) { - size_t newcapa = stream->capa * 2; - stream->data = realloc(stream->data, (size_t)newcapa); - stream->capa = newcapa; + if (fd < 0) + return (ssize_t) - 1; + + char buf[RBUF_SIZE]; + size_t size = 0; + size_t rsize = 0; + + while ((size = (size_t)read(fd, buf, RBUF_SIZE)) > 0) { + if ((stream->wpos + size) > stream->capa) { + size_t newcapa = stream->capa * 2; + + stream->data = realloc(stream->data, (size_t)newcapa); + stream->capa = newcapa; + } + memcpy(&(stream->data[stream->wpos]), buf, (size_t)size); + stream->wpos += size; + rsize += size; } - memcpy(&(stream->data[stream->wpos]), buf, (size_t)size); - stream->wpos += size; - rsize += size; - } - close(fd); - return (ssize_t)rsize; + close(fd); + return (ssize_t) rsize; } char bstream_getc(bstream_t * stream) { - size_t unread = stream->wpos - stream->rpos; + size_t unread = stream->wpos - stream->rpos; - if (unread == 0) - return EOF; - return (char)stream->data[stream->rpos++]; + if (unread == 0) + return EOF; + return (char)stream->data[stream->rpos++]; } size_t bstream_wpos(bstream_t * stream) { - return stream->wpos; + return stream->wpos; } size_t bstream_rpos(bstream_t * stream) { - return stream->rpos; + return stream->rpos; } void bstream_destroy(bstream_t * stream) { - if (stream != NULL) - free(stream->data); + if (stream != NULL) + free(stream->data); } void bstream_free(bstream_t * stream) { - if (stream != NULL) - free(stream->data); - free(stream); + if (stream != NULL) + free(stream->data); + free(stream); } diff --git a/libxtools/bstream.h b/libxtools/bstream.h index 8e52315..20ac588 100644 --- a/libxtools/bstream.h +++ b/libxtools/bstream.h @@ -11,10 +11,10 @@ #include typedef struct { - size_t rpos; - size_t wpos; - size_t capa; - uint8_t* data; + size_t rpos; + size_t wpos; + size_t capa; + uint8_t* data; } bstream_t; diff --git a/libxtools/bstream_test.c b/libxtools/bstream_test.c index 7c04278..ad45a70 100644 --- a/libxtools/bstream_test.c +++ b/libxtools/bstream_test.c @@ -10,38 +10,42 @@ #include void test_rwrite(void) { - bstream_t stream; - bstream_init(&stream); - char* data = "_123456789"; - size_t dsize = strlen(data); - ssize_t wsize = 0; + bstream_t stream; - size_t count = 3; - for (size_t i = 0; i < count; i++) { - wsize += bstream_write(&stream, data, dsize); - } - printf("wsize = %ld, data = [%s]\n", wsize, stream.data); + bstream_init(&stream); + char* data = "_123456789"; + size_t dsize = strlen(data); + ssize_t wsize = 0; - MASSERT(stream.wpos == dsize * count); - MASSERT(wsize == (ssize_t)(dsize * count)); + size_t count = 3; - size_t bsize = bstream_wpos(&stream); - char* buf = malloc((size_t)bsize + (size_t)1); - memset(buf, 0, (size_t)bsize + (size_t)1); + for (size_t i = 0; i < count; i++) { + wsize += bstream_write(&stream, data, dsize); + } + printf("wsize = %ld, data = [%s]\n", wsize, stream.data); - ssize_t rsize = bstream_read(&stream, buf, bsize); - printf("rsize = %lu, buf = [%s]\n", rsize, buf); + MASSERT(stream.wpos == dsize * count); + MASSERT(wsize == (ssize_t) (dsize * count)); - MASSERT(wsize == (ssize_t)(dsize * count)); - MASSERT(rsize == wsize); + size_t bsize = bstream_wpos(&stream); + char* buf = malloc((size_t)bsize + (size_t)1); - bstream_destroy(&stream); + memset(buf, 0, (size_t)bsize + (size_t)1); + + ssize_t rsize = bstream_read(&stream, buf, bsize); + + printf("rsize = %lu, buf = [%s]\n", rsize, buf); + + MASSERT(wsize == (ssize_t) (dsize * count)); + MASSERT(rsize == wsize); + + bstream_destroy(&stream); } -int main(int argc, char **argv) { - (void)argc; - (void)argv; - test_rwrite(); - return 0; +int main(int argc, char** argv) { + (void)argc; + (void)argv; + test_rwrite(); + return 0; } diff --git a/libxtools/clcomp.c b/libxtools/clcomp.c index 7903b60..b0e3eeb 100644 --- a/libxtools/clcomp.c +++ b/libxtools/clcomp.c @@ -13,14 +13,15 @@ #include static char* strcopy(char* src) { - size_t srcsize = strlen(src) + 1; - char* dst = malloc(srcsize); - memset(dst, '\0', srcsize); - strcpy(dst, src); - return dst; + size_t srcsize = strlen(src) + 1; + char* dst = malloc(srcsize); + + memset(dst, '\0', srcsize); + strcpy(dst, src); + return dst; } -void clcomp_init(clcomp_t* comp, vmapper_t* vmapper, char** argv, int argc) { +void clcomp_init(clcomp_t * comp, vmapper_t * vmapper, char** argv, int argc) { comp->argv = argv; comp->argc = argc; comp->argn = 1; @@ -28,97 +29,99 @@ void clcomp_init(clcomp_t* comp, vmapper_t* vmapper, char** argv, int argc) { comp->errstr = NULL; comp->vmapper = vmapper; if (comp->argc > comp->argn) { - cllexer_init(&(comp->lexer), comp->argv[comp->argn]); + cllexer_init(&(comp->lexer), comp->argv[comp->argn]); } } -char* clcomp_geterr(clcomp_t* comp) { +char* clcomp_geterr(clcomp_t * comp) { return comp->errstr; } -int clcomp_gettok(clcomp_t* comp, char* token) { - if (comp->argn > comp->argc) { - strcpy(token, "EOF"); - return TOKEN_ENDF; - } - - int toktype = cllexer_gettok(&(comp->lexer), token); - if (toktype == TOKEN_ENDF && comp->argn != comp->argc) { - comp->argn++; - cllexer_init(&(comp->lexer), comp->argv[comp->argn]); - strcpy(token, "space"); - return TOKEN_SPACE; - } - return toktype; +int clcomp_gettok(clcomp_t * comp, char* token) { + if (comp->argn > comp->argc) { + strcpy(token, "EOF"); + return TOKEN_ENDF; + } + + int toktype = cllexer_gettok(&(comp->lexer), token); + + if (toktype == TOKEN_ENDF && comp->argn != comp->argc) { + comp->argn++; + cllexer_init(&(comp->lexer), comp->argv[comp->argn]); + strcpy(token, "space"); + return TOKEN_SPACE; + } + return toktype; } -int clcomp_parse(clcomp_t* comp) { +int clcomp_parse(clcomp_t * comp) { char token[1024]; int toktype = TOKEN_NULL; int i = 0; char* key = NULL; char* val = NULL; + while (toktype != TOKEN_ENDF) { - toktype = clcomp_gettok(comp, token); - i++; - printf("cllexer_parse res: %d: %d [%s]\n", i, toktype, token); - switch (comp->pos) { - case 0: { - if (toktype == TOKEN_PREF) { - comp->pos = 1; - printf("pos %d: TOKEN_PREF %s\n", comp->pos, token); + toktype = clcomp_gettok(comp, token); + i++; + printf("cllexer_parse res: %d: %d [%s]\n", i, toktype, token); + switch (comp->pos) { + case 0:{ + if (toktype == TOKEN_PREF) { + comp->pos = 1; + printf("pos %d: TOKEN_PREF %s\n", comp->pos, token); + } + continue; } - continue; - } - case 1: { - if (toktype == TOKEN_WORD) { - comp->pos = 2; - key = strcopy(token); - printf("pos %d: TOKEN_WORD %s\n", comp->pos, token); - continue; - } else { - comp->errstr = "Unknown key token"; - goto error; + case 1:{ + if (toktype == TOKEN_WORD) { + comp->pos = 2; + key = strcopy(token); + printf("pos %d: TOKEN_WORD %s\n", comp->pos, token); + continue; + } else { + comp->errstr = "Unknown key token"; + goto error; + } } - } - case 2: { - if (toktype == TOKEN_DELIM || toktype == TOKEN_SPACE) { - comp->pos = 3; - printf("pos %d: TOKEN_DELIM %s\n", comp->pos, token); - continue; - } else { - comp->errstr = "Unknown delimeter token"; - goto error; + case 2:{ + if (toktype == TOKEN_DELIM || toktype == TOKEN_SPACE) { + comp->pos = 3; + printf("pos %d: TOKEN_DELIM %s\n", comp->pos, token); + continue; + } else { + comp->errstr = "Unknown delimeter token"; + goto error; + } } - } - case 3: { - if (toktype == TOKEN_WORD) { - comp->pos = 0; - printf("pos %d: TOKEN_WORD %s\n", comp->pos, token); - val = strcopy(token); - printf("keyval = [%s], [%s]\n", key, val); - vmapper_set(comp->vmapper, key, val); - free(key); - free(val); - continue; - } else { - comp->errstr = "Unknown key token"; - goto error; + case 3:{ + if (toktype == TOKEN_WORD) { + comp->pos = 0; + printf("pos %d: TOKEN_WORD %s\n", comp->pos, token); + val = strcopy(token); + printf("keyval = [%s], [%s]\n", key, val); + vmapper_set(comp->vmapper, key, val); + free(key); + free(val); + continue; + } else { + comp->errstr = "Unknown key token"; + goto error; + } } - } - } + } } return 0; - error: + error: free(key); free(val); return -1; } -void clcomp_destroy(clcomp_t* clcomp) { - (void)clcomp; +void clcomp_destroy(clcomp_t * clcomp) { + (void)clcomp; } diff --git a/libxtools/clcomp.h b/libxtools/clcomp.h index 4ccfd4e..a172748 100644 --- a/libxtools/clcomp.h +++ b/libxtools/clcomp.h @@ -20,9 +20,9 @@ typedef struct { char* errstr; } clcomp_t; -void clcomp_init(clcomp_t* clcomp, vmapper_t* vmapper, char** argv, int argc); -int clcomp_gettok(clcomp_t* clcomp, char* token); -int clcomp_parse(clcomp_t* clcomp); -char* clcomp_geterr(clcomp_t* clcomp); -void clcomp_destroy(clcomp_t* clcomp); +void clcomp_init(clcomp_t * clcomp, vmapper_t * vmapper, char** argv, int argc); +int clcomp_gettok(clcomp_t * clcomp, char* token); +int clcomp_parse(clcomp_t * clcomp); +char* clcomp_geterr(clcomp_t * clcomp); +void clcomp_destroy(clcomp_t * clcomp); #endif diff --git a/libxtools/clcomp_test.c b/libxtools/clcomp_test.c index 48226bb..2e597ab 100644 --- a/libxtools/clcomp_test.c +++ b/libxtools/clcomp_test.c @@ -12,17 +12,19 @@ #include #include -int main(int argc, char **argv) { +int main(int argc, char** argv) { (void)argc; (void)argv; - char*_argv[] = { argv[0], "--qwerty=12345", "--foo=bar" }; + char* _argv[] = { argv[0], "--qwerty=12345", "--foo=bar" }; int _argc = 2; vmapper_t vmapper; + vmapper_init(&vmapper); clcomp_t clcomp; + clcomp_init(&clcomp, &vmapper, _argv, _argc); clcomp_parse(&clcomp); diff --git a/libxtools/clconfig.c b/libxtools/clconfig.c index ef889e6..cad90b9 100644 --- a/libxtools/clconfig.c +++ b/libxtools/clconfig.c @@ -10,33 +10,34 @@ #include #include -void clconfig_init(clconfig_t* clconfig, int argc, char **argv) { - clconfig->errstr = NULL; - vmapper_init(&(clconfig->vmapper)); - clcomp_init(&(clconfig->comp), &(clconfig->vmapper), argv, argc); +void clconfig_init(clconfig_t * clconfig, int argc, char** argv) { + clconfig->errstr = NULL; + vmapper_init(&(clconfig->vmapper)); + clcomp_init(&(clconfig->comp), &(clconfig->vmapper), argv, argc); } -int clconfig_bind(clconfig_t* clconfig, int type, char* name, void* ptr) { - vmapper_t* vmapper = &(clconfig->vmapper); - return vmapper_bind(vmapper, type, name, ptr); +int clconfig_bind(clconfig_t * clconfig, int type, char* name, void* ptr) { + vmapper_t* vmapper = &(clconfig->vmapper); + + return vmapper_bind(vmapper, type, name, ptr); } -int clconfig_parse(clconfig_t* clconfig) { +int clconfig_parse(clconfig_t * clconfig) { int res = clcomp_parse(&(clconfig->comp)); + if (res < 0) { - if ((clconfig->errstr = clcomp_geterr(&(clconfig->comp))) == NULL) { - clconfig->errstr = "Undefined command line error"; - } + if ((clconfig->errstr = clcomp_geterr(&(clconfig->comp))) == NULL) { + clconfig->errstr = "Undefined command line error"; + } } return res; } -char* clconfig_geterr(clconfig_t* clconfig) { +char* clconfig_geterr(clconfig_t * clconfig) { return clconfig->errstr; } -void clconfig_destroy(clconfig_t* clconfig) { - clcomp_destroy(&(clconfig->comp)); - vmapper_destroy(&(clconfig->vmapper)); +void clconfig_destroy(clconfig_t * clconfig) { + clcomp_destroy(&(clconfig->comp)); + vmapper_destroy(&(clconfig->vmapper)); } - diff --git a/libxtools/clconfig.h b/libxtools/clconfig.h index 88c2d81..e439732 100644 --- a/libxtools/clconfig.h +++ b/libxtools/clconfig.h @@ -11,21 +11,21 @@ #include typedef struct { - clcomp_t comp; - vmapper_t vmapper; - int argc; - char ** argv; - char* errstr; + clcomp_t comp; + vmapper_t vmapper; + int argc; + char** argv; + char* errstr; } clconfig_t; #define GCONF_STR MAPPER_STR #define GCONF_INT MAPPER_INT #define GCONF_BOOL MAPPER_BOOL -void clconfig_init(clconfig_t* clconfig, int argc, char **argv); -int clconfig_bind(clconfig_t* clconfig, int type, char* name, void* ptr); -int clconfig_parse(clconfig_t* clconfig); -char* clconfig_geterr(clconfig_t* clconfig); -void clconfig_destroy(clconfig_t* clconfig); +void clconfig_init(clconfig_t * clconfig, int argc, char** argv); +int clconfig_bind(clconfig_t * clconfig, int type, char* name, void* ptr); +int clconfig_parse(clconfig_t * clconfig); +char* clconfig_geterr(clconfig_t * clconfig); +void clconfig_destroy(clconfig_t * clconfig); #endif diff --git a/libxtools/clconfig_test.c b/libxtools/clconfig_test.c index 02cd284..8666ba4 100644 --- a/libxtools/clconfig_test.c +++ b/libxtools/clconfig_test.c @@ -9,33 +9,35 @@ #include #include -int main(int argc, char **argv) { - (void)argc; - (void)argv; +int main(int argc, char** argv) { + (void)argc; + (void)argv; - char*_argv[] = { argv[0], "--strkey=num5678", "--intkey=12345" }; - int _argc = 2; + char* _argv[] = { argv[0], "--strkey=num5678", "--intkey=12345" }; + int _argc = 2; - clconfig_t clconfig; - clconfig_init(&clconfig, _argc, _argv); + clconfig_t clconfig; - int intkey = 0; - char* strkey = NULL; + clconfig_init(&clconfig, _argc, _argv); - clconfig_bind(&clconfig, GCONF_INT, "intkey", &intkey); - clconfig_bind(&clconfig, GCONF_STR, "strkey", &strkey); + int intkey = 0; + char* strkey = NULL; - int res = clconfig_parse(&clconfig); - if (res < 0) { - printf("error: %s\n", clconfig_geterr(&clconfig)); - } + clconfig_bind(&clconfig, GCONF_INT, "intkey", &intkey); + clconfig_bind(&clconfig, GCONF_STR, "strkey", &strkey); - MASSERT(res == 0); + int res = clconfig_parse(&clconfig); - clconfig_destroy(&clconfig); + if (res < 0) { + printf("error: %s\n", clconfig_geterr(&clconfig)); + } - printf("int key = %d\n", intkey); - printf("str key = %s\n", strkey); + MASSERT(res == 0); - return 0; + clconfig_destroy(&clconfig); + + printf("int key = %d\n", intkey); + printf("str key = %s\n", strkey); + + return 0; } diff --git a/libxtools/cllexer.c b/libxtools/cllexer.c index d105cad..bc55c34 100644 --- a/libxtools/cllexer.c +++ b/libxtools/cllexer.c @@ -22,19 +22,19 @@ #define LCONTEXT_UNDEF 7 static int get_ltype(char newletter) { - switch (newletter) { + switch (newletter) { case '-': case '+': - return LTYPE_PREFIX; + return LTYPE_PREFIX; case '=': - return LTYPE_DELIM; + return LTYPE_DELIM; case EOF: - return LTYPE_EOF; - } - return LTYPE_LETTER; + return LTYPE_EOF; + } + return LTYPE_LETTER; } -void cllexer_init(cllexer_t* lexer, char* arg) { +void cllexer_init(cllexer_t * lexer, char* arg) { lexer->arg = arg; lexer->rpos = 0; lexer->tpos = 0; @@ -42,125 +42,129 @@ void cllexer_init(cllexer_t* lexer, char* arg) { lexer->newletter = '\0'; } -static void cllexer_getletter(cllexer_t* lexer, char* arg, int size) { +static void cllexer_getletter(cllexer_t * lexer, char* arg, int size) { lexer->newletter = EOF; if (lexer->rpos < size) { - lexer->newletter = arg[lexer->rpos++]; + lexer->newletter = arg[lexer->rpos++]; } } -int cllexer_gettok(cllexer_t* lexer, char* token) { - - char* arg = lexer->arg; - size_t size = strlen(arg); - - if (lexer->currcontext == LCONTEXT_START) { - lexer->newletter = arg[lexer->rpos++]; - int ltype = get_ltype(lexer->newletter); - int newcontext = LCONTEXT_ENDFL; - switch (ltype) { - case LTYPE_PREFIX: { - newcontext = LCONTEXT_PREFIX; - break; - } - case LTYPE_DELIM: { - newcontext = LCONTEXT_DELIM; - break; - } - case LTYPE_LETTER: { - newcontext = LCONTEXT_WORD; - break; - } - case LTYPE_EOF: { - newcontext = LCONTEXT_ENDFL; - break; - } - } - lexer->currcontext = newcontext; - } +int cllexer_gettok(cllexer_t * lexer, char* token) { - while (lexer->currcontext != LCONTEXT_ENDFL) { + char* arg = lexer->arg; + size_t size = strlen(arg); - int ltype = get_ltype(lexer->newletter); + if (lexer->currcontext == LCONTEXT_START) { + lexer->newletter = arg[lexer->rpos++]; + int ltype = get_ltype(lexer->newletter); + int newcontext = LCONTEXT_ENDFL; - switch (lexer->currcontext) { - case LCONTEXT_ENDFL: { - lexer->currcontext = LCONTEXT_ENDFL; - break; - } - case LCONTEXT_DELIM: { - int newcontext = lexer->currcontext; switch (ltype) { - case LTYPE_PREFIX: - case LTYPE_LETTER: { - newcontext = LCONTEXT_WORD; + case LTYPE_PREFIX:{ + newcontext = LCONTEXT_PREFIX; break; } - case LTYPE_EOF: { - newcontext = LCONTEXT_ENDFL; - break; - } - } - if (newcontext != lexer->currcontext) { - lexer->currcontext = newcontext; - token[lexer->tpos] = '\0'; - lexer->tpos = 0; - return TOKEN_DELIM; - } - break; - } - case LCONTEXT_PREFIX: { - int newcontext = lexer->currcontext; - switch (ltype) { - case LTYPE_DELIM: { + case LTYPE_DELIM:{ newcontext = LCONTEXT_DELIM; break; } - case LTYPE_LETTER: { + case LTYPE_LETTER:{ newcontext = LCONTEXT_WORD; break; } - case LTYPE_EOF: { + case LTYPE_EOF:{ newcontext = LCONTEXT_ENDFL; break; } } - if (newcontext != lexer->currcontext) { - lexer->currcontext = newcontext; - token[lexer->tpos++] = '\0'; - lexer->tpos = 0; - return TOKEN_PREF; - } - break; - } - case LCONTEXT_WORD: { - int newcontext = lexer->currcontext; - switch (ltype) { - case LTYPE_DELIM: { - newcontext = LCONTEXT_DELIM; + lexer->currcontext = newcontext; + } + + while (lexer->currcontext != LCONTEXT_ENDFL) { + + int ltype = get_ltype(lexer->newletter); + + switch (lexer->currcontext) { + case LCONTEXT_ENDFL:{ + lexer->currcontext = LCONTEXT_ENDFL; break; } - case LTYPE_EOF: { - newcontext = LCONTEXT_ENDFL; + case LCONTEXT_DELIM:{ + int newcontext = lexer->currcontext; + + switch (ltype) { + case LTYPE_PREFIX: + case LTYPE_LETTER:{ + newcontext = LCONTEXT_WORD; + break; + } + case LTYPE_EOF:{ + newcontext = LCONTEXT_ENDFL; + break; + } + } + if (newcontext != lexer->currcontext) { + lexer->currcontext = newcontext; + token[lexer->tpos] = '\0'; + lexer->tpos = 0; + return TOKEN_DELIM; + } + break; + } + case LCONTEXT_PREFIX:{ + int newcontext = lexer->currcontext; + + switch (ltype) { + case LTYPE_DELIM:{ + newcontext = LCONTEXT_DELIM; + break; + } + case LTYPE_LETTER:{ + newcontext = LCONTEXT_WORD; + break; + } + case LTYPE_EOF:{ + newcontext = LCONTEXT_ENDFL; + break; + } + } + if (newcontext != lexer->currcontext) { + lexer->currcontext = newcontext; + token[lexer->tpos++] = '\0'; + lexer->tpos = 0; + return TOKEN_PREF; + } + break; + } + case LCONTEXT_WORD:{ + int newcontext = lexer->currcontext; + + switch (ltype) { + case LTYPE_DELIM:{ + newcontext = LCONTEXT_DELIM; + break; + } + case LTYPE_EOF:{ + newcontext = LCONTEXT_ENDFL; + break; + } + } + if (newcontext != lexer->currcontext) { + lexer->currcontext = newcontext; + token[lexer->tpos] = '\0'; + lexer->tpos = 0; + return TOKEN_WORD; + } break; } } - if (newcontext != lexer->currcontext) { - lexer->currcontext = newcontext; - token[lexer->tpos] = '\0'; - lexer->tpos = 0; - return TOKEN_WORD; - } - break; - } + token[lexer->tpos++] = lexer->newletter; + cllexer_getletter(lexer, arg, size); } - token[lexer->tpos++] = lexer->newletter; - cllexer_getletter(lexer, arg, size); - } - - lexer->currcontext = LCONTEXT_ENDFL; - lexer->tpos = 0; - token[lexer->tpos] = '\0'; - strcpy(token, "EOF"); - return TOKEN_ENDF; + + lexer->currcontext = LCONTEXT_ENDFL; + lexer->tpos = 0; + token[lexer->tpos] = '\0'; + strcpy(token, "EOF"); + return TOKEN_ENDF; } diff --git a/libxtools/cllexer.h b/libxtools/cllexer.h index e1ef66e..4efaf7f 100644 --- a/libxtools/cllexer.h +++ b/libxtools/cllexer.h @@ -16,15 +16,15 @@ typedef struct { - char* arg; - int currcontext; - int argn; - int rpos; - int tpos; - char newletter; + char* arg; + int currcontext; + int argn; + int rpos; + int tpos; + char newletter; } cllexer_t; -void cllexer_init(cllexer_t* lexer, char* arg); -int cllexer_gettok(cllexer_t* lexer, char* token); +void cllexer_init(cllexer_t * lexer, char* arg); +int cllexer_gettok(cllexer_t * lexer, char* token); #endif diff --git a/libxtools/cllexer_test.c b/libxtools/cllexer_test.c index 3b47c36..b1f5c3d 100644 --- a/libxtools/cllexer_test.c +++ b/libxtools/cllexer_test.c @@ -10,22 +10,24 @@ #include -int main(int argc, char **argv) { +int main(int argc, char** argv) { (void)argc; (void)argv; char* arg = "--qwerty=-num-12345"; cllexer_t lex; + cllexer_init(&lex, arg); char token[1024]; int toktype = TOKEN_NULL; int i = 0; + while (toktype != TOKEN_ENDF) { - toktype = cllexer_gettok(&lex, token); - printf("cllexer_gettok res: %d: %d [%s]\n", i, toktype, token); - i++; + toktype = cllexer_gettok(&lex, token); + printf("cllexer_gettok res: %d: %d [%s]\n", i, toktype, token); + i++; } return 0; diff --git a/libxtools/massert.c b/libxtools/massert.c index 760d21a..85c4a82 100644 --- a/libxtools/massert.c +++ b/libxtools/massert.c @@ -8,7 +8,7 @@ #include -void x__assert (char* path, int line, const char* func) { - printf("%s:%d: assert error in %s\n", path, line, func); - exit(1); +void x__assert(char* path, int line, const char* func) { + printf("%s:%d: assert error in %s\n", path, line, func); + exit(1); } diff --git a/libxtools/massert.h b/libxtools/massert.h index 5192231..0596e93 100644 --- a/libxtools/massert.h +++ b/libxtools/massert.h @@ -12,5 +12,5 @@ #define MASSERT(expr) if (!(expr)) \ { x__assert(__FILE__, __LINE__, (const char*)__func__); } -void x__assert (char* path, int line, const char* func); +void x__assert(char* path, int line, const char* func); #endif diff --git a/libxtools/tccomp.c b/libxtools/tccomp.c index d4a2c08..c6a17f0 100644 --- a/libxtools/tccomp.c +++ b/libxtools/tccomp.c @@ -25,101 +25,105 @@ #define POS4TYPE TOKEN_COMM static char* strcopy(char* src) { - size_t srcsize = strlen(src) + 1; - char* dst = malloc(srcsize); - memset(dst, '\0', srcsize); - strcpy(dst, src); - return dst; + size_t srcsize = strlen(src) + 1; + char* dst = malloc(srcsize); + + memset(dst, '\0', srcsize); + strcpy(dst, src); + return dst; } -tccomp_t * new_tccomp(tclexer_t * lexer, vmapper_t* vmapper) { - tccomp_t *comp = malloc(sizeof(tccomp_t)); - if (comp == NULL) return NULL; - comp->lexer = lexer; - comp->vmapper = vmapper; - comp->pos = 0; - comp->lnum = 0; - return comp; +tccomp_t* new_tccomp(tclexer_t * lexer, vmapper_t * vmapper) { + tccomp_t* comp = malloc(sizeof(tccomp_t)); + + if (comp == NULL) + return NULL; + comp->lexer = lexer; + comp->vmapper = vmapper; + comp->pos = 0; + comp->lnum = 0; + return comp; } -void tccomp_init(tccomp_t * comp, tclexer_t * lexer, vmapper_t* vmapper) { - comp->lexer = lexer; - comp->vmapper = vmapper; - comp->pos = 0; - comp->lnum = 0; +void tccomp_init(tccomp_t * comp, tclexer_t * lexer, vmapper_t * vmapper) { + comp->lexer = lexer; + comp->vmapper = vmapper; + comp->pos = 0; + comp->lnum = 0; } int tccomp_parse(tccomp_t * comp) { - char token[MAX_TOK_SIZE]; - int toktype = -1; - tclexer_t* lexer = comp->lexer; - char* key = NULL; - char* val = NULL; - - while (true) { - toktype = tclexer_get_token(lexer, token, MAX_TOK_SIZE); - if (toktype == TOKEN_SPACE) { - continue; - } - if (toktype == TOKEN_COMM) { - continue; - } - //printf("tok=%d pos=%d line=%d [%s]\n", toktype, comp->pos, comp->lnum, token); - - if (toktype == TOKEN_NEWLN) { - comp->lnum++; - } + char token[MAX_TOK_SIZE]; + int toktype = -1; + tclexer_t* lexer = comp->lexer; + char* key = NULL; + char* val = NULL; - switch (comp->pos) { - case 0: { - if (toktype == TOKEN_NEWLN) { - comp->pos = 0; - break; - } - if (toktype != TOKEN_WORD) { - return -1; + while (true) { + toktype = tclexer_get_token(lexer, token, MAX_TOK_SIZE); + if (toktype == TOKEN_SPACE) { + continue; } - comp->pos++; - key = strcopy(token); - break; - } - case 1: { - if (toktype != TOKEN_OPER) { - return -1; + if (toktype == TOKEN_COMM) { + continue; } - comp->pos++; - break; - } - case 2: { - if (toktype != TOKEN_WORD) { - return -1; + //printf("tok=%d pos=%d line=%d [%s]\n", toktype, comp->pos, comp->lnum, token); + + if (toktype == TOKEN_NEWLN) { + comp->lnum++; } - comp->pos++; - val = strcopy(token); - break; - } - case 3: { - if (toktype != TOKEN_NEWLN && toktype != TOKEN_ENDFL) { - return -1; + + switch (comp->pos) { + case 0:{ + if (toktype == TOKEN_NEWLN) { + comp->pos = 0; + break; + } + if (toktype != TOKEN_WORD) { + return -1; + } + comp->pos++; + key = strcopy(token); + break; + } + case 1:{ + if (toktype != TOKEN_OPER) { + return -1; + } + comp->pos++; + break; + } + case 2:{ + if (toktype != TOKEN_WORD) { + return -1; + } + comp->pos++; + val = strcopy(token); + break; + } + case 3:{ + if (toktype != TOKEN_NEWLN && toktype != TOKEN_ENDFL) { + return -1; + } + comp->pos = 0; + //printf("keyval = [%s], [%s]\n", key, val); + vmapper_set(comp->vmapper, key, val); + free(key); + free(val); + break; + } } - comp->pos = 0; - //printf("keyval = [%s], [%s]\n", key, val); - vmapper_set(comp->vmapper, key, val); - free(key); - free(val); - break; - } + if (toktype == TOKEN_ENDFL) + break; } - if (toktype == TOKEN_ENDFL) break; - } - return 0; + return 0; } -void tccomp_destroy(tccomp_t* comp) { - (void)comp; +void tccomp_destroy(tccomp_t * comp) { + (void)comp; } -void tccomp_free(tccomp_t* comp) { - free(comp); +void tccomp_free(tccomp_t * comp) { + free(comp); } diff --git a/libxtools/tccomp.h b/libxtools/tccomp.h index bbf8503..da82e98 100644 --- a/libxtools/tccomp.h +++ b/libxtools/tccomp.h @@ -9,16 +9,16 @@ #include typedef struct { - tclexer_t* lexer; - vmapper_t* vmapper; - int pos; - int lnum; + tclexer_t* lexer; + vmapper_t* vmapper; + int pos; + int lnum; } tccomp_t; -tccomp_t * new_tccomp(tclexer_t * lexer, vmapper_t* vmapper); -void tccomp_init(tccomp_t* comp, tclexer_t* lexer, vmapper_t* vmapper); -int tccomp_parse(tccomp_t* comp); -void tccomp_destroy(tccomp_t* comp); -void tccomp_free(tccomp_t* comp); +tccomp_t* new_tccomp(tclexer_t * lexer, vmapper_t * vmapper); +void tccomp_init(tccomp_t * comp, tclexer_t * lexer, vmapper_t * vmapper); +int tccomp_parse(tccomp_t * comp); +void tccomp_destroy(tccomp_t * comp); +void tccomp_free(tccomp_t * comp); #endif diff --git a/libxtools/tccomp_test.c b/libxtools/tccomp_test.c index a96c8fe..92466cb 100644 --- a/libxtools/tccomp_test.c +++ b/libxtools/tccomp_test.c @@ -18,55 +18,58 @@ int main(void) { - char* src = "key1 = var1 # comment 1\nkey2 = var2 # comment 2 and 3\n# comment 4\nkey3 = var3"; + char* src = "key1 = var1 # comment 1\nkey2 = var2 # comment 2 and 3\n# comment 4\nkey3 = var3"; - bstream_t stream; + bstream_t stream; - bstream_init(&stream); + bstream_init(&stream); - tclexer_t lexer; - tclexer_init(&lexer, &stream); + tclexer_t lexer; - vmapper_t vmapper; - vmapper_init(&vmapper); + tclexer_init(&lexer, &stream); - tccomp_t comp; - tccomp_init(&comp, &lexer, &vmapper); + vmapper_t vmapper; - bstream_write(&stream, src, strlen(src)); + vmapper_init(&vmapper); - int port = 0; - bool flag = false; - char* ident = NULL; + tccomp_t comp; - vmapper_bind_int(&vmapper, "port", &port); - vmapper_bind_string(&vmapper, "ident", &ident); - vmapper_bind_bool(&vmapper, "flag", &flag); + tccomp_init(&comp, &lexer, &vmapper); - vmapper_set(&vmapper, "port", "12345"); - vmapper_set(&vmapper, "ident", "qwerty"); - vmapper_set(&vmapper, "flag", "true"); + bstream_write(&stream, src, strlen(src)); - int res = tccomp_parse(&comp); + int port = 0; + bool flag = false; + char* ident = NULL; - if (res < 0) { - printf("parsing error pos %d line %d\n", comp.pos, comp.lnum); - } + vmapper_bind_int(&vmapper, "port", &port); + vmapper_bind_string(&vmapper, "ident", &ident); + vmapper_bind_bool(&vmapper, "flag", &flag); - printf("port = %d\n", port); - MASSERT(port == 12345); + vmapper_set(&vmapper, "port", "12345"); + vmapper_set(&vmapper, "ident", "qwerty"); + vmapper_set(&vmapper, "flag", "true"); - printf("ident = %s\n", ident); - MASSERT(strcmp(ident, "qwerty") == 0); - free(ident); + int res = tccomp_parse(&comp); - printf("flag = %d\n", flag); - MASSERT(flag == true); + if (res < 0) { + printf("parsing error pos %d line %d\n", comp.pos, comp.lnum); + } - tccomp_destroy(&comp); - tclexer_destroy(&lexer); - vmapper_destroy(&vmapper); - bstream_destroy(&stream); + printf("port = %d\n", port); + MASSERT(port == 12345); - return 0; + printf("ident = %s\n", ident); + MASSERT(strcmp(ident, "qwerty") == 0); + free(ident); + + printf("flag = %d\n", flag); + MASSERT(flag == true); + + tccomp_destroy(&comp); + tclexer_destroy(&lexer); + vmapper_destroy(&vmapper); + bstream_destroy(&stream); + + return 0; } diff --git a/libxtools/tclexer.c b/libxtools/tclexer.c index 1b24661..4334d39 100644 --- a/libxtools/tclexer.c +++ b/libxtools/tclexer.c @@ -29,248 +29,251 @@ static int get_ltype(char letter) { - switch (letter) { + switch (letter) { case '\n': - return LTYPE_NEWLN; + return LTYPE_NEWLN; case ' ': - return LTYPE_SPACE; + return LTYPE_SPACE; case '#': case ';': - return LTYPE_COMMB; + return LTYPE_COMMB; case '=': - return LTYPE_OPER; + return LTYPE_OPER; case EOF: - return LTYPE_ENDFL; - } - return LTYPE_LETTER; + return LTYPE_ENDFL; + } + return LTYPE_LETTER; } tclexer_t* new_tclexer(bstream_t * stream) { - tclexer_t* lexer = malloc(sizeof(tclexer_t)); - if (lexer == NULL) return NULL; - lexer->stream = stream; - lexer->context = LEXCONT_UNDEF; - return lexer; + tclexer_t* lexer = malloc(sizeof(tclexer_t)); + + if (lexer == NULL) + return NULL; + lexer->stream = stream; + lexer->context = LEXCONT_UNDEF; + return lexer; } void tclexer_init(tclexer_t * lexer, bstream_t * stream) { - lexer->stream = stream; - lexer->context = LEXCONT_UNDEF; - lexer->pos = 0; + lexer->stream = stream; + lexer->context = LEXCONT_UNDEF; + lexer->pos = 0; } int tclexer_get_token(tclexer_t * lexer, char* token, int maxsize) { - lexer->pos = 0; - - if (lexer->pos > (maxsize - 1)) { - return -2; - } + lexer->pos = 0; - if (lexer->context == LEXCONT_UNDEF) { - lexer->letter = bstream_getc(lexer->stream); - } + if (lexer->pos > (maxsize - 1)) { + return -2; + } - while (true) { - int ltype = get_ltype(lexer->letter); + if (lexer->context == LEXCONT_UNDEF) { + lexer->letter = bstream_getc(lexer->stream); + } - switch (lexer->context) { - case LEXCONT_ENDFL:{ - return TOKEN_ENDFL; - } - case LEXCONT_WORD:{ - int newcontext = LEXCONT_WORD; + while (true) { + int ltype = get_ltype(lexer->letter); - switch (ltype) { - case LTYPE_SPACE:{ - newcontext = LEXCONT_SPACE; - break; + switch (lexer->context) { + case LEXCONT_ENDFL:{ + return TOKEN_ENDFL; } - case LTYPE_NEWLN:{ - newcontext = LEXCONT_NEWLN; - break; - } - case LTYPE_COMMB:{ - newcontext = LEXCONT_COMM; - break; - } - case LTYPE_OPER:{ - newcontext = LEXCONT_OPER; - break; - } - case LTYPE_ENDFL:{ - newcontext = LEXCONT_ENDFL; - break; - } - } - if (newcontext != lexer->context) { - lexer->context = newcontext; - token[lexer->pos++] = '\0'; - return TOKEN_WORD; - } - token[lexer->pos++] = lexer->letter; - break; - } - case LEXCONT_COMM:{ - int newcontext = LEXCONT_COMM; + case LEXCONT_WORD:{ + int newcontext = LEXCONT_WORD; - switch (ltype) { - case LTYPE_NEWLN:{ - newcontext = LEXCONT_NEWLN; - break; - } - case LTYPE_ENDFL:{ - newcontext = LEXCONT_ENDFL; - break; + switch (ltype) { + case LTYPE_SPACE:{ + newcontext = LEXCONT_SPACE; + break; + } + case LTYPE_NEWLN:{ + newcontext = LEXCONT_NEWLN; + break; + } + case LTYPE_COMMB:{ + newcontext = LEXCONT_COMM; + break; + } + case LTYPE_OPER:{ + newcontext = LEXCONT_OPER; + break; + } + case LTYPE_ENDFL:{ + newcontext = LEXCONT_ENDFL; + break; + } + } + if (newcontext != lexer->context) { + lexer->context = newcontext; + token[lexer->pos++] = '\0'; + return TOKEN_WORD; + } + token[lexer->pos++] = lexer->letter; + break; } - } - if (newcontext != lexer->context) { - token[lexer->pos++] = '\0'; - lexer->context = newcontext; - return TOKEN_COMM; - } - token[lexer->pos++] = lexer->letter; - break; - } - case LEXCONT_SPACE:{ - int newcontext = LEXCONT_SPACE; + case LEXCONT_COMM:{ + int newcontext = LEXCONT_COMM; - switch (ltype) { - case LTYPE_OPER:{ - newcontext = LEXCONT_OPER; - break; - } - case LTYPE_COMMB:{ - newcontext = LEXCONT_COMM; - break; + switch (ltype) { + case LTYPE_NEWLN:{ + newcontext = LEXCONT_NEWLN; + break; + } + case LTYPE_ENDFL:{ + newcontext = LEXCONT_ENDFL; + break; + } + } + if (newcontext != lexer->context) { + token[lexer->pos++] = '\0'; + lexer->context = newcontext; + return TOKEN_COMM; + } + token[lexer->pos++] = lexer->letter; + break; } - case LTYPE_LETTER:{ - newcontext = LEXCONT_WORD; - break; - } - case LTYPE_NEWLN:{ - newcontext = LEXCONT_NEWLN; - break; - } - case LTYPE_ENDFL:{ - newcontext = LEXCONT_ENDFL; - break; - } - } - if (newcontext != lexer->context) { - lexer->context = newcontext; - strcpy(token, "SPACE"); - return TOKEN_SPACE; - } - token[lexer->pos++] = lexer->letter; - break; - } - case LEXCONT_OPER:{ - int newcontext = LEXCONT_OPER; + case LEXCONT_SPACE:{ + int newcontext = LEXCONT_SPACE; - switch (ltype) { - case LTYPE_SPACE:{ - newcontext = LEXCONT_SPACE; - break; - } - case LTYPE_NEWLN:{ - newcontext = LEXCONT_NEWLN; - break; - } - case LTYPE_COMMB:{ - newcontext = LEXCONT_COMM; - break; - } - case LTYPE_LETTER:{ - newcontext = LEXCONT_WORD; - break; - } - case LTYPE_ENDFL:{ - newcontext = LEXCONT_ENDFL; - break; + switch (ltype) { + case LTYPE_OPER:{ + newcontext = LEXCONT_OPER; + break; + } + case LTYPE_COMMB:{ + newcontext = LEXCONT_COMM; + break; + } + case LTYPE_LETTER:{ + newcontext = LEXCONT_WORD; + break; + } + case LTYPE_NEWLN:{ + newcontext = LEXCONT_NEWLN; + break; + } + case LTYPE_ENDFL:{ + newcontext = LEXCONT_ENDFL; + break; + } + } + if (newcontext != lexer->context) { + lexer->context = newcontext; + strcpy(token, "SPACE"); + return TOKEN_SPACE; + } + token[lexer->pos++] = lexer->letter; + break; } - } - if (newcontext != lexer->context) { - lexer->context = newcontext; - strcpy(token, "="); - return TOKEN_OPER; - } - token[lexer->pos++] = lexer->letter; - break; - } - case LEXCONT_NEWLN:{ - int newcontext = LEXCONT_NEWLN; + case LEXCONT_OPER:{ + int newcontext = LEXCONT_OPER; - switch (ltype) { - case LTYPE_SPACE:{ - newcontext = LEXCONT_SPACE; - break; - } - case LTYPE_COMMB:{ - newcontext = LEXCONT_COMM; - break; - } - case LTYPE_LETTER:{ - newcontext = LEXCONT_WORD; - break; + switch (ltype) { + case LTYPE_SPACE:{ + newcontext = LEXCONT_SPACE; + break; + } + case LTYPE_NEWLN:{ + newcontext = LEXCONT_NEWLN; + break; + } + case LTYPE_COMMB:{ + newcontext = LEXCONT_COMM; + break; + } + case LTYPE_LETTER:{ + newcontext = LEXCONT_WORD; + break; + } + case LTYPE_ENDFL:{ + newcontext = LEXCONT_ENDFL; + break; + } + } + if (newcontext != lexer->context) { + lexer->context = newcontext; + strcpy(token, "="); + return TOKEN_OPER; + } + token[lexer->pos++] = lexer->letter; + break; } - case LTYPE_ENDFL:{ - newcontext = LEXCONT_ENDFL; - break; - } - } - if (newcontext != lexer->context) { - lexer->context = newcontext; - strcpy(token, "NL"); - return TOKEN_NEWLN; - } - token[lexer->pos++] = lexer->letter; - break; - } + case LEXCONT_NEWLN:{ + int newcontext = LEXCONT_NEWLN; - case LEXCONT_UNDEF: - default:{ - int newcontext = LEXCONT_UNDEF; - switch (ltype) { - case LTYPE_SPACE:{ - newcontext = LEXCONT_SPACE; - break; - } - case LTYPE_NEWLN:{ - newcontext = LEXCONT_NEWLN; - break; - } - case LTYPE_COMMB:{ - newcontext = LEXCONT_COMM; - break; + switch (ltype) { + case LTYPE_SPACE:{ + newcontext = LEXCONT_SPACE; + break; + } + case LTYPE_COMMB:{ + newcontext = LEXCONT_COMM; + break; + } + case LTYPE_LETTER:{ + newcontext = LEXCONT_WORD; + break; + } + case LTYPE_ENDFL:{ + newcontext = LEXCONT_ENDFL; + break; + } + } + if (newcontext != lexer->context) { + lexer->context = newcontext; + strcpy(token, "NL"); + return TOKEN_NEWLN; + } + token[lexer->pos++] = lexer->letter; + break; } - case LTYPE_LETTER:{ - newcontext = LEXCONT_WORD; - break; - } - case LTYPE_OPER:{ - newcontext = LEXCONT_OPER; - break; - } - case LTYPE_ENDFL:{ - newcontext = LEXCONT_ENDFL; - break; + + case LEXCONT_UNDEF: + default:{ + int newcontext = LEXCONT_UNDEF; + + switch (ltype) { + case LTYPE_SPACE:{ + newcontext = LEXCONT_SPACE; + break; + } + case LTYPE_NEWLN:{ + newcontext = LEXCONT_NEWLN; + break; + } + case LTYPE_COMMB:{ + newcontext = LEXCONT_COMM; + break; + } + case LTYPE_LETTER:{ + newcontext = LEXCONT_WORD; + break; + } + case LTYPE_OPER:{ + newcontext = LEXCONT_OPER; + break; + } + case LTYPE_ENDFL:{ + newcontext = LEXCONT_ENDFL; + break; + } + } + lexer->context = newcontext; + token[lexer->pos++] = lexer->letter; + break; } } - lexer->context = newcontext; - token[lexer->pos++] = lexer->letter; - break; - } + lexer->letter = bstream_getc(lexer->stream); } - lexer->letter = bstream_getc(lexer->stream); - } - return TOKEN_ENDFL; + return TOKEN_ENDFL; } -void tclexer_destroy(tclexer_t* lexer) { - (void)lexer; +void tclexer_destroy(tclexer_t * lexer) { + (void)lexer; } -void tclexer_free(tclexer_t* lexer) { - free(lexer); +void tclexer_free(tclexer_t * lexer) { + free(lexer); } diff --git a/libxtools/tclexer.h b/libxtools/tclexer.h index d8c872b..3971b4a 100644 --- a/libxtools/tclexer.h +++ b/libxtools/tclexer.h @@ -8,10 +8,10 @@ #include typedef struct { - bstream_t* stream; - int context; - char letter; - int pos; + bstream_t* stream; + int context; + char letter; + int pos; } tclexer_t; #define MAX_TOK_SIZE 1024 @@ -27,6 +27,6 @@ typedef struct { tclexer_t* new_tclexer(bstream_t * stream); void tclexer_init(tclexer_t * tclexer, bstream_t * stream); int tclexer_get_token(tclexer_t * tclexer, char* token, int maxsize); -void tclexer_destroy(tclexer_t* lexer); -void tclexer_free(tclexer_t* lexer); +void tclexer_destroy(tclexer_t * lexer); +void tclexer_free(tclexer_t * lexer); #endif diff --git a/libxtools/tclexer_test.c b/libxtools/tclexer_test.c index 17a5ef4..8378ae6 100644 --- a/libxtools/tclexer_test.c +++ b/libxtools/tclexer_test.c @@ -14,24 +14,27 @@ int main(void) { - char* src = " key1 = var1 # comment 1\nkey2 = var2 # comment 2 and 3\n# comment 4\nkey3 = var3"; + char* src = " key1 = var1 # comment 1\nkey2 = var2 # comment 2 and 3\n# comment 4\nkey3 = var3"; - bstream_t stream; - bstream_init(&stream); - bstream_write(&stream, src, strlen(src)); + bstream_t stream; + bstream_init(&stream); + bstream_write(&stream, src, strlen(src)); - tclexer_t lexer; - tclexer_init(&lexer, &stream); - int token_typ = TOKEN_NULL; - char token[MAX_TOK_SIZE]; - while ((token_typ = tclexer_get_token(&lexer, token, MAX_TOK_SIZE)) != TOKEN_ENDFL) { - printf("%d:[%s]\n", token_typ, token); - } + tclexer_t lexer; - tclexer_destroy(&lexer); - bstream_destroy(&stream); + tclexer_init(&lexer, &stream); - return 0; + int token_typ = TOKEN_NULL; + char token[MAX_TOK_SIZE]; + + while ((token_typ = tclexer_get_token(&lexer, token, MAX_TOK_SIZE)) != TOKEN_ENDFL) { + printf("%d:[%s]\n", token_typ, token); + } + + tclexer_destroy(&lexer); + bstream_destroy(&stream); + + return 0; } diff --git a/libxtools/tconfig.c b/libxtools/tconfig.c index 60f0261..e628daa 100644 --- a/libxtools/tconfig.c +++ b/libxtools/tconfig.c @@ -11,31 +11,33 @@ #include #include -void tconfig_init(tconfig_t* tconfig) { - bstream_init(&(tconfig->stream)); - vmapper_init(&(tconfig->mapper)); - tclexer_init(&(tconfig->lexer), &(tconfig->stream)); - tccomp_init(&(tconfig->comp), &(tconfig->lexer), &(tconfig->mapper)); +void tconfig_init(tconfig_t * tconfig) { + bstream_init(&(tconfig->stream)); + vmapper_init(&(tconfig->mapper)); + tclexer_init(&(tconfig->lexer), &(tconfig->stream)); + tccomp_init(&(tconfig->comp), &(tconfig->lexer), &(tconfig->mapper)); } -int tconfig_bind(tconfig_t* tconfig, int type, char* name, void* ptr) { - vmapper_t* vmapper = &(tconfig->mapper); - return vmapper_bind(vmapper, type, name, ptr); +int tconfig_bind(tconfig_t * tconfig, int type, char* name, void* ptr) { + vmapper_t* vmapper = &(tconfig->mapper); + + return vmapper_bind(vmapper, type, name, ptr); } -ssize_t tconfig_read(tconfig_t* tconfig, char* filename) { - bstream_t* stream = &(tconfig->stream); - return bstream_fread(stream, filename); +ssize_t tconfig_read(tconfig_t * tconfig, char* filename) { + bstream_t* stream = &(tconfig->stream); + + return bstream_fread(stream, filename); } -int tconfig_parse(tconfig_t* tconfig) { +int tconfig_parse(tconfig_t * tconfig) { - return tccomp_parse(&(tconfig->comp)); + return tccomp_parse(&(tconfig->comp)); } -void tconfig_destroy(tconfig_t* tconfig) { - tccomp_destroy(&(tconfig->comp)); - tclexer_destroy(&(tconfig->lexer)); - bstream_destroy(&(tconfig->stream)); - vmapper_destroy(&(tconfig->mapper)); +void tconfig_destroy(tconfig_t * tconfig) { + tccomp_destroy(&(tconfig->comp)); + tclexer_destroy(&(tconfig->lexer)); + bstream_destroy(&(tconfig->stream)); + vmapper_destroy(&(tconfig->mapper)); } diff --git a/libxtools/tconfig.h b/libxtools/tconfig.h index 73cc7bd..2fe2aed 100644 --- a/libxtools/tconfig.h +++ b/libxtools/tconfig.h @@ -12,20 +12,20 @@ #include typedef struct { - bstream_t stream; - tclexer_t lexer; - tccomp_t comp; - vmapper_t mapper; + bstream_t stream; + tclexer_t lexer; + tccomp_t comp; + vmapper_t mapper; } tconfig_t; #define TCONF_STR MAPPER_STR #define TCONF_INT MAPPER_INT #define TCONF_BOOL MAPPER_BOOL -void tconfig_init(tconfig_t* tconfig); -int tconfig_bind(tconfig_t* tconfig, int type, char* name, void* ptr); -ssize_t tconfig_read(tconfig_t* tconfig, char* filename); -int tconfig_parse(tconfig_t* tconfig); -void tconfig_destroy(tconfig_t* tconfig); +void tconfig_init(tconfig_t * tconfig); +int tconfig_bind(tconfig_t * tconfig, int type, char* name, void* ptr); +ssize_t tconfig_read(tconfig_t * tconfig, char* filename); +int tconfig_parse(tconfig_t * tconfig); +void tconfig_destroy(tconfig_t * tconfig); #endif diff --git a/libxtools/tconfig_test.c b/libxtools/tconfig_test.c index 97ee0bf..be8a579 100644 --- a/libxtools/tconfig_test.c +++ b/libxtools/tconfig_test.c @@ -10,30 +10,33 @@ #include #include -int main(int argc, char **argv) { - (void)argc; - (void)argv; +int main(int argc, char** argv) { + (void)argc; + (void)argv; - tconfig_t tconfig; - tconfig_init(&tconfig); + tconfig_t tconfig; - int intkey = 0; - char* strkey = NULL; + tconfig_init(&tconfig); - tconfig_bind(&tconfig, TCONF_INT, "intkey", &intkey); - tconfig_bind(&tconfig, TCONF_STR, "strkey", &strkey); + int intkey = 0; + char* strkey = NULL; - ssize_t rsize = tconfig_read(&tconfig, "test.conf"); - printf("%ld\n", rsize); - MASSERT(rsize > 0); + tconfig_bind(&tconfig, TCONF_INT, "intkey", &intkey); + tconfig_bind(&tconfig, TCONF_STR, "strkey", &strkey); - int res = tconfig_parse(&tconfig); - MASSERT(res == -1); + ssize_t rsize = tconfig_read(&tconfig, "test.conf"); - tconfig_destroy(&tconfig); + printf("%ld\n", rsize); + MASSERT(rsize > 0); - printf("int key = %d\n", intkey); - printf("str key = %s\n", strkey); - return 0; + int res = tconfig_parse(&tconfig); + + MASSERT(res == -1); + + tconfig_destroy(&tconfig); + + printf("int key = %d\n", intkey); + printf("str key = %s\n", strkey); + return 0; } diff --git a/libxtools/vmapper.c b/libxtools/vmapper.c index f4066aa..e012bef 100644 --- a/libxtools/vmapper.c +++ b/libxtools/vmapper.c @@ -10,37 +10,41 @@ #include static char* copystr(char* src) { - size_t srcsize = strlen(src) + 1; - char* dest = malloc(srcsize); - memset(dest, '\0', srcsize); - strcpy(dest, src); - return dest; + size_t srcsize = strlen(src) + 1; + char* dest = malloc(srcsize); + + memset(dest, '\0', srcsize); + strcpy(dest, src); + return dest; } static mlink_t* new_mlink_string(char* name, char** val) { - mlink_t* mlink = malloc(sizeof(mlink_t)); - mlink->name = name; - mlink->vptr = (void*)val; - mlink->type = MAPPER_STR; - return mlink; + mlink_t* mlink = malloc(sizeof(mlink_t)); + + mlink->name = name; + mlink->vptr = (void *)val; + mlink->type = MAPPER_STR; + return mlink; } static mlink_t* new_mlink_integer(char* name, int* val) { - mlink_t* mlink = malloc(sizeof(mlink_t)); - mlink->name = name; - mlink->vptr = (void*)val; - mlink->type = MAPPER_INT; - return mlink; + mlink_t* mlink = malloc(sizeof(mlink_t)); + + mlink->name = name; + mlink->vptr = (void *)val; + mlink->type = MAPPER_INT; + return mlink; } static mlink_t* new_mlink_bool(char* name, bool* val) { - mlink_t* mlink = malloc(sizeof(mlink_t)); - mlink->name = name; - mlink->vptr = (void*)val; - mlink->type = MAPPER_BOOL; - return mlink; + mlink_t* mlink = malloc(sizeof(mlink_t)); + + mlink->name = name; + mlink->vptr = (void *)val; + mlink->type = MAPPER_BOOL; + return mlink; } @@ -48,150 +52,164 @@ static mlink_t* new_mlink_bool(char* name, bool* val) { vmapper_t* new_vmapper(void) { - vmapper_t* vmapper = malloc(sizeof(vmapper_t)); - if (vmapper == NULL) return NULL; - vmapper->mlinks = malloc(sizeof(mlink_t) * MAPPER_INITCAPA); - vmapper->capa = MAPPER_INITCAPA; - vmapper->size = 0; - vmapper->err = false; - vmapper->errstr = NULL; - return vmapper; + vmapper_t* vmapper = malloc(sizeof(vmapper_t)); + + if (vmapper == NULL) + return NULL; + vmapper->mlinks = malloc(sizeof(mlink_t) * MAPPER_INITCAPA); + vmapper->capa = MAPPER_INITCAPA; + vmapper->size = 0; + vmapper->err = false; + vmapper->errstr = NULL; + return vmapper; } -void vmapper_init(vmapper_t* vmapper) { - vmapper->mlinks = malloc(sizeof(mlink_t) * MAPPER_INITCAPA); - vmapper->capa = MAPPER_INITCAPA; - vmapper->size = 0; - vmapper->err = false; - vmapper->errstr = NULL; - return; +void vmapper_init(vmapper_t * vmapper) { + vmapper->mlinks = malloc(sizeof(mlink_t) * MAPPER_INITCAPA); + vmapper->capa = MAPPER_INITCAPA; + vmapper->size = 0; + vmapper->err = false; + vmapper->errstr = NULL; + return; } #define RES_BIND_OK ((int)0) #define RES_BIND_ERR ((int)-1) -int vmapper_check_capa(vmapper_t* vmapper) { - if (vmapper->size == vmapper->capa) { - size_t newcapa = vmapper->capa * 2; - mlink_t** newmlinks = realloc(vmapper->mlinks, newcapa); - if (newmlinks == NULL) return RES_BIND_ERR; - vmapper->mlinks = newmlinks; - vmapper->capa = newcapa; - } - return RES_BIND_OK; -} - -int vmapper_bind_string(vmapper_t* vmapper, char* name, char** val) { - int res = 0; - if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) { - return res; - } - mlink_t* mlink = new_mlink_string(name, val); - vmapper->mlinks[vmapper->size] = mlink; - vmapper->size++; - return RES_BIND_OK; -} - -int vmapper_bind_int(vmapper_t* vmapper, char* name, int* val) { - int res = 0; - if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) { - return res; - } - mlink_t* mlink = new_mlink_integer(name, val); - vmapper->mlinks[vmapper->size] = mlink; - vmapper->size++; - return RES_BIND_OK; -} - - -int vmapper_bind_bool(vmapper_t* vmapper, char* name, bool* val) { - int res = 0; - if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) { - return res; - } - mlink_t* mlink = new_mlink_bool(name, val); - vmapper->mlinks[vmapper->size] = mlink; - vmapper->size++; - return RES_BIND_OK; -} - -int vmapper_set_int(vmapper_t* vmapper, char* key, char* val) { - for (size_t i = 0; i < vmapper->size; i++) { - mlink_t* mlink = vmapper->mlinks[i]; - if (mlink->type == MAPPER_INT && strcmp(mlink->name, key) == 0) { - char* eptr = NULL; - *(int*)(mlink->vptr) = (int)strtol(val, &eptr, 10); +int vmapper_check_capa(vmapper_t * vmapper) { + if (vmapper->size == vmapper->capa) { + size_t newcapa = vmapper->capa * 2; + mlink_t** newmlinks = realloc(vmapper->mlinks, newcapa); + + if (newmlinks == NULL) + return RES_BIND_ERR; + vmapper->mlinks = newmlinks; + vmapper->capa = newcapa; } - } - return 0; + return RES_BIND_OK; } -int vmapper_set_string(vmapper_t* vmapper, char* key, char* val) { - for (size_t i = 0; i < vmapper->size; i++) { - mlink_t* mlink = vmapper->mlinks[i]; - if (mlink->type == MAPPER_STR && strcmp(mlink->name, key) == 0) { - *(char**)(mlink->vptr) = copystr(val); +int vmapper_bind_string(vmapper_t * vmapper, char* name, char** val) { + int res = 0; + + if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) { + return res; } - } - return 0; + mlink_t* mlink = new_mlink_string(name, val); + + vmapper->mlinks[vmapper->size] = mlink; + vmapper->size++; + return RES_BIND_OK; } -int vmapper_set_bool(vmapper_t* vmapper, char* key, char* val) { - for (size_t i = 0; i < vmapper->size; i++) { - mlink_t* mlink = vmapper->mlinks[i]; - if (mlink->type == MAPPER_BOOL && strcmp(mlink->name, key) == 0) { - if (strcmp(val, "true") == 0) { - *(bool*)(mlink->vptr) = true; - } - if (strcmp(val, "false") == 0) { - *(bool*)(mlink->vptr) = false; - } +int vmapper_bind_int(vmapper_t * vmapper, char* name, int* val) { + int res = 0; + + if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) { + return res; } - } - return 0; + mlink_t* mlink = new_mlink_integer(name, val); + + vmapper->mlinks[vmapper->size] = mlink; + vmapper->size++; + return RES_BIND_OK; } -int vmapper_bind(vmapper_t* vmapper, int type, char* name, void* val) { - switch (type) { - case MAPPER_STR: { - return vmapper_bind_string(vmapper, name, (char**)val); - } - case MAPPER_INT: { - return vmapper_bind_int(vmapper, name, (int*)val); - } - case MAPPER_BOOL: { - return vmapper_bind_bool(vmapper, name, (bool*)val); + +int vmapper_bind_bool(vmapper_t * vmapper, char* name, bool* val) { + int res = 0; + + if ((res = vmapper_check_capa(vmapper)) != RES_BIND_OK) { + return res; } - } - return 0; + mlink_t* mlink = new_mlink_bool(name, val); + + vmapper->mlinks[vmapper->size] = mlink; + vmapper->size++; + return RES_BIND_OK; } +int vmapper_set_int(vmapper_t * vmapper, char* key, char* val) { + for (size_t i = 0; i < vmapper->size; i++) { + mlink_t* mlink = vmapper->mlinks[i]; + if (mlink->type == MAPPER_INT && strcmp(mlink->name, key) == 0) { + char* eptr = NULL; -int vmapper_set(vmapper_t* vmapper, char* key, char* val) { - vmapper_set_int(vmapper, key, val); - vmapper_set_string(vmapper, key, val); - vmapper_set_bool(vmapper, key, val); - return 0; + *(int *)(mlink->vptr) = (int)strtol(val, &eptr, 10); + } + } + return 0; } -void vmapper_destroy(vmapper_t* vmapper) { - if (vmapper != NULL) { +int vmapper_set_string(vmapper_t * vmapper, char* key, char* val) { for (size_t i = 0; i < vmapper->size; i++) { - free(vmapper->mlinks[i]); + mlink_t* mlink = vmapper->mlinks[i]; + + if (mlink->type == MAPPER_STR && strcmp(mlink->name, key) == 0) { + *(char **)(mlink->vptr) = copystr(val); + } } - free(vmapper->mlinks); - } - return; + return 0; } -void vmapper_free(vmapper_t* vmapper) { - if (vmapper != NULL) { +int vmapper_set_bool(vmapper_t * vmapper, char* key, char* val) { for (size_t i = 0; i < vmapper->size; i++) { - free(vmapper->mlinks[i]); + mlink_t* mlink = vmapper->mlinks[i]; + + if (mlink->type == MAPPER_BOOL && strcmp(mlink->name, key) == 0) { + if (strcmp(val, "true") == 0) { + *(bool *)(mlink->vptr) = true; + } + if (strcmp(val, "false") == 0) { + *(bool *)(mlink->vptr) = false; + } + } + } + return 0; +} + +int vmapper_bind(vmapper_t * vmapper, int type, char* name, void* val) { + switch (type) { + case MAPPER_STR:{ + return vmapper_bind_string(vmapper, name, (char **)val); + } + case MAPPER_INT:{ + return vmapper_bind_int(vmapper, name, (int *)val); + } + case MAPPER_BOOL:{ + return vmapper_bind_bool(vmapper, name, (bool *)val); + } + } + return 0; +} + + + +int vmapper_set(vmapper_t * vmapper, char* key, char* val) { + vmapper_set_int(vmapper, key, val); + vmapper_set_string(vmapper, key, val); + vmapper_set_bool(vmapper, key, val); + return 0; +} + +void vmapper_destroy(vmapper_t * vmapper) { + if (vmapper != NULL) { + for (size_t i = 0; i < vmapper->size; i++) { + free(vmapper->mlinks[i]); + } + free(vmapper->mlinks); + } + return; +} + +void vmapper_free(vmapper_t * vmapper) { + if (vmapper != NULL) { + for (size_t i = 0; i < vmapper->size; i++) { + free(vmapper->mlinks[i]); + } + free(vmapper->mlinks); } - free(vmapper->mlinks); - } - free(vmapper); + free(vmapper); } diff --git a/libxtools/vmapper.h b/libxtools/vmapper.h index 6d54058..0135d5a 100644 --- a/libxtools/vmapper.h +++ b/libxtools/vmapper.h @@ -12,9 +12,9 @@ typedef struct { - char* name; - int type; - void* vptr; + char* name; + int type; + void* vptr; } mlink_t; #define MAPPER_STR 1 @@ -22,28 +22,28 @@ typedef struct { #define MAPPER_BOOL 3 typedef struct { - mlink_t** mlinks; - size_t size; - size_t capa; - bool err; - char* errstr; + mlink_t** mlinks; + size_t size; + size_t capa; + bool err; + char* errstr; } vmapper_t; vmapper_t* new_vmapper(void); -void vmapper_init(vmapper_t* vmapper); -int vmapper_check_capa(vmapper_t* vmapper); -int vmapper_bind_string(vmapper_t* vmapper, char* name, char** val); -int vmapper_bind_int(vmapper_t* vmapper, char* name, int* val); -int vmapper_bind_bool(vmapper_t* vmapper, char* name, bool* val); +void vmapper_init(vmapper_t * vmapper); +int vmapper_check_capa(vmapper_t * vmapper); +int vmapper_bind_string(vmapper_t * vmapper, char* name, char** val); +int vmapper_bind_int(vmapper_t * vmapper, char* name, int* val); +int vmapper_bind_bool(vmapper_t * vmapper, char* name, bool* val); -int vmapper_set_int(vmapper_t* vmapper, char* key, char* val); -int vmapper_set_string(vmapper_t* vmapper, char* key, char* val); -int vmapper_set_bool(vmapper_t* vmapper, char* key, char* val); +int vmapper_set_int(vmapper_t * vmapper, char* key, char* val); +int vmapper_set_string(vmapper_t * vmapper, char* key, char* val); +int vmapper_set_bool(vmapper_t * vmapper, char* key, char* val); -int vmapper_set(vmapper_t* vmapper, char* key, char* val); -int vmapper_bind(vmapper_t* vmapper, int type, char* name, void* val); +int vmapper_set(vmapper_t * vmapper, char* key, char* val); +int vmapper_bind(vmapper_t * vmapper, int type, char* name, void* val); -void vmapper_destroy(vmapper_t* vmapper); -void vmapper_free(vmapper_t* vmapper); +void vmapper_destroy(vmapper_t * vmapper); +void vmapper_free(vmapper_t * vmapper); #endif diff --git a/libxtools/vmapper_test.c b/libxtools/vmapper_test.c index 43b278d..0c4ca32 100644 --- a/libxtools/vmapper_test.c +++ b/libxtools/vmapper_test.c @@ -10,36 +10,37 @@ #include #include -int main(int argc, char **argv) { - (void)argc; - (void)argv; +int main(int argc, char** argv) { + (void)argc; + (void)argv; - vmapper_t vmapper; - vmapper_init(&vmapper); + vmapper_t vmapper; - int port = 0; - bool flag = false; - char* ident = NULL; + vmapper_init(&vmapper); - vmapper_bind_int(&vmapper, "port", &port); - vmapper_bind_string(&vmapper, "ident", &ident); - vmapper_bind_bool(&vmapper, "flag", &flag); + int port = 0; + bool flag = false; + char* ident = NULL; - vmapper_set(&vmapper, "port", "12345"); - vmapper_set(&vmapper, "ident", "qwerty"); - vmapper_set(&vmapper, "flag", "true"); + vmapper_bind_int(&vmapper, "port", &port); + vmapper_bind_string(&vmapper, "ident", &ident); + vmapper_bind_bool(&vmapper, "flag", &flag); - printf("port = %d\n", port); - MASSERT(port = 12345); + vmapper_set(&vmapper, "port", "12345"); + vmapper_set(&vmapper, "ident", "qwerty"); + vmapper_set(&vmapper, "flag", "true"); - printf("ident = %s\n", ident); - MASSERT(strcmp(ident, "qwerty") == 0); - free(ident); + printf("port = %d\n", port); + MASSERT(port = 12345); - printf("flag = %d\n", flag); - MASSERT(flag = true); + printf("ident = %s\n", ident); + MASSERT(strcmp(ident, "qwerty") == 0); + free(ident); - vmapper_destroy(&vmapper); + printf("flag = %d\n", flag); + MASSERT(flag = true); - return 0; + vmapper_destroy(&vmapper); + + return 0; }