tows_c.c File Reference

#include "scicos_block4.h"
#include "machine.h"
#include "stack-c.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "MALLOC.h"

Include dependency graph for tows_c.c:

Go to the source code of this file.

Data Structures
struct	towork_struct
Defines
#define	codehm
Functions
int C2F()	cvstr (integer *, integer *, char *, integer *, unsigned long int)
int C2F()	mputnc ()
int C2F()	namstr ()
void C2F()	mopen ()
int C2F()	cluni0 (char *name, char *nams, integer *ln, long int name_len, long int nams_len)
void C2F()	mclose (integer *fd, double *res)
void	sciprint (char *fmt,...)
void	tows_c (scicos_block *block, int flag)
Variables
static int	id [nsiz]
static char	fmtd [3] = {'d','l','\000'}
static char	fmti [3] = {'i','l','\000'}
static char	fmtl [3] = {'l','l','\000'}
static char	fmts [3] = {'s','l','\000'}
static char	fmtc [3] = {'c','l','\000'}
static char	fmtul [3] = {'u','l','\000'}
static char	fmtus [3] = {'u','s','\000'}
static char	fmtuc [3] = {'u','c','\000'}
static char *	str_hmlst [] = {"hm","dims","entries"}

---

Define Documentation

#define codehm

Value:

ptr_i[6]   = 17; \
        ptr_i[7]   = 3;  \
        ptr_i[8]   = 1;  \
        ptr_i[9]   = ptr_i[8]  + 11; \
        ptr_i[10]  = ptr_i[9]  + 4;  \
        ptr_i[11]  = ptr_i[10] + 2 + nz*nu*nu2; \
        ptr_i[12]  = 10; \
        ptr_i[13]  = 1; \
        ptr_i[14]  = 3; \
        ptr_i[15]  = 0; \
        ptr_i[16]  = 1; \
        ptr_i[17]  = ptr_i[16] + 2; \
        ptr_i[18]  = ptr_i[17] + 4; \
        ptr_i[19]  = ptr_i[18] + 7; \
        i = (int)strlen(str_hmlst[0]);   \
        C2F(cvstr)(&i,&ptr_i[20],str_hmlst[0],(l=0,&l),(unsigned long) i); \
        j = (int)strlen(str_hmlst[1]); \
        C2F(cvstr)(&j,&ptr_i[20+i],str_hmlst[1],(l=0,&l),(unsigned long) j); \
        k = (int)strlen(str_hmlst[2]); \
        C2F(cvstr)(&k,&ptr_i[20+i+j],str_hmlst[2],(l=0,&l),(unsigned long) k); \
        ptr_i[33]  = 8; \
        ptr_i[34]  = 1; \
        ptr_i[35]  = 3; \
        ptr_i[36]  = 4; \
        ptr_i[37]  = nu; \
        ptr_i[38]  = nu2; \
        ptr_i[39]  = nz;

Definition at line 35 of file tows_c.c.

Referenced by tows_c().

---

Function Documentation

int C2F() cluni0	(	char *	name,
		char *	nams,
		integer *	ln,
		long int	name_len,
		long int	nams_len
	)

expand in_name to produce out_name

Parameters:

	in_name	the input string that we want to expand
	out_name	the output string
	out_n	number of character of out_name
	lin	length of in_name
	lout	length of out_name

Returns:

0

Definition at line 35 of file cluni0.c.

References Cluni0(), GetenvB(), getUpdateEnvVar(), HOME, k, PATH_MAX, SCI, SCI_a, and setUpdateEnvVar().

{
        int nc= PATH_MAX;
        static char SCI[PATH_MAX],HOME[PATH_MAX],TMP[PATH_MAX];
        static int k;
        
        if ( ( n==0 ) || (getUpdateEnvVar() == 1) )
        {
                GetenvB("SCI"   , SCI ,nc);
                GetenvB("HOME"  , HOME,nc);
                GetenvB("TMPDIR", TMP ,nc);
                n=n+1;
                setUpdateEnvVar(0);
        }
        
        /* in_name[lin]='\0';*/
        if ( Cluni0(SCI,SCI_a,in_name,out_name,lin) == 0 )
                if ( Cluni0(HOME,HOME_a,in_name,out_name,lin) == 0 )
                        if ( Cluni0(TMP,TMP_a,in_name,out_name,lin) == 0 )
                        {
                                strncpy(out_name,in_name,(size_t)lin);
                                out_name[lin]='\0';
                        }
        
        *out_n = (int)strlen(out_name);
        #ifdef _MSC_VER
                for (k=0 ; k < *out_n ;k++) if ( out_name[k]=='/') out_name[k]='\\';
        #else
                for (k=0 ; k < *out_n ;k++) if ( out_name[k]=='\\') out_name[k]='/';
        #endif
        
        return(0);
}

