/*

Copyright (C) 2011 rofl0r

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "../lib/include/strlib.h"

#include "../lib/include/stringptrlist.h"

#include "../lib/include/stringptr.h"

#include "../lib/include/hashlist.h"

#include "../lib/include/fileparser.h"

#include "../lib/include/logger.h"

#include "../lib/include/strswitch.h"

#include <fcntl.h>

#include <stddef.h>

#include <unistd.h>

#include <stdlib.h>

typedef sblist size_t_ptrlist;

typedef struct {

size_t len;

stringptrlist* list;

} hashrec;

typedef struct {

stringptr* id;

uint32_t hash;

hashlist* h;

} sectionrec;

static uint32_t daliashash_sp(stringptr* str) {

uint_fast32_t h = 0;

unsigned char* s = (void*) str->ptr;

size_t size = str->size;

while (size) {

h = 16*h + *s++;

h ^= h>>24 & 0xf0;

size--;

}

return h & 0xfffffff;

}

stringptr normalize(stringptr* id, char* workbuf, ssize_t buflen) {

size_t i;

size_t os = buflen;

char hexbuf[5];

stringptr res = {workbuf, 0};

for(i = 0; i < id->size; i++) {

switch(id->ptr[i]) {

case STRSWITCH_ALPHA:

buflen--;

if(buflen <= 0) goto err;

*workbuf++ = id->ptr[i];

break;

default:

buflen -= 4;

if(buflen <= 0) goto err;

ulz_snprintf(hexbuf, 5, "0x%.2X", id->ptr[i]);

memcpy(workbuf, hexbuf, 4);

workbuf += 4;

break;

}

}

if(buflen > 0)

*workbuf = 0;

res.size = os - buflen;

out:

return res;

err:

res.ptr = NULL;

goto out;

}

typedef sblist variant_info_list;

typedef struct {

int c;

size_t_ptrlist* members;

variant_info_list* variants;

} variant_info;

variant_info* find_variant(sblist* variants, int c) {

size_t i;

variant_info* res;

for(i = 0; i < sblist_getsize(variants); i++) {

res = sblist_get(variants, i);

if(res->c == c) return res;

}

return NULL;

}

int in_member_list(variant_info* variant, size_t index) {

size_t i, *r;

for(i = 0; i < sblist_getsize(variant->members); i++) {

r = sblist_get(variant->members, i);

if (*r == index) return 1;

}

return 0;

}

void write_enum(int outfd, sectionrec* sref) {

hashlist* h;

hashlist_iterator iter2;

hashrec *href;

stringptrlist* newlist;

size_t i;

stringptr *entry, normalized;

char norm_buf[1024];

char buf[1024];

log_put(outfd, VARISL("typedef enum {\n\tstringswitch_enumerator_default_member_name("), VARIS(sref->id), VARISL("),"), NULL);

h = sref->h;

hashlist_iterator_init(&iter2);

while((href = hashlist_next(h, &iter2))) {

newlist = href->list;

for(i = 0; i < stringptrlist_getsize(newlist); i++) {

entry = stringptrlist_get(newlist, i);

log_put(1, VARISL("id "), VARIS(sref->id), VARISL(", entry: "), VARII((int) entry->size), VARISL(", "), VARIS(entry), NULL);

normalized = normalize(entry, norm_buf, sizeof(norm_buf));

ulz_snprintf(buf, sizeof(buf), "\tstringswitch_enumerator_member_name(%s, %s),\n", sref->id->ptr, normalized.ptr);

log_putc(outfd, buf);

}

}

log_put(outfd, VARISL("} stringswitch_enumerator_name("), VARIS(sref->id), VARISL(");\n"), NULL);

}

// initialise with members list, containing all ids

variant_info_list* get_variants(size_t_ptrlist* members, stringptr* last_prefix, stringptrlist* block_strings, size_t block_len) {

size_t i;

variant_info vr, *vp;

stringptr* next_prefix, *act;

size_t* id;

if(last_prefix->size == block_len) return NULL;

variant_info_list* res = NULL;

stringptr temp;

char c;

for(i = 0; i < sblist_getsize(members); i++) {

id = sblist_get(members, i);

act = stringptrlist_get(block_strings, *id);

if(last_prefix->size == 0 || stringptr_here(act, 0, last_prefix)) {

if(!res) res = sblist_new(sizeof(variant_info), 16);

if(!(vp = find_variant(res, act->ptr[last_prefix->size]))) {

vr.c = act->ptr[last_prefix->size];

vr.members = sblist_new(sizeof(size_t), stringptrlist_getsize(members));

vr.variants = NULL;

sblist_add(res, &vr);

vp = find_variant(res, vr.c);

}

sblist_add(vp->members, id);

}

}

if(res) {

for (i = 0; i < sblist_getsize(res); i++) {

vp = sblist_get(res, i);

c = vp->c;

temp.size = 1;

temp.ptr = &c;

next_prefix = stringptr_concat(last_prefix, &temp, NULL);

vp->variants = get_variants(vp->members, next_prefix, block_strings, block_len);

}

}

return res;

}

void print_level_tabs(int fd, size_t level) {

size_t i;

for (i = 0; i < level + 3; i++)

ulz_fprintf(fd, "\t");

}

void dump_variants(int outfd, stringptr* section_name, variant_info_list* variants,

stringptrlist* block_strings, size_t level, size_t previous_membercount, ssize_t backindent) {

if(variants == NULL) return;

variant_info* vp;

stringptr* act, normalized;

char norm_buf[1024];

size_t membercount;

size_t* id;

int switched = 0;

sblist_iter(variants, vp) {

membercount = sblist_getsize(vp->members);

if(membercount == previous_membercount) {

print_level_tabs(outfd, level - backindent);

ulz_fprintf(outfd, "if(str[%zu]!='%c') goto main_default;\n", level, vp->c);

backindent++;

} else {

if(!switched) {

print_level_tabs(outfd, level - backindent);

ulz_fprintf(outfd, "switch(str[%zu]) {\n", level);

switched = 1;

backindent--;

}

print_level_tabs(outfd, level - backindent);

ulz_fprintf(outfd, "case '%c':\n", vp->c);

}

if(!vp->variants) {

print_level_tabs(outfd, level - backindent);

id = sblist_get(vp->members, 0);

act = sblist_get(block_strings, *id);

normalized = normalize(act, norm_buf, sizeof(norm_buf));

log_put(outfd, VARISL("\treturn stringswitch_enumerator_member_name("),

VARIS(section_name), VARISL(", "), VARIS(&normalized), VARISL(");"), NULL);

}

dump_variants(outfd, section_name, vp->variants, block_strings, level+1, membercount, backindent);

}

if(switched) {

print_level_tabs(outfd, level - backindent);

ulz_fprintf(outfd, "default: goto main_default;\n");

backindent++;

print_level_tabs(outfd, level - backindent);

ulz_fprintf(outfd, "}\n");

}

}

void free_variants(variant_info_list* v) {

(void) v;

// TODO

}

void write_length_block(int outfd, hashrec* block_href, stringptr* section_name) {

stringptrlist* newlist;

size_t i;

stringptr temp;

newlist = block_href->list;

log_put(outfd, VARISL("\t\tcase "),VARII((int) block_href->len), VARISL(":"), NULL);

size_t_ptrlist* initial_members = sblist_new(sizeof(size_t), stringptrlist_getsize(block_href->list));

temp.size = 0;

temp.ptr = NULL;

for(i = 0; i < stringptrlist_getsize(block_href->list); i++)

sblist_add(initial_members, &i);

variant_info_list* variants = get_variants(initial_members, &temp, block_href->list, block_href->len);

dump_variants(outfd, section_name, variants, block_href->list, 0, stringptrlist_getsize(block_href->list), 0);

sblist_free(initial_members);

free_variants(variants);

}

void codegen(hashlist* hashlists) {

sectionrec *sref;

hashrec *href;

hashlist_iterator iter, iter2;

hashlist_iterator_init(&iter);

int outfd = -1;

char buf[1024];

if(hashlists) while((sref = hashlist_next(hashlists, &iter))) {

// iterating through the "sections", that is each different strswitch usage

ulz_snprintf(buf, sizeof(buf), "stringswitch_impl_%s.c", sref->id->ptr);

outfd = open(buf, O_CREAT | O_TRUNC | O_WRONLY, 0660);

if(outfd == -1) {

log_putc(2, buf);

log_perror(" : couldnt open");

return;

}

log_put(1, VARISL("writing to "), VARIC(buf), NULL);

write_enum(outfd, sref);

log_put(outfd, VARISL("static int stringswitch_enumerator_eval_func("), VARIS(sref->id),

VARISL(") (char* str, size_t l) {"), NULL);

log_put(outfd, VARISL("\tswitch(l) {"), NULL);

hashlist_iterator_init(&iter2);

while((href = hashlist_next(sref->h, &iter2))) {

// iterating through the different length blocks in our switch statement

write_length_block(outfd, href, sref->id);

}

log_put(outfd, VARISL("\t\tdefault:\n\t\t\tmain_default:\n\t\t\treturn stringswitch_enumerator_default_member_name("),

VARIS(sref->id), VARISL(");\n\t}\n}"), NULL);

close(outfd);

}

}

void free_sections_hashlist(hashlist* l) {

// TODO ... free recursive

(void) l;

}

// we have a hashlist, "hashlists", in which we will insert one record of type

// sectionrec per different "section". a section is the identifier of a stringswitch statement.

// this rec contains a reference to another hashlist, which will contain one stringptrlist per

// length of the "add"ed entries.

static stringptr* command_prefix = SPL("//stringswitch_gen ");

hashlist* parse(char* file) {

hashlist *hashlists = NULL;

hashlist *h = NULL;

fileparser fb, *f = &fb;

stringptr line;

stringptr command;

stringptr param1, param2;

size_t x;

hashrec hr, *href;

sectionrec sr, *sref;

sblist* sbt;

stringptrlist* newlist;

uint32_t p1hash;

size_t i;

fileparser_open(f, file);

while(!fileparser_readline(f) && !fileparser_getline(f, &line)) {

if(stringptr_here(&line, 0, command_prefix)) {

command.ptr = line.ptr + command_prefix->size;

x = 0;

while(command_prefix->size + x < line.size &&

!(command.ptr[x] == ' ' || command.ptr[x] == 0)) x++;

command.size = x;

//log_puts(1, &command); log_putln(1);

param1.ptr = command.ptr + x + 1;

if(param1.ptr >= line.ptr + line.size) {

ulz_printf("no param1\n");

goto err;

}

x = 0;

while(command_prefix->size + command.size + x + 1 < line.size &&

!(param1.ptr[x] == ' ' || param1.ptr[x] == 0))

x++;

param1.size = x;

//log_puts(1, &param1); log_putln(1);

if(!hashlists)

hashlists = hashlist_new(64, sizeof(sectionrec));

p1hash = daliashash_sp(&param1);

h = NULL;

sbt = hashlist_get(hashlists, p1hash);

if(!sbt) {

insert_hashlist:

h = hashlist_new(64, sizeof(hashrec));

sr.h = h;

sr.hash = p1hash;

sr.id = stringptr_copy(&param1);

hashlist_add(hashlists, p1hash, &sr);

sbt = hashlist_get(hashlists, p1hash);

}

if(!h)

for(i = 0; i < sblist_getsize(sbt); i++) {

sref = sblist_get(sbt, i);

if(sref->hash == p1hash && EQ(&param1, sref->id)) {

h = sref->h;

break;

}

}

if(!h) goto insert_hashlist;

if(EQ(&command, SPL("add"))) {

param2.ptr = param1.ptr + x + 1;

if(param2.ptr >= line.ptr + line.size) {

ulz_printf("no param2\n");

goto err;

}

if(param2.ptr[0] != '"') {

ulz_printf("add parameter must be double-quoted\n");

goto err;

}

param2.ptr++;

if(param2.ptr >= line.ptr + line.size) {

ulz_printf("no param2\n");

goto err;

}

x = 0;

while(command_prefix->size + command.size + param1.size + x + 2 + 1 < line.size &&

!(param2.ptr[x] == '"' || param2.ptr[x] == 0)) x++;

param2.size = x;

//log_puts(1, &param2); log_putln(1);

newlist = NULL;

sbt = hashlist_get(h, param2.size);

if(!sbt) {

insert_stringptrlist:

newlist = stringptrlist_new(4);

hr.len = param2.size;

hr.list = newlist;

hashlist_add(h, param2.size, &hr);

sbt = hashlist_get(h, param2.size);

}

if(!newlist)

for(i = 0; i < sblist_getsize(sbt); i++) {

href = sblist_get(sbt, i);

if(href->len == param2.size) {

newlist = href->list;

break;

}

}

if(!newlist) goto insert_stringptrlist;

stringptrlist_add(newlist, stringptr_strdup(&param2), param2.size);

} else {

#if 0

param2.size = 0;

param2.ptr = 0;

#else

log_put(1, VARISL("the \"add\" command needs an additional parameter embedded in double quotes!"), NULL);

goto err;

#endif

}

}

}

goto out;

err:

if(hashlists) free_sections_hashlist(hashlists);

hashlists = NULL;

out:

fileparser_close(f);

return hashlists;

}

int main(int argc, char** argv) {

int i;

hashlist* sections;

ulz_printf("stringswitch generator 1.0 by rofl0r\n");

ulz_printf("^~^~^~^~^~^~^~^~^~^~^~^~^~^~^~^~^~^~\n");

if(argc == 1) {

ulz_printf("pass one or more filenames containing stringswitch directives embedded as C99 comments!\n");

return 1;

}

for(i = 1; i < argc; i++) {

if(access(argv[i], R_OK) != -1) {

sections = parse(argv[i]);

if(!sections) return 1;

codegen(sections);

}

}

return 0;

}