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;
}
