libRASCH

Home   General About libRASCH/News Design Screen shots Sample programs (with source code) License   Download libRASCH Tools   Documentation User Developer   Resources Mailing list Supported Formats Plugins Status Links   Contact About this site   Last updated Tue Mar 27 23:03:52 2007

load_xml_v0.c Go to the documentation of this file. /*---------------------------------------------------------------------------- * * Copyright (C) 2002-2005, Raphael Schneider * See the file COPYING for information on usage and redistribution. * * $Id: $ * *--------------------------------------------------------------------------*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <time.h> #include <assert.h> #include <libxml/tree.h> #include <libxml/xpath.h> #include <libxml/parser.h> #include "mime64.h" #ifndef WIN32 #include <unistd.h> #endif #define _LIBRASCH_BUILD #define _DEFINE_INFO_STRUCTS_PROP #include <ra_priv.h> #undef _DEFINE_INFO_STRUCTS #include <pl_general.h> #include <ra_linked_list.h> struct event_info { long id; long start; long end; }; /* struct event_info */ int eval_loadxml_v0(meas_handle mh, const char *file) { struct ra_meas *mm = (struct ra_meas *) mh; char fn[MAX_PATH_RA]; int ret; xmlDocPtr doc; FILE *fp; if (!mm) return -1; if (file) strncpy(fn, file, MAX_PATH_RA); else get_eval_file_xml(mm, fn); /* first check if eval-file is available */ fp = fopen(fn, "r"); if (fp == NULL) return 0; fclose(fp); if ((doc = xmlParseFile(fn)) == NULL) { _ra_set_error(mh, RA_ERR_READ_EVAL, "libRASCH"); return -1; } if (!doc->children || ((xmlStrcmp(doc->children->name, (xmlChar *)"libRASCH") != 0) && (xmlStrcmp(doc->children->name, (xmlChar *)"libMTK") != 0))) { xmlFreeDoc(doc); _ra_set_error(mh, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } ret = read_evals_xml(mm, doc->children); xmlFreeDoc(doc); return ret; } /* ra_eval_loadxml() */ int get_eval_file_xml(meas_handle mh, char *f) { long dir = 0; value_handle vh; rec_handle rh; rh = ra_rec_get_first(mh, 0); vh = ra_value_malloc(); if (ra_info_get(rh, RA_INFO_REC_GEN_DIR_L, vh) != 0) { ra_value_free(vh); return -1; } dir = ra_value_get_long(vh); if (ra_info_get(rh, RA_INFO_REC_GEN_PATH_C, vh) != 0) { ra_value_free(vh); return -1; } if (dir) sprintf(f, "%s%ceval_ra.mte", ra_value_get_string(vh), SEPERATOR); else sprintf(f, "%s.mte", ra_value_get_string(vh)); ra_value_free(vh); return 0; } /* get_eval_file_xml() */ int read_evals_xml(meas_handle mh, xmlNodePtr parent) { struct ra_meas *meas = (struct ra_meas *) mh; struct eval *e; int ret = 0; xmlNodePtr node, child; xmlChar *c; value_handle vh; vh = ra_value_malloc(); node = parent->children; while (node) { if (xmlStrcmp(node->name, (xmlChar *)"Evaluation") != 0) { node = node->next; continue; } e = (struct eval *)calloc(1, sizeof(struct eval)); ra_list_add((void **)&(meas->eval.evaluations), e); e->handle_id = RA_HANDLE_EVAL; e->meas = meas; child = get_node(node, "Flags"); if (child) { if (xmlHasProp(child, (xmlChar *)"original") != NULL) e->original = 1; if (xmlHasProp(child, (xmlChar *)"default") != NULL) e->def = 1; } c = xmlGetProp(node, (xmlChar *)"name"); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "name", vh); xmlFree(c); } child = get_node(node, "comment"); c = xmlNodeGetContent(child); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "description", vh); xmlFree(c); } child = get_node(node, "add-ts"); c = xmlNodeGetContent(child); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "add-timestamp", vh); xmlFree(c); } child = get_node(node, "modify-ts"); c = xmlNodeGetContent(child); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "modify-timestamp", vh); xmlFree(c); } child = get_node(node, "user"); c = xmlNodeGetContent(child); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "add-user", vh); xmlFree(c); } child = get_node(node, "host"); c = xmlNodeGetContent(child); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "add-host", vh); xmlFree(c); } child = get_node(node, "program"); c = xmlNodeGetContent(child); if (c != NULL) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute(e, "add-program", vh); xmlFree(c); } if ((ret = read_sets_xml(e, node)) != 0) return ret; node = node->next; } ra_value_free(vh); return ret; } /* read_evals_xml() */ xmlNodePtr get_node(xmlNodePtr parent, char *name) { xmlNodePtr child = parent->children; while (child) { if (xmlStrcmp(child->name, (xmlChar *)name) == 0) return child; child = child->next; } return NULL; } /* get_node() */ int read_sets_xml(struct eval *e, xmlNodePtr parent) { int ret = 0; struct eval_class *cl; xmlNodePtr child, node = parent->children; xmlChar *c; int use_ascii = 0; long num_events; struct event_info *evi; while (node) { if (xmlStrcmp(node->name, (xmlChar *)"Event-Set") != 0) { node = node->next; continue; } cl = calloc(1, sizeof(struct eval_class)); cl->handle_id = RA_HANDLE_EVAL_CLASS; cl->meas = e->meas; cl->eval = e; c = xmlGetProp(node, (xmlChar *)"name"); if (c) { strncpy(cl->id_ascii, (const char *)c, MAX_ID_LEN); cl->id = get_class_id(cl->ascii_id); ra_value_set_string(vh, (const char *)c); ra_eval_attribute_set(cl, "name", vh); xmlFree(c); } else { free(cl); continue; /* TODO: think if an error should be returned */ } child = get_node(node, "number-events"); c = xmlNodeGetContent(child); if (c) { num_events = atol((const char *)c); xmlFree(c); } else { free(cl); continue; /* TODO: think if an error should be returned */ } /* add event-class here so we are sure that an ASCII-id and the number of events are available */ ra_list_add((void **)&(e->cl), cl); child = get_node(node, "desc"); c = xmlNodeGetContent(child); if (c) { ra_value_set_string(vh, (const char *)c); ra_eval_attribute_set(cl, "description", vh); xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"event-encoding"); if (c && (xmlStrcmp(c, (xmlChar *)"ascii") == 0)) use_ascii = 1; evi = (struct event_info *)calloc(num_events, sizeof(struct event_info)); if (type == EVENT_TYPE_CONT) ret = read_events_start_end_xml(node, evi, num_events); else { for (l = 0; l < num_events; l++) evi[l].start = evi[l].end = -1; } if (ret != 0) break; for (l = 0; l < num_events; l++) evi[l].id = ra_class_add_event(cl, evi[l].start, evi[l].end); if ((ret = read_props_xml(cl, node, use_ascii, evi, num_events)) != 0) { free(evi); break; } if (read_templates_xml(cl, node) != 0) { free(evi); return -1; } free(evi); node = node->next; } return ret; } /* read_sets_xml() */ int read_events_start_end_xml(xmlNodePtr parent, struct event_info *evi, long num_events) { xmlChar *c; void *t; long size; xmlNodePtr curr; long l, data_size; data_size = num_events * sizeof(long); curr = get_node(parent, "event-start"); c = xmlNodeGetContent(curr); if (!c) { _ra_set_error(set, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } decode_base64(c, strlen((const char *)c), &t, &size, data_size); for (l = 0; l < size; l++) evi[l].start = t[l]; xmlFree(c); free(t); curr = get_node(parent, "event-end"); c = xmlNodeGetContent(curr); if (!c) { _ra_set_error(set, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } decode_base64(c, strlen((const char *)c), &t, &size, data_size); for (l = 0; l < size; l++) evi[l].end = t[l]; xmlFree(c); free(t); if (size != data_size) { _ra_set_error(set, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } return 0; } /* read_events_start_end_xml() */ int read_props_xml(struct event_set *set, xmlNodePtr parent, int use_ascii, struct event_info *evi, long num_events) { xmlNodePtr child, node = parent->children; xmlChar *c; while (node) { struct event_property *prop; if (xmlStrcmp(node->name, (xmlChar *)"Event-Property") != 0) { node = node->next; continue; } prop = calloc(1, sizeof(struct event_property)); prop->handle_id = RA_HANDLE_EVPROP; prop->set = set; prop->eval = set->eval; ra_list_add((void **) &(set->eval->prop), prop); set->eval->num_props++; c = xmlGetProp(node, (xmlChar *)"name"); if (c) { strncpy(prop->name, (const char *)c, EVAL_MAX_NAME); strncpy(prop->id_ascii, (const char *)c, EVAL_MAX_NAME); xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"val-type"); if (c) { if (xmlStrcmp(c, (xmlChar *)"short") == 0) prop->val_type = EVPROP_TYPE_SHORT; else if (xmlStrcmp(c, (xmlChar *)"long") == 0) prop->val_type = EVPROP_TYPE_LONG; else if (xmlStrcmp(c, (xmlChar *)"double") == 0) prop->val_type = EVPROP_TYPE_DOUBLE; else if (xmlStrcmp(c, (xmlChar *)"char") == 0) prop->val_type = EVPROP_TYPE_CHAR; else if (xmlStrcmp(c, (xmlChar *)"short-array") == 0) prop->val_type = EVPROP_TYPE_SHORT_ARRAY; else if (xmlStrcmp(c, (xmlChar *)"long-array") == 0) prop->val_type = EVPROP_TYPE_LONG_ARRAY; else if (xmlStrcmp(c, (xmlChar *)"double-array") == 0) prop->val_type = EVPROP_TYPE_DOUBLE_ARRAY; else { _ra_set_error(set, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; /* file corrupt */ } xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"use-minmax"); if (c) { if (c[0] == '1') prop->use_minmax = 1; else prop->use_minmax = 0; xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"min-value"); if (c) { prop->min_value = atof((const char *)c); xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"max-value"); if (c) { prop->max_value = atof((const char *)c); xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"unit"); if (c) { strncpy(prop->unit, (const char *)c, EVAL_MAX_UNIT); xmlFree(c); } child = get_node(node, "desc"); c = xmlNodeGetContent(child); if (c) { strncpy(prop->desc, (const char *)c, EVAL_MAX_DESC); xmlFree(c); } read_events_xml(prop, node, use_ascii); node = node->next; } return 0; } /* read_props_xml() */ int read_events_xml(struct event_property *prop, xmlNodePtr parent, int use_ascii) { int ret = 0; xmlNodePtr curr; xmlChar *c; curr = get_node(parent, "events"); /* If events stored in ASCII, read them and leave function */ if (use_ascii) return handle_value_events_ascii(prop, curr); /* get the event string */ c = xmlNodeGetContent(curr); if (!c) { _ra_set_error(prop, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } /* if not a char-event */ if (prop->val_type == EVPROP_TYPE_CHAR) ret = handle_char_events(prop, c); else ret = handle_value_events(prop, c); xmlFree(c); return ret; } /* read_events_xml() */ int handle_value_events_ascii(struct event_property *prop, xmlNodePtr parent) { struct event_set *set = prop->set; long l, idx; xmlNodePtr node; xmlChar *c; /* get "destination" type (if available); this is needed when changes in the type of an event-property happens */ idx = -1; for (l = 0; l < (sizeof(ra_event_props) / sizeof(struct event_prop_desc)); l++) { if (strcmp(ra_event_props[l].id_ascii, prop->id_ascii) == 0) { idx = l; break; } } if (idx != -1) prop->val_type = ra_event_props[idx].val_type; /* prepare memory for event values */ switch (prop->val_type) { case EVPROP_TYPE_SHORT: prop->idx = set->n_short; set->n_short += 1; set->s = realloc(set->s, sizeof(short *) * set->n_short); set->s[prop->idx] = malloc(sizeof(short) * set->num_events); break; case EVPROP_TYPE_LONG: prop->idx = set->n_long; set->n_long += 1; set->l = realloc(set->l, sizeof(long *) * set->n_long); set->l[prop->idx] = malloc(sizeof(long) * set->num_events); break; case EVPROP_TYPE_DOUBLE: prop->idx = set->n_double; set->n_double += 1; set->d = realloc(set->d, sizeof(double *) * set->n_double); set->d[prop->idx] = malloc(sizeof(double) * set->num_events); break; case EVPROP_TYPE_CHAR: prop->idx = set->n_char; set->n_char += 1; set->c = realloc(set->d, sizeof(char **) * set->n_char); set->c[prop->idx] = malloc(sizeof(char *) * set->num_events); break; case EVPROP_TYPE_SHORT_ARRAY: prop->idx = set->n_short_array; set->n_short_array += 1; set->sa = realloc(set->sa, sizeof(short **) * set->n_short_array); set->sa[prop->idx] = malloc(sizeof(short *) * set->num_events); set->sa_ch = realloc(set->sa_ch, sizeof(short **) * set->n_short_array); set->sa_ch[prop->idx] = malloc(sizeof(short *) * set->num_events); set->sa_num_elem = realloc(set->sa_num_elem, sizeof(long *) * set->n_short_array); set->sa_num_elem[prop->idx] = malloc(sizeof(long) * set->num_events); break; case EVPROP_TYPE_LONG_ARRAY: prop->idx = set->n_long_array; set->n_long_array += 1; set->la = realloc(set->la, sizeof(long **) * set->n_long_array); set->la[prop->idx] = malloc(sizeof(long *) * set->num_events); set->la_ch = realloc(set->sa_ch, sizeof(short **) * set->n_short_array); set->la_ch[prop->idx] = malloc(sizeof(short *) * set->num_events); set->la_num_elem = realloc(set->la_num_elem, sizeof(long *) * set->n_long_array); set->la_num_elem[prop->idx] = malloc(sizeof(long) * set->num_events); break; case EVPROP_TYPE_DOUBLE_ARRAY: prop->idx = set->n_double_array; set->n_double_array += 1; set->da = realloc(set->da, sizeof(double **) * set->n_double_array); set->da[prop->idx] = malloc(sizeof(double *) * set->num_events); set->da_ch = realloc(set->sa_ch, sizeof(short **) * set->n_short_array); set->da_ch[prop->idx] = malloc(sizeof(short *) * set->num_events); set->da_num_elem = realloc(set->da_num_elem, sizeof(long *) * set->n_double_array); set->da_num_elem[prop->idx] = malloc(sizeof(long) * set->num_events); break; } node = parent->children; while (node) { long idx; c = xmlGetProp(node, (xmlChar *)"index"); idx = atol((const char *)c); xmlFree(c); if (idx >= set->num_events) return -1; /* FIXME: better error handling */ switch (prop->val_type) { case EVPROP_TYPE_SHORT: read_short(node, prop, idx); break; case EVPROP_TYPE_LONG: read_long(node, prop, idx); break; case EVPROP_TYPE_DOUBLE: read_double(node, prop, idx); break; case EVPROP_TYPE_CHAR: read_char(node, prop, idx); break; case EVPROP_TYPE_SHORT_ARRAY: read_short_array(node, prop, idx); break; case EVPROP_TYPE_LONG_ARRAY: read_long_array(node, prop, idx); break; case EVPROP_TYPE_DOUBLE_ARRAY: read_double_array(node, prop, idx); break; default: return -1; /* FIXME: better error handling */ break; } /* no need to check that node is "event" */ node = node->next; } return 0; } /* handle_value_events_ascii() */ int read_short(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; xmlChar *c; struct event_set *set = prop->set; content = node->children; if (!content) return -1; c = xmlNodeGetContent(content); set->s[prop->idx][idx] = (short)atoi((const char *)c); xmlFree(c); return 0; } /* read_short() */ int read_long(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; xmlChar *c; struct event_set *set = prop->set; content = node->children; if (!content) return -1; c = xmlNodeGetContent(content); set->l[prop->idx][idx] = (long)atol((const char *)c); xmlFree(c); return 0; } /* read_long() */ int read_double(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; xmlChar *c; struct event_set *set = prop->set; content = node->children; if (!content) return -1; c = xmlNodeGetContent(content); set->d[prop->idx][idx] = xmlXPathCastStringToNumber(c); xmlFree(c); return 0; } /* read_double() */ int read_char(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; xmlChar *c; struct event_set *set = prop->set; content = node->children; if (!content) return -1; c = xmlNodeGetContent(content); set->c[prop->idx][idx] = calloc(strlen((const char *)c) + 1, sizeof(char)); strncpy(set->c[prop->idx][idx], (const char *)c, strlen((const char *)c)); xmlFree(c); return 0; } /* read_char() */ int read_short_array(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; struct event_set *set = prop->set; long n_elem = 0; short *buf = NULL; short *ch_buf = NULL; xmlChar *c; content = node->children; if (!content) return -1; while (content) { long idx2; c = xmlGetProp(content, (xmlChar *)"index"); idx2 = atol((const char *)c); xmlFree(c); if ((idx2+1) > n_elem) { n_elem = idx2 + 1; buf = realloc(buf, sizeof(short) * n_elem); ch_buf = realloc(ch_buf, sizeof(short) * n_elem); } c = xmlGetProp(content, (xmlChar *)"ch"); ch_buf[idx2] = (short)atol((const char *)c); xmlFree(c); c = xmlNodeGetContent(content); buf[idx2] = (short)atoi((const char *)c); xmlFree(c); content = content->next; } if (buf) { set->sa[prop->idx][idx] = buf; set->sa_ch[prop->idx][idx] = ch_buf; set->sa_num_elem[prop->idx][idx] = n_elem; } return 0; } /* read_short_array() */ int read_long_array(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; struct event_set *set = prop->set; long n_elem = 0; long *buf = NULL; short *ch_buf = NULL; xmlChar *c; content = node->children; if (!content) return -1; while (content) { long idx2; c = xmlGetProp(content, (xmlChar *)"index"); idx2 = atol((const char *)c); xmlFree(c); if ((idx2+1) > n_elem) { n_elem = idx2 + 1; buf = realloc(buf, sizeof(long) * n_elem); } c = xmlGetProp(content, (xmlChar *)"ch"); ch_buf[idx2] = (short)atol((const char *)c); xmlFree(c); c = xmlNodeGetContent(content); buf[idx2] = (long)atol((const char *)c); xmlFree(c); content = content->next; } if (buf) { set->la[prop->idx][idx] = buf; set->la_ch[prop->idx][idx] = ch_buf; set->la_num_elem[prop->idx][idx] = n_elem; } return 0; } /* read_long_array() */ int read_double_array(xmlNodePtr node, struct event_property *prop, long idx) { xmlNodePtr content; struct event_set *set = prop->set; long n_elem = 0; double *buf = NULL; short *ch_buf = NULL; xmlChar *c; content = node->children; if (!content) return -1; while (content) { long idx2; c = xmlGetProp(content, (xmlChar *)"index"); idx2 = atol((const char *)c); xmlFree(c); if ((idx2+1) > n_elem) { n_elem = idx2 + 1; buf = realloc(buf, sizeof(double) * n_elem); } c = xmlGetProp(content, (xmlChar *)"ch"); ch_buf[idx2] = (short)atol((const char *)c); xmlFree(c); c = xmlNodeGetContent(content); buf[idx2] = xmlXPathCastStringToNumber(c); xmlFree(c); content = content->next; } if (buf) { set->da[prop->idx][idx] = buf; set->da_ch[prop->idx][idx] = ch_buf; set->da_num_elem[prop->idx][idx] = n_elem; } return 0; } /* read_double_array() */ int handle_char_events(struct event_property *prop, xmlChar *c) { int ret = 0; struct event_set *set = prop->set; char *p_curr, *p_next; long cnt; prop->idx = set->n_char; set->n_char += 1; set->c = realloc(set->c, sizeof(char **) * set->n_char); memset(&(set->c[prop->idx]), 0, sizeof(char *)); p_curr = (char *)c; p_next = find_next_string(p_curr); cnt = 0; while (p_curr) { set->c[prop->idx] = realloc(set->c[prop->idx], sizeof(char *) * (cnt + 1)); set->c[prop->idx][cnt] = calloc(strlen(p_curr) + 1, sizeof(char)); strncpy(set->c[prop->idx][cnt], p_curr, strlen(p_curr)); cnt++; if (!p_next) break; p_curr = p_next; p_next = find_next_string(p_curr); } if (set->num_events == 0) set->num_events = cnt; else { /* TODO: think about what to do if number of events in a set are not the same */ if (set->num_events > cnt) set->num_events = cnt; } return ret; } /* handle_char_events() */ char * find_next_string(char *s) { char *p = s; int len = strlen(s); while ((p = strchr(p, 10))) { if ((!p) || ((p - s) >= (len - 2))) { if (p) *p = '\0'; return NULL; } if ((p[1] == '.') && (p[2] == 10)) { *p = '\0'; p += 3; break; } p++; } if (p >= (s + len)) return NULL; return p; } /* find_next_string() */ int handle_value_events(struct event_property *prop, xmlChar *c) { int ret = 0; void *t = NULL; long size, cnt; struct event_set *set = prop->set; long data_size, l, idx; double *buf = NULL; /* decode and put values as double in an array */ switch (prop->val_type) { case EVPROP_TYPE_SHORT: data_size = set->num_events * sizeof(short); decode_base64(c, strlen((const char *)c), &t, &size, data_size); cnt = set->num_events_alloc = size / sizeof(short); buf = malloc(sizeof(double) * set->num_events); for (l = 0; l < set->num_events; l++) buf[l] = (double)((short *)t)[l]; break; case EVPROP_TYPE_LONG: data_size = set->num_events * sizeof(long); decode_base64(c, strlen((const char *)c), &t, &size, data_size); cnt = set->num_events_alloc = size / sizeof(long); buf = malloc(sizeof(double) * set->num_events); for (l = 0; l < set->num_events; l++) buf[l] = (double)((long *)t)[l]; break; case EVPROP_TYPE_DOUBLE: data_size = set->num_events * sizeof(double); decode_base64(c, strlen((const char *)c), &t, &size, data_size); cnt = set->num_events_alloc = size / sizeof(double); buf = malloc(sizeof(double) * set->num_events); memcpy(buf, t, size); break; } if (t) free(t); if (set->num_events == 0) set->num_events = cnt; else { /* TODO: think about what to do if number of events in a set are not the same */ if (set->num_events > cnt) set->num_events = cnt; } /* get "destination" type (if available); this is needed when changes in the type of an event-property happens */ idx = -1; for (l = 0; l < (sizeof(ra_event_props) / sizeof(struct event_prop_desc)); l++) { if (strcmp(ra_event_props[l].id_ascii, prop->id_ascii) == 0) { idx = l; break; } } if (idx != -1) prop->val_type = ra_event_props[idx].val_type; switch (prop->val_type) { case EVPROP_TYPE_SHORT: prop->idx = set->n_short; set->n_short += 1; set->s = realloc(set->s, sizeof(short *) * set->n_short); set->s[prop->idx] = malloc(sizeof(short) * set->num_events); for (l = 0; l < set->num_events; l++) set->s[prop->idx][l] = (short)buf[l]; break; case EVPROP_TYPE_LONG: prop->idx = set->n_long; set->n_long += 1; set->l = realloc(set->l, sizeof(long *) * set->n_long); set->l[prop->idx] = malloc(sizeof(long) * set->num_events); for (l = 0; l < set->num_events; l++) set->l[prop->idx][l] = (long)buf[l]; break; case EVPROP_TYPE_DOUBLE: prop->idx = set->n_double; set->n_double += 1; set->d = realloc(set->d, sizeof(double *) * set->n_double); set->d[prop->idx] = malloc(sizeof(double) * set->num_events); memcpy(set->d[prop->idx], buf, sizeof(double) * set->num_events); break; } if (buf) free(buf); if (size != data_size) { _ra_set_error(prop, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } return ret; } /* handle_value_events() */ int read_templates_xml(struct event_set *set, xmlNodePtr parent) { xmlNodePtr child, node = parent->children; xmlChar *c; struct template_struct *templ = set->templ; while (node) { if (xmlStrcmp(node->name, (xmlChar *)"Template") != 0) { node = node->next; continue; } templ = calloc(1, sizeof(struct template_struct)); templ->handle_id = RA_HANDLE_TEMPLATE; templ->set = set; ra_list_add((void **) &(set->templ), templ); set->num_templates++; child = node->children; while (child) { if (xmlStrcmp(child->name, (xmlChar *)"Channel") != 0) { child = child->next; continue; } templ->num_ch++; templ->ch = realloc(templ->ch, sizeof(int) * templ->num_ch); templ->template_size = realloc(templ->template_size, sizeof(int) * templ->num_ch); c = xmlGetProp(child, (xmlChar *)"number"); if (c) { templ->ch[templ->num_ch - 1] = atoi((const char *)c); xmlFree(c); } c = xmlGetProp(child, (xmlChar *)"size"); if (c) { templ->template_size[templ->num_ch - 1] = atoi((const char *)c); xmlFree(c); } child = child->next; } c = xmlGetProp(node, (xmlChar *)"event-prop"); if (c) { struct event_property *prop = find_prop(set->eval, (const char *)c); if (prop) prop->templ = templ; xmlFree(c); } if (read_single_template_xml(templ, node) != 0) { _ra_set_error(set, RA_ERR_EVAL_FILE_CORRUPT, "libRASCH"); return -1; } node = node->next; } return 0; } /* read_templates_xml() */ prop_handle find_prop(struct eval *e, const char *name) { struct event_property *prop = e->prop; while (prop) { if (strcmp(prop->id_ascii, name) == 0) return prop; prop = prop->next; } return NULL; } /* find_prop() */ int read_single_template_xml(struct template_struct *templ, xmlNodePtr parent) { void *t; long size; xmlChar *c; xmlNodePtr curr, node = parent->children; while (node) { if (xmlStrcmp(node->name, (xmlChar *)"single") != 0) { node = node->next; continue; } templ->num_templates++; templ->st = realloc(templ->st, sizeof(struct single_template) * templ->num_templates); c = xmlGetProp(node, (xmlChar *)"number"); if (c) { templ->st[templ->num_templates - 1].num = atol((const char *)c); xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"fiducial-offset"); if (c) { templ->st[templ->num_templates - 1].fiducial_offset = atoi((const char *)c); xmlFree(c); } c = xmlGetProp(node, (xmlChar *)"type"); if (c) { templ->st[templ->num_templates - 1].type = atol((const char *)c); xmlFree(c); } templ->st[templ->num_templates - 1].data = malloc(sizeof(double *) * templ->num_ch); curr = node->children; while (curr) { int idx; if (xmlStrcmp(curr->name, (xmlChar *)"data") != 0) { curr = curr->next; continue; } c = xmlGetProp(curr, (xmlChar *)"ch-index"); if (!c) return -1; /* file corrupt */ idx = atoi((const char *)c); xmlFree(c); if ((idx >= templ->num_ch) || (idx < 0)) return -1; /* file corrupt */ c = xmlNodeGetContent(curr); if (!c) return -1; decode_base64(c, strlen((const char *)c), &t, &size, -1); templ->st[templ->num_templates - 1].data[idx] = malloc(size); memcpy(templ->st[templ->num_templates - 1].data[idx], t, size); xmlFree(c); free(t); curr = curr->next; } node = node->next; } return 0; } /* read_single_tempalate_xml() */