Scilab [trunk]: scilab/modules/fileio/src/c/fileio.c File Reference

int SciStrtoStr __PARAMS ( (int *Scistring, int *nstring, int *ptrstrings, char **strh) )

Definition at line 335 of file fileio.c.

00336 {
00337   char *s,*p;
00338   int li,ni,*SciS,i,job=1;
00339   
00340   li=ptrstrings[0];
00341   ni=ptrstrings[*nstring] - li + *nstring +1;
00342   p=(char *) MALLOC(ni);
00343   if (p ==NULL)  return MEM_LACK;
00344   SciS= Scistring;
00345   s=p;
00346   for ( i=1 ; i<*nstring+1 ; i++) 
00347     {
00348       ni=ptrstrings[i]-li;
00349       li=ptrstrings[i];
00350       F2C(cvstr)(&ni,SciS,s,&job,(long int)ni);
00351       SciS += ni;
00352       s += ni;
00353       if (i<*nstring) {
00354         *s='\n';
00355         s++;
00356       }
00357     }
00358   *s='\0';
00359   *strh=p;
00360   return 0;
00361 }

void Free_Scan __PARAMS ( (int nrow, int ncol, sfdir *type_s, entry **data) )

Definition at line 311 of file fileio.c.

References data, FREE, i, j, s, SF_C, and SF_S.

00312 {
00313   int i,j;
00314   entry * Data;
00315   Data=*data;
00316 
00317   if (nrow != 0) {
00318     for ( j=0 ; j < ncol ; j++)
00319       if ( (type_s[j] ==  SF_C) || (type_s[j] ==  SF_S) ) 
00320         /* free allocated strings in scan data area */
00321         for ( i=0 ; i < nrow ; i++) {
00322           FREE(Data[j+ncol*i].s);
00323         }
00324   }
00325   /* free scaned data area */
00326   if (ncol>0) FREE(Data);
00327 }

int Store_Scan __PARAMS ( (int *nrow, int *ncol, sfdir *type_s, sfdir *type, int *retval, int *retval_s, rec_entry *buf, entry **data, int rowcount, int n) )

Definition at line 218 of file fileio.c.

00219 { 
00220   int i,j,nr,nc,err;
00221   entry * Data;
00222   int blk=20; /* block size for memory allocation */
00223   nr=*nrow;
00224   nc=*ncol;
00225 
00226   if (rowcount==0) {
00227     for ( i=0 ; i < MAXSCAN ; i++) type_s[i]=SF_F; /* initialisation */
00228     if (nr<0) nr=blk;
00229     nc=n;
00230     *ncol=nc;
00231     *retval_s=*retval;
00232     if (n==0) {
00233       return 0;
00234     }
00235     if ( (*data = (entry *) MALLOC(nc*nr*sizeof(entry)))==NULL) {
00236       err= MEM_LACK;
00237       goto bad1;
00238     }
00239     for ( i=0 ; i < nc ; i++) type_s[i]=type[i];
00240 
00241   }
00242   else {
00243     /* check if number of data read match with previous number */
00244     if ( (n !=nc ) || (*retval_s != *retval) ){
00245       err=MISMATCH;
00246       goto bad2;
00247     }
00248     /* check if types of data read match with previous types */
00249     for ( i=0 ; i < nc ; i++)
00250       if (type[i] != type_s[i]) {
00251         err=MISMATCH;
00252         goto bad2;
00253       }
00254 
00255     /* check for memory and REALLOC if necessary*/
00256     if (rowcount>= nr) {
00257       nr=nr+blk;
00258       *nrow=nr;
00259       if ( (*data = (entry *) REALLOC(*data,nc*nr*sizeof(entry)))==NULL) {
00260         err= MEM_LACK;
00261         goto bad2;
00262       }
00263     }
00264   } 
00265   Data=*data;
00266   /* store values scanned in a new row */
00267   for ( i=0 ; i < nc ; i++) 
00268     {
00269       switch ( type_s[i] )
00270         {
00271         case SF_C:
00272         case SF_S:
00273           Data[i+nc*rowcount].s=buf[i].c;
00274           break;
00275         case SF_LUI:
00276           Data[i+nc*rowcount].d=(double)buf[i].lui;
00277           break;
00278         case SF_SUI:
00279           Data[i+nc*rowcount].d=(double)buf[i].sui;
00280           break;
00281         case SF_UI:
00282           Data[i+nc*rowcount].d=(double)buf[i].ui;
00283           break;
00284         case SF_LI:
00285           Data[i+nc*rowcount].d=(double)buf[i].li;
00286           break;
00287         case SF_SI:
00288           Data[i+nc*rowcount].d=(double)buf[i].si;
00289           break;
00290         case SF_I:
00291           Data[i+nc*rowcount].d=(double)buf[i].i;
00292           break;
00293         case SF_LF:
00294           Data[i+nc*rowcount].d=buf[i].lf;
00295           break;
00296         case SF_F:
00297           Data[i+nc*rowcount].d=(double)buf[i].f;
00298           break;
00299         }
00300     } /* rowcount */
00301   return 0;
00302  bad1:
00303   /* FREE allocated strings in scan buffer */
00304   for ( j=0 ; j < MAXSCAN ; j++)
00305     if ( (type_s[j] ==  SF_C) || (type_s[j] ==  SF_S))  FREE(buf[j].c);
00306   
00307  bad2: 
00308   return err;
00309 }

int Sci_Store __PARAMS ( (int nrow, int ncol, entry *data, sfdir *type, int retval_s) )

Definition at line 66 of file fileio.c.

References C2F, CreateVar, CreateVarFromPtr, data, FREE, i, i1, intersiz, j, l, Lhs, LhsVar, MALLOC, MEM_LACK, mkmlistfromvars(), n, NULL, PutLhsVar, RET_BUG, Rhs, s, SF_C, SF_S, and stk.

00067 {
00068   int cur_i,i,j,i1,one=1,zero=0,k,l,iarg,colcount;
00069   sfdir cur_type;
00070   char ** temp;
00071      
00072 
00073   /* create Scilab variable with each column of data */
00074   if (ncol+Rhs > intersiz ){
00075     Scierror(998,"Error:\ttoo many directive in scanf\r\n");
00076     return RET_BUG;
00077   }
00078   iarg=Rhs;
00079   if (Lhs > 1) {
00080     if (nrow==0) {/* eof encountered before any data */
00081       CreateVar(++iarg, "d", &one, &one, &l);
00082       LhsVar(1) = iarg;
00083       *stk(l) = -1.0;
00084       for ( i = 2; i <= Lhs ; i++) 
00085       {
00086         iarg++;
00087         CreateVar(iarg,"d",&zero,&zero,&l);
00088         LhsVar(i) = iarg;
00089       }
00090       PutLhsVar();
00091       return 0;
00092     }
00093     CreateVar(++iarg, "d", &one, &one, &l);
00094     *stk(l) = (double) retval_s;
00095     LhsVar(1)=iarg;
00096     if (ncol==0) goto Complete;
00097 
00098     for ( i=0 ; i < ncol ; i++) { 
00099       if ( (type[i] == SF_C) || (type[i] == SF_S) ) {
00100         if( (temp = (char **) MALLOC(nrow*ncol*sizeof(char **)))==NULL) return MEM_LACK;
00101         k=0;
00102         for (j=0;j<nrow;j++) temp[k++]=data[i+ncol*j].s;
00103         CreateVarFromPtr(++iarg, "S", &nrow, &one, temp);
00104         FREE(temp);
00105         /*for (j=0;j<nrow;j++) FREE(data[i+ncol*j].s);*/ 
00106       }
00107       else {
00108         CreateVar(++iarg, "d", &nrow, &one, &l);
00109         for ( j=0 ; j < nrow ; j++) 
00110           *stk(l+j)= data[i+ncol*j].d;
00111       }
00112 
00113       LhsVar(i+2)=iarg;
00114     }
00115     /*FREE(data);*/
00117   Complete:
00118     for ( i = ncol+2; i <= Lhs ; i++) 
00119       {
00120         iarg++;
00121         CreateVar(iarg,"d",&zero,&zero,&l);
00122         LhsVar(i) = iarg;
00123       }
00124   }
00125   else {/* Lhs==1 */
00126     char *ltype="cblock";
00127     int multi=0,endblk,ii,n;
00128 
00129     cur_type=type[0];
00130     
00131     for (i=0;i<ncol;i++)
00132       if (type[i] != cur_type)  {
00133         multi=1;
00134         break;
00135       }
00136     if (multi) {
00137       i=strlen(ltype);
00138       iarg=Rhs;
00139       CreateVarFromPtr(++iarg, "c", &one, &i, &ltype); /* the mlist type field */
00140       cur_type=type[0];
00141       i=0;cur_i=i;
00142 
00143       while (1) {
00144         if (i < ncol)  
00145           endblk=(type[i] != cur_type);
00146         else
00147           endblk=1;
00148         if (endblk) {
00149           colcount=i - cur_i;
00150           if (nrow==0) {
00151             CreateVar(++iarg, "d", &zero, &zero, &l);}
00152           else if ( (cur_type == SF_C) || (cur_type == SF_S) ) {
00153             if( (temp = (char **) MALLOC(nrow*colcount*sizeof(char **)))==NULL) return MEM_LACK;
00154             k=0;
00155             for (i1=cur_i;i1<i;i1++)
00156               for (j=0;j<nrow;j++) temp[k++]=data[i1+ncol*j].s;
00157             CreateVarFromPtr(++iarg, "S", &nrow, &colcount,temp);
00158             FREE(temp);
00159             /*for (i1=cur_i;i1<i;i1++)
00160               for (j=0;j<nrow;j++) FREE(data[i1+ncol*j].s);*/
00161           }
00162           else {
00163             CreateVar(++iarg, "d", &nrow, &colcount, &l);
00164             ii=0;
00165             for (i1=cur_i;i1<i;i1++) {
00166               for ( j=0 ; j < nrow ; j++) 
00167                 *stk(l+j+nrow*ii)= data[i1+ncol*j].d;
00168               ii++;
00169             }
00170           }
00171           if (i>=ncol) break;
00172           cur_i=i;
00173           cur_type=type[i];
00174 
00175         }
00176         i++;
00177       }
00178       n=iarg-Rhs; /* number of list fields*/
00179       
00180       iarg++;
00181       i=Rhs+1;
00182       C2F(mkmlistfromvars)(&i,&n);
00183       LhsVar(1)=i;
00184     }
00185     else {
00186       if (nrow==0) {
00187         CreateVar(Rhs+1, "d", &zero, &zero, &l);}
00188       else if ( (cur_type == SF_C) || (cur_type == SF_S) ) {
00189         if( (temp = (char **) MALLOC(nrow*ncol*sizeof(char **)))==NULL) return MEM_LACK;
00190         k=0;
00191         for (i1=0;i1<ncol;i1++)
00192           for (j=0;j<nrow;j++) temp[k++]=data[i1+ncol*j].s;
00193         CreateVarFromPtr(Rhs+1, "S", &nrow, &ncol, temp);
00194         FREE(temp);
00195         /*for (i1=0;i1<ncol;i1++)
00196           for (j=0;j<nrow;j++) FREE(data[i1+ncol*j].s);*/
00197       }
00198       else {
00199         CreateVar(Rhs+1, "d", &nrow, &ncol, &l);
00200         ii=0;
00201         for (i1=0;i1<ncol;i1++) {
00202           for ( j=0 ; j < nrow ; j++) 
00203             *stk(l+j+nrow*ii)= data[i1+ncol*j].d;
00204           ii++;
00205         }
00206       }
00207     }
00208     LhsVar(1)=Rhs+1;
00209   }
00210   PutLhsVar();
00211   return 0;
00212 }

