void video_close(void) {
#ifndef NO_DEVMODE
MEM_FREE(v_stats.layer_rects);
MEM_FREE(v_stats.layer_lines);
#endif
Texture* tex = DARRAY_DATA_PTR(textures, Texture);
uint active_textures = 0;
for(uint i = 0; i < textures.size; ++i)
if(tex[i].active)
active_textures++;
if(active_textures > 0)
LOG_WARNING("%d textures are still active!", textures.size);
darray_free(&vertex_buffer);
darray_free(&textures);
darray_free(&rects_out);
for(uint i = 0; i < bucket_count; ++i) {
if(rect_buckets[i].reserved)
darray_free(&rect_buckets[i]);
if(rect_buckets[i].reserved)
darray_free(&line_buckets[i]);
}
LOG_INFO("Video closed");
}
// TODO: Use some magic here to allocate right size pools
bool mml_deserialize(MMLObject* mml, const char* string) {
assert(mml);
assert(string);
mml->node_pool = darray_create(sizeof(MMLNode), 0);
mml->str_pool = darray_create(sizeof(char), 0);
// Tokenize
DArray tokens;
bool result = mml_tokenize(mml, string, &tokens);
if(!result) {
darray_free(&tokens);
mml_free(mml);
return false;
}
// Parse
result = mml_parse(mml, &tokens);
if(!result) {
darray_free(&tokens);
mml_free(mml);
return false;
}
darray_free(&tokens);
return true;
}
/**
* Remove all entries in the context's include path.
*/
XKB_EXPORT void
xkb_context_include_path_clear(struct xkb_context *ctx)
{
char **path;
darray_foreach(path, ctx->includes)
free(*path);
darray_free(ctx->includes);
darray_foreach(path, ctx->failed_includes)
free(*path);
darray_free(ctx->failed_includes);
}
DArray* graph_vertex_get_out_edges(const Graph *g, const Vertex *v)
{
unsigned long index;
DArray *out_edges;
Edge *e;
assert(g != NULL);
assert(v != NULL);
out_edges = darray_create();
if(NULL == out_edges) {
fprintf(stderr, "Cannot create out-edge list (%s:%d)\n",
__FUNCTION__, __LINE__);
return NULL;
}
for(index = 0; index < darray_size(v->edges); index++) {
e = (Edge *)darray_index(v->edges, index);
if(v == e->source) {
if(darray_append(out_edges, e) < 0) {
fprintf(stderr, "Cannot construct out-edge list (%s:%d)\n",
__FUNCTION__, __LINE__);
darray_free(out_edges);
return NULL;
}
}
}
return out_edges;
}
void problem_02_test_basic(){
/* declare and initialize a new array */
DArray array;
int majority = 0;
darray_init(&array);
/* initialize array */
darray_append(&array, 3);
darray_append(&array, 3);
darray_append(&array, 4);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 4);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 4);
majority = find_majority_basic(&array);
if(majority == FAILURE){
printf("No majority value found!\n");
}else{
printf("Majority value: %d\n", majority);
}
/* free up the underlying array */
darray_free(&array);
}
DArray* graph_get_edges(const Graph *g)
{
unsigned long index;
DArray *edges;
Vertex *v;
assert(g != NULL);
edges = darray_create();
if(NULL == edges) {
fprintf(stderr, "Cannot create edge list (%s:%d)\n",
__FUNCTION__, __LINE__);
return NULL;
}
for(index = 0; index < darray_size(g->vertices); index++) {
v = (Vertex *)darray_index(g->vertices, index);
if(darray_concat(edges, v->edges) < 0) {
fprintf(stderr, "Cannot construct edge list (%s:%d)\n",
__FUNCTION__, __LINE__);
darray_free(edges);
return NULL;
}
}
return edges;
}
/* Complexity: o(1) */
void heap_free(Heap *heap)
{
assert(heap != NULL);
/* Only free heap container and darray container,
* not the data stored in the heap */
darray_free(heap->h);
free(heap);
}
void
rsynth_phones(rsynth_t * rsynth, char *phone, int len)
{
darray_t elm;
darray_t f0;
unsigned frames;
darray_init(&elm, sizeof(char), len);
darray_init(&f0, sizeof(float), len);
if ((frames = phone_to_elm(rsynth, len, phone, &elm, &f0))) {
if (rsynth_verbose(rsynth))
fprintf(stderr, "[%.*s]\n", len, phone);
rsynth_flush(rsynth,
rsynth_interpolate(rsynth,
(unsigned char *) darray_find(&elm, 0),elm.items,
(float *) darray_find(&f0,0),
f0.items));
}
darray_free(&f0);
darray_free(&elm);
}
static inline void config_section_free(struct config_section *section)
{
struct config_item *items = section->items.array;
size_t i;
for (i = 0; i < section->items.num; i++)
config_item_free(items+i);
darray_free(§ion->items);
bfree(section->name);
}
void config_close(config_t config)
{
struct config_section *defaults, *sections;
size_t i;
if (!config) return;
defaults = config->defaults.array;
sections = config->sections.array;
for (i = 0; i < config->defaults.num; i++)
config_section_free(defaults+i);
for (i = 0; i < config->sections.num; i++)
config_section_free(sections+i);
darray_free(&config->defaults);
darray_free(&config->sections);
bfree(config->file);
bfree(config);
}
void tcmu_config_destroy(struct tcmu_config *cfg)
{
struct tcmu_conf_option *opt;
if (!cfg)
return;
darray_foreach(opt, tcmu_options) {
if (opt->type == TCMU_OPT_STR)
free(opt->opt_str);
}
darray_free(tcmu_options);
free(cfg->path);
free(cfg);
cfg = NULL;
}
void problem_05_test_sum(){
/* declare and initialize a new array */
DArray array;
int missing;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 5);
darray_append(&array, 6);
missing = get_missing_number_sum_formula(&array, 5);
printf("The missing number is: %d\n", missing);
/* free up the underlying array */
darray_free(&array);
}
void problem_01_test_hash(){
/* declare and initialize a new array */
DArray array;
int search = 16;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 4);
darray_append(&array, 45);
darray_append(&array, 6);
darray_append(&array, 10);
darray_append(&array, -8);
array_has_sum_of_hash(&array, array.size, search);
/* free up the underlying array */
darray_free(&array);
}
/* Creates the real pixel format for the target window */
static int gl_choose_pixel_format(HDC hdc, struct gs_init_data *info)
{
struct darray attribs;
int color_bits = get_color_format_bits(info->format);
int depth_bits = get_depth_format_bits(info->zsformat);
int stencil_bits = get_stencil_format_bits(info->zsformat);
UINT num_formats;
BOOL success;
int format;
if (!color_bits) {
blog(LOG_ERROR, "gl_init_pixel_format: color format not "
"supported");
return false;
}
darray_init(&attribs);
add_attrib(&attribs, WGL_DRAW_TO_WINDOW_ARB, GL_TRUE);
add_attrib(&attribs, WGL_SUPPORT_OPENGL_ARB, GL_TRUE);
add_attrib(&attribs, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB);
add_attrib(&attribs, WGL_DOUBLE_BUFFER_ARB, GL_TRUE);
add_attrib(&attribs, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB);
add_attrib(&attribs, WGL_COLOR_BITS_ARB, color_bits);
add_attrib(&attribs, WGL_DEPTH_BITS_ARB, depth_bits);
add_attrib(&attribs, WGL_STENCIL_BITS_ARB, stencil_bits);
add_attrib(&attribs, 0, 0);
success = wglChoosePixelFormatARB(hdc, attribs.array, NULL, 1, &format,
&num_formats);
if (!success || !num_formats) {
blog(LOG_ERROR, "wglChoosePixelFormatARB failed, %u",
GetLastError());
format = 0;
}
darray_free(&attribs);
return format;
}
void problem_01_test_sort(){
/* declare and initialize a new array */
DArray array;
int search = 16;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 4);
darray_append(&array, 45);
darray_append(&array, 6);
darray_append(&array, 10);
darray_append(&array, -8);
if(!array_has_sum_of(&array, array.capacity, search)){
printf("Array has two elements with sum %d\n", search);
}else{
printf("Array doesn't have two elements with sum %d\n", search);
}
/* free up the underlying array */
darray_free(&array);
}
int main(int argc, char *argv[])
{
dyn_array_t arr = darray_make(4);
// Store 1,2,3,4 in array
for (int i = 0; i < darray_size(arr); ++i) darray_set(arr, i, i);
// Print arr[i] = i for i=[1,4]
for (int i = 0; i < darray_size(arr); ++i) printf("arr[%d] = %d\n", i, *darray_get(arr, i));
darray_append(&arr, 5);
darray_append(&arr, 6);
darray_prepend(&arr, 7);
darray_prepend(&arr, 8);
// Print arr[i] = j for i=[1,8]
for (int i = 0; i < darray_size(arr); ++i) printf("arr[%d] = %d\n", i, *darray_get(arr, i));
darray_free(&arr);
arr = NULL;
return 0;
}
int main(void) {
darray(long) arr = darray_new();
darray_char str = darray_new();
darray(long*) arrp = darray_new();
arrp.onFree = _arr_free_handler;
#define reset(arr) do {darray_free(arr); darray_init(arr);} while(0)
size_t i;
trace("Generating amalgams (internal)");
generateAmalgams();
plan_tests(54);
testLits();
testing(darray_pushptr);
{
int vMaxCount = 10;//ARRAY_SIZE(lotsOfNumbers);
for (int k=0; k < vMaxCount; k++) {
long* p = malloc(sizeof(long));
*p = lotsOfNumbers[k];
darray_push(arrp, p);
}
ok1(darray_size(arrp) == vMaxCount);
ok1(darray_alloc(arrp) >= darray_size(arrp));
long **i;
size_t j = 0;
darray_foreach(i, arrp) {
if (i - arrp.item != j)
break;
if (**i != (long)lotsOfNumbers[j])
break;
j++;
};
ok1(j == vMaxCount);
darray_free_all(arrp);
ok1(_free_count == vMaxCount);
}
testing(darray_push);
{
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++)
darray_push(arr, lotsOfNumbers[i]);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(darray_alloc(arr) >= darray_size(arr));
ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)));
}
testing(darray_insert);
{
darray_insert(arr, 0, 123456);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)+1);
ok1(!memcmp(arr.item+1, lotsOfNumbers, sizeof(lotsOfNumbers)));
ok1(darray_item(arr, 0) == 123456);
darray_insert(arr, 15, 0x112233);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)+2);
ok1(darray_item(arr, 15) == 0x112233);
ok1(!memcmp(arr.item+1, lotsOfNumbers, 14*sizeof(long)));
ok1(!memcmp(arr.item+16, &lotsOfNumbers[14], ARRAY_SIZE(lotsOfNumbers)-(15*sizeof(long))));
}
testing(darray_del);
{
darray_del(arr, 15);
darray_del(arr, 0);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)));
}
reset(arr);
testing(darray_prepend, darray_pop);
{
for (i = ARRAY_SIZE(lotsOfNumbers); i;)
darray_prepend(arr, lotsOfNumbers[--i]);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(darray_alloc(arr) >= darray_size(arr));
ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)));
for (i = ARRAY_SIZE(lotsOfNumbers); i;) {
if (darray_pop(arr) != (long)lotsOfNumbers[--i]) {
i++;
break;
}
}
ok1(i==0);
ok1(darray_size(arr) == 0);
}
reset(arr);
testing(darray_from_c, darray_foreach, darray_foreach_reverse);
{
long *i;
size_t j;
darray_from_c(arr, lotsOfNumbers);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(darray_alloc(arr) >= darray_size(arr));
ok1(memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)) == 0);
j = 0;
darray_foreach(i, arr) {
if (i - arr.item != j)
break;
if (*i != (long)lotsOfNumbers[j])
break;
j++;
};
ok1(j == ARRAY_SIZE(lotsOfNumbers));
j = 0;
darray_foreach_reverse(i, arr) {
if (i - arr.item != darray_size(arr)-j-1)
break;
if (*i != (long)lotsOfNumbers[darray_size(arr)-j-1])
break;
j++;
};
ok1(j == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_append_string);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++)
darray_append_string(str, lotsOfStrings[i]);
ok1(str.size == amalgams.stringsSize);
ok1(str.alloc > str.size);
ok1(str.item[str.size] == 0);
ok1(!strcmp(str.item, amalgams.stringsF));
}
reset(str);
testing(darray_prepend_string);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++)
darray_prepend_string(str, lotsOfStrings[i]);
ok1(str.size == amalgams.stringsSize);
ok1(str.alloc > str.size);
ok1(str.item[str.size] == 0);
ok1(!strcmp(str.item, amalgams.stringsB));
}
reset(str);
testing(darray_from_string);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) {
darray_from_string(str, lotsOfStrings[i]);
if (str.size != strlen(lotsOfStrings[i]))
break;
if (str.alloc < strlen(lotsOfStrings[i])+1)
break;
if (strcmp(str.item, lotsOfStrings[i]))
break;
}
ok1(i == ARRAY_SIZE(lotsOfStrings));
}
reset(str);
testing(darray_resize0);
{
size_t prevSize=0, size;
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++, prevSize=size) {
size = lotsOfNumbers[i] & 0xFFFF;
darray_resize0(arr, size);
if (darray_size(arr) != size)
break;
if (darray_alloc(arr) < size)
break;
if (size>prevSize) {
if (!isZeros(arr.item+prevSize, (size-prevSize)*sizeof(*arr.item)))
break;
}
//fill the darray with lotsOfNumbers garbage
memtile(arr.item, darray_size(arr)*sizeof(*arr.item), lotsOfNumbers, sizeof(lotsOfNumbers));
}
ok1(i == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_realloc);
{
size_t s,a;
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) {
arr.size = (s = lotsOfNumbers[i] >> 16);
//give size a nonsense value to make sure darray_realloc doesn't care about it
a = amalgams.stringsSize/sizeof(*arr.item)+2;
darray_realloc(arr, a = lotsOfNumbers[i] % ((amalgams.stringsSize/sizeof(*arr.item))+1));
if (a*sizeof(*arr.item) > amalgams.stringsSize)
break;
if (darray_alloc(arr) != a)
break;
if (darray_size(arr) != s)
break;
memtile(arr.item, a*sizeof(*arr.item), amalgams.stringsF, a*sizeof(*arr.item));
if (memcmp(arr.item, amalgams.stringsF, a*sizeof(*arr.item)))
break;
}
ok1(i == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_growalloc);
{
size_t prevA, s, a;
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) {
arr.size = (s = lotsOfNumbers[i] >> 16);
//give size a nonsense value to make sure darray_growalloc doesn't care about it
a = amalgams.stringsSize/sizeof(*arr.item)+2;
prevA = darray_alloc(arr);
darray_growalloc(arr, a = lotsOfNumbers[i] % ((amalgams.stringsSize/sizeof(*arr.item))+1));
if (a*sizeof(*arr.item) > amalgams.stringsSize)
break;
if (darray_alloc(arr) < a)
break;
if (darray_alloc(arr) < prevA)
break;
if (darray_size(arr) != s)
break;
memtile(arr.item, a*sizeof(*arr.item), amalgams.stringsF, a*sizeof(*arr.item));
if (memcmp(arr.item, amalgams.stringsF, a*sizeof(*arr.item)))
break;
//clear the darray every now and then
if (!(lotsOfNumbers[i] & 15)) {
reset(arr);
}
}
ok1(i == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_make_room);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) {
char *dest = darray_make_room(str, strlen(lotsOfStrings[i]));
if (str.alloc < str.size+strlen(lotsOfStrings[i]))
break;
if (dest != str.item+str.size)
break;
memcpy(dest, lotsOfStrings[i], strlen(lotsOfStrings[i]));
str.size += strlen(lotsOfStrings[i]);
}
ok1(i == ARRAY_SIZE(lotsOfStrings));
ok1(str.size == amalgams.stringsSize);
darray_append(str, 0);
ok1(!strcmp(str.item, amalgams.stringsF));
}
reset(str);
testing(darray_appends, darray_prepends, darray_pop_check);
{
darray(const char*) arr = darray_new();
const char *n[9] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight"};
#if HAVE_TYPEOF
darray_appends(arr, n[5], n[6], n[7], n[8]);
#else
darray_appends_t(arr, const char *, n[5], n[6], n[7], n[8]);
#endif
ok1(darray_size(arr)==4 && darray_alloc(arr)>=4);
#if HAVE_TYPEOF
darray_prepends(arr, n[0], n[1], n[2], n[3], n[4]);
#else
darray_prepends_t(arr, const char *, n[0], n[1], n[2], n[3], n[4]);
#endif
ok1(darray_size(arr)==9 && darray_alloc(arr)>=9);
ok1(arr.item[0]==n[0] &&
arr.item[1]==n[1] &&
arr.item[2]==n[2] &&
arr.item[3]==n[3] &&
arr.item[4]==n[4] &&
arr.item[5]==n[5] &&
arr.item[6]==n[6] &&
arr.item[7]==n[7] &&
arr.item[8]==n[8]);
ok1(darray_pop_check(arr)==n[8] &&
darray_pop_check(arr)==n[7] &&
darray_pop_check(arr)==n[6] &&
darray_pop_check(arr)==n[5] &&
darray_pop_check(arr)==n[4] &&
darray_pop_check(arr)==n[3] &&
darray_pop_check(arr)==n[2] &&
darray_pop_check(arr)==n[1] &&
darray_pop_check(arr)==n[0]);
ok1(darray_size(arr)==0);
ok1(darray_pop_check(arr)==NULL && darray_pop_check(arr)==NULL && darray_pop_check(arr)==NULL);
darray_free(arr);
}
trace("Freeing amalgams (internal)");
freeAmalgams();
return exit_status();
}
char *test_darray_operations()
{
darray_t *array = darray_create(sizeof(int), 100);
mu_assert(array != NULL, "darray_create failed.");
mu_assert(array->contents != NULL, "contents are wrong in darray");
mu_assert(array->end == 0, "end isn't at the right spot");
mu_assert(array->element_size == sizeof(int), "element size is wrong.");
mu_assert(array->max == 100, "wrong max length on initial size");
int *val1 = darray_new(array);
mu_assert(val1 != NULL, "failed to make a new element");
int *val2 = darray_new(array);
mu_assert(val2 != NULL, "failed to make a new element");
darray_set(array, 0, val1);
darray_set(array, 1, val2);
mu_assert(darray_get(array, 0) == val1, "Wrong first value.");
mu_assert(darray_get(array, 1) == val2, "Wrong second value.");
int *val_check = darray_remove(array, 0);
mu_assert(val_check != NULL, "Should not get NULL.");
mu_assert(*val_check == *val1, "Should get the first value.");
mu_assert(darray_get(array, 0) == NULL, "Should be gone.");
darray_free(val_check);
val_check = darray_remove(array, 1);
mu_assert(val_check != NULL, "Should not get NULL.");
mu_assert(*val_check == *val2, "Should get the first value.");
mu_assert(darray_get(array, 1) == NULL, "Should be gone.");
darray_free(val_check);
int old_max = array->max;
darray_expand(array);
mu_assert(array->max == old_max + array->expand_rate, "Wrong size after expand.");
darray_contract(array);
mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
darray_contract(array);
mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
int i = 0;
for(i = 0; i < 1000; i++) {
int *val = darray_new(array);
darray_attach(array, val);
*val = i * 333;
darray_push(array, val);
}
mu_assert(array->max == 1201, "Wrong max size.");
for(i = 999; i > 0; i--) {
int *val = darray_pop(array);
mu_assert(val != NULL, "Shouldn't get a NULL.");
mu_assert(*val == i * 333, "Wrong value.");
darray_free(val);
}
darray_destroy(array);
return NULL;
}
static inline bool ep_compile_pass_shader(struct effect_parser *ep,
struct gs_effect_technique *tech,
struct gs_effect_pass *pass, struct ep_pass *pass_in,
size_t pass_idx, enum gs_shader_type type)
{
struct dstr shader_str;
struct dstr location;
struct darray used_params; /* struct dstr */
struct darray *pass_params = NULL; /* struct pass_shaderparam */
gs_shader_t *shader = NULL;
bool success = true;
dstr_init(&shader_str);
darray_init(&used_params);
dstr_init(&location);
dstr_copy(&location, ep->cfp.lex.file);
if (type == GS_SHADER_VERTEX)
dstr_cat(&location, " (Vertex ");
else if (type == GS_SHADER_PIXEL)
dstr_cat(&location, " (Pixel ");
/*else if (type == SHADER_GEOMETRY)
dstr_cat(&location, " (Geometry ");*/
assert(pass_idx <= UINT_MAX);
dstr_catf(&location, "shader, technique %s, pass %u)", tech->name,
(unsigned)pass_idx);
if (type == GS_SHADER_VERTEX) {
ep_makeshaderstring(ep, &shader_str,
&pass_in->vertex_program.da, &used_params);
pass->vertshader = gs_vertexshader_create(shader_str.array,
location.array, NULL);
shader = pass->vertshader;
pass_params = &pass->vertshader_params.da;
} else if (type == GS_SHADER_PIXEL) {
ep_makeshaderstring(ep, &shader_str,
&pass_in->fragment_program.da, &used_params);
pass->pixelshader = gs_pixelshader_create(shader_str.array,
location.array, NULL);
shader = pass->pixelshader;
pass_params = &pass->pixelshader_params.da;
}
#if 0
blog(LOG_DEBUG, "+++++++++++++++++++++++++++++++++++");
blog(LOG_DEBUG, " %s", location.array);
blog(LOG_DEBUG, "-----------------------------------");
blog(LOG_DEBUG, "%s", shader_str.array);
blog(LOG_DEBUG, "+++++++++++++++++++++++++++++++++++");
#endif
if (shader)
success = ep_compile_pass_shaderparams(ep, pass_params,
&used_params, shader);
else
success = false;
dstr_free(&location);
dstr_array_free(used_params.array, used_params.num);
darray_free(&used_params);
dstr_free(&shader_str);
return success;
}
int main(int argc, char **argv)
{
FILE *fd, *fdw;
char *orgbuf,*buf, *p, *ptr, *tt;
int size, n, j;
struct darray_s *darr, *darr_line;
struct darray_s **item;
char filename[50], outfile[50];
if (argc < 2) {
printf("format error: csv2json {filename}\n");
exit(0);
}
strcpy(filename, argv[1]);
strcpy(outfile, argv[1]);
strcat(outfile, ".json");
printf("filename:%s, outfile:%s\n", filename, outfile);
fd = fopen(filename, "r+");
if (fd == NULL) {
perror("open input file err");
exit(0);
}
//fdw = fopen(strcat(argv[1],".json"), "w");
fdw = fopen(outfile, "w");
if (fdw == NULL) {
perror("open write file err");
exit(0);
}
/* load data into dynamic array */
orgbuf = buf = (char*)calloc(1, LINE);
darr = (u_char *)darray_calloc(linecount_fd(fd), sizeof(buf));
while (fgets(buf, LINE, fd)) {
// printf("buf:%s\n", buf);
darr_line = darray_calloc(strcount(buf, ',')+1, LINE);
//printf("%p\n", darr_line);
tt = darray_pushback(darr);
//printf("1 values: %p\n", tt);
memcpy(tt, &darr_line, sizeof(darr_line));
trim(buf);
while (p = strchr(buf, ',')) {
size = p-buf;
ptr = darray_pushback(darr_line);
//printf("2 buf:%s, size:%d, ptr:%p\n", buf, size, ptr);
strncpy(ptr, buf, size);
buf = p+1;
trim(buf);
}
ptr = darray_pushback(darr_line);
size = strlen(buf);
//printf("2 buf:%s, size:%d, ptr:%p\n", buf, size, ptr);
strncpy(ptr, buf, size);
buf = orgbuf;
memset(buf, 0, LINE);
}
/* write json file */
item = darr->da_values;
if (darray_count(darr) > 3) fprintf(fdw, "[");
for (n=3; n<darray_count(darr); n++) {
fprintf(fdw, "{");
for (j=0; j<darray_count(*item); j++) {
//printf("tt:%s\n", item[1]->da_values+j*item[1]->da_size);
if (strcmp(item[1]->da_values+j*item[1]->da_size, "0") == 0)
fprintf(fdw, "\"%s\":\"%s\"", item[0]->da_values+j*item[n]->da_size, item[n]->da_values+j*item[n]->da_size);
else if (strcmp(item[1]->da_values+j*item[1]->da_size, "2") == 0) {
fprintf(fdw, "\"%s\":\"%s\"", item[0]->da_values+j*item[n]->da_size, item[n]->da_values+j*item[n]->da_size);
/*
char tt[1024];
memset(tt, 0, 1024);
printf("len:%d\n", strlen(*(item[n]->da_values+j*item[n]->da_size)));
memcpy(tt, item[n]->da_values+j*item[n]->da_size+1, strlen(item[n]->da_values+j*item[n]->da_size)-2);
fprintf(fdw, "\"%s\":%s", item[0]->da_values+j*item[n]->da_size, item[n]->da_values+j*item[n]->da_size);
*/
} else if (strcmp(item[1]->da_values+j*item[1]->da_size, "1") == 0)
fprintf(fdw, "\"%s\":%d", item[0]->da_values+j*item[n]->da_size, atoi(item[n]->da_values+j*item[n]->da_size));
else
printf("data tyep err.");
if (j<darray_count(*item)-1)
fprintf(fdw, ", ");
}
if (n < darray_count(darr)-1)
fprintf(fdw, "}, \n");
else
fprintf(fdw, "}");
}
if (darray_count(darr) > 3) fprintf(fdw, "]\n");
free(orgbuf);
darray_free(darr);
fclose(fd);
fclose(fdw);
return 0;
}
void minimap_close(void){
darray_free(&minimap_pointers);
}
void mml_free(MMLObject* mml) {
assert(mml);
darray_free(&(mml->node_pool));
darray_free(&(mml->str_pool));
}
void MemoryAllocation_Destructor(DArray *array) { darray_free(array); }
static void _scws_msegment(scws_t s, int end, int zlen)
{
word_t **wmap, query;
struct scws_zchar *zmap;
unsigned char *txt;
rule_item_t r1;
int i, j, k, ch, clen, start;
pool_t p;
/* pool used to management some dynamic memory */
p = pool_new();
/* create wmap & zmap */
wmap = s->wmap = (word_t **) darray_new(zlen, zlen, sizeof(word_t));
zmap = s->zmap = (struct scws_zchar *) pmalloc(p, zlen * sizeof(struct scws_zchar));
txt = s->txt;
start = s->off;
s->zis = -1;
for (i = 0; start < end; i++)
{
ch = txt[start];
clen = SCWS_CHARLEN(ch);
if (clen == 1)
{
while (start++ < end)
{
ch = txt[start];
if (start == end || SCWS_CHARLEN(txt[start]) > 1)
break;
clen++;
}
wmap[i][i] = (word_t) pmalloc_z(p, sizeof(word_st));
wmap[i][i]->tf = 0.5;
wmap[i][i]->flag |= SCWS_ZFLAG_ENGLISH;
strcpy(wmap[i][i]->attr, SCWS_IS_ALPHA(txt[start-1]) ? attr_en : attr_un);
}
else
{
query = xdict_query(s->d, txt + start, clen);
wmap[i][i] = (word_t) pmalloc(p, sizeof(word_st));
if (query == NULL)
{
wmap[i][i]->tf = 0.5;
wmap[i][i]->idf = 0.0;
wmap[i][i]->flag = 0;
strcpy(wmap[i][i]->attr, attr_un);
}
else
{
ch = query->flag;
query->flag = SCWS_WORD_FULL;
memcpy(wmap[i][i], query, sizeof(word_st));
if (query->attr[0] == '#')
wmap[i][i]->flag |= SCWS_ZFLAG_SYMBOL;
if (ch & SCWS_WORD_MALLOCED)
free(query);
}
start += clen;
}
zmap[i].start = start - clen;
zmap[i].end = start;
}
/* fixed real zlength */
zlen = i;
/* create word query table */
for (i = 0; i < zlen; i++)
{
k = 0;
for (j = i+1; j < zlen; j++)
{
query = xdict_query(s->d, txt + zmap[i].start, zmap[j].end - zmap[i].start);
if (query == NULL)
break;
ch = query->flag;
if ((ch & SCWS_WORD_FULL) && memcmp(query->attr, attr_na, 2))
{
wmap[i][j] = (word_t) pmalloc(p, sizeof(word_st));
memcpy(wmap[i][j], query, sizeof(word_st));
wmap[i][i]->flag |= SCWS_ZFLAG_WHEAD;
for (k = i+1; k <= j; k++)
wmap[k][k]->flag |= SCWS_ZFLAG_WPART;
}
if (ch & SCWS_WORD_MALLOCED)
free(query);
if (!(ch & SCWS_WORD_PART))
break;
}
if (k--)
{
/* set nr2 to some short name */
if ((k == (i+1)))
{
if (!memcmp(wmap[i][k]->attr, attr_nr, 2))
wmap[i][i]->flag |= SCWS_ZFLAG_NR2;
//if (wmap[i][k]->attr[0] == 'n')
//wmap[i][i]->flag |= SCWS_ZFLAG_N2;
}
/* clean the PART flag for the last word */
if (k < j)
wmap[i][k]->flag ^= SCWS_WORD_PART;
}
}
if (s->r == NULL)
goto do_segment;
/* auto rule set for name & zone & chinese numeric */
/* one word auto rule check */
for (i = 0; i < zlen; i++)
{
if (SCWS_NO_RULE1(wmap[i][i]->flag))
continue;
r1 = scws_rule_get(s->r, txt + zmap[i].start, zmap[i].end - zmap[i].start);
if (r1 == NULL)
continue;
clen = r1->zmin > 0 ? r1->zmin : 1;
if ((r1->flag & SCWS_ZRULE_PREFIX) && (i < (zlen - clen)))
{
/* prefix, check after (zmin~zmax) */
// 先检查 zmin 字内是否全部符合要求
// 再在 zmax 范围内取得符合要求的字
// int i, j, k, ch, clen, start;
for (ch = 1; ch <= clen; ch++)
{
j = i + ch;
___ZRULE_CHECKER1___
___ZRULE_CHECKER3___
}
if (ch <= clen)
continue;
/* no limit znum or limit to a range */
j = i + ch;
while (1)
{
if ((!r1->zmax && r1->zmin) || (r1->zmax && (clen >= r1->zmax)))
break;
___ZRULE_CHECKER1___
___ZRULE_CHECKER3___
clen++;
j++;
}
// 注意原来2字人名,识别后仍为2字的情况
if (wmap[i][i]->flag & SCWS_ZFLAG_NR2)
{
if (clen == 1)
continue;
wmap[i][i+1]->flag |= SCWS_WORD_PART;
}
/* ok, got: i & clen */
k = i + clen;
wmap[i][k] = (word_t) pmalloc(p, sizeof(word_st));
wmap[i][k]->tf = r1->tf;
wmap[i][k]->idf = r1->idf;
wmap[i][k]->flag = (SCWS_WORD_RULE|SCWS_WORD_FULL);
strncpy(wmap[i][k]->attr, r1->attr, 2);
wmap[i][i]->flag |= SCWS_ZFLAG_WHEAD;
for (j = i+1; j <= k; j++)
wmap[j][j]->flag |= SCWS_ZFLAG_WPART;
if (!(wmap[i][i]->flag & SCWS_ZFLAG_WPART))
i = k;
continue;
}
if ((r1->flag & SCWS_ZRULE_SUFFIX) && (i >= clen))
{
/* suffix, check before */
for (ch = 1; ch <= clen; ch++)
{
j = i - ch;
___ZRULE_CHECKER2___
___ZRULE_CHECKER3___
}
if (ch <= clen)
continue;
/* no limit znum or limit to a range */
j = i - ch;
while (1)
{
if ((!r1->zmax && r1->zmin) || (r1->zmax && (clen >= r1->zmax)))
break;
___ZRULE_CHECKER2___
___ZRULE_CHECKER3___
clen++;
j--;
}
/* ok, got: i & clen (maybe clen=1 & [k][i] isset) */
k = i - clen;
if (wmap[k][i] != NULL)
continue;
wmap[k][i] = (word_t) pmalloc(p, sizeof(word_st));
wmap[k][i]->tf = r1->tf;
wmap[k][i]->idf = r1->idf;
wmap[k][i]->flag = SCWS_WORD_FULL;
strncpy(wmap[k][i]->attr, r1->attr, 2);
wmap[k][k]->flag |= SCWS_ZFLAG_WHEAD;
for (j = k+1; j <= i; j++)
{
wmap[j][j]->flag |= SCWS_ZFLAG_WPART;
if ((j != i) && (wmap[k][j] != NULL))
wmap[k][j]->flag |= SCWS_WORD_PART;
}
continue;
}
}
/* two words auto rule check (欧阳** , **西路) */
for (i = zlen - 2; i >= 0; i--)
{
/* with value ==> must be have SCWS_WORD_FULL, so needn't check it ag. */
if ((wmap[i][i+1] == NULL) || (wmap[i][i+1]->flag & SCWS_WORD_PART))
continue;
k = i+1;
r1 = scws_rule_get(s->r, txt + zmap[i].start, zmap[k].end - zmap[i].start);
if (r1 == NULL)
continue;
clen = r1->zmin > 0 ? r1->zmin : 1;
if ((r1->flag & SCWS_ZRULE_PREFIX) && (k < (zlen - clen)))
{
for (ch = 1; ch <= clen; ch++)
{
j = k + ch;
___ZRULE_CHECKER1___
___ZRULE_CHECKER3___
}
if (ch <= clen)
continue;
/* no limit znum or limit to a range */
j = k + ch;
while (1)
{
if ((!r1->zmax && r1->zmin) || (r1->zmax && (clen >= r1->zmax)))
break;
___ZRULE_CHECKER1___
___ZRULE_CHECKER3___
clen++;
j++;
}
/* ok, got: i & clen */
k = k + clen;
wmap[i][k] = (word_t) pmalloc(p, sizeof(word_st));
wmap[i][k]->tf = r1->tf;
wmap[i][k]->idf = r1->idf;
wmap[i][k]->flag = SCWS_WORD_FULL;
strncpy(wmap[i][k]->attr, r1->attr, 2);
wmap[i][i+1]->flag |= SCWS_WORD_PART;
for (j = i+2; j <= k; j++)
wmap[j][j]->flag |= SCWS_ZFLAG_WPART;
i--;
continue;
}
if ((r1->flag & SCWS_ZRULE_SUFFIX) && (i >= clen))
{
/* suffix, check before */
for (ch = 1; ch <= clen; ch++)
{
j = i - ch;
___ZRULE_CHECKER2___
___ZRULE_CHECKER3___
}
if (ch <= clen)
continue;
/* no limit znum or limit to a range */
j = i - ch;
while (1)
{
if ((!r1->zmax && r1->zmin) || (r1->zmax && (clen >= r1->zmax)))
break;
___ZRULE_CHECKER2___
___ZRULE_CHECKER3___
clen++;
j--;
}
/* ok, got: i & clen (maybe clen=1 & [k][i] isset) */
k = i - clen;
i = i + 1;
wmap[k][i] = (word_t) pmalloc(p, sizeof(word_st));
wmap[k][i]->tf = r1->tf;
wmap[k][i]->idf = r1->idf;
wmap[k][i]->flag = SCWS_WORD_FULL;
strncpy(wmap[k][i]->attr, r1->attr, 2);
wmap[k][k]->flag |= SCWS_ZFLAG_WHEAD;
for (j = k+1; j <= i; j++)
{
wmap[j][j]->flag |= SCWS_ZFLAG_WPART;
if (wmap[k][j] != NULL)
wmap[k][j]->flag |= SCWS_WORD_PART;
}
i -= (clen+1);
continue;
}
}
/* real do the segment */
do_segment:
/* find the easy break point */
for (i = 0, j = 0; i < zlen; i++)
{
if (wmap[i][i]->flag & SCWS_ZFLAG_WPART)
continue;
if (i > j)
_scws_mseg_zone(s, j, i-1);
j = i;
if (!(wmap[i][i]->flag & SCWS_ZFLAG_WHEAD))
{
_scws_mset_word(s, i, i);
j++;
}
}
/* the lastest zone */
if (i > j)
_scws_mseg_zone(s, j, i-1);
/* the last single for duality */
if ((s->mode & SCWS_DUALITY) && (s->zis >= 0) && !(s->zis & SCWS_ZIS_USED))
{
i = s->zis;
SCWS_PUT_RES(s->zmap[i].start, s->wmap[i][i]->idf, (s->zmap[i].end - s->zmap[i].start), s->wmap[i][i]->attr);
}
/* free the wmap & zmap */
pool_free(p);
darray_free((void **) wmap);
}
void number2text_free(t_number2text *x) {
/* free Holmes structures */
darray_free(&x->text);
}
NavMesh ai_precalc_navmesh(DArray geometry, DArray platforms,
float width, float height) {
NavMesh res;
ai_precalc_bounds(width, height);
DArray navpoints = _gen_navpoints(geometry, platforms);
DArray edges = _gen_edges(navpoints, geometry);
Vector2* navpoints_v = DARRAY_DATA_PTR(navpoints, Vector2);
Edge* edges_e = DARRAY_DATA_PTR(edges, Edge);
uint n = navpoints.size;
res.n_nodes = n;
res.navpoints = MEM_ALLOC(sizeof(Vector2) * n);
res.neighbour_count = MEM_ALLOC(sizeof(uint) * n);
res.neighbours_start = MEM_ALLOC(sizeof(uint) * n);
float* adjacency = MEM_ALLOC(sizeof(float) * n*n);
res.distance = MEM_ALLOC(sizeof(float) * n*n);
res.radius = MEM_ALLOC(sizeof(float) * n);
res.nn_grid_count = MEM_ALLOC(sizeof(uint) * nn_grid_cells);
res.nn_grid_start = MEM_ALLOC(sizeof(uint) * nn_grid_cells);
memset(res.neighbour_count, 0, sizeof(uint) * n);
memset(adjacency, 0, sizeof(float) * n*n);
memset(res.distance, 0, sizeof(float) * n*n);
memset(res.nn_grid_count, 0, sizeof(uint) * nn_grid_cells);
memset(res.nn_grid_start, 0, sizeof(uint) * nn_grid_cells);
for(uint i = 0; i < navpoints.size; ++i) {
res.navpoints[i] = navpoints_v[i];
res.radius[i] = ai_wall_distance(navpoints_v[i], geometry);
}
for(uint i = 0; i < edges.size; ++i) {
float dist = vec2_length(vec2_sub(
navpoints_v[edges_e[i].v1], navpoints_v[edges_e[i].v2]));
adjacency[IDX_2D(edges_e[i].v1, edges_e[i].v2, n)] = dist;
adjacency[IDX_2D(edges_e[i].v2, edges_e[i].v1, n)] = dist;
res.neighbour_count[edges_e[i].v1]++;
res.neighbour_count[edges_e[i].v2]++;
}
// Pracalc node neighbour lists
uint total_neighbours = res.neighbour_count[0];
res.neighbours_start[0] = 0;
for(uint i = 1; i < n; ++i) {
res.neighbours_start[i] =
res.neighbours_start[i-1] + res.neighbour_count[i-1];
total_neighbours += res.neighbour_count[i];
}
res.neighbours = MEM_ALLOC(sizeof(uint) * total_neighbours);
for(uint i = 0; i < n; ++i) {
uint idx = res.neighbours_start[i];
for(uint j = 0; j < n; ++j) {
if(adjacency[IDX_2D(i, j, n)] > 0.0f)
res.neighbours[idx++] = j;
}
assert(idx == res.neighbours_start[i] + res.neighbour_count[i]);
}
memcpy(res.distance, adjacency, sizeof(float) * n*n);
// Change zero distances to infinities
for(uint i = 0; i < n*n; ++i)
if(res.distance[i] == 0.0f)
res.distance[i] = 10000000.0f;
// Floyd-Warshall
for(uint i = 0; i < n; ++i)
for(uint j = 0; j < n; ++j)
for(uint k = 0; k < n; ++k)
res.distance[IDX_2D(j, k, n)] = MIN(res.distance[IDX_2D(j, k, n)],
res.distance[IDX_2D(j, i, n)]+res.distance[IDX_2D(i, k, n)]);
// Precalc nearest-navpoint grid
DArray grid_cell;
DArray nn_grid;
res.nn_grid_start[0] = 0;
nn_grid = darray_create(sizeof(uint), 0);
for(uint i = 0; i < nn_grid_cells; ++i) {
grid_cell = darray_create(sizeof(uint), 0);
for(uint j = 0; j < nn_samples; ++j) {
Vector2 p = _rand_point_in_nn_grid_cell(i);
uint nearest_navpoint = _nearest_navpoint(p, geometry, navpoints);
if(nearest_navpoint >= n) // Point was inside wall, skip
continue;
bool unique = true;
uint* existing_navpoints = DARRAY_DATA_PTR(grid_cell, uint);
for(uint k = 0; k < grid_cell.size; ++k)
if(existing_navpoints[k] == nearest_navpoint)
unique = false;
if(unique)
darray_append(&grid_cell, &nearest_navpoint);
}
res.nn_grid_count[i] = grid_cell.size;
if(i > 0)
res.nn_grid_start[i] =
res.nn_grid_start[i-1] + res.nn_grid_count[i-1];
uint* cell_navpoints = DARRAY_DATA_PTR(grid_cell, uint);
darray_append_multi(&nn_grid, cell_navpoints, grid_cell.size);
darray_free(&grid_cell);
}
// Hack, works properly as long as darray_free only does
// MEM_FREE(darray.data);
res.nn_grid = (uint*)nn_grid.data;
darray_free(&navpoints);
darray_free(&edges);
MEM_FREE(adjacency);
_precalc_vis(geometry, &res);
return res;
}
int main()
{
struct body_s *bod, *out;
struct buf_s *buf;
int n = 0,i=0;
ssize_t len = 0;
uint16_t cmdid = 0;
int32_t num=-16;
struct darray_s *da;
struct head_s *head;
bod = (struct body_s*)calloc(PACKET_SIZE, sizeof(struct body_s));
out = (struct body_s*)calloc(1, sizeof(struct body_s));
printf("boy size:%d\n", sizeof(struct body_s));
printf("num:%lld, zigzag:%lld\n", (int64_t)num, zigzag((int64_t)num));
head = (struct head_s*)calloc(1, sizeof(struct head_s));
if (head == NULL) return 0;
head->cmdid = 0xF001;
head->seq = 0x10001;
head->uid = 0x1000;
head->aid = 0x0001;
buf = buf_calloc(1024);
len = enpacket(head, (u_char*)NULL, 0, 0, NULL, 0, buf);
printf("packet buf:%p, len:%d\n", buf->buf_pos, (int)buf->buf_len);
hexdump((u_char *)buf->buf_pos, buf->buf_len);
memset(head, 0, sizeof(struct head_s));
len = dehead(buf, head);
if (len==-1) {
printf("errno:%d, errstr:%s\n", errno, strerror(errno));
exit(1);
}
printf("cmdid:%x\n", head->cmdid);
switch (head->cmdid){
case 0xF001:
//out->a17 = (u_char*)calloc(1,10);
da = darray_calloc(1, sizeof(*bod));
if (depacket_da(buf, NULL, 0, da) == -1)
perror("ERR DEBODY\n");
printf("da used %d\n",da->da_used);
body_handler(head, (struct body_s*)da->da_values);
darray_free(da);
break;
default:
break;
}
free(bod);
free(out);
free(head);
buf_free(buf);
}
int opt_replace_const(expr *prog)
{
if( !prog )
return 0;
// Get current number of variables, used to estimate the
// memory usage of each new constant added to the program
vars *v = pgm_get_vars( expr_get_program(prog) );
unsigned nfloat = vars_get_count(v, vtFloat);
unsigned nstring = vars_get_count(v, vtString);
unsigned nvar = vars_get_total(v);
// If not enough variables, exit
if( nvar > 255 )
return 0;
// Search all constant values in the program and store
// the value and number of times repeated
cvalue_list *lst = darray_new(cvalue,256);
int num = update_cvalue(prog, lst);
// If no constant values, exit.
if( !num )
{
darray_free(lst);
return 0;
}
// Now, sort constant values by "usage gain"
cvalue_list_sort(lst);
// Extract all constant values that produce a gain:
unsigned cs = 0, cn = 0;
for(unsigned i=0; i<lst->len && nvar<256; i++)
{
cvalue *cv = lst->data + i;
int bytes = cvalue_saved_bytes(cv);
// Add one extra byte if the variable number is
// more than 127:
if( nvar > 127 )
bytes += cv->count;
if( bytes > 0 )
continue;
// Ok, we can replace the variable
if( cv->str )
{
char name[256];
sprintf(name, "__s%d", cs);
cs++;
nstring++;
nvar++;
info_print(expr_get_file_name(prog), 0, "replacing constant var %s$=\"%.*s\" (%d times, %d bytes)\n",
name, cv->slen, cv->str, cv->count, bytes);
// Creates the variable
cv->vid = vars_new_var(v, name, vtString, expr_get_file_name(prog), 0);
cv->status = 1;
// Replace all instances of the constant value with the variables
replace_cvalue(prog, cv);
}
else
{
char name[256];
if( cv->num < 100000 && cv->num == round(cv->num) )
{
if( cv->num >= 0 )
sprintf(name, "__n%.0f", cv->num);
else
sprintf(name, "__n_%.0f", -cv->num);
}
else if( cv->num < 1000 && round(10000000 * cv->num) == 1000000 * round(10 * cv->num) )
{
if( cv->num >= 0 )
sprintf(name, "__n%.0f_%.0f", trunc(cv->num), 10 * (cv->num - trunc(cv->num)));
else
sprintf(name, "__n_%.0f_%.0f", -trunc(cv->num), -10 * (cv->num - trunc(cv->num)) );
}
else
{
sprintf(name, "__nd%d", cn);
cn++;
}
nfloat++;
nvar++;
info_print(expr_get_file_name(prog), 0, "replacing constant var %s=%g (%d times, %d bytes)\n",
name, cv->num, cv->count, bytes);
cv->vid = vars_new_var(v, name, vtFloat, expr_get_file_name(prog), 0);
cv->status = 1;
// Replace all instances of the constant value with the variables
replace_cvalue(prog, cv);
}
}
// Sort again by absolute value, this tends to generate smaller code
cvalue_list_sort_abs(lst);
// Now, add all variable initializations to the program, first numeric, then strings:
expr *init = 0, *last_stmt = 0, *dim = 0;
for(unsigned i=0; i<lst->len; i++)
{
cvalue *cv = lst->data + i;
if( cv->status == 1 && !cv->str )
{
last_stmt = create_num_assign(prog->mngr, lst, last_stmt, cv->num, cv->vid);
if( !init ) init = last_stmt;
cv->status = 2;
}
}
// Now, all DIM expressions
for(unsigned i=0; i<lst->len; i++)
{
cvalue *cv = lst->data + i;
if( cv->status == 1 && cv->str )
{
dim = create_str_dim(prog->mngr, lst, dim, cv->slen, cv->vid);
cv->status = 2;
}
}
if( dim )
{
last_stmt = expr_new_stmt(prog->mngr, last_stmt, dim, STMT_DIM);
if( !init ) init = last_stmt;
}
// And all string assignments
for(unsigned i=0; i<lst->len; i++)
{
cvalue *cv = lst->data + i;
if( cv->status == 2 && cv->str )
{
last_stmt = create_str_assign(prog->mngr, last_stmt, cv->str, cv->slen, cv->vid);
if( !init ) init = last_stmt;
cv->status = 2;
}
}
add_to_prog(prog, init);
darray_free(lst);
return 0;
}
