int rotate_log(struct rotator *rr,char *filename) {
char *dir,*base,*oldname,*newname;
DIR *dirh;
struct dirent des,*de;
struct array *names;
struct assoc *changes,*orders;
int order,i,n;
dirbasename(filename,&dir,&base);
log_debug(("Rotating in '%s'",dir));
dirh = opendir(dir);
if(!dirh) {
log_error(("Could not rotate log file"));
return 1;
}
names = array_create(type_free,0);
changes = assoc_create(0,0,type_free,0);
orders = assoc_create(0,0,type_free,0);
while(1) {
if(readdir_r(dirh,&des,&de)) {
log_error(("Problem reading directory during log rotation"));
break;
}
if(!de) { break; }
order = matching_file(rr,filename,de->d_name,&newname);
if(order == MATCH_IGNORE) { continue; }
if(order == MATCH_DELETE) {
log_debug(("delete %s",de->d_name));
unlink(de->d_name);
} else {
oldname = strdup(de->d_name);
array_insert(names,oldname);
assoc_set(changes,oldname,newname);
assoc_set(orders,oldname,make_int(order));
}
}
if(closedir(dirh)) {
log_error(("Could not closedir during log rotation!"));
/* But continue: what else to do? */
}
array_sort(names,sort_names,orders);
n = array_length(names);
for(i=0;i<n;i++) {
oldname = array_index(names,i);
newname = assoc_lookup(changes,oldname);
log_warn(("name=%s -> %s",oldname,newname));
rename_file(rr,dir,oldname,newname);
}
assoc_release(changes);
assoc_release(orders);
array_release(names);
free(dir);
free(base);
return 0;
}
int dstack_pop(struct dstack *st, void **p)
{
unsigned long sz;
void *xp;
sz = array_SIZE(&st->x);
if (sz) {
xp = array_index(&st->x, sz - 1);
array_chop(&st->x, sz - 1);
return !!(*p = xp);
} else return 0;
}
// XXX stats to sourcelist for sources
// XXX int numbers in jpf
// XXX nl in stats emission for clarity
// XXX leaks when mount fails
// XXX periodic hang-up-and-reopen
static void stat_timer_tick(evutil_socket_t fd,short what,void *arg) {
struct running *rr = (struct running *)arg;
struct source *src;
struct interface *ic;
struct jpf_value *out,*out_srcs,*out_src,*out_ics,*out_ic,*out_mem;
struct jpf_callbacks jpf_emitter_cb;
struct jpf_emitter jpf_emitter;
char *time_str;
int i;
if(rr->stats_fd==-1) { return; }
log_debug(("main stat collection loop"));
out_srcs = jpfv_important_assoc(0);
for(i=0;i<array_length(rr->src);i++) {
src = (struct source *)array_index(rr->src,i);
out_src = jpfv_assoc();
src_global_stats(src,out_src);
if(src->stats) { src->stats(src,out_src); }
jpfv_assoc_add(out_srcs,src->name,out_src);
}
out_ics = jpfv_important_assoc(0);
for(i=0;i<array_length(rr->icc);i++) {
ic = (struct interface *)array_index(rr->icc,i);
out_ic = jpfv_assoc();
ic_global_stats(ic,out_ic);
jpfv_assoc_add(out_ics,ic->name,out_ic);
}
out = jpfv_important_assoc(0);
time_str= iso_localtime(0);
jpfv_assoc_add(out,"time",jpfv_string(time_str));
free(time_str);
jpfv_assoc_add(out,"sources",out_srcs);
jpfv_assoc_add(out,"interfaces",out_ics);
out_mem = jpfv_important_array(1);
jpfv_array_add(out_mem,out);
jpf_emit_fd(&jpf_emitter_cb,&jpf_emitter,rr->stats_fd);
jpf_emit_df(out_mem,&jpf_emitter_cb,&jpf_emitter);
jpf_emit_done(&jpf_emitter);
jpfv_free(out_mem);
}
void array_rm(array *array, int i) {
assert(array != NULL);
if (i >= array->size)
return;
array->size--;
void *e = array_index(array, i);
if (i != array->size) {
memmove(e, e + array->el_size, array->el_size * (array->size - i));
}
}
int array_add(array *array, void *el, size_t len) {
assert(array != NULL);
if (array->limit < array->size + 1) {
int ret = array_resize(array, array->limit * 2);
if (!ret)
return 0;
}
memcpy(array_index(array, array->size), el, len);
array->size++;
return 1;
}
int io_poll_find_unused(const struct array *arr, unsigned long *ret)
{
const struct io_pollfd *pfd;
unsigned long ind;
unsigned long len;
len = array_size(arr);
for (ind = 0; ind < len; ++ind) {
pfd = array_index(arr, ind);
if (pfd->fd == -1) {
*ret = ind;
return 1;
}
}
return 0;
}
#include <stdio.h>
#include <event2/event.h>
#include <event2/thread.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include "running.h"
#include "jpf/jpf.h"
#include "config.h"
#include "util/misc.h"
#include "util/strbuf.h"
#include "util/array.h"
#include "util/assoc.h"
#include "util/path.h"
#include "util/logging.h"
#include "util/rotate.h"
#include "sourcelist.h"
#include "syncsource.h"
#include "syncif.h"
#include "source.h"
#include "interface.h"
#include "request.h"
#include "sources/http/http.h"
#include "sources/file2.h"
#include "sources/cache/file.h"
#include "sources/cache/mmap.h"
#include "sources/meta.h"
#include "interfaces/fuse.h"
CONFIG_LOGGING(running);
// XXX stats to sourcelist for sources
// XXX int numbers in jpf
// XXX nl in stats emission for clarity
// XXX leaks when mount fails
// XXX periodic hang-up-and-reopen
static void stat_timer_tick(evutil_socket_t fd,short what,void *arg) {
struct running *rr = (struct running *)arg;
struct source *src;
struct interface *ic;
struct jpf_value *out,*out_srcs,*out_src,*out_ics,*out_ic,*out_mem;
struct jpf_callbacks jpf_emitter_cb;
struct jpf_emitter jpf_emitter;
char *time_str;
int i;
if(rr->stats_fd==-1) { return; }
log_debug(("main stat collection loop"));
out_srcs = jpfv_important_assoc(0);
for(i=0;i<array_length(rr->src);i++) {
src = (struct source *)array_index(rr->src,i);
out_src = jpfv_assoc();
src_global_stats(src,out_src);
if(src->stats) { src->stats(src,out_src); }
jpfv_assoc_add(out_srcs,src->name,out_src);
}
out_ics = jpfv_important_assoc(0);
for(i=0;i<array_length(rr->icc);i++) {
ic = (struct interface *)array_index(rr->icc,i);
out_ic = jpfv_assoc();
ic_global_stats(ic,out_ic);
jpfv_assoc_add(out_ics,ic->name,out_ic);
}
out = jpfv_important_assoc(0);
time_str= iso_localtime(0);
jpfv_assoc_add(out,"time",jpfv_string(time_str));
free(time_str);
jpfv_assoc_add(out,"sources",out_srcs);
jpfv_assoc_add(out,"interfaces",out_ics);
out_mem = jpfv_important_array(1);
jpfv_array_add(out_mem,out);
jpf_emit_fd(&jpf_emitter_cb,&jpf_emitter,rr->stats_fd);
jpf_emit_df(out_mem,&jpf_emitter_cb,&jpf_emitter);
jpf_emit_done(&jpf_emitter);
jpfv_free(out_mem);
}
static void do_exit(void *eb) {
log_info(("All interfaces have exited: stopping event loop"));
event_base_loopexit((struct event_base *)eb,0);
}
static void sigkill_self(evutil_socket_t fd,short what,void *arg) {
log_warn(("Did not quit nicely, sending SIGKILL to self"));
kill(getpid(),SIGKILL);
}
// XXX cond for regular exit
// XXX -9 after delay
#define SIGKILL_DELAY 90 /* sec */
static void user_quit(evutil_socket_t fd,short what,void *arg) {
struct running *rr = (struct running *)arg;
int i;
struct array *icc;
struct timeval sigkill_delay = { SIGKILL_DELAY, 0 };
icc = rr->icc;
array_acquire(icc);
log_info(("Sending quit to interfaces (%d)",array_length(icc)));
for(i=0;i<array_length(icc);i++) {
ic_quit((struct interface *)array_index(icc,i));
}
array_release(icc);
event_del(rr->stat_timer);
event_add(rr->sigkill_timer,&sigkill_delay);
}
void array_nub(array *array) {
assert(array != NULL);
array_sort(array);
if (array->size < 2)
return;
for (int i = 1; i < array->size; i++) {
void *e, *p;
e = array_index(array, i);
p = e - array->el_size;
if (memcmp(p, e, array->el_size) == 0) {
array->size--;
if (i != array->size) {
memmove(e, e + array->el_size, array->el_size * (array->size - i));
i--;
}
}
}
}
void dplib_convt::convert_dplib_expr(const exprt &expr)
{
if(expr.id()==ID_symbol)
{
convert_identifier(expr.get_string(ID_identifier));
}
else if(expr.id()==ID_nondet_symbol)
{
convert_identifier("nondet$"+expr.get_string(ID_identifier));
}
else if(expr.id()==ID_typecast)
{
assert(expr.operands().size()==1);
const exprt &op=expr.op0();
if(expr.type().id()==ID_bool)
{
if(op.type().id()==ID_signedbv ||
op.type().id()==ID_unsignedbv ||
op.type().id()==ID_pointer)
{
convert_dplib_expr(op);
dplib_prop.out << "/=";
convert_dplib_expr(gen_zero(op.type()));
}
else
{
throw "TODO typecast1 "+op.type().id_string()+" -> bool";
}
}
else if(expr.type().id()==ID_signedbv ||
expr.type().id()==ID_unsignedbv)
{
unsigned to_width=unsafe_string2unsigned(id2string(expr.type().get(ID_width)));
if(op.type().id()==ID_signedbv)
{
unsigned from_width=unsafe_string2unsigned(id2string(op.type().get(ID_width)));
if(from_width==to_width)
convert_dplib_expr(op);
else if(from_width<to_width)
{
dplib_prop.out << "SX(";
convert_dplib_expr(op);
dplib_prop.out << ", " << to_width << ")";
}
else
{
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << ")[" << (to_width-1) << ":0]";
}
}
else if(op.type().id()==ID_unsignedbv)
{
unsigned from_width=unsafe_string2unsigned(id2string(op.type().get(ID_width)));
if(from_width==to_width)
convert_dplib_expr(op);
else if(from_width<to_width)
{
dplib_prop.out << "(0bin";
for(unsigned i=from_width; i<to_width; i++)
dplib_prop.out << "0";
dplib_prop.out << " @ ";
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << "))";
}
else
{
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << ")[" << (to_width-1) << ":0]";
}
}
else if(op.type().id()==ID_bool)
{
if(to_width>1)
{
dplib_prop.out << "(0bin";
for(unsigned i=1; i<to_width; i++)
dplib_prop.out << "0";
dplib_prop.out << " @ ";
dplib_prop.out << "IF ";
convert_dplib_expr(op);
dplib_prop.out << " THEN 0bin1 ELSE 0bin0 ENDIF)";
}
else
{
dplib_prop.out << "IF ";
convert_dplib_expr(op);
dplib_prop.out << " THEN 0bin1 ELSE 0bin0 ENDIF";
}
}
else
{
throw "TODO typecast2 "+op.type().id_string()+
" -> "+expr.type().id_string();
}
}
else if(expr.type().id()==ID_pointer)
{
if(op.type().id()==ID_pointer)
{
convert_dplib_expr(op);
}
else
throw "TODO typecast3 "+op.type().id_string()+" -> pointer";
}
else
throw "TODO typecast4 ? -> "+expr.type().id_string();
}
else if(expr.id()==ID_struct)
{
dplib_prop.out << "(# ";
const struct_typet &struct_type=to_struct_type(expr.type());
const struct_typet::componentst &components=
struct_type.components();
assert(components.size()==expr.operands().size());
unsigned i=0;
for(struct_typet::componentst::const_iterator
it=components.begin();
it!=components.end();
it++, i++)
{
if(i!=0) dplib_prop.out << ", ";
dplib_prop.out << it->get(ID_name);
dplib_prop.out << ":=";
convert_dplib_expr(expr.operands()[i]);
}
dplib_prop.out << " #)";
}
else if(expr.id()==ID_constant)
{
if(expr.type().id()==ID_unsignedbv ||
expr.type().id()==ID_signedbv ||
expr.type().id()==ID_bv)
{
dplib_prop.out << "0bin" << expr.get(ID_value);
}
else if(expr.type().id()==ID_pointer)
{
const irep_idt &value=expr.get(ID_value);
if(value=="NULL")
{
dplib_prop.out << "(# object:="
<< pointer_logic.get_null_object()
<< ", offset:="
<< bin_zero(config.ansi_c.pointer_width) << " #)";
}
else
throw "unknown pointer constant: "+id2string(value);
}
else if(expr.type().id()==ID_bool)
{
if(expr.is_true())
dplib_prop.out << "TRUE";
else if(expr.is_false())
dplib_prop.out << "FALSE";
else
throw "unknown boolean constant";
}
else if(expr.type().id()==ID_array)
{
dplib_prop.out << "ARRAY (i: " << array_index_type() << "):";
assert(!expr.operands().empty());
unsigned i=0;
forall_operands(it, expr)
{
if(i==0)
dplib_prop.out << "\n IF ";
else
dplib_prop.out << "\n ELSIF ";
dplib_prop.out << "i=" << array_index(i) << " THEN ";
convert_array_value(*it);
i++;
}
dplib_prop.out << "\n ELSE ";
convert_dplib_expr(expr.op0());
dplib_prop.out << "\n ENDIF";
}
else if(expr.type().id()==ID_integer ||
/*
* Dump_types - dump all typing information
*/
void Dmp_type( int cnt, unsigned_32 *offs )
/*****************************************/
{
int i;
addr32_ptr *p32;
addr48_ptr *p48;
unsigned_8 *ptr;
unsigned_16 index;
unsigned_16 curr_index;
unsigned_32 coff;
char name[256];
unsigned_8 buff[256];
for( i = 0; i < cnt; i++ ) {
coff = 0;
Wdputs( " Data " );
Putdec( i );
Wdputs( ": offset " );
Puthex( offs[i], 8 );
Wdputslc( "\n" );
curr_index = 0;
for( ;; ) {
Wlseek( coff + Curr_sectoff + offs[i] );
Wread( buff, sizeof( buff ) );
Wdputs( " " );
Puthex( coff, 4 );
Wdputs( ": " );
ptr = buff+2;
switch( buff[1] ) {
case SCALAR:
StartType( "SCALAR", ++curr_index );
ptr = buff+3;
Get_local_name( name, ptr, buff );
Wdputs( " \"" );
Wdputs( name );
Wdputs( "\" scalar type = " );
scalar_type( buff[2] );
Wdputslc( "\n" );
break;
case SCOPE:
StartType( "SCOPE", ++curr_index);
Get_local_name( name, ptr, buff );
Wdputs( " \"" );
Wdputs( name );
Wdputslc( "\"\n" );
break;
case NAME:
StartType( "NAME", ++curr_index);
ptr = Get_type_index( ptr, &index );
ptr = Get_type_index( ptr, &index );
Get_local_name( name, ptr, buff );
Wdputs( " \"" );
Wdputs( name );
Wdputs( "\" type idx = " );
Putdec( index );
Wdputs( " scope idx = " );
ptr = Get_type_index( buff+2, &index );
Putdec( index );
Wdputslc( "\n" );
break;
case CUE_TABLE:
Wdputs( "cue table offset=" );
Puthex( *(unsigned_32 *)ptr, 8 );
Wdputslc( "\n" );
break;
case TYPE_EOF:
return;
case BYTE_INDEX:
StartType( "BYTE_INDEX ARRAY", ++curr_index);
array_index( ptr, 1 );
break;
case WORD_INDEX:
StartType( "WORD_INDEX ARRAY", ++curr_index);
array_index( ptr, 2 );
break;
case LONG_INDEX:
StartType( "LONG_INDEX ARRAY", ++curr_index);
array_index( ptr, 4 );
break;
case TYPE_INDEX:
StartType( "TYPE_INDEX ARRAY", ++curr_index);
Wdputs( " index type = " );
ptr = Get_type_index( ptr, &index );
Putdec( index );
base_type_index( ptr );
break;
case DESC_INDEX:
StartType( "DESC_INDEX ARRAY", ++curr_index);
desc_array( ptr, false );
break;
case DESC_INDEX_386:
StartType( "DESC_INDEX ARRAY", ++curr_index);
desc_array( ptr, true );
break;
case BYTE_RANGE:
StartType( "BYTE_RANGE", ++curr_index);
range( ptr, 1 );
break;
case WORD_RANGE:
StartType( "WORD_RANGE", ++curr_index);
range( ptr, 2 );
break;
case LONG_RANGE:
StartType( "LONG_RANGE", ++curr_index);
range( ptr, 4 );
break;
case PTR_NEAR:
StartType( "NEAR PTR", ++curr_index);
Wdputs( " " );
near_ptr( buff );
break;
case PTR_FAR:
StartType( "FAR PTR", ++curr_index);
Wdputs( " " );
base_type_index( ptr );
break;
case PTR_HUGE:
StartType( "HUGE PTR", ++curr_index);
Wdputs( " " );
base_type_index( ptr );
break;
case PTR_NEAR_DEREF:
StartType( "NEAR_DEREF PTR", ++curr_index);
Wdputs( " " );
near_ptr( buff );
break;
case PTR_FAR_DEREF:
StartType( "FAR_DEREF PTR", ++curr_index);
Wdputs( " " );
base_type_index( ptr );
break;
case PTR_HUGE_DEREF:
StartType( "HUGE_DEREF PTR", ++curr_index);
Wdputs( " " );
base_type_index( ptr );
break;
case PTR_NEAR386:
StartType( "NEAR386 PTR", ++curr_index);
Wdputs( " " );
near_ptr( buff );
break;
case PTR_FAR386:
StartType( "FAR386 PTR", ++curr_index);
Wdputs( " " );
base_type_index( ptr );
break;
case PTR_NEAR386_DEREF:
StartType( "NEAR386_DEREF PTR", ++curr_index);
Wdputs( " " );
near_ptr( buff );
break;
case PTR_FAR386_DEREF:
StartType( "FAR386_DEREF PTR", ++curr_index);
Wdputs( "\n " );
base_type_index( ptr );
break;
case CLIST:
StartType( "ENUM_LIST", ++curr_index);
Wdputs( " number of consts = " );
Puthex( *ptr, 4 );
Wdputs( " scalar type = " );
scalar_type( buff[4] );
Wdputslc( "\n" );
break;
case CONST_BYTE:
Wdputslc( "CONST_BYTE\n" );
enum_const( buff, 1 );
break;
case CONST_WORD:
Wdputslc( "CONST_WORD\n" );
enum_const( buff, 2 );
break;
case CONST_LONG:
Wdputslc( "CONST_LONG\n" );
enum_const( buff, 4 );
break;
case FLIST:
StartType( "FIELD_LIST", ++curr_index);
Wdputs( " number of fields = " );
Puthex( *ptr, 4 );
if( buff[0] > 4 ) {
Wdputs( " size = " );
ptr += 2;
Puthex( *ptr, 8 );
}
Wdputslc( "\n" );
break;
case FIELD_BYTE:
Wdputslc( "FIELD_BYTE\n" );
bit_field_struct( buff, 1, false );
break;
case FIELD_WORD:
Wdputslc( "FIELD_WORD\n" );
bit_field_struct( buff, 2, false );
break;
case FIELD_LONG:
Wdputslc( "FIELD_LONG\n" );
bit_field_struct( buff, 4, false );
break;
case BIT_BYTE:
Wdputslc( "BIT_BYTE\n" );
bit_field_struct( buff, 1, true );
break;
case BIT_WORD:
Wdputslc( "BIT_WORD\n" );
bit_field_struct( buff, 2, true );
break;
case BIT_LONG:
Wdputslc( "BIT_LONG\n" );
bit_field_struct( buff, 4, true );
break;
case FIELD_CLASS:
Wdputslc( "FIELD_CLASS\n" );
bit_field_class( buff, false );
break;
case BIT_CLASS:
Wdputslc( "BIT_CLASS\n" );
bit_field_class( buff, true );
break;
case INHERIT_CLASS:
Wdputslc( "INHERIT_CLASS\n" );
Wdputs( " adjust locator = " );
ptr = Dump_location_expression( ptr, " " );
Wdputs( " ancestor type = " );
Get_type_index( ptr, &index );
Putdec( index );
Wdputslc( "\n" );
break;
case PNEAR:
StartType( "NEAR PROC", ++curr_index);
near_far_proc( buff );
break;
case PFAR:
StartType( "FAR PROC", ++curr_index);
near_far_proc( buff );
break;
case PNEAR386:
StartType( "NEAR386 PROC", ++curr_index);
near_far_proc( buff );
break;
case PFAR386:
StartType( "FAR386 PROC", ++curr_index);
near_far_proc( buff );
break;
case EXT_PARMS:
Wdputslc( "EXT_PARMS\n" );
param_type_index( (unsigned_8)buff[0]-2, ptr );
break;
case CHAR_BYTE:
StartType( "CHAR_BYTE", ++curr_index);
Wdputs( " length = " );
Puthex( *ptr, 2 );
Wdputslc( "\n" );
break;
case CHAR_WORD:
StartType( "CHAR_WORD", ++curr_index);
Wdputs( " length = " );
Puthex( *ptr, 4 );
Wdputslc( "\n" );
break;
case CHAR_LONG:
StartType( "CHAR_LONG", ++curr_index);
Wdputs( " length = " );
Puthex( *ptr, 8 );
Wdputslc( "\n" );
break;
case CHAR_IND:
StartType( "CHAR_IND", ++curr_index);
Wdputs( " scalar type = " );
scalar_type( buff[2] );
p32 = (addr32_ptr *)ptr;
Puthex( p32->segment, 4 );
Wdputc( ':' );
Puthex( p32->offset, 4 );
Wdputslc( "\n" );
break;
case CHAR_IND_386:
StartType( "CHAR_IND_386", ++curr_index);
Wdputs( " scalar type = " );
scalar_type( buff[2] );
p48 = (addr48_ptr *)ptr;
Puthex( p48->segment, 4 );
Wdputc( ':' );
Puthex( p48->offset, 8 );
Wdputslc( "\n" );
break;
case CHAR_LOCATION:
StartType( "CHAR_LOC", ++curr_index);
Wdputs( " scalar type = " );
scalar_type( buff[2] );
Wdputs( " size locator = " );
ptr = Dump_location_expression( ptr + 1, " " );
Wdputslc( "\n" );
break;
}
coff += buff[0];
if( coff >= (offs[i+1] - offs[i]) ) {
break;
}
}
}
} /* Dmp_type */
/** \brief read a MATLAB-array from a .mat file.
\todo Currently, the returned array is always DOUBLE.
\param file the .mat file
\param varname the name of the variable in the .mat file; can be NULL, in this case the
first variable is read.
\return the Array-struct or NULL in case an error occurred
*/
Array* read_array_matlab( const char *file, const char *varname ){
mat_t *mfile;
matvar_t *marr=NULL;
dprintf("Reading variable '%s' from file: '%s'\n", varname, file);
mfile = Mat_Open( file, MAT_ACC_RDONLY);
if( !mfile ){
errprintf("Error opening MATLAB file '%s'\n", file );
return NULL;
}
if( varname ){
marr = Mat_VarRead( mfile, varname );
} else {
marr = Mat_VarReadNext( mfile );
}
Mat_Close( mfile );
dprintf("Done\n");
if( !marr ){
errprintf("Something is wrong, could not read variable\n");
return NULL;
}
Array *out=array_new( DOUBLE, marr->rank, marr->dims );
ulong i;
uint *index=(uint*)malloc( out->ndim*sizeof(uint));
for( i=0; i<marr->nbytes/marr->data_size; i++ ){
array_calc_colindex( i, out->size, out->ndim, index );
switch( marr->data_type ){
case MAT_T_INT8:
*((double*)array_index(out,index))=(double)(*(int8_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_UINT8:
*((double*)array_index(out,index))=(double)(*(uint8_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_INT16:
*((double*)array_index(out,index))=(double)(*(int16_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_UINT16:
*((double*)array_index(out,index))=(double)(*(uint16_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_INT32:
*((double*)array_index(out,index))=(double)(*(int32_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_UINT32:
*((double*)array_index(out,index))=(double)(*(uint32_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_INT64:
*((double*)array_index(out,index))=(double)(*(int64_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_UINT64:
*((double*)array_index(out,index))=(double)(*(uint64_t*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_SINGLE:
*((double*)array_index(out,index))=(double)(*(float*)(marr->data+(i*marr->data_size)));
break;
case MAT_T_DOUBLE:
*((double*)array_index(out,index))=(double)(*(double*)(marr->data+(i*marr->data_size)));
break;
default:
errprintf("Unknown Data-Type in MATLAB-file!\n");
break;
}
}
free(index);
return out;
}
