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

ra.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: ra.c 810 2005-05-22 10:16:48Z rasch $ * *--------------------------------------------------------------------------*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <assert.h> #include <locale.h> #ifdef WIN32 #include <windows.h> #endif #define _LIBRASCH_BUILD #include <ra_priv.h> #include <ra_version.h> #include <ra.h> #include <ra_error_txt.h> #include <handle_plugin.h> #include <pl_general.h> #include <ra_file.h> #include <ra_endian.h> #include <libxml/tree.h> #include <libxml/parser.h> int ra_print_debug_infos; int ra_in_error; int ra_endian_type; char ra_i18n_codeset[MAX_I18N_LEN]; LIBRAAPI ra_handle ra_lib_init(void) { int ret = 0; struct librasch *ra; if (getenv("LIBRASCH_DEBUG")) ra_print_debug_infos = 1; else ra_print_debug_infos = 0; ra_in_error = 0; set_endian_type(); /* set global variable ra_endian_type */ ra = malloc(sizeof(*ra)); if (ra == NULL) return NULL; memset(ra, 0, sizeof(*ra)); ra->handle_id = RA_HANDLE_LIB; _ra_set_error(ra, RA_ERR_NONE, "libRASCH"); ra->hf.get_plugin = get_plugin_by_name; if ((ret = read_config(ra)) != 0) { if (ret == -1) _ra_set_error(ra, RA_WARN_NO_CONFIG_FILE, "libRASCH"); else _ra_set_error(ra, RA_ERR_READ_CONFIG, "libRASCH"); return (ra_handle)ra; } /* set global variable ra_i18n_codeset; do it after reading the config because on Win32, the place of the translation will be set when installing libRASCH */ init_i18n(ra); close_plugins(ra->pl_head); if (read_plugins(ra) != 0) { _ra_set_error(ra, RA_ERR_LOAD_PLUGINS, "libRASCH"); return (ra_handle)ra; } return (ra_handle)ra; } /* ra_lib_init() */ void set_endian_type() { short s; char *t; s = 'U'*256 + 'N'; t = (char *)&s; if (*t == 'N') ra_endian_type = RA_LITTLE_ENDIAN; else ra_endian_type = RA_BIG_ENDIAN; } /* set_endian_type() */ void init_i18n(struct librasch *ra) { const char *l = NULL; /* when in debug mode, do not set language so messages are not translated */ if (ra_print_debug_infos) return; l = setlocale(LC_MESSAGES, ""); if(l) { char *p = NULL; char *buf; buf = malloc(strlen(l)+1); strcpy(buf, l); p = strrchr(buf, '.'); if (p) { /* when the charset startes with a number, then add 'CP' so iconv understand the charset */ if ((*(p+1) >= '0') && (*(p+1) <= '9') && (strlen(p+1) < (MAX_I18N_LEN-3))) sprintf(ra_i18n_codeset, "CP%s", p+1); else strncpy(ra_i18n_codeset, p+1, MAX_I18N_LEN); } else ra_i18n_codeset[0] = '\0'; free(buf); } bindtextdomain(PACKAGE, ra->config.po_dir); textdomain(PACKAGE); } /* init_i18n() */ LIBRAAPI int get_endian_type() { return ra_endian_type; } /* get_endian_type() */ int read_config(struct librasch *ra) { char fn[MAX_PATH_RA]; xmlDocPtr doc; xmlNodePtr node; xmlChar *c; /* set configuration to values which work when no config-file is found */ init_config(&(ra->config)); #ifdef WIN32 /* Under Win32 we try first to get the configuration from the Registry (because Visual Studio Installer allows to change Registry settings during install). If it fails to get infos from the Resgistr, try to get infos from a librasch.conf file. */ if (read_win32_registry(ra) == 0) return 0; #endif if (!find_config_file(fn)) return -1; if (ra_print_debug_infos) fprintf(stderr, gettext("config-file: %s\n"), fn); if ((doc = xmlParseFile(fn)) == NULL) return -2; if (!doc->children || (xmlStrcmp(doc->children->name, (xmlChar *)"librasch-config") != 0)) { xmlFreeDoc(doc); return -2; } /* TODO: think about config structure */ node = doc->children->children; while (node) { #ifdef _DEBUG /* only needed for Win32 to handle debug-build plugins */ if (xmlStrcmp(node->name, (xmlChar *)"plugin-path-debug") == 0) #else if (xmlStrcmp(node->name, (xmlChar *)"plugin-path") == 0) #endif /* _DEBUG */ { c = xmlNodeGetContent(node); if (c != NULL) { strncpy(ra->config.plugin_dir, (const char *)c, EVAL_MAX_NAME); if (ra_print_debug_infos) fprintf(stderr, gettext("config plugin-dir: %s\n"), c); xmlFree(c); } } else if (xmlStrcmp(node->name, (xmlChar *)"po-path") == 0) { c = xmlNodeGetContent(node); if (c != NULL) { strncpy(ra->config.po_dir, (const char *)c, EVAL_MAX_NAME); if (ra_print_debug_infos) fprintf(stderr, gettext("po-dir: %s\n"), ra->config.po_dir); xmlFree(c); } } node = node->next; } xmlFreeDoc(doc); return 0; } /* read_config() */ void init_config(struct config_info *conf) { char curr_dir[MAX_PATH_RA]; sprintf(curr_dir, ".%c", SEPERATOR); strcpy(conf->plugin_dir, curr_dir); strncpy(conf->po_dir, LOCALEDIR, MAX_PATH_RA); } /* init_config() */ #ifdef WIN32 int read_win32_registry(struct librasch *ra) { int ret = -1; HKEY key; DWORD size, type; /* Check that libRASCH is installed */ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\libRASCH", 0, KEY_READ, &key) != ERROR_SUCCESS) return -1; size = MAX_PATH_RA; type = REG_SZ; #ifdef _DEBUG if (RegQueryValueEx(key, "plugin_path_debug", 0, &type, (LPBYTE)(ra->config.plugin_dir), &size) == ERROR_SUCCESS) ret = 0; #else if (RegQueryValueEx(key, "plugin_path", 0, &type, (LPBYTE)(ra->config.plugin_dir), &size) == ERROR_SUCCESS) ret = 0; #endif /* _DEBUG */ if (RegQueryValueEx(key, "po_path", 0, &type, (LPBYTE)(ra->config.po_dir), &size) == ERROR_SUCCESS) ret = 0; RegCloseKey(key); return ret; } /* read_win32_registry() */ #endif /* WIN32 */ int find_config_file(char *fn) { FILE *fp = NULL; int found = 0; /* first check current-dir */ sprintf(fn, ".%clibrasch.conf", SEPERATOR); fp = fopen(fn, "r"); #ifdef LINUX if (!fp) { /* if not found in the current directory then check on Linux first the HOME directory */ sprintf(fn, "%s/librasch.conf", getenv("HOME")); fp = fopen(fn, "r"); } #endif /* LINUX */ if (!fp) { /* now check /etc under LINUX resp. system-dir under Windows */ #ifdef LINUX sprintf(fn, "/etc/librasch.conf"); #else /* WINDOWS */ GetWindowsDirectory(fn, MAX_PATH_RA); strcat(fn, "\\librasch.conf"); #endif fp = fopen(fn, "r"); } if (fp) { found = 1; fclose(fp); } return found; } /* find_config_file() */ LIBRAAPI void ra_lib_close(ra_handle h) { struct librasch *ra = (struct librasch *)h; close_plugins(ra->pl_head); if (ra->error_from) { free(ra->error_from); ra->error_from = NULL; } free(ra); } /* ra_lib_close() */ LIBRAAPI long ra_lib_get_error(ra_handle h, char *text, int len) { struct librasch *ra = (struct librasch *)h; if (!h || (ra->error_number == 0)) return 0; if (text && len > 0) { char *t; int len_use; if (ra->error_from) len_use = len - strlen(ra->error_from) - 2; else len_use = len; if (len_use <= 0) { strncpy(text, ra->error_from, len); text[len-1] = '\0'; return ra->error_number; } t = malloc(len_use); get_error_text(ra->error_number, t, len_use); if (ra->error_from) sprintf(text, "%s: %s", ra->error_from, t); else strcpy(text, t); free(t); utf8_to_local_inplace(text, len); } return ra->error_number; } /* ra_lib_get_error() */ #ifdef WIN32 void get_error_text(long err, char *text, int len) { text[0] = '\0'; if (err > 0) get_error_text_ra(err, text, len); else { LPVOID msg_buf; if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, -err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &msg_buf, 0, NULL)) { return; } strncpy(text, (LPCTSTR)msg_buf, len); LocalFree(msg_buf); } } /* get_error_text() */ #endif /* WIN32 */ #ifdef LINUX void get_error_text(long err, char *text, int len) { text[0] = '\0'; if (err > 0) get_error_text_ra(err, text, len); else strerror_r(-err, text, len); } /* get_error_text() */ #endif /* LINUX */ void get_error_text_ra(long err, char *text, int len) { const char *c; if (err <= 0) return; if (err <= ra_num_error_text) { c = ra_error_text[err-1]; strncpy(text, (c[0]=='\0' ? "" : gettext(c)), len); } else if ((err > RA_WARNING) && ((err - RA_WARNING) <= ra_num_warning_text)) { c = ra_warning_text[err - RA_WARNING - 1]; strncpy(text, (c[0]=='\0' ? "" : gettext(c)), len); } } /* get_error_text_ra() */ LIBRAAPI void _ra_set_error_int(any_handle h, long error, const char *error_from, const char *file, int line) { struct librasch *ra; if (ra_in_error) { fprintf(stderr, gettext("circular set_error-calling, this should NOT happen\n")); return; } ra_in_error = 1; if (!h) return; /* get pointer to struct librasch */ ra = (struct librasch *)ra_lib_handle_from_any_handle(h); if (!ra) { ra_in_error = 0; return; } if (ra->error_from) { free(ra->error_from); ra->error_from = NULL; } if (error_from || file) { ra->error_from = malloc(strlen(error_from)+strlen(file)+4+10); ra->error_from[0] = '\0'; if (error_from) strcat(ra->error_from, error_from); if (file) { char t[20]; if (error_from) strcat(ra->error_from, " ("); strcat(ra->error_from, file); sprintf(t, ":%d", line); strcat(ra->error_from, t); if (error_from) strcat(ra->error_from, ")"); } } /* if error == 0 -> os error */ if (error == 0) { #ifdef LINUX ra->error_number = -errno; #endif #ifdef WIN32 ra->error_number = GetLastError(); ra->error_number = -ra->error_number; #endif } else ra->error_number = error; if (ra_print_debug_infos && (ra->error_number != RA_ERR_NONE)) { char t[1000]; long err_num; err_num = ra_lib_get_error(ra, t, 1000); fprintf(stderr, "%s:%d - %s (%ld)\n", file, line, t, err_num); } ra_in_error = 0; } /* _ra_set_error() */ LIBRAAPI ra_handle ra_lib_handle_from_any_handle(any_handle h) { unsigned short type = *((unsigned short *)h); struct ra_meas *meas; ra_handle ra = NULL; switch (type) { case RA_HANDLE_LIB: ra = h; break; case RA_HANDLE_MEAS: case RA_HANDLE_REC: case RA_HANDLE_EVAL: case RA_HANDLE_EVAL_CLASS: case RA_HANDLE_EVAL_PROP: case RA_HANDLE_EVAL_SUMMARY: meas = ra_meas_handle_from_any_handle(h); if (meas) ra = meas->ra; break; case RA_HANDLE_PLUGIN: ra = ((struct plugin_struct *)h)->ra; break; case RA_HANDLE_PROC: ra = ((struct proc_info *)h)->ra; break; case RA_HANDLE_VIEW: ra = ((struct view_info *)h)->ra; break; case RA_HANDLE_FIND: default: break; } return ra; } /* ra_lib_handle_from_any_handle() */ LIBRAAPI meas_handle ra_meas_handle_from_any_handle(any_handle h) { unsigned short type = *((unsigned short *)h); struct ra_rec *rec; struct eval *eval; struct eval_class *cl; struct eval_property *prop; struct eval_summary *sum; meas_handle mh = NULL; if (h == NULL) return NULL; switch (type) { case RA_HANDLE_MEAS: mh = h; break; case RA_HANDLE_REC: rec = (struct ra_rec *)h; mh = rec->meas; break; case RA_HANDLE_EVAL: eval = (struct eval *)h; mh = eval->meas; break; case RA_HANDLE_EVAL_CLASS: cl = (struct eval_class *)h; mh = cl->meas; break; case RA_HANDLE_EVAL_PROP: prop = (struct eval_property *)h; mh = prop->meas; break; case RA_HANDLE_EVAL_SUMMARY: sum = (struct eval_summary *)h; mh = sum->meas; break; default: _ra_set_error(h, RA_ERR_UNKNOWN_HANDLE, "libRASCH"); break; } return mh; } /* ra_meas_handle_from_any_handle() */ LIBRAAPI int ra_lib_use_plugin(ra_handle h, int plugin_index, int use_it) { struct librasch *ra = (struct librasch *)h; struct plugin_struct *p = get_plugin(ra, plugin_index); if (!p) { _ra_set_error(h, RA_ERR_UNKNOWN_PLUGIN, "libRASCH"); return -1; } p->info.use_plugin = use_it; return 0; } /* ra_lib_use_plugin() */ struct plugin_struct * get_plugin(struct librasch *ra, int number) { struct plugin_struct *p = ra->pl_head; int cnt = number; while (p && cnt--) p = p->next; return p; } /* get_plugin() */ struct plugin_struct * get_plugin_by_name(struct librasch *ra, const char *name) { struct plugin_struct *p = ra->pl_head; while (p && (strcmp(p->info.name, name) != 0)) p = p->next; return p; } /* get_plugin_by_name() */ LIBRAAPI plugin_handle ra_plugin_get_by_num(ra_handle h, int plugin_num, int search_all) { struct librasch *ra = (struct librasch *)h; struct plugin_struct *p = get_plugin(ra, plugin_num); if (p && !search_all && !p->info.use_plugin) { _ra_set_error(h, RA_ERR_UNKNOWN_PLUGIN, "libRASCH"); p = NULL; } return p; } /* ra_plugin_get_by_num() */ LIBRAAPI plugin_handle ra_plugin_get_by_name(ra_handle h, const char *name, int search_all) { struct librasch *ra = (struct librasch *)h; struct plugin_struct *p = NULL; char *name_utf8; if (!h) { _ra_set_error(h, RA_ERR_ERROR_INTERNAL, "libRASCH"); return NULL; } name_utf8 = malloc(strlen(name) * 2); local_to_utf8(name, name_utf8, strlen(name) * 2); p = get_plugin_by_name(ra, name_utf8); free(name_utf8); if (p && !search_all && !p->info.use_plugin) { _ra_set_error(h, RA_ERR_UNKNOWN_PLUGIN, "libRASCH"); p = NULL; } return p; } /* ra_plugin_get_by_name() */ LIBRAAPI ra_find_handle ra_meas_find_first(ra_handle h, const char *dir, struct ra_find_struct *rfs) { char *dir_utf8; struct plugin_struct *p = ((struct librasch *)h)->pl_head; struct find_meas *f = calloc(1, sizeof(struct find_meas)); f->handle_id = RA_HANDLE_FIND; dir_utf8 = malloc(strlen(dir) * 2); local_to_utf8(dir, dir_utf8, strlen(dir) * 2); while (p) { /* use plugin and (find_meas() is assigned) ? */ if (!p->info.use_plugin || !p->access.find_meas) { p = p->next; continue; } /* look for signals handled by current plugin in dir */ (*p->access.find_meas) (dir_utf8, f); /* next plugin */ p = p->next; } free(dir_utf8); if (f->num <= 0) { free(f); f = NULL; } else { strcpy(rfs->name, f->names[f->curr]); utf8_to_local_inplace(rfs->name, MAX_PATH_RA); f->curr++; } return (ra_find_handle) f; } /* ra_meas_find_first() */ LIBRAAPI int ra_meas_find_next(ra_find_handle h, struct ra_find_struct *rfs) { struct find_meas *f = (struct find_meas *)h; f->handle_id = RA_HANDLE_FIND; if (!f || (f->curr >= f->num)) return 0; strcpy(rfs->name, f->names[f->curr]); utf8_to_local_inplace(rfs->name, MAX_PATH_RA); f->curr++; return 1; } /* ra_meas_find_next() */ LIBRAAPI void ra_meas_close_find(ra_find_handle h) { int i; struct find_meas *f = (struct find_meas *)h; if (f == NULL) return; if (f->names != NULL) { for (i = 0; i < f->num; i++) { if (f->names[i] != NULL) ra_free_mem(f->names[i]); } ra_free_mem(f->names); } free(f); } /* ra_meas_close_find() */ LIBRAAPI meas_handle ra_meas_open(ra_handle h, const char *file, const char *eval_file, int fast) { struct librasch *ra = (struct librasch *)h; struct plugin_struct *p; meas_handle mh = NULL; struct ra_meas *meas = NULL; char *file_utf8; char *eval_file_utf8 = NULL; if (!ra) return NULL; p = ra->pl_head; file_utf8 = malloc(strlen(file) * 2); local_to_utf8(file, file_utf8, strlen(file) * 2); if (eval_file != NULL) { eval_file_utf8 = malloc(strlen(eval_file) * 2); local_to_utf8(eval_file, eval_file_utf8, strlen(eval_file) * 2); } while (p) { /* use plugin and (open_meas() is assigned) ? */ if (!p->info.use_plugin || !p->access.open_meas || !p->access.check_meas) { p = p->next; continue; } /* check if current plugin supports file */ if ((*p->access.check_meas)(file_utf8)) { /* yes, correct plugin -> open it */ mh = (*p->access.open_meas)(h, file_utf8); if (mh) { meas = (struct ra_meas *)mh; meas->handle_id = RA_HANDLE_MEAS; /* save pointer to overall ra struct */ meas->ra = h; /* and save pointer to handling plugin */ meas->p = p; /* get max. samplerate and calc channel scaling factors */ calc_x_scales(meas); /* read evaluation */ /* store given evaluation filename */ if (eval_file != NULL) strncpy(meas->eval.filename, eval_file_utf8, MAX_PATH_RA); else meas->eval.filename[0] = '\0'; load_eval(mh, eval_file_utf8); /* first load eval (if avail.) */ read_evaluation(mh); /* then read original (if not alread in eval) */ break; } } /* try next plugin */ p = p->next; } free(file_utf8); free(eval_file_utf8); if (meas == NULL) _ra_set_error(ra, RA_ERR_UNSUP_FORMAT, "libRASCH"); return meas; } /* ra_meas_open() */ int calc_x_scales(struct ra_meas *meas) { value_handle vh; rec_handle rh; int i; vh = ra_value_malloc(); rh = ra_rec_get_first(meas, 0); if (ra_info_get(rh, RA_INFO_REC_GEN_NUM_CHANNEL_L, vh) == 0) meas->num_ch = ra_value_get_long(vh); if (meas->num_ch <= 0) { meas->max_samplerate = 1.0; ra_value_free(vh); return 0; } meas->x_scale = malloc(sizeof(double) * meas->num_ch); memset(meas->x_scale, 0, sizeof(double) * meas->num_ch); meas->max_samplerate = 0.0; for (i = 0; i < meas->num_ch; i++) { ra_value_set_number(vh, i); if (ra_info_get(rh, RA_INFO_REC_CH_SAMPLERATE_D, vh) != 0) continue; meas->x_scale[i] = ra_value_get_double(vh); if (meas->max_samplerate < meas->x_scale[i]) meas->max_samplerate = meas->x_scale[i]; } ra_value_free(vh); for (i = 0; i < meas->num_ch; i++) meas->x_scale[i] /= meas->max_samplerate; return 0; } /* calc_x_scales() */ LIBRAAPI meas_handle ra_meas_new(ra_handle h, const char *dir, const char *name) { struct librasch *ra = (struct librasch *)h; plugin_handle pl; struct plugin_struct *p; meas_handle mh = NULL; struct ra_meas *meas = NULL; char *dir_utf8; char *name_utf8; /* measurement will be handled by rasch-file plugin */ pl = ra_plugin_get_by_name(h, "rasch-file", 0); if (!pl) return NULL; p = (struct plugin_struct *)pl; /* to be sure, check that new_meas() function exists in ra-raw plugin */ if (!p->access.new_meas) { _ra_set_error(h, RA_ERR_PL_API_NOT_AVAIL, "libRASCH"); return NULL; } dir_utf8 = malloc(strlen(dir) * 2); local_to_utf8(dir, dir_utf8, strlen(dir) * 2); name_utf8 = malloc(strlen(name) * 2); local_to_utf8(name, name_utf8, strlen(name) * 2); mh = (*p->access.new_meas)(dir_utf8, name_utf8); if (!mh) goto error; /* create measurement and set needed info */ meas = (struct ra_meas *)mh; meas->handle_id = RA_HANDLE_MEAS; /* save pointer to overall lib struct */ meas->ra = ra; /* and save pointer to handling plugin */ meas->p = p; /* get max. samplerate and calc channel scaling factors */ calc_x_scales(meas); error: free(dir_utf8); free(name_utf8); return meas; } /* ra_meas_new() */ LIBRAAPI int ra_meas_save(meas_handle mh) { /* (TODO: think about how to implement one save function (for measurement and evaluation))*/ int ret = -1; unsigned short type = *((unsigned short *)mh); if (type == RA_HANDLE_MEAS) /* to be sure that correct handle is used */ { struct plugin_struct *p = ((struct ra_meas *)mh)->p; if (p->access.save_meas) ret = (*p->access.save_meas)(mh); else _ra_set_error(mh, RA_ERR_PL_API_NOT_AVAIL, "libRASCH"); } else _ra_set_error(mh, RA_ERR_WRONG_HANDLE, "libRASCH"); return ret; } /* ra_meas_save() */ LIBRAAPI void ra_meas_close(meas_handle mh) { long l; struct ra_meas *meas = (struct ra_meas *) mh; struct plugin_struct *p = NULL; if (!mh) return; p = meas->p; free_eval_infos(&(meas->eval)); /* is close_meas() assigned ? */ if (p->access.close_meas) (*p->access.close_meas) (mh); if (meas->sessions) { for (l = 0; l < meas->num_sessions; l++) free_session_rec(meas->sessions[l].root_rec); ra_free_mem(meas->sessions); meas->num_sessions = 0; } if (meas->x_scale) free(meas->x_scale); ra_free_mem(meas); } /* ra_meas_close() */ LIBRAAPI int ra_info_get(any_handle h, int id, value_handle vh) { unsigned short type; struct plugin_struct *p; /* in-validate value so in case of error 'vh' has no value */ ra_value_reset(vh); if (!h || (id < 0) || !vh) return -1; if (check_handle_type(h, id) != 0) return -1; type = *((unsigned short *)h); if (type == RA_HANDLE_LIB) return get_lib_info((ra_handle)h, id, vh); if (type == RA_HANDLE_PLUGIN) return get_plugin_info((plugin_handle)h, id, vh); if ((type == RA_HANDLE_MEAS) && (id > RA_INFO_MEASUREMENT_START) && (id < RA_INFO_MEASUREMENT_END)) return get_meas_general_info((meas_handle)h, id, vh); if ((id > RA_INFO_EVALUATION) && (id < RA_INFO_EVALUATION_END)) return eval_get_info(h, id, vh); if ((id > RA_INFO_SESSION_START) && (id < RA_INFO_SESSION_END)) return get_session_info(h, id, vh); if ((id > RA_INFO_PROCESSING_START) && (id < RA_INFO_PROCESSING_END)) return get_proc_info(h, id, vh); p = get_plugin_from_handle(h); if (!p) return -1; if (p->access.get_info_id) return (*p->access.get_info_id)(h, id, vh); else _ra_set_error(h, RA_ERR_PL_API_NOT_AVAIL, "libRASCH"); return -1; } /* ra_info_get() */ int check_handle_type(any_handle h, int id) { int ret = -1; unsigned short type = *((unsigned short *)h); switch (type) { case RA_HANDLE_LIB: if ((id > RA_INFO_LIB_START) && (id < RA_INFO_LIB_END)) ret = 0; break; case RA_HANDLE_MEAS: if ((id > RA_INFO_MEASUREMENT_START) && (id < RA_INFO_OBJECT_END)) ret = 0; break; case RA_HANDLE_REC: if ((id > RA_INFO_RECORDING_START) && (id < RA_INFO_RECORDING_END)) ret = 0; break; case RA_HANDLE_FIND: if ((id > RA_INFO_MEASUREMENT_START) && (id < RA_INFO_OBJECT_END)) ret = 0; break; case RA_HANDLE_EVAL: if ((id > RA_INFO_EVAL_START) && (id < RA_INFO_EVAL_END)) ret = 0; break; case RA_HANDLE_EVAL_CLASS: if ((id > RA_INFO_CLASS_START) && (id < RA_INFO_CLASS_END)) ret = 0; break; case RA_HANDLE_EVAL_PROP: if ((id > RA_INFO_PROP_START) && (id < RA_INFO_PROP_END)) ret = 0; break; case RA_HANDLE_EVAL_SUMMARY: if ((id > RA_INFO_SUM_START) && (id < RA_INFO_SUM_END)) ret = 0; break; case RA_HANDLE_PLUGIN: if ((id > RA_INFO_PLUGIN_START) && (id < RA_INFO_PLUGIN_END)) ret = 0; break; case RA_HANDLE_PROC: if ((id > RA_INFO_PROCESSING_START) && (id < RA_INFO_PROCESSING_END)) ret = 0; break; case RA_HANDLE_VIEW: _ra_set_error(h, RA_ERR_UNSUPPORTED, "libRASCH"); break; default: _ra_set_error(h, RA_ERR_UNKNOWN_HANDLE, "libRASCH"); break; } return ret; } /* check_handle_type() */ int get_lib_info(ra_handle ra, int id, value_handle vh) { int ret = 0; long cnt; struct plugin_struct *p; struct meta_info *meta_inf; char t[1000]; /* get infos about asked measurement info */ meta_inf = get_meta_info(id); if (!ra || !meta_inf || (id <= RA_INFO_LIB_START) || (id >= RA_INFO_LIB_END)) { _ra_set_error(ra, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } set_meta_info(vh, meta_inf->name, meta_inf->desc, meta_inf->id); switch (id) { case RA_INFO_NUM_PLUGINS_L: p = ((struct librasch *)ra)->pl_head; cnt = 0; while (p) { cnt++; p = p->next; } ra_value_set_long(vh, cnt); break; case RA_INFO_VERSION_C: sprintf(t, "%d.%d.%d%s", LIBRASCH_MAJ_VERSION, LIBRASCH_MIN_VERSION, LIBRASCH_PATCH_LEVEL, LIBRASCH_EXTRA_VERSION); ra_value_set_string_utf8(vh, t); break; default: _ra_set_error(ra, RA_ERR_UNKNOWN_INFO, "libRASCH"); ret = -1; break; } return ret; } /* get_lib_info() */ int get_plugin_info(plugin_handle pl, int id, value_handle vh) { int ret = 0; struct ra_value *v = (struct ra_value *)vh; struct plugin_struct *p = (struct plugin_struct *)pl; struct meta_info *meta_inf; const char *c; /* get infos about asked measurement info */ meta_inf = get_meta_info(id); if (!pl || !meta_inf || (id <= RA_INFO_PLUGIN_START) || (id >= RA_INFO_PLUGIN_END)) { _ra_set_error(pl, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } if (((id >= RA_INFO_PL_RES_NAME_C) && (id <= RA_INFO_PL_RES_DEFAULT_L)) && ((v->number < 0) || (v->number >= p->info.num_results))) { _ra_set_error(pl, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } if (((id >= RA_INFO_PL_OPT_NAME_C) && (id <= RA_INFO_PL_OPT_TYPE_L)) && ((v->number < 0) || (v->number >= p->info.num_options))) { _ra_set_error(pl, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } /* internal checks */ if (((id >= RA_INFO_PL_RES_NAME_C) && (id <= RA_INFO_PL_RES_DEFAULT_L)) && (p->info.res == NULL)) { fprintf(stderr, gettext("critical error - get_plugin_info() in ra.c:\ntried to get result-infos but mem was not set\nplugin used: %s\n"), p->info.name); exit(-1); /* _ra_set_error(pl, RA_ERR_INTERNAL_PLUGIN_ERROR, "libRASCH"); return -1; */ } if (((id >= RA_INFO_PL_OPT_NAME_C) && (id <= RA_INFO_PL_OPT_TYPE_L)) && (p->info.opt == NULL)) { fprintf(stderr, gettext("critical error - get_plugin_info() in ra.c:\ntried to get option-infos but mem was not set\nplugin used: %s\n"), p->info.name); exit(-1); /* _ra_set_error(pl, RA_ERR_INTERNAL_PLUGIN_ERROR, "libRASCH"); return -1; */ } set_meta_info(vh, meta_inf->name, meta_inf->desc, meta_inf->id); switch (id) { case RA_INFO_PL_NAME_C: ra_value_set_string_utf8(vh, p->info.name); break; case RA_INFO_PL_DESC_C: ra_value_set_string_utf8(vh, p->info.desc); break; case RA_INFO_PL_FILE_C: ra_value_set_string_utf8(vh, p->info.file); break; case RA_INFO_PL_USE_IT_L: ra_value_set_long(vh, p->info.use_plugin); break; case RA_INFO_PL_TYPE_L: ra_value_set_long(vh, p->info.type); break; case RA_INFO_PL_VERSION_C: ra_value_set_string_utf8(vh, p->info.version); break; case RA_INFO_PL_BUILD_TS_C: ra_value_set_string_utf8(vh, p->info.build_ts); break; case RA_INFO_PL_LICENSE_L: ra_value_set_long(vh, p->info.license); break; case RA_INFO_PL_NUM_OPTIONS_L: ra_value_set_long(vh, p->info.num_options); break; case RA_INFO_PL_OPT_NAME_C: c = p->info.opt[v->number].name; ra_value_set_string_utf8(vh, (c[0]=='\0' ? "" : gettext(c))); break; case RA_INFO_PL_OPT_DESC_C: c = p->info.opt[v->number].desc; ra_value_set_string_utf8(vh, (c[0]=='\0' ? "" : gettext(c))); break; case RA_INFO_PL_OPT_TYPE_L: ra_value_set_long(vh, p->info.opt[v->number].type); break; case RA_INFO_PL_NUM_RESULTS_L: ra_value_set_long(vh, p->info.num_results); break; case RA_INFO_PL_RES_NAME_C: c = p->info.res[v->number].name; ra_value_set_string_utf8(vh, (c[0]=='\0' ? "" : gettext(c))); break; case RA_INFO_PL_RES_DESC_C: c = p->info.res[v->number].desc; ra_value_set_string_utf8(vh, (c[0]=='\0' ? "" : gettext(c))); break; case RA_INFO_PL_RES_TYPE_L: ra_value_set_long(vh, p->info.res[v->number].type); break; case RA_INFO_PL_RES_DEFAULT_L: ra_value_set_long(vh, p->info.res[v->number].def); break; default: _ra_set_error(pl, RA_ERR_UNKNOWN_INFO, "libRASCH"); ret = -1; break; } return ret; } /* get_plugin_info() */ int get_meas_general_info(meas_handle mh, int id, value_handle vh) { int ret = 0; struct ra_meas *meas = (struct ra_meas *)mh; struct ra_value *v = (struct ra_value *)vh; struct meta_info *meta_inf; /* get infos about asked measurement info */ meta_inf = get_meta_info(id); if (!meas || !meta_inf || (id <= RA_INFO_MEASUREMENT_START) || (id >= RA_INFO_MEASUREMENT_END)) { _ra_set_error(mh, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } set_meta_info(vh, meta_inf->name, meta_inf->desc, meta_inf->id); if (id == RA_INFO_NUM_SESSIONS_L) ra_value_set_long(vh, meas->num_sessions); else if (id == RA_INFO_MAX_SAMPLERATE_D) ra_value_set_double(vh, meas->max_samplerate); else if (id == RA_INFO_CH_XSCALE_D) { if (v->number >= meas->num_ch) { _ra_set_error(mh, RA_ERR_OUT_OF_RANGE, "libRASCH"); return -1; } ra_value_set_double(vh, meas->x_scale[v->number]); } else { struct plugin_struct *p = get_plugin_from_handle(mh); if (!p) return -1; if (p->access.get_info_id) ret = (*p->access.get_info_id)(mh, id, vh); else _ra_set_error(mh, RA_ERR_PL_API_NOT_AVAIL, "libRASCH"); } return ret; } /* get_meas_general_info() */ int get_session_info(any_handle h, int id, value_handle vh) { int ret = 0; struct ra_meas * meas; struct ra_value *v = (struct ra_value *)vh; if ((id <= RA_INFO_SESSION_START) || (id >= RA_INFO_SESSION_END)) return -1; meas = (struct ra_meas *)ra_meas_handle_from_any_handle(h); if (!meas) return -1; if (v->number >= meas->num_sessions) return -1; switch (id) { case RA_INFO_SES_NAME_C: ra_value_set_string_utf8(vh, meas->sessions[v->number].name); break; case RA_INFO_SES_DESC_C: ra_value_set_string_utf8(vh, meas->sessions[v->number].desc); break; default: ret = -1; break; } return ret; } /* get_session_info() */ int get_proc_info(any_handle h, int id, value_handle vh) { int ret = 0; struct proc_info *proc; if ((id <= RA_INFO_PROCESSING_START) || (id >= RA_INFO_PROCESSING_END)) return -1; proc = (struct proc_info *)h; if (!proc) return -1; switch (id) { case RA_INFO_PROC_NUM_RES_SETS_L: ra_value_set_long(vh, proc->num_result_sets); break; case RA_INFO_PROC_NUM_RES_L: ra_value_set_long(vh, proc->num_results); break; default: ret = -1; break; } return ret; } /* get_proc_info() */ struct plugin_struct * get_plugin_from_handle(any_handle h) { struct plugin_struct *p = NULL; unsigned short type = *((unsigned short *)h); switch (type) { case RA_HANDLE_MEAS: p = ((struct ra_meas *)h)->p; break; case RA_HANDLE_REC: p = ((struct ra_rec *)h)->meas->p; break; case RA_HANDLE_EVAL: p = ((struct eval *)h)->meas->p; break; case RA_HANDLE_EVAL_CLASS: p = ((struct eval_class *)h)->meas->p; break; case RA_HANDLE_EVAL_PROP: p = ((struct eval_property *)h)->meas->p; break; case RA_HANDLE_EVAL_SUMMARY: p = ((struct eval_summary *)h)->meas->p; break; } if (!p) _ra_set_error(h, RA_ERR_ERROR, "libRASCH"); return p; } /* get_plugin_from_handle() */ LIBRAAPI int ra_info_get_by_name(any_handle h, const char *name, value_handle vh) { char *name_utf8; name_utf8 = malloc(strlen(name) * 2); local_to_utf8(name, name_utf8, strlen(name) * 2); if (find_ra_info_by_name(vh, name_utf8) != 0) return -1; return ra_info_get(h, ra_value_get_info(vh), vh); } /* ra_info_get_by_name() */ LIBRAAPI int ra_info_get_by_idx(any_handle h, int info_type, int idx, value_handle vh) { struct plugin_struct *p; /* in-validate value so in case of error 'vh' has no value */ ra_value_reset(vh); if ((h == NULL) || (idx < 0) || (vh == NULL)) { _ra_set_error(h, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } p = get_plugin_from_handle(h); if (!p) return -1; if (p->access.get_info_idx) return (*p->access.get_info_idx)(h, info_type, idx, vh); else _ra_set_error(h, RA_ERR_PL_API_NOT_AVAIL, "libRASCH"); return -1; } /* ra_info_get_by_idx() */ LIBRAAPI int ra_info_set(any_handle h, value_handle vh) { struct meta_info *meta_inf; struct ra_value *v = (struct ra_value *)vh; struct plugin_struct *p; p = get_plugin_from_handle(h); if (!p) return -1; /* get infos about asked measurement info */ meta_inf = get_meta_info(v->id); /* all var's ok? */ if ((v == NULL) || (meta_inf == NULL)) { _ra_set_error(h, RA_ERR_UNKNOWN_INFO, "libRASCH"); return -1; } set_meta_info(vh, meta_inf->name, meta_inf->desc, meta_inf->id); if (p->access.set_info) return (*p->access.set_info)(h, vh); else _ra_set_error(h, RA_ERR_PL_API_NOT_AVAIL, "libRASCH"); return -1; } /* ra_info_set() */ LIBRAAPI rec_handle ra_rec_get_first(meas_handle mh, long session) { struct ra_meas *meas = (struct ra_meas *) mh; if (!meas || (session < 0) || (session > meas->num_sessions)) { _ra_set_error(mh, RA_ERR_OUT_OF_RANGE, "libRASCH"); return NULL; } return meas->sessions[session].root_rec; } /* ra_rec_get_first() */ LIBRAAPI rec_handle ra_rec_get_next(rec_handle rh) { /* TODO: think about if "follows" is correct and insert link to user-manual (if written) */ return ((struct ra_rec *) rh)->next; } /* ra_rec_get_next() */ LIBRAAPI rec_handle ra_rec_get_first_child(rec_handle rh) { return ((struct