Here is the call graph for this function:

int C2F() cvstr	(	integer *	,
		integer *	,
		char *	,
		integer *	,
		unsigned long	int
	)

Definition at line 24 of file cvstr.c.

{
  if (*job == 0) C2F(asciitocode)(n, line, str, &cx1, str_len);
  else C2F(codetoascii)(n, line, str, str_len);
  return 0;
}

void C2F() mclose	(	integer *	fd,
		double *	res
	)

close the file with id *fd if *id != -1 and *id != -2 the current file if *id = -1 all opened file if *id = -2

Definition at line 22 of file mclose.c.

References _, C2F(), delfile(), fd, GetCurrentFileId(), GetFileOpenedInScilab(), GetMaximumFileOpenedInScilab(), Max, Min, res, res1(), and sciprint().

{     
        int fd1;
        int res1 = 1;
        *res = 0.0;
        switch ( *fd )
        {
        case -2 :
                /* closing all opened files */
                for ( fd1=0; fd1< GetMaximumFileOpenedInScilab(); fd1++) {
                        if ( GetFileOpenedInScilab(fd1) )
                        {
                                fclose( GetFileOpenedInScilab(fd1) );
                                res1 = ferror( GetFileOpenedInScilab(fd1));
                                if (res1 != 0) *res =1;
                                C2F(delfile)(&fd1);
                        }
                }
                break;
        default :
                fd1 = (*fd == -1 ) ? GetCurrentFileId() : Min(Max(*fd,0),GetMaximumFileOpenedInScilab()-1);
                if ( fd1 != -1 ) 
                {
                        if ( GetFileOpenedInScilab(fd1) )
                        {
                                if (fclose(GetFileOpenedInScilab(fd1)))
                                {
                                        *res = (double)ferror(GetFileOpenedInScilab(fd1));
                                }
                                C2F(delfile)(&fd1);
                        }
                        else
                        {
                                *res = 0.0;
                                sciprint(_("%s: Cannot close file whose descriptor is %d: File is not active.\n"),"mclose",fd1);
                        }
                }
                else 
                {
                        *res = -1.0;
                        sciprint(_("%s: Cannot close file whose descriptor is %d: No file to close.\n"),"mclose",fd1);
                }
        }
}

Here is the call graph for this function:

void C2F() mopen

(

)

int C2F() mputnc

(

)

int C2F() namstr

(

)

void sciprint	(	char *	fmt,
			...
	)

Print

Parameters:

	fmt	Format of the format string
	...

Definition at line 36 of file sciprint.c.

{
        va_list ap;

        va_start(ap,fmt);
        scivprint(fmt,ap);
        va_end (ap);
}

void tows_c	(	scicos_block *	block,
		int	flag
	)

Definition at line 97 of file tows_c.c.

References C2F(), cluni0(), towork_struct::cnt, codehm, cvstr(), env, fd, filename, FILENAME_MAX, fmtc, fmtd, fmti, fmtl, fmts, fmtuc, fmtul, fmtus, FREE, get_scicos_time(), getenv(), GetImagInPortPtrs, GetInPortCols, GetInPortRows, Getint16InPortPtrs, Getint32InPortPtrs, Getint8InPortPtrs, GetInType, GetRealInPortPtrs, Getuint16InPortPtrs, Getuint32InPortPtrs, Getuint8InPortPtrs, i, id, ierr, scicos_block::ipar, j, k, l, towork_struct::loop, lout, mclose(), mopen(), mputnc(), namstr(), nsiz, NULL, out_n, res, scicos_free(), scicos_malloc(), sciprint(), SCSCOMPLEX_N, SCSINT16_COP, SCSINT16_N, SCSINT32_COP, SCSINT32_N, SCSINT8_COP, SCSINT8_N, SCSINT_COP, SCSREAL_COP, SCSREAL_N, SCSUINT16_COP, SCSUINT16_N, SCSUINT32_COP, SCSUINT32_N, SCSUINT8_COP, SCSUINT8_N, set_block_error(), str, swap, towork_struct::work, scicos_block::work, and towork_struct::workt.

