static void emit_c_encoded_array_size(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { char *tn = ls->structname->lctypename; char *tn_ = dots_to_underscores(tn); emit(0,"int __%s_encoded_array_size(const %s *p, int elements)", tn_, tn_); emit(0,"{"); emit(1,"int size = 0, element;"); emit(1, "for (element = 0; element < elements; element++) {"); emit(0,""); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); emit_c_array_loops_start(lcm, f, lm, "p", FLAG_NONE); int indent = 2+imax(0, g_ptr_array_size(lm->dimensions) - 1); emit(indent, "size += __%s_encoded_array_size(%s, %s);", dots_to_underscores (lm->type->lctypename), make_accessor(lm, "p", g_ptr_array_size(lm->dimensions) - 1), make_array_size(lm, "p", g_ptr_array_size(lm->dimensions) - 1)); emit_c_array_loops_end(lcm, f, lm, "p", FLAG_NONE); emit(0,""); } emit(1,"}"); emit(1, "return size;"); emit(0,"}"); emit(0,""); }
static void emit_c_decode_array(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { char *tn = ls->structname->lctypename; char *tn_ = dots_to_underscores(tn); emit(0,"int __%s_decode_array(const void *buf, int offset, int maxlen, %s *p, int elements)", tn_, tn_); emit(0,"{"); emit(1, "int pos = 0, thislen, element;"); emit(0,""); emit(1, "for (element = 0; element < elements; element++) {"); emit(0,""); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); emit_c_array_loops_start(lcm, f, lm, "p", lcm_is_constant_size_array(lm) ? FLAG_NONE : FLAG_EMIT_MALLOCS); int indent = 2+imax(0, g_ptr_array_size(lm->dimensions) - 1); emit(indent, "thislen = __%s_decode_array(buf, offset + pos, maxlen - pos, %s, %s);", dots_to_underscores (lm->type->lctypename), make_accessor(lm, "p", g_ptr_array_size(lm->dimensions) - 1), make_array_size(lm, "p", g_ptr_array_size(lm->dimensions) - 1)); emit(indent, "if (thislen < 0) return thislen; else pos += thislen;"); emit_c_array_loops_end(lcm, f, lm, "p", FLAG_NONE); emit(0,""); } emit(1, "}"); emit(1, "return pos;"); emit(0,"}"); emit(0,""); }
static void emit_c_clone_array(lcmgen_t *lcm, FILE *f, lcm_struct_t *lr) { char *tn = lr->structname->lctypename; char *tn_ = dots_to_underscores(tn); emit(0,"int __%s_clone_array(const %s *p, %s *q, int elements)", tn_, tn_, tn_); emit(0,"{"); emit(1, "int element;"); emit(1, "for (element = 0; element < elements; element++) {"); emit(0,""); for (unsigned int m = 0; m < g_ptr_array_size(lr->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(lr->members, m); emit_c_array_loops_start(lcm, f, lm, "q", lcm_is_constant_size_array(lm) ? FLAG_NONE : FLAG_EMIT_MALLOCS); int indent = 2+imax(0, g_ptr_array_size(lm->dimensions) - 1); emit(indent, "__%s_clone_array(%s, %s, %s);", dots_to_underscores (lm->type->lctypename), make_accessor(lm, "p", g_ptr_array_size(lm->dimensions) - 1), make_accessor(lm, "q", g_ptr_array_size(lm->dimensions) - 1), make_array_size(lm, "p", g_ptr_array_size(lm->dimensions) - 1)); emit_c_array_loops_end(lcm, f, lm, "p", FLAG_NONE); emit(0,""); } emit(1, "}"); emit(1, "return 0;"); emit(0,"}"); emit(0,""); }
static gboolean on_motion_notify (GtkWidget *widget, GdkEventMotion *event, void *user_data) { Viewer *self = (Viewer*) user_data; gtku_gl_drawing_area_set_context (self->gl_area); double ray_start[3]; double ray_dir[3]; _window_coord_to_ray (event->x, widget->allocation.height - event->y, ray_start, ray_dir); // is anyone hovering? if (self->picking_handler == NULL || !self->picking_handler->picking) { // find a new hover? double best_distance = HUGE; EventHandler *best_handler = NULL; for (unsigned int eidx = 0; eidx < g_ptr_array_size(self->event_handlers); eidx++) { EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx); handler->hovering = 0; if (handler->enabled && handler->hover_query) { double this_distance = handler->hover_query(self, handler, ray_start, ray_dir); if (this_distance < best_distance && this_distance >= 0) { best_distance = this_distance; best_handler = handler; } } } // notify the new handler if (best_handler) best_handler->hovering = 1; viewer_request_redraw(self); } // give picking handler first dibs int consumed = 0; if (self->picking_handler && !self->picking_handler->picking) self->picking_handler = NULL; if (self->picking_handler && self->picking_handler->enabled && self->picking_handler->mouse_motion) { consumed = self->picking_handler->mouse_motion(self, self->picking_handler, ray_start, ray_dir, event); update_status_bar(self); } // try all the other handlers in order of priority for (unsigned int eidx = 0; !consumed && eidx < g_ptr_array_size(self->event_handlers); eidx++) { EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx); if (handler != self->picking_handler && handler->enabled && handler->mouse_motion) if (handler->mouse_motion(self, handler, ray_start, ray_dir, event)) break; } return TRUE; }
static void emit_encode_nohash(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { const char* sn = ls->structname->shortname; if(0 == g_ptr_array_size(ls->members)) { emit(0, "int %s::_encodeNoHash(void *, int, int) const", sn); emit(0, "{"); emit(1, "return 0;"); emit(0, "}"); emit(0, ""); return; } emit(0, "int %s::_encodeNoHash(void *buf, int offset, int maxlen) const", sn); emit(0, "{"); emit(1, "int pos = 0, tlen;"); emit(0, ""); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); int num_dims = g_ptr_array_size(lm->dimensions); if (0 == num_dims) { if (lcm_is_primitive_type(lm->type->lctypename)) { if(!strcmp(lm->type->lctypename, "string")) { emit(1, "char* %s_cstr = (char*) this->%s.c_str();", lm->membername, lm->membername); emit(1, "tlen = __string_encode_array(buf, offset + pos, maxlen - pos, &%s_cstr, 1);", lm->membername); } else { emit(1, "tlen = __%s_encode_array(buf, offset + pos, maxlen - pos, &this->%s, 1);", lm->type->lctypename, lm->membername); } emit(1, "if(tlen < 0) return tlen; else pos += tlen;"); } else { _encode_recursive(lcm, f, lm, 0, 0); } } else { lcm_dimension_t *last_dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, num_dims - 1); // for non-string primitive types with variable size final // dimension, add an optimization to only call the primitive encode // functions only if the final dimension size is non-zero. if(lcm_is_primitive_type(lm->type->lctypename) && strcmp(lm->type->lctypename, "string") && !is_dim_size_fixed(last_dim->size)) { emit(1, "if(%s%s > 0) {", dim_size_prefix(last_dim->size), last_dim->size); _encode_recursive(lcm, f, lm, 0, 1); emit(1, "}"); } else { _encode_recursive(lcm, f, lm, 0, 0); } } emit(0,""); } emit(1, "return pos;"); emit(0,"}"); emit(0,""); }
static int emit_header(lcmgen_t *lcm, lcm_struct_t *ls) { start_file("_new"); // define the class emit(0, "function S = %s_new()", sn); emit(1, "S = struct(..."); // data members int const members = g_ptr_array_size(ls->members); for (unsigned int mx = 0; mx < members; mx++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, mx); char* lm_tnc = dots_to_double_colons(lm->type->lctypename); emit_start(2, "'%s', ", lm->membername); int const dimensions = g_ptr_array_size(lm->dimensions); int const primitive = lcm_is_primitive_type(lm->type->lctypename); if (0 == dimensions) { emit_continue("%s%s", map_type_name(lm_tnc) , primitive ? "(0)" : "_new()"); } else { emit_continue("repmat( %s%s, [", map_type_name(lm_tnc), primitive ? "(0)" : "_new()"); for (int dx = 0; dx < dimensions - 1; ++dx) { lcm_dimension_t *dim = (lcm_dimension_t *) g_ptr_array_index(lm->dimensions, dx); emit_continue("%s, ", dim->size); } lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, dimensions - 1); emit_continue("%s%s] )", dim->size, dimensions == 1 ? ", 1" : ""); } emit_end("%s", (members == mx + 1 ? " );" : ",...")); } emit(0, "%%endfunction"); emit(0, ""); // // constants TODO // if (g_ptr_array_size(ls->constants) > 0) { // emit(1, "public:"); // for (unsigned int i = 0; i < g_ptr_array_size(ls->constants); i++) { // lcm_constant_t *lc = (lcm_constant_t *) g_ptr_array_index(ls->constants, i); // assert(lcm_is_legal_const_type(lc->lctypename)); // // const char *suffix = ""; // if (!strcmp(lc->lctypename, "int64_t")) // suffix = "LL"; // char const * mapped_typename = map_type_name(lc->lctypename); // emit(2, "static const %-8s %s = %s%s;", mapped_typename, // lc->membername, lc->val_str, suffix); // //free(mapped_typename); // } // emit(0, ""); // } // emit(9, "};"); // // free(tn_); end_file(); }
static int emit_encoded_size_nohash(lcmgen_t *lcm, lcm_struct_t *ls) { start_file("_encodedSize_nohash"); emit(0, "function s = %s_encodedSize_nohash(S)", sn); emit(1, "s = uint32(0);"); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); char* lm_tnc = dots_to_double_colons(lm->type->lctypename); int const encsize = encoded_size(lm_tnc); int const dimensions = g_ptr_array_size(lm->dimensions); if (encsize > -1) {//known constant size emit_start(1, "s = s + %d", encsize); for (int dx = 0; dx < dimensions; ++dx) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, dx); emit_continue(" * %s", dim->size); } emit_end(";"); } else { if (0 == dimensions) { emit(1, "s = s + %s_encodedSize_nohash(S.%s);", map_type_name(lm_tnc), lm->membername); } else { //emit: for each dimension for (int dx = 0; dx < dimensions; ++dx) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, dx); emit(1 + dx, "for dx%d = 1:%s", dx, dim->size); } {//do emit_start(1 + dimensions, "s = s + %s_encodedSize_nohash(S.%s(", map_type_name(lm_tnc), lm->membername); for (int dx = 0; dx < dimensions - 1; ++dx) { emit_continue("dx%d,", dx); } emit_end("dx%d));", dimensions - 1); } //end for (int dx = dimensions; dx > 0; --dx) { emit(dx, "end"); } } } free(lm_tnc); } emit(0, "%%endfunction"); emit(0, ""); end_file(); }
static void emit_encoded_size_nohash(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { const char *sn = ls->structname->shortname; emit(0, "int %s::_getEncodedSizeNoHash() const", sn); emit(0, "{"); if(0 == g_ptr_array_size(ls->members)) { emit(1, "return 0;"); emit(0,"}"); emit(0,""); return; } emit(1, "int enc_size = 0;"); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); int ndim = g_ptr_array_size(lm->dimensions); if(lcm_is_primitive_type(lm->type->lctypename) && strcmp(lm->type->lctypename, "string")) { emit_start(1, "enc_size += "); for(int n=0; n < ndim - 1; n++) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, n); emit_continue("%s%s * ", dim_size_prefix(dim->size), dim->size); } if(ndim > 0) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, ndim - 1); emit_end("__%s_encoded_array_size(NULL, %s%s);", lm->type->lctypename, dim_size_prefix(dim->size), dim->size); } else { emit_end("__%s_encoded_array_size(NULL, 1);", lm->type->lctypename); } } else { for(int n=0; n < ndim; n++) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, n); emit(1+n, "for (int a%d = 0; a%d < %s%s; a%d++) {", n, n, dim_size_prefix(dim->size), dim->size, n); } emit_start(ndim + 1, "enc_size += this->%s", lm->membername); for(int i=0; i<ndim; i++) emit_continue("[a%d]", i); if(!strcmp(lm->type->lctypename, "string")) { emit_end(".size() + 4 + 1;"); } else { emit_end("._getEncodedSizeNoHash();"); } for(int n=ndim-1; n >= 0; n--) { emit(1 + n, "}"); } } } emit(1, "return enc_size;"); emit(0,"}"); emit(0,""); }
void encode_recursive(zcmgen_t *zcm, zcm_member_t *lm, FILE *f, primitive_info_t *pinfo, char *accessor, int depth) { // base case: primitive array if (depth+1 == g_ptr_array_size(lm->dimensions) && pinfo != NULL) { char accessor_array[1024]; make_accessor_array(lm, "", accessor_array); if (!strcmp(pinfo->storage, "byte")) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); if (dim->mode == ZCM_VAR) { emit(2+depth, "if (this.%s > 0)", dim->size); emit(3+depth, "outs.write(this.%s, 0, %s);", accessor_array, dim->size); } else { emit(2+depth, "outs.write(this.%s, 0, %s);", accessor_array, dim->size); } return; } // some other kind of primitive array. // This seems to be slower than the default (and is untested for correctness), hence it is disabled. if (0 && !strcmp(pinfo->storage, "float")) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit(2+depth, "{ ByteBuffer bbuf = ByteBuffer.allocate(%s%s*4); bbuf.order(ByteOrder.BIG_ENDIAN); ", dim_size_prefix(dim->size), dim->size); emit(2+depth, " bbuf.asFloatBuffer().put(this.%s);", accessor_array); emit(2+depth, " outs.write(bbuf.array()); }"); return; } } // base case: generic if (depth == g_ptr_array_size(lm->dimensions)) { emit_start(2 + g_ptr_array_size(lm->dimensions),""); if (pinfo != NULL) freplace(f, pinfo->encode, accessor); else freplace(f, "#._encodeRecursive(outs);", accessor); emit_end(" "); return; } zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit(2+depth, "for (int %c = 0; %c < %s%s; %c++) {", 'a'+depth, 'a'+depth, dim_size_prefix(dim->size), dim->size, 'a'+depth); encode_recursive(zcm, lm, f, pinfo, accessor, depth+1); emit(2+depth, "}"); }
static int emit_decode_nohash(lcmgen_t *lcm, lcm_struct_t *ls) { start_file("_decode_nohash"); emit(0, "function [pos, S] = %s_decode_nohash(buf, pos, maxlen, S, elems)", sn); emit(1, "for ix = 1:elems"); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); char* lm_tnc = dots_to_double_colons(lm->type->lctypename); int const dimensions = g_ptr_array_size(lm->dimensions); if (0 == dimensions) { emit(2, "[pos, t] = %s_decode_nohash(buf, pos, maxlen, S(ix).%s, 1);", map_type_name(lm_tnc), lm->membername); emit(2, "S(ix).%s = t(1);", lm->membername); } else { //emit: for each dimension for (int dx = 0; dx < dimensions - 1; ++dx) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, dx); emit(2 + dx, "for dx%d = 1:%s", dx, dim->size); } {//do emit_start(1 + (dimensions > 1 ? dimensions : 1), "[pos, t] = %s_decode_nohash(buf, pos, maxlen, S(ix).%s(", map_type_name(lm_tnc), lm->membername); for (int dx = 0; dx < dimensions - 1; ++dx) { emit_continue("dx%d,", dx); } lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, dimensions - 1); emit_end(":), %s);", dim->size); emit_start(1 + (dimensions > 1 ? dimensions : 1), "S(ix).%s(", lm->membername); for (int dx = 0; dx < dimensions - 1; ++dx) { emit_continue("dx%d,", dx); } emit_end(":) = t(1:%s);", dim->size); } //end for (int dx = dimensions - 1; dx > 0; --dx) { emit(1 + dx, "end"); } } free(lm_tnc); } emit(1, "end"); emit(0, "%%endfunction"); end_file(); }
void decode_recursive(zcmgen_t *zcm, zcm_member_t *lm, FILE *f, primitive_info_t *pinfo, char *accessor, int depth) { // base case: primitive array if (depth+1 == g_ptr_array_size(lm->dimensions) && pinfo != NULL) { char accessor_array[1024]; make_accessor_array(lm, "", accessor_array); // byte array if (!strcmp(pinfo->storage, "byte")) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit_start(2+depth, "ins.readFully(this.%s, 0, %s);", accessor_array, dim->size); return; } // some other kind of primitive array. // This seems to be slower than the default (and is untested for correctness), hence it is disabled. if (0 && !strcmp(pinfo->storage, "float")) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit(2+depth, "{ byte bb[] = new byte[%s%s*4]; ins.readFully(bb); ByteBuffer bbuf = ByteBuffer.wrap(bb); bbuf.order(ByteOrder.BIG_ENDIAN); ", dim_size_prefix(dim->size), dim->size); emit(2+depth, " bbuf.asFloatBuffer().get(this.%s); }", accessor_array); return; } } // base case: generic if (depth == g_ptr_array_size(lm->dimensions)) { emit_start(2 + g_ptr_array_size(lm->dimensions),""); if (pinfo != NULL) freplace(f, pinfo->decode, accessor); else { emit_continue("%s = %s._decodeRecursiveFactory(ins);", accessor, make_fqn(zcm, lm->type->lctypename)); } emit_end(""); return; } zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit(2+depth, "for (int %c = 0; %c < %s%s; %c++) {", 'a'+depth, 'a'+depth, dim_size_prefix(dim->size), dim->size, 'a'+depth); decode_recursive(zcm, lm, f, pinfo, accessor, depth+1); emit(2+depth, "}"); }
int emit_m(lcmgen_t *lcm) { // iterate through all defined message types for (unsigned int i = 0; i < g_ptr_array_size(lcm->structs); i++) { lcm_struct_t *ls = (lcm_struct_t *) g_ptr_array_index(lcm->structs, i); // generate code if needed { emit_header(lcm, ls); emit_encode(lcm, ls); emit_decode(lcm, ls); emit_encoded_size(lcm, ls); emit_get_hash(lcm, ls); // emit(0, "const char* %s::getTypeName()", sn); // emit(0, "{"); // emit(1, "return \"%s\";", sn); // emit(0, "}"); // emit(0, ""); emit_encode_nohash(lcm, ls); emit_decode_nohash(lcm, ls); emit_encoded_size_nohash(lcm, ls); emit_compute_hash(lcm, ls); } } return 0; }
static gboolean on_scroll_notify (GtkWidget *widget, GdkEventScroll *event, void *user_data) { Viewer *self = (Viewer*) user_data; gtku_gl_drawing_area_set_context (self->gl_area); double ray_start[3]; double ray_dir[3]; _window_coord_to_ray (event->x, widget->allocation.height - event->y, ray_start, ray_dir); // give picking handler first dibs int consumed = 0; if (self->picking_handler && !self->picking_handler->picking) self->picking_handler = NULL; if (self->picking_handler && self->picking_handler->enabled && self->picking_handler->mouse_scroll) { consumed = self->picking_handler->mouse_scroll(self, self->picking_handler, ray_start, ray_dir, event); update_status_bar(self); } // try all the other handlers in order of priority for (unsigned int eidx = 0; !consumed && eidx < g_ptr_array_size(self->event_handlers); eidx++) { EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx); if (handler != self->picking_handler && handler->enabled && handler->mouse_scroll) if (handler->mouse_scroll(self, handler, ray_start, ray_dir, event)) break; } return TRUE; }
static gint on_main_window_key_press_event (GtkWidget *widget, GdkEventKey *event, void *user) { Viewer *self = (Viewer*) user; // give picking handler first dibs int consumed = 0; if (self->picking_handler && self->picking_handler->enabled && self->picking_handler->picking && self->picking_handler->key_press) { consumed = self->picking_handler->key_press(self, self->picking_handler, event); update_status_bar(self); } // try all the other handlers in order of priority for (unsigned int eidx = 0; !consumed && eidx < g_ptr_array_size(self->event_handlers); eidx++) { EventHandler *handler = g_ptr_array_index(self->event_handlers, eidx); if (handler != self->picking_handler && handler->enabled && handler->key_press) { consumed = handler->key_press(self, handler, event); if (consumed) break; } } return consumed; }
int emit_cpp(lcmgen_t *lcmgen) { // iterate through all defined message types for (unsigned int i = 0; i < g_ptr_array_size(lcmgen->structs); i++) { lcm_struct_t *lr = (lcm_struct_t *) g_ptr_array_index(lcmgen->structs, i); const char *tn = lr->structname->lctypename; char *tn_ = dots_to_slashes(tn); // compute the target filename char *header_name = g_strdup_printf("%s%s%s.hpp", getopt_get_string(lcmgen->gopt, "cpp-hpath"), strlen(getopt_get_string(lcmgen->gopt, "cpp-hpath")) > 0 ? G_DIR_SEPARATOR_S : "", tn_); // generate code if needed if (lcm_needs_generation(lcmgen, lr->lcmfile, header_name)) { make_dirs_for_file(header_name); FILE *f = fopen(header_name, "w"); if (f == NULL) return -1; emit_header_start(lcmgen, f, lr); emit_encode(lcmgen, f, lr); emit_decode(lcmgen, f, lr); emit_encoded_size(lcmgen, f, lr); emit_get_hash(lcmgen, f, lr); emit(0, "const char* %s::getTypeName()", lr->structname->shortname); emit(0, "{"); emit(1, "return \"%s\";", lr->structname->shortname); emit(0, "}"); emit(0, ""); emit_encode_nohash(lcmgen, f, lr); emit_decode_nohash(lcmgen, f, lr); emit_encoded_size_nohash(lcmgen, f, lr); emit_compute_hash(lcmgen, f, lr); emit_compare(lcmgen, f, lr); emit(0, "/// Testing (ignores dynamic arrays & affects only first and last elements of static arrays)"); emit(0, "/// {"); emit_print(lcmgen, f, lr); emit_init_test(lcmgen, f, lr); emit_inc_test(lcmgen, f, lr); emit_compare_test(lcmgen, f, lr); emit(0, "/// }"); emit_package_namespace_close(lcmgen, f, lr); emit(0, "#endif"); fclose(f); } g_free(header_name); free(tn_); } return 0; }
static int struct_has_string_member(zcm_struct_t *lr) { for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); if(!strcmp("string", lm->type->lctypename)) return 1; } return 0; }
static void emit_compute_hash(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { const char *sn = ls->structname->shortname; int last_complex_member = -1; for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); if(!lcm_is_primitive_type(lm->type->lctypename)) last_complex_member = m; } if(last_complex_member >= 0) { emit(0, "uint64_t %s::_computeHash(const __lcm_hash_ptr *p)", sn); emit(0, "{"); emit(1, "const __lcm_hash_ptr *fp;"); emit(1, "for(fp = p; fp != NULL; fp = fp->parent)"); emit(2, "if(fp->v == %s::getHash)", sn); emit(3, "return 0;"); if(g_ptr_array_size(ls->members)) { emit(1, "const __lcm_hash_ptr cp = { p, (void*)%s::getHash };", sn); } emit(0, ""); emit(1, "uint64_t hash = 0x%016"PRIx64"LL +", ls->hash); for (unsigned int m = 0; m <= last_complex_member; m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); char* lm_tnc = dots_to_double_colons(lm->type->lctypename); if(!lcm_is_primitive_type(lm->type->lctypename)) { emit(2, " %s::_computeHash(&cp)%s", lm_tnc, (m == last_complex_member) ? ";" : " +"); } free(lm_tnc); } emit(0, ""); } else { emit(0, "uint64_t %s::_computeHash(const __lcm_hash_ptr *)", sn); emit(0, "{"); emit(1, "uint64_t hash = 0x%016"PRIx64"LL;", ls->hash); } emit(1, "return (hash<<1) + ((hash>>63)&1);"); emit(0, "}"); emit(0, ""); }
static void _encode_recursive(lcmgen_t* lcm, FILE* f, lcm_member_t* lm, int depth, int extra_indent) { int indent = extra_indent + 1 + depth; // primitive array if (depth+1 == g_ptr_array_size(lm->dimensions) && lcm_is_primitive_type(lm->type->lctypename) && strcmp(lm->type->lctypename, "string")) { lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit_start(indent, "tlen = __%s_encode_array(buf, offset + pos, maxlen - pos, &this->%s", lm->type->lctypename, lm->membername); for(int i=0; i<depth; i++) emit_continue("[a%d]", i); emit_end("[0], %s%s);", dim_size_prefix(dim->size), dim->size); emit(indent, "if(tlen < 0) return tlen; else pos += tlen;"); return; } // if(depth == g_ptr_array_size(lm->dimensions)) { if(!strcmp(lm->type->lctypename, "string")) { emit_start(indent, "char* __cstr = (char*) this->%s", lm->membername); for(int i=0; i<depth; i++) emit_continue("[a%d]", i); emit_end(".c_str();"); emit(indent, "tlen = __string_encode_array(buf, offset + pos, maxlen - pos, &__cstr, 1);"); } else { emit_start(indent, "tlen = this->%s", lm->membername); for(int i=0; i<depth; i++) emit_continue("[a%d]", i); emit_end("._encodeNoHash(buf, offset + pos, maxlen - pos);"); } emit(indent, "if(tlen < 0) return tlen; else pos += tlen;"); return; } lcm_dimension_t *dim = (lcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit(indent, "for (int a%d = 0; a%d < %s%s; a%d++) {", depth, depth, dim_size_prefix(dim->size), dim->size, depth); _encode_recursive(lcm, f, lm, depth+1, extra_indent); emit(indent, "}"); }
/** Make an accessor that points to the last array **/ static void make_accessor_array(zcm_member_t *lm, const char *obj, char *s) { int ndim = g_ptr_array_size(lm->dimensions); int pos = 0; s[0] = 0; pos += sprintf(s, "%s%s%s", obj, obj[0]==0 ? "" : ".", lm->membername); for (int d = 0 ; d < ndim - 1; d++) pos += sprintf(&s[pos],"[%c]", 'a'+d); }
static void emit_c_num_fields(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { char *tn = ls->structname->lctypename; char *tn_ = dots_to_underscores(tn); emit(0,"int %s_num_fields(void)", tn_); emit(0,"{"); emit(1, "return %d;", g_ptr_array_size(ls->members)); emit(0,"}"); emit(0,""); }
static void on_select_no_event_handlers_activate (GtkMenuItem *mi, void *user_data) { Viewer *self = (Viewer*) user_data; for (unsigned int eidx = 0; eidx < g_ptr_array_size(self->event_handlers); eidx++) { EventHandler *ehandler = g_ptr_array_index(self->event_handlers, eidx); ehandler->enabled = 0; gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(ehandler->cmi), ehandler->enabled); } }
static void emit_c_array_loops_end(lcmgen_t *lcm, FILE *f, lcm_member_t *lm, const char *n, int flags) { if (g_ptr_array_size(lm->dimensions) == 0) return; for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions) - 1; i++) { int indent = g_ptr_array_size(lm->dimensions) - i; if (flags & FLAG_EMIT_FREES) { char *accessor = make_accessor(lm, "p", g_ptr_array_size(lm->dimensions) - 1 - i); emit(indent+1, "if (%s) free(%s);", accessor, accessor); } emit(indent, "}"); emit(indent, "}"); } if (flags & FLAG_EMIT_FREES) { char *accessor = make_accessor(lm, "p", 0); emit(2, "if (%s) free(%s);", accessor, accessor); } }
static void on_select_no_renderers_activate (GtkMenuItem *mi, void *user_data) { Viewer *self = (Viewer*) user_data; for (unsigned int ridx = 0; ridx < g_ptr_array_size(self->renderers); ridx++) { Renderer *renderer = g_ptr_array_index(self->renderers, ridx); renderer->enabled = 0; gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(renderer->cmi), renderer->enabled); } }
void tile_set_draw(struct tile_set *ts) { if (!ts) return; for (int tidx = 0; tidx < g_ptr_array_size(ts->tiles); tidx++) { struct tile_texture *tt = g_ptr_array_index(ts->tiles, tidx); if (tt->tile->generation == ts->drawing_generation) tile_set_draw_tile(ts, tt); } }
static void emit_decode_nohash(lcmgen_t *lcm, FILE *f, lcm_struct_t *ls) { const char* sn = ls->structname->shortname; if(0 == g_ptr_array_size(ls->members)) { emit(0, "int %s::_decodeNoHash(const void *, int, int)", sn); emit(0, "{"); emit(1, "return 0;"); emit(0, "}"); emit(0, ""); return; } emit(0, "int %s::_decodeNoHash(const void *buf, int offset, int maxlen)", sn); emit(0, "{"); emit(1, "int pos = 0, tlen;"); emit(0, ""); for (unsigned int m = 0; m < g_ptr_array_size(ls->members); m++) { lcm_member_t *lm = (lcm_member_t *) g_ptr_array_index(ls->members, m); if (0 == g_ptr_array_size(lm->dimensions) && lcm_is_primitive_type(lm->type->lctypename)) { if(!strcmp(lm->type->lctypename, "string")) { emit(1, "int32_t __%s_len__;", lm->membername); emit(1, "tlen = __int32_t_decode_array(buf, offset + pos, maxlen - pos, &__%s_len__, 1);", lm->membername); emit(1, "if(tlen < 0) return tlen; else pos += tlen;"); emit(1, "if(__%s_len__ > maxlen - pos) return -1;", lm->membername); emit(1, "this->%s.assign(((const char*)buf) + offset + pos, __%s_len__ - 1);", lm->membername, lm->membername); emit(1, "pos += __%s_len__;", lm->membername); } else { emit(1, "tlen = __%s_decode_array(buf, offset + pos, maxlen - pos, &this->%s, 1);", lm->type->lctypename, lm->membername); emit(1, "if(tlen < 0) return tlen; else pos += tlen;"); } } else { _decode_recursive(lcm, f, lm, 0); } emit(0,""); } emit(1, "return pos;"); emit(0, "}"); emit(0, ""); }
int emit_c(lcmgen_t *lcmgen) { //////////////////////////////////////////////////////////// // ENUMS for (unsigned int i = 0; i < g_ptr_array_size(lcmgen->enums); i++) { lcm_enum_t *le = (lcm_enum_t *) g_ptr_array_index(lcmgen->enums, i); if (emit_enum(lcmgen, le)) return -1; } //////////////////////////////////////////////////////////// // STRUCTS for (unsigned int i = 0; i < g_ptr_array_size(lcmgen->structs); i++) { lcm_struct_t *lr = (lcm_struct_t *) g_ptr_array_index(lcmgen->structs, i); if (emit_struct(lcmgen, lr)) return -1; } return 0; }
// Create an accessor for member lm, whose name is "n". For arrays, // the dim'th dimension is accessed. E.g., dim=0 will have no // additional brackets, dim=1 has [a], dim=2 has [a][b]. static char *make_accessor(lcm_member_t *lm, const char *n, int dim) { char *tmp = (char *) malloc(128); if (g_ptr_array_size(lm->dimensions) == 0) { sprintf(tmp, "&(%s[element].%s)", n, lm->membername); } else { int pos = sprintf(tmp, "%s[element].%s", n, lm->membername); for (unsigned int d = 0; d < dim; d++) { pos += sprintf(&tmp[pos], "[%c]", d + 'a'); } } return tmp; }
static void on_save_preferences (Viewer *viewer, GKeyFile *keyfile, void *user_data) { RendererCamThumb *self = user_data; GPtrArray *keys = gu_hash_table_get_keys(self->cam_handlers); for (int k = 0; k < g_ptr_array_size(keys); k++) { char *key = g_ptr_array_index(keys, k); cam_renderer_t *cr = g_hash_table_lookup(self->cam_handlers, key); char str[80]; sprintf (str, "%d %d", cr->render_place, cr->expanded); g_key_file_set_string (keyfile, RENDERER_NAME, key, str); } }
static void on_mode_change(GtkMenuItem *mi, void *user) { Viewer *viewer = (Viewer*) user; for (unsigned int i = 0; i < g_ptr_array_size(viewer->modes); i++) { struct ViewerMode *vm = (struct ViewerMode*) g_ptr_array_index(viewer->modes, i); if (vm->menu_item == mi) { viewer->mode = i; return; } } assert(0); }
static char *make_array_size(lcm_member_t *lm, const char *n, int dim) { if (g_ptr_array_size(lm->dimensions) == 0) return g_strdup_printf("1"); else { lcm_dimension_t *ld = (lcm_dimension_t *) g_ptr_array_index(lm->dimensions, dim); switch (ld->mode) { case LCM_CONST: return g_strdup_printf("%s", ld->size); case LCM_VAR: return g_strdup_printf("%s[element].%s", n, ld->size); } } assert(0); return NULL; }