Here is the call graph for this function:

int NumTokens __PARAMS ( (char *string) )

Definition at line 12 of file fileio.c.

00013 {
00014   char buf[128];
00015   int n=1;
00016   int lnchar=0,ntok=-1;
00017   int length = strlen(string)+1;
00018 
00019   if (string != 0)
00020         { 
00022     sscanf(string,"%*[ \t\n]%n",&lnchar);
00023     while ( n != 0 && n != EOF && lnchar <= length  )
00024                 { 
00025                         int nchar1=0,nchar2=0;
00026                         ntok++;
00027                         n= sscanf(&(string[lnchar]),"%[^ \n\t]%n%*[ \t\n]%n",buf,&nchar1,&nchar2);
00028                         lnchar += (nchar2 <= nchar1) ? nchar1 : nchar2 ;
00029                 }
00030 
00031     return(ntok);
00032   }
00033   return(FAIL);
00034 }

int StringConvert ( char * str )

Definition at line 38 of file fileio.c.

References count, and str1.

Referenced by __PARAMS(), C2F(), int_objfprintfMat(), int_objfscanf(), int_objfscanfMat(), and int_objnumTokens().

00040 {
00041   char *str1;
00042   int count=0;
00043   str1 = str;
00044   
00045   while ( *str != 0) 
00046     {
00047       if ( *str == '\\' ) 
00048         {
00049           switch ( *(str+1)) 
00050             {
00051             case 'n' : *str1 = '\n' ; str1++; str += 2;count++;break;
00052             case 't' : *str1 = '\t' ; str1++; str += 2;break;
00053             case 'r' : *str1 = '\r' ; str1++; str += 2;break;
00054             default : *str1 = *str; str1++; str++;break;
00055             }
00056         }
00057       else 
00058         {
00059           *str1 = *str; str1++; str++;
00060         }
00061     }
00062   *str1 = '\0';
00063   return count;
00064 }

Here is the caller graph for this function:


Functions
int NumTokens	__PARAMS ((char *string))
int	StringConvert (char *str)
int Sci_Store	__PARAMS ((int nrow, int ncol, entry data, sfdir type, int retval_s))
int Store_Scan	__PARAMS ((int nrow, int ncol, sfdir type_s, sfdir type, int retval, int retval_s, rec_entry buf, entry *data, int rowcount, int n))
void Free_Scan	__PARAMS ((int nrow, int ncol, sfdir type_s, entry *data))
int SciStrtoStr	__PARAMS ((int Scistring, int nstring, int ptrstrings, char *strh))

fileio.c File Reference

Functions

Function Documentation