{
 /* for mopen */
 int fd;
 char *status;
 int swap = 1;
 double res;
 int out_n;
 long int lout;
 char filename[FILENAME_MAX];
 /* for name of file */
 char str[100];
 /* generic pointer */
 SCSREAL_COP *u_d,*u_cd,*ptr_d,*sav_d;
 SCSINT8_COP *u_c,*ptr_c,*sav_c;
 SCSUINT8_COP *u_uc, *ptr_uc,*sav_uc;
 SCSINT16_COP *u_s,*ptr_s,*sav_s;
 SCSUINT16_COP *u_us,*ptr_us,*sav_us;
 SCSINT_COP *ptr_i;
 SCSINT32_COP *u_l,*ptr_l,*sav_l;
 SCSUINT32_COP *u_ul,*ptr_ul,*sav_ul;
 double sav_t;
 /* the struct ptr of that block */
 towork_struct *ptr;
 /* */
 int nu,nu2,ut;
 int nz;
 double t,t_old;
 /* local */
 int i,j,k,l;
 int ierr;

 int  ismat=0;

 /* for path of TMPDIR/workspace */
 char env[256];
 char sep[2];
#ifdef _MSC_VER
  sep[0]='\\';
#else
  sep[0]='/';
#endif
  sep[1]='\0';

 /* retrieve param of that block */
 nu  = GetInPortRows(block,1); /* number of rows of inputs*/
 nu2 = GetInPortCols(block,1); /* number of cols of inputs*/
 ut  = GetInType(block,1);     /* input type */
 nz  = block->ipar[0];         /* buffer size */

 /* check if u is a matrix */
 if (nu2!=1) {
   ismat=1;
 }

 if (flag==4) { /* init */

   /* begin campaign of allocations */
   if((*(block->work)=(towork_struct*) scicos_malloc(sizeof(towork_struct)))==NULL) {
     set_block_error(-16);
     return;
   }

   ptr = *(block->work);

   /*
    * t
    */
   if((ptr->workt=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                          nz*sizeof(double)))==NULL) {
     set_block_error(-16);
     scicos_free(ptr);
     *(block->work) = NULL;
     return;
   }
   ptr_i    = (int*) ptr->workt;
   ptr_i[6] = 1;
   ptr_i[7] = nz;
   ptr_i[8] = 1;
   ptr_i[9] = 0;

   ptr_d = (SCSREAL_COP *) &(ptr_i[10]);
   for (i=0;i<nz;i++) {
     ptr_d[i]=-1;
   }

   /* Scilab variable code name */
   C2F(namstr)(id,(i=29,&i),(j=1,&j),(k=0,&k));

   ptr_i    = (int*) ptr->workt;
   ptr_i[0] = id[0];
   ptr_i[1] = id[1];
   ptr_i[2] = id[2];
   ptr_i[3] = id[3];
   ptr_i[4] = id[4];
   ptr_i[5] = id[5];

   /*
    * x
    */
   switch (ut)
   {
    case SCSREAL_N    :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(double)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 1;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 0;
        ptr_d      = (SCSREAL_COP *) &(ptr_i[44]);

      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(double)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        ptr_i[6]   = 1;
        ptr_i[7]   = nz;
        ptr_i[8]   = nu;
        ptr_i[9]   = 0;
        ptr_d      = (SCSREAL_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_d[i] = 0.;
      }
      break;

    case SCSCOMPLEX_N :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             2*nz*nu*nu2*sizeof(double)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 1;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 1;
        ptr_d      = (SCSREAL_COP *) &(ptr_i[44]);

      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              2*nz*nu*sizeof(double)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        ptr_i[6]   = 1;
        ptr_i[7]   = nz;
        ptr_i[8]   = nu;
        ptr_i[9]   = 1;
        ptr_d      = (SCSREAL_COP *) &(ptr_i[10]);
      }
      for (i=0;i<2*nu*nu2*nz;i++) {
        ptr_d[i] = 0.;
      }
      break;

    case SCSINT8_N    :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(char)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 8;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 1;
        ptr_c      = (SCSINT8_COP *) &(ptr_i[44]);

      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(char)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        ptr_i[6]   = 8;
        ptr_i[7]   = nz;
        ptr_i[8]   = nu;
        ptr_i[9]   = 1;
        ptr_c      = (SCSINT8_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_c[i] = 0;
      }
      break;

    case SCSINT16_N   :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(short)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 8;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 2;
        ptr_s      = (SCSINT16_COP *) &(ptr_i[44]);
      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(short)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        ptr_i[6]   = 8;
        ptr_i[7]   = nz;
        ptr_i[8]   = nu;
        ptr_i[9]   = 2;
        ptr_s      = (SCSINT16_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_s[i] = 0;
      }
      break;

    case SCSINT32_N   :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(long)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 8;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 4;
        ptr_l      = (SCSINT32_COP *) &(ptr_i[44]);
      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(long)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        ptr_i[6]   = 8;
        ptr_i[7]   = nz;
        ptr_i[8]   = nu;
        ptr_i[9]   = 4;
        ptr_l      = (SCSINT32_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_l[i] = 0;
      }
      break;

    case SCSUINT8_N   :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(unsigned char)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 8;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 11;
        ptr_uc     = (SCSUINT8_COP *) &(ptr_i[44]);
      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(unsigned char)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i       = (int*) ptr->work;
        ptr_i[6]    = 8;
        ptr_i[7]    = nz;
        ptr_i[8]    = nu;
        ptr_i[9]    = 11;
        ptr_uc      = (SCSUINT8_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_uc[i] = 0;
      }
      break;

    case SCSUINT16_N  :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(unsigned short)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 8;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 12;
        ptr_us     = (SCSUINT16_COP *) &(ptr_i[44]);
      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(unsigned short)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i = (int*) ptr->work;
        ptr_i[6]    = 8;
        ptr_i[7]    = nz;
        ptr_i[8]    = nu;
        ptr_i[9]    = 12;
        ptr_us      = (SCSUINT16_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_us[i] = 0;
      }
      break;

    case SCSUINT32_N  :
      if (ismat) {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int) + \
                                             2*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (2+4+7)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             (3)*sizeof(int) + \
                                             4*sizeof(int) + \
                                             nz*nu*nu2*sizeof(unsigned long)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i      = (int*) ptr->work;
        codehm
        ptr_i[40]  = 8;                     /*head of entries for hm*/
        ptr_i[41]  = nu*nu2*nz;
        ptr_i[42]  = 1;
        ptr_i[43]  = 14;
        ptr_ul     = (SCSUINT32_COP *) &(ptr_i[44]);
      }
      else {
        if((ptr->work=(void *) scicos_malloc(6*sizeof(int)+4*sizeof(int)+ \
                                              nz*nu*sizeof(unsigned long)))==NULL) {
          set_block_error(-16);
          scicos_free(ptr->workt);
          scicos_free(ptr);
          *(block->work) = NULL;
          return;
        }
        ptr_i = (int*) ptr->work;
        ptr_i[6]    = 8;
        ptr_i[7]    = nz;
        ptr_i[8]    = nu;
        ptr_i[9]    = 14;
        ptr_ul      = (SCSUINT32_COP *) &(ptr_i[10]);
      }
      for (i=0;i<nu*nu2*nz;i++) {
        ptr_ul[i] = 0;
      }
      break;

    default  : /* Add a message here */
               break;
   }

   /* Scilab variable code name */
   C2F(namstr)(id,(i=33,&i),(j=1,&j),(k=0,&k));

   ptr_i    = (int*) ptr->work;
   ptr_i[0] = id[0];
   ptr_i[1] = id[1];
   ptr_i[2] = id[2];
   ptr_i[3] = id[3];
   ptr_i[4] = id[4];
   ptr_i[5] = id[5];

   /*
    * cnt
    */
   ptr->cnt = 0;

   /*
    * loop
    */
   ptr->loop = 0;
 }

 else if (flag==5) { /* finish */

   ptr = *(block->work);

   if (ptr!=NULL) {
     /* Put file name in str */
     C2F(cvstr)(&(block->ipar[1]),&(block->ipar[2]),str,(j=1,&j), \
                 (unsigned long)strlen(str));
     str[block->ipar[1]] = '\0';

     /* retrieve path of TMPDIR/workspace */
     strcpy(env,getenv("TMPDIR"));
     strcat(env,sep);
     strcat(env,"Workspace");
     strcat(env,sep);
     strcat(env,str);

     /* open tmp file */
     status = "wb"; /* "w" : write */
                    /* "b" : binary (required for Windows) */
     lout   = FILENAME_MAX;
     C2F(cluni0)(env, filename, &out_n,1,lout);
     C2F(mopen)(&fd,env,status,&swap,&res,&ierr);
     if (ierr != 0) {
       sciprint("Error when opening file '%s'.\n",str);
       scicos_free(ptr->workt);
       scicos_free(ptr);
       *(block->work) = NULL;
       set_block_error(-3);
       return;
     }

     /* check loop */

     /* we don't are at the end of the buffer :
      * only first records will be saved
      */
     if ((ptr->cnt==0)&&(ptr->loop==0)) { /* nothing have been stored */
       ptr_i = (int*) ptr->workt;
       ptr_i[6] = 1;
       ptr_i[7] = 0;
       ptr_i[8] = 0;
       ptr_i[9] = 0;
       ptr_i = (int*) ptr->work;
       ptr_i[6] = 1;
       ptr_i[7] = 0;
       ptr_i[8] = 0;
       ptr_i[9] = 0;
     }
     if ((ptr->cnt!=0)&&(ptr->cnt!=nz)&&(ptr->loop==0)) { /* something stored */
                                                          /* but we don't are at the end */
       ptr_i    = (int*) ptr->workt;
       ptr_i[7] = ptr->cnt;
       ptr_i    = (int*) ptr->work;
       /* hmat */
       if (ismat) {
         ptr_i[39] = ptr->cnt;
         ptr_i[41] = ptr->cnt*nu*nu2;
       }
       /* vector or matrix */
       else {
         /* matrix case */
         if (ptr_i[8] != 1) {
           /* */
           k=nz-ptr->cnt;
           /* */
           switch (ut) {
             case SCSREAL_N    :
                for(i=0;i<ptr_i[8]-1;i++) {
                  for(j=0;j<ptr->cnt;j++) {
                    *((double *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)) = \
                         *((double *)(&ptr_i[10]) + (((i+1)*nz)+j));
                  }
                }
               break;

             case SCSCOMPLEX_N :
                for(i=0;i<ptr_i[8]-1;i++) {
                  for(j=0;j<ptr->cnt;j++) {
                    *((double *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)) = \
                         *((double *)(&ptr_i[10]) + (((i+1)*nz)+j));
                    *((double *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)+nz*nu) = \
                         *((double *)(&ptr_i[10]) + (((i+1)*nz)+j)+nz*nu);
                  }
                }
               break;

             case SCSINT8_N :
                for(i=0;i<ptr_i[8]-1;i++) {
                  for(j=0;j<ptr->cnt;j++) {
                    *((char *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)) = \
                         *((char *)(&ptr_i[10]) + (((i+1)*nz)+j));
                  }
                }
               break;

             case SCSINT16_N :
                for(i=0;i<ptr_i[8]-1;i++) {
                  for(j=0;j<ptr->cnt;j++) {
                    *((short *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)) = \
                         *((short *)(&ptr_i[10]) + (((i+1)*nz)+j));
                  }
                }
               break;

             case SCSINT32_N :
                for(i=0;i<ptr_i[8]-1;i++) {
                  for(j=0;j<ptr->cnt;j++) {
                    *((long *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)) = \
                         *((long *)(&ptr_i[10]) + (((i+1)*nz)+j));
                  }
                }
               break;

             case SCSUINT8_N :
                for(i=0;i<ptr_i[8]-1;i++) {
                  for(j=0;j<ptr->cnt;j++) {
                    *((unsigned char *)(&ptr_i[10]) + (((i+1)*nz)+j-(i+1)*k)) = \
                         *((