void resman_check_watch(struct resman *rman)
{
struct watch_dir *wdir;
unsigned int idx;
unsigned int num_handles = dynarr_size(rman->watch_handles);
if(!num_handles) {
return;
}
idx = WaitForMultipleObjectsEx(num_handles, rman->watch_handles, FALSE, 0, TRUE);
if(idx == WAIT_FAILED) {
unsigned int err = GetLastError();
fprintf(stderr, "failed to check for file modification: %u\n", err);
return;
}
if(idx >= WAIT_OBJECT_0 && idx < WAIT_OBJECT_0 + num_handles) {
if(!(wdir = rb_find(rman->wdirbyev, rman->watch_handles[idx]))) {
fprintf(stderr, "got change handle, but failed to find corresponding watch_dir!\n");
return;
}
handle_event(rman, rman->watch_handles[idx], wdir);
/* restart the watch call */
ReadDirectoryChangesW(wdir->handle, wdir->buf, RES_BUF_SIZE, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE, 0, &wdir->over, 0);
}
}
int main(int argc, char **argv)
{
int i;
int *arr;
if(argc < 2) {
printf("pass a bunch of numbers to sort them\n");
return 1;
}
/* create a new dynamic array of string pointers */
arr = dynarr_alloc(0, sizeof *arr);
for(i=1; i<argc; i++) {
char *endp;
int n = strtol(argv[i], &endp, 0);
if(endp == argv[i]) {
fprintf(stderr, "%s is not a number\n", argv[i]);
dynarr_free(arr);
return 1;
}
/* add a new string to the array (the argument is copied) */
arr = dynarr_push(arr, &n);
}
qsort(arr, dynarr_size(arr), sizeof *arr, cmpfunc);
for(i=0; i<dynarr_size(arr); i++) {
printf("%d\n", arr[i]);
}
dynarr_free(arr);
return 0;
}
static struct dynarr *parse_specifier_qualifier_sc_internal(struct parser *parser, int mask) {
union token tok;
void *nd;
struct dynarr *darr = dynarr_init();
while (1) {
tok = lexer_next_token(parser->lexer);
if ((mask & INTERNAL_PARSE_SPECIFIER) && initiate_type_specifier(tok)) {
lexer_put_back(parser->lexer, tok);
nd = parse_type_specifier(parser);
} else if ((mask & INTERNAL_PARSE_QUALIFIER) && initiate_type_qualifier(tok)) {
nd = type_qualifier_init(tok.tok_tag);
} else if ((mask & INTERNAL_PARSE_STORAGE_CLASS) && initiate_storage_class_specifier(tok)) {
nd = storage_class_specifier_init(tok.tok_tag);
} else {
lexer_put_back(parser->lexer, tok);
break;
}
dynarr_add(darr, nd);
}
#if DEBUG
if (dynarr_size(darr) == 0) {
// lexer_dump_remaining(parser->lexer);
file_reader_dump_remaining(parser->lexer->cstream);
tok = lexer_next_token(parser->lexer); // this is putback
token_dump(tok);
}
#endif
assert(dynarr_size(darr) > 0);
return darr;
}
void *resman_get_res_data(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->data;
}
return 0;
}
char * lsystem_getRandProduction (const LSYSTEM * l, const char s) {
PRODUCTION * sp = lsystem_getProduction (l, s);
int i = 0;
char
* r = NULL,
* v = NULL;
//printf ("%s (%p, \'%c\')...\n", __FUNCTION__, l, s);
if (sp == NULL) {
r = xph_alloc_name (2, "LSYSTEM production");
r[0] = s;
r[1] = '\0';
return r;
}
i = dynarr_size (sp->exp);
if (i == 1) {
v = *(char **)dynarr_front (sp->exp);
//printf ("got \"%s\" as the 0-th index of %p\n", v, sp->exp);
r = xph_alloc (strlen (v) + 1);
strcpy (r, v);
return r;
}
i = rand () % i;
v = *(char **)dynarr_at (sp->exp, i);
//printf ("got \"%s\" as the %d-th index of %p\n", v, i, sp->exp);
r = xph_alloc (strlen (v) + 1);
strcpy (r, v);
//printf ("...%s\n", __FUNCTION__);
return r;
}
const char *resman_get_res_name(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->name;
}
return 0;
}
void resman_destroy(struct resman *rman)
{
int i;
if(!rman) return;
for(i=0; i<dynarr_size(rman->res); i++) {
if(!rman->res[i]) continue;
if(rman->destroy_func) {
rman->destroy_func(i, rman->destroy_func_cls);
}
free(rman->res[i]->name);
free(rman->res[i]);
}
dynarr_free(rman->res);
resman_tpool_release(rman->tpool);
#if defined(WIN32) || defined(__WIN32__)
dynarr_free(rman->wait_handles);
#else
dynarr_free(rman->wait_fds);
#endif
resman_destroy_file_monitor(rman);
pthread_mutex_destroy(&rman->lock);
}
// the caller should push and pop the typedef table
struct compound_statement *parse_compound_statement(struct parser *parser) {
expect(parser->lexer, TOK_LBRACE);
// lexer_push_typedef_tab(parser->lexer);
// look one token ahead to determing if this is a declaration or statement or empty block
union token tok = lexer_next_token(parser->lexer);
struct dynarr *decl_or_stmt_list = dynarr_init();
while (tok.tok_tag != TOK_RBRACE) {
if (initiate_declaration(tok)) {
#if 0
if (dynarr_size(stmtList) > 0) {
panic("encounter declaration after statement");
}
#endif
lexer_put_back(parser->lexer, tok);
dynarr_add(decl_or_stmt_list, parse_declaration(parser));
} else { // initiate a statement
lexer_put_back(parser->lexer, tok);
dynarr_add(decl_or_stmt_list, parse_statement(parser));
}
tok = lexer_next_token(parser->lexer);
}
// lexer_pop_typedef_tab(parser->lexer);
return compound_statement_init(decl_or_stmt_list);
}
static void pp_define_object_macro(struct lexer *lexer, const char *name) {
struct dynarr *darr = store_token_until_newline(lexer);
// simple check for: #define x x case.
// a real example is in: /usr/include/bits/confname.h
//
// the ultimate way to sovle the (indirectly) referring itself obj/func macro is
// constructing the macro expanding tree
if (dynarr_size(darr) == 1) {
union token *tok = dynarr_get(darr, 0);
if (tok->tok_tag == TOK_IDENTIFIER && strcmp(tok->id.s, name) == 0) {
token_destroy(*tok);
free(tok);
dynarr_destroy(darr);
red("ignore identity obj macro %s", name);
return;
}
}
struct macro *macro = obj_macro_init(darr);
define_macro(lexer, name, macro);
#if DUMP_MACRO
// fprintf(stderr, "%s define the macro %s\n", lexer->cstream->path, name);
macro_dump(lexer, name, macro);
#endif
}
int resman_get_res_result(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->result;
}
return -1;
}
int resman_get_res_load_count(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->num_loads;
}
return -1;
}
void resman_stop_watch(struct resman *rman, struct resource *res)
{
int i, sz;
struct watch_dir *wdir;
if(!res->watch_path) {
return;
}
if(!(wdir = rb_find(rman->watchdirs, res->watch_path))) {
return;
}
/* if there is no other reference to this watch dir, destroy it */
if(--wdir->nref <= 0) {
/* find the handle in the watch_handles array and remove it */
sz = dynarr_size(rman->watch_handles);
for(i=0; i<sz; i++) {
if(rman->watch_handles[i] == wdir->handle) {
/* swap the end for it and pop */
rman->watch_handles[i] = rman->watch_handles[sz - 1];
rman->watch_handles[sz - 1] = 0;
dynarr_pop(rman->watch_handles);
break;
}
}
rb_delete(rman->wdirbyev, wdir->over.hEvent);
rb_delete(rman->watchdirs, wdir->watch_path);
CancelIo(wdir->handle);
CloseHandle(wdir->handle);
CloseHandle(wdir->over.hEvent);
free(wdir->watch_path);
free(wdir);
res->watch_path = 0;
} else {
/* just remove this watch item */
if(wdir->items && wdir->items->res == res) {
struct watch_item *tmp = wdir->items;
wdir->items = wdir->items->next;
free(tmp);
} else {
struct watch_item *wprev = wdir->items;
struct watch_item *witem = wprev->next;
while(witem) {
if(witem->res == res) {
struct watch_item *tmp = witem;
wprev->next = witem->next;
break;
}
witem = witem->next;
}
}
}
}
static void wait_for_any_event(struct resman *rman)
{
unsigned int num_handles;
if(!(num_handles = dynarr_size(rman->wait_handles))) {
return;
}
WaitForMultipleObjectsEx(num_handles, rman->wait_handles, FALSE, INFINITE, TRUE);
}
// The declarator is for function
static void register_func_parameters_for_typedef(struct parser *parser, struct declarator *declarator) {
struct dynarr *suff_list = declarator->direct_declarator->suff_list;
assert(dynarr_size(suff_list) == 1);
struct direct_declarator_suffix *suff = dynarr_get(suff_list, 0);
assert(suff->empty_paren || suff->param_type_list != NULL);
if (suff->param_type_list != NULL) {
DYNARR_FOREACH_BEGIN(suff->param_type_list->param_decl_list, parameter_declaration, each);
register_func_parameter_for_typedef(parser, each);
DYNARR_FOREACH_END();
}
}
int lsystem_addProduction (LSYSTEM * l, const char s, const char * p) {
PRODUCTION * sp = lsystem_getProduction (l, s);
if (sp == NULL) {
sp = production_create (s, p);
dynarr_push (l->p, sp);
dynarr_sort (l->p, production_sort);
} else {
production_addRule (sp, p);
}
return dynarr_size (sp->exp);
}
static int find_resource(struct resman *rman, const char *fname)
{
int i, sz = dynarr_size(rman->res);
for(i=0; i<sz; i++) {
if(strcmp(rman->res[i]->name, fname) == 0) {
return i;
}
}
return -1;
}
static int add_resource(struct resman *rman, const char *fname, void *data)
{
int i, idx = -1, size = dynarr_size(rman->res);
struct resource *res;
struct resource **tmparr;
/* allocate a new resource */
if(!(res = malloc(sizeof *res))) {
return -1;
}
memset(res, 0, sizeof *res);
res->name = strdup(fname);
assert(res->name);
res->data = data;
pthread_mutex_init(&res->lock, 0);
/* check to see if there's an empty (previously erased) slot */
for(i=0; i<size; i++) {
if(!rman->res[i]) {
idx = i;
break;
}
}
if(idx == -1) {
/* free slot not found, append a new one */
idx = size;
if(!(tmparr = dynarr_push(rman->res, &res))) {
free(res->name);
free(res);
return -1;
}
rman->res = tmparr;
} else {
/* free slot found, just use it */
res = rman->res[idx];
}
res->id = idx; /* set the resource id */
resman_reload(rman, rman->res[idx]);
return idx;
}
void nodedb_c_destruct(NodeCurve *n)
{
unsigned int i, num;
num = dynarr_size(n->curves);
for(i = 0; i < num; i++)
{
NdbCCurve *c;
if((c = dynarr_index(n->curves, i)) != NULL && c->name[0] != '\0')
{
printf("destroying curve %u\n", i);
dynarr_destroy(c->keys);
list_destroy(c->curve);
}
}
dynarr_destroy(n->curves);
n->curves = NULL;
}
static void wait_for_any_event(struct resman *rman)
{
int i, res, numfds, maxfd = 0;
fd_set rdset;
if(!(numfds = dynarr_size(rman->wait_fds))) {
return;
}
FD_ZERO(&rdset);
for(i=0; i<numfds; i++) {
int fd = rman->wait_fds[i];
FD_SET(fd, &rdset);
if(fd > maxfd) maxfd = fd;
}
while((res = select(maxfd + 1, &rdset, 0, 0, 0)) == -1 && errno == EINTR);
if(res == -1) {
fprintf(stderr, "failed to wait for any events: %s\n", strerror(errno));
}
}
static void worldmap_input (EntComponent comp, EntSpeech speech)
{
Entity
this = component_entityAttached (comp);
worldmapData
map = component_getData (entity_getAs (Worldmap, "worldmap"));
struct input_event
* input = speech->arg;
hexPos
pos = position_get (entity_getByName ("PLAYER"));
// the span index is backwards compared to usual because i'd like it to maintain the usual span mapping, which is 0 = hex level, MapSpan = pole level - xph 2012 01 17
if (!input->active)
return;
switch (input->code)
{
case IR_UI_MENU_INDEX_DOWN:
if (map->spanTypeFocus == FOCUS_SPAN && map->spanFocus != 0)
{
if (map->typeFocus != 0)
{
textureDestroy (map->spanTextures[map->spanFocus]);
map->spanTextures[map->spanFocus] = NULL;
}
map->spanFocus--;
map->types = mapDataTypes (hexPos_platter (pos, map->spanFocus));
if (map->types)
map->typeFocus = 0;
}
else if (map->types && map->typeFocus < (dynarr_size (map->types) - 1))
{
map->typeFocus++;
if (map->spanTextures[map->spanFocus])
{
textureDestroy (map->spanTextures[map->spanFocus]);
map->spanTextures[map->spanFocus] = NULL;
}
}
break;
case IR_UI_MENU_INDEX_UP:
if (map->spanTypeFocus == FOCUS_SPAN && map->spanFocus != map->worldSpan)
{
if (map->typeFocus != 0)
{
textureDestroy (map->spanTextures[map->spanFocus]);
map->spanTextures[map->spanFocus] = NULL;
}
map->spanFocus++;
map->types = mapDataTypes (hexPos_platter (pos, map->spanFocus));
if (map->types)
map->typeFocus = 0;
}
else if (map->typeFocus != 0)
{
map->typeFocus--;
if (map->spanTextures[map->spanFocus])
{
textureDestroy (map->spanTextures[map->spanFocus]);
map->spanTextures[map->spanFocus] = NULL;
}
}
break;
case IR_UI_MODE_SWITCH:
map->spanTypeFocus ^= 1;
break;
case IR_WORLDMAP_SWITCH:
printf ("focusing world\n");
entity_message (this, NULL, "loseFocus", NULL);
entity_messageGroup ("PlayerAvatarEntities", NULL, "gainFocus", NULL);
break;
default:
break;
}
}
int anm_get_animation_count(const struct anm_node *node)
{
return dynarr_size(node->animations);
}
int intstack_pop(struct intstack *stk) {
assert(dynarr_size(stk) > 0);
return (int) (long) stk->list[--stk->size];
}
int intstack_subtop(struct intstack *stk) {
assert(dynarr_size(stk) >= 2);
return (int) (long) stk->list[stk->size - 2];
}
/* poll will be called with a high frequency anyway, so let's not spend
* too much time on done callbacks each time through it
*/
timeslice = rman->opt[RESMAN_OPT_TIMESLICE];
if(timeslice > 0 && resman_get_time_msec() - start_time > timeslice) {
break;
}
}
return 0;
}
int resman_wait(struct resman *rman)
{
wait_for_any_event(rman);
return 0;
}
const char *resman_get_res_name(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->name;
}
return 0;
}
void resman_set_res_data(struct resman *rman, int res_id, void *data)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
rman->res[res_id]->data = data;
}
}
void *resman_get_res_data(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->data;
}
return 0;
}
int resman_get_res_result(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->result;
}
return -1;
}
int resman_get_res_load_count(struct resman *rman, int res_id)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
return rman->res[res_id]->num_loads;
}
return -1;
}
#if defined(WIN32) || defined(__WIN32__)
int *resman_get_wait_fds(struct resman *rman, int *num_fds)
{
static int once;
if(!once) {
once = 1;
fprintf(stderr, "warning: resman_get_wait_fds does nothing on windows\n");
}
return 0;
}
void **resman_get_wait_handles(struct resman *rman, int *num_handles)
{
*num_handles = dynarr_size(rman->wait_handles);
return rman->wait_handles;
}
static void wait_for_any_event(struct resman *rman)
{
unsigned int num_handles;
if(!(num_handles = dynarr_size(rman->wait_handles))) {
return;
}
WaitForMultipleObjectsEx(num_handles, rman->wait_handles, FALSE, INFINITE, TRUE);
}
#else /* UNIX */
int *resman_get_wait_fds(struct resman *rman, int *num_fds)
{
*num_fds = dynarr_size(rman->wait_fds);
return rman->wait_fds;
}
int resman_poll(struct resman *rman)
{
int i, num_res;
unsigned long start_time, timeslice;
/* first check all the resources to see if anyone is pending deletion */
num_res = dynarr_size(rman->res);
for(i=0; i<num_res; i++) {
struct resource *res = rman->res[i];
if(!res) {
continue;
}
/* also make sure we're it's off the queues/workers before deleting */
if(res->delete_pending && !res->pending) {
if(rman->destroy_func) {
rman->destroy_func(i, rman->destroy_func_cls);
}
remove_resource(rman, i);
}
}
/* then check for modified files */
resman_check_watch(rman);
#if !defined(WIN32) && !defined(__WIN32__)
/* empty the thread pool event pipe (fd is nonblocking) */
while(read(rman->tpool_wait_fd, &i, sizeof i) > 0);
#endif
if(!rman->done_func) {
return 0; /* no done callback; there's no point in checking anything */
}
start_time = resman_get_time_msec();
for(i=0; i<num_res; i++) {
struct resource *res = rman->res[i];
if(!res) {
continue;
}
pthread_mutex_lock(&res->lock);
if(!res->done_pending) {
int reload = res->reload_timeout && res->reload_timeout <= start_time;
pthread_mutex_unlock(&res->lock);
if(reload) {
printf("file \"%s\" modified, delayed reload\n", res->name);
res->reload_timeout = 0;
resman_reload(rman, res);
}
continue;
}
/* so a done callback *is* pending... */
res->done_pending = 0;
if(rman->done_func(i, rman->done_func_cls) == -1) {
/* done-func returned -1, so let's remove the resource
* but only if this was the first load. Otherwise keep it
* around in case it gets valid again...
*/
if(res->num_loads == 0) {
pthread_mutex_unlock(&res->lock);
remove_resource(rman, i);
continue;
}
}
res->num_loads++;
resman_start_watch(rman, res); /* start watching the file for modifications */
pthread_mutex_unlock(&res->lock);
/* poll will be called with a high frequency anyway, so let's not spend
* too much time on done callbacks each time through it
*/
timeslice = rman->opt[RESMAN_OPT_TIMESLICE];
if(timeslice > 0 && resman_get_time_msec() - start_time > timeslice) {
break;
}
}
return 0;
}
void resman_set_res_data(struct resman *rman, int res_id, void *data)
{
if(res_id >= 0 && res_id < dynarr_size(rman->res)) {
rman->res[res_id]->data = data;
}
}
void plugin_set_input(Plugin *p, int index, PValueType type, const char *name, va_list taglist)
{
if(p == NULL)
return;
if(index < 0)
{
LOG_ERR(("Plug-in \"%s\" attempted to set input with negative index--ignored", p->name));
return;
}
if((p->input == NULL && index != 0) || (p->input != NULL && (size_t) index != dynarr_size(p->input)))
{
LOG_ERR(("Plug-in \"%s\" attempted to set input \"%s\" with bad index %d--ignored", p->name, name, index));
return;
}
if(type < P_VALUE_BOOLEAN || type > P_VALUE_MODULE)
{
LOG_ERR(("Plug-in \"%s\" attempted to set input %d with bad type %d--ignored", p->name, index, type));
return;
}
if(p->input == NULL)
p->input = dynarr_new(sizeof (Input), 2);
if(p->input != NULL)
{
Input i;
stu_strncpy(i.name, sizeof i.name, name);
i.type = type;
i.spec.req = i.spec.def = i.spec.min = i.spec.max = 0;
i.spec.enums = NULL;
i.desc = NULL;
value_init(&i.spec.min_val);
value_init(&i.spec.max_val);
value_init(&i.spec.def_val);
for(;;)
{
int tag = va_arg(taglist, int);
if(tag == P_INPUT_TAG_DONE)
break;
else if(tag < P_INPUT_TAG_DONE || tag > P_INPUT_TAG_DESC) /* Generous. */
{
LOG_WARN(("Aborting on bad tag value for %s.%s: %d", p->name, i.name, tag));
break;
}
else if(tag == P_INPUT_TAG_REQUIRED)
i.spec.req = 1;
else if(tag == P_INPUT_TAG_MIN)
i.spec.min = value_set_defminmax_va(&i.spec.min_val, i.type, &taglist);
else if(tag == P_INPUT_TAG_MAX)
i.spec.max = value_set_defminmax_va(&i.spec.max_val, i.type, &taglist);
else if(tag == P_INPUT_TAG_DEFAULT)
i.spec.def = value_set_defminmax_va(&i.spec.def_val, i.type, &taglist);
else if(tag == P_INPUT_TAG_ENUM)
{
const char *st;
if(i.spec.enums == NULL)
i.spec.enums = dynstr_new_sized(64);
st = dynstr_string(i.spec.enums);
if(st != NULL && *st != '\0' && st[strlen(st) - 1] != '|') /* Make sure there are separators. */
dynstr_append_c(i.spec.enums, '|');
dynstr_append(i.spec.enums, va_arg(taglist, char *));
}
else if(tag == P_INPUT_TAG_DESC)
i.desc = va_arg(taglist, char *);
}
static int sync_geometry_layer(const NodeGeometry *node, const NdbGLayer *layer,
const NodeGeometry *target, const NdbGLayer *tlayer)
{
const uint8 *data, *tdata;
size_t i, size, tsize, esize;
int send = 0;
/* printf("synchronizing geometry layer '%s' against '%s'\n", layer->name, tlayer->name);*/
/* Basically break the dynarr abstraction, for speed. */
esize = dynarr_get_elem_size(layer->data);
size = dynarr_size(layer->data);
tsize = dynarr_size(tlayer->data);
data = dynarr_index(layer->data, 0);
tdata = dynarr_index(tlayer->data, 0);
/* printf(" local geometry size: %u at %p, remote is %u at %p\n", size, data, tsize, tdata);*/
for(i = 0; i < size; i++)
{
if(i >= tsize) /* If data is not even in target, we must send it. */
send = 1;
else
{
send = memcmp(data, tdata, esize) != 0; /* If it fits, compare to see if send needed. */
/* If vertex layer, do more intelligent comparison for deleted vertices. */
if(tlayer->id == 0 && tlayer->type == VN_G_LAYER_VERTEX_XYZ && tdata != NULL)
{
if(vertex_deleted((real64 *) data))
{
if(vertex_deleted((real64 *) tdata))
send = 0;
}
}
else if(tlayer->id == 1 && tlayer->type == VN_G_LAYER_POLYGON_CORNER_UINT32 && tdata != NULL) /* And for polygon layers, too. */
{
/* printf("base polygon %u: local delete is %d, remote is %d, send=%d (local=%p remote=%p)\n",
i, polygon_deleted((uint32 *) data), polygon_deleted((uint32 *) tdata), send, data, tdata);
*/ if(polygon_deleted((uint32 *) data) && !polygon_deleted((uint32 *) tdata))
{
/* printf(" deleting polygon %u.%u\n", target->node.id, i);*/
verse_send_g_polygon_delete(target->node.id, i);
send = 0;
}
}
}
/* if(send)
printf(" send %s %u in %u is %d\n", layer->name, i, node->node.id, send);
*/ if(send)
{
switch(tlayer->type)
{
case VN_G_LAYER_VERTEX_XYZ:
verse_send_g_vertex_set_xyz_real64(target->node.id, tlayer->id, i,
((const real64 *) data)[0],
((const real64 *) data)[1],
((const real64 *) data)[2]);
break;
case VN_G_LAYER_VERTEX_UINT32:
verse_send_g_vertex_set_uint32(target->node.id, tlayer->id, i, ((const uint32 *) data)[0]);
break;
case VN_G_LAYER_VERTEX_REAL:
verse_send_g_vertex_set_real64(target->node.id, tlayer->id, i, ((const real64 *) data)[0]);
break;
case VN_G_LAYER_POLYGON_CORNER_UINT32:
verse_send_g_polygon_set_corner_uint32(target->node.id, tlayer->id, i,
((const uint32 *) data)[0],
((const uint32 *) data)[1],
((const uint32 *) data)[2],
((const uint32 *) data)[3]);
break;
case VN_G_LAYER_POLYGON_CORNER_REAL:
verse_send_g_polygon_set_corner_real64(target->node.id, tlayer->id, i,
((const real64 *) data)[0],
((const real64 *) data)[1],
((const real64 *) data)[2],
((const real64 *) data)[3]);
break;
case VN_G_LAYER_POLYGON_FACE_UINT8:
verse_send_g_polygon_set_face_uint8(target->node.id, tlayer->id, i,
((const uint8 *) data)[0]);
break;
case VN_G_LAYER_POLYGON_FACE_UINT32:
verse_send_g_polygon_set_face_uint32(target->node.id, tlayer->id, i,
((const uint32 *) data)[0]);
break;
case VN_G_LAYER_POLYGON_FACE_REAL:
verse_send_g_polygon_set_face_real64(target->node.id, tlayer->id, i,
((const real64 *) data)[0]);
break;
default:
;
}
}
data += esize;
tdata += esize;
}
if(size < tsize) /* We have less data than the target, so delete remainder. */
{
send = 1;
printf("** Target is too large, deleting -------------------------------------------------------\n");
/* if(layer->type >= VN_G_LAYER_VERTEX_XYZ && layer->type < VN_G_LAYER_POLYGON_CORNER_UINT32)
{
for(i = size; i < tsize; i++)
verse_send_g_vertex_delete_real64(target->node.id, i);
}
*/ if(tlayer->id == 1)
{
printf("deleting excess polygons\n");
for(i = size; i < tsize; i++)
verse_send_g_polygon_delete(target->node.id, i);
}
}
return send;
}
