Пример #1
0
/*********************************************************************
 *   Function:        double *SfHKL( sf, index, error )
 *
 *   Description:    Reads '#Q' line.
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Poiter to a 3x1 dbl. array( HKL[0]=HKL[H]=H_value,
 *                            HKL[1]=HKL[K]=K_value,
 *                            HKL[2]=HKL[L]=L_value.
 *            NULL => errors.
 *
 *   Possible errors:
 *            SF_ERR_LINE_EMPTY
 *            SF_ERR_FILE_READ
 *            SF_ERR_SCAN_NOT_FOUND
 *            SF_ERR_LINE_NOT_FOUND
 *            SF_ERR_MEMORY_ALLOC    | => mulstrtod()
 *
 *   Remark:  The memory allocated should be freed by the application
 *
 *********************************************************************/
DllExport double *
SfHKL( SpecFile *sf, long index, int *error )
{
     char        *line=NULL;
     double      *HKL = NULL;
     long         i;

     if ( sfSetCurrent(sf,index,error) == -1 )
          return((double *)NULL);

     if ( sfGetHeaderLine( sf, FROM_SCAN, SF_RECIP_SPACE, &line, error) == -1 )
          return((double *)NULL);

     /*
      * Convert into double .
      */
     i = mulstrtod( line, &HKL, error );
     free(line);

     if ( i < 0)
         return( (double *)NULL );

     if ( i != 3 ) {
        *error = SF_ERR_LINE_EMPTY;
         free( HKL );
         return( (double *)NULL );
     }

     return( HKL );
}
Пример #2
0
/*********************************************************************
 *   Function:        char *SfUser( sf, index, error )
 *
 *   Description:    Gets spec user information from the last file header
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            User.(From 1st #C line !)
 *   Possible errors:
 *            SF_ERR_MEMORY_ALLOC    ||=>  findWordInLine()
 *            SF_ERR_LINE_NOT_FOUND    |
 *            SF_ERR_FILE_READ    |
 *            SF_ERR_SCAN_NOT_FOUND    | =>  getFirstFileC()
 *            SF_ERR_HEADER_NOT_FOUND    |
 *            SF_ERR_USER_NOT_FOUND
 *
 *********************************************************************/
DllExport char *
SfUser( SpecFile *sf, long index, int *error )
{

     char        *line=NULL;
     char        *user;
     char         word[] = "User =";

     if (sfSetCurrent(sf,index,error) == -1)
          return((char *)NULL);

     if (sfGetHeaderLine( sf, FROM_FILE, SF_COMMENT, &line, error) == -1)
          return((char *)NULL);

     /*
      * Find user.
      */
     user = sfFindWord( line, word, error );

     if ( user == (char *) NULL) {
        *error = SF_ERR_USER_NOT_FOUND;
         return((char *)NULL);
     }

     free(line);
     return( user );
}
Пример #3
0
/*********************************************************************
 *   Function:        long SfNoMca( sf, index, error )
 *
 *   Description:    Gets number of mca spectra in a scan
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Number of data lines ,
 *            ( -1 ) => errors.
 *   Possible errors:
 *            SF_ERR_SCAN_NOT_FOUND
 *
 *********************************************************************/
DllExport long
SfNoMca( SpecFile *sf, long index, int *error )
{

     if (sfSetCurrent(sf,index,error) == -1 )
             return(-1);

     return( ((SpecScan *)sf->current->contents)->mcaspectra );

}
Пример #4
0
/*********************************************************************
 *   Function:        long SfNoHeaderBefore( sf, index, error )
 *
 *   Description:    Gets number of scan header lines before data.
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Scan index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Number of scan header lines before data ,
 *            ( -1 ) => errors.
 *   Possible errors:
 *            SF_ERR_SCAN_NOT_FOUND
 *
 *********************************************************************/
DllExport long
SfNoHeaderBefore( SpecFile *sf, long index, int *error )
{
     if ( sfSetCurrent(sf,index,error) == -1 )
          return(-1);

    /*
     * Obsolete... give some reasonable!
     */
     return(-1);
}
Пример #5
0
/*********************************************************************
 *   Function:        char SfFileDate( sf, index, error )
 *
 *   Description:     Gets date from the last file header
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *                   (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Date.(From #D line !)
 *            NULL => errors.
 *
 *   Possible errors:
 *            SF_ERR_MEMORY_ALLOC   | => readHeader()
 *            SF_ERR_LINE_NOT_FOUND
 *            SF_ERR_LINE_EMPTY
 *            SF_ERR_FILE_READ
 *            SF_ERR_HEADER_NOT_FOUND
 *            SF_ERR_SCAN_NOT_FOUND
 *
 *********************************************************************/
DllExport char *
SfFileDate( SpecFile *sf, long index, int *error )
{
     char   *date = NULL;

     if ( sfSetCurrent(sf,index,error) == -1 )
          return((char *)NULL);

     if ( sfGetHeaderLine(sf,FROM_FILE,SF_DATE,&date,error) == -1 )
          return((char *)NULL);

     return( date );
}
Пример #6
0
/*********************************************************************
 *   Function:        char *SfDate( sf, index, error )
 *
 *   Description:    Gets date from scan header
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Date.(From #D line !),
 *            NULL => errors.
 *   Possible errors:
 *            SF_ERR_MEMORY_ALLOC    | => readHeader()
 *            SF_ERR_LINE_NOT_FOUND
 *            SF_ERR_FILE_READ
 *            SF_ERR_SCAN_NOT_FOUND
 *
 *   Remark:  The memory allocated should be freed by the application
 *
 *********************************************************************/
DllExport char *
SfDate(SpecFile *sf, long index, int *error )
{
     char        *line=NULL;

     if ( sfSetCurrent(sf,index,error) == -1 )
          return(line);

     if ( sfGetHeaderLine( sf, FROM_SCAN, SF_DATE, &line, error))
          return((char *)NULL);

     return( line );
}
Пример #7
0
DllExport long     
SfFileHeader ( SpecFile *sf, long index, char *string, char ***lines, int *error) 
{
     char   *headbuf,
            *endheader;

     if (sfSetCurrent(sf,index,error) == -1)
          return(-1);

     headbuf   = sf->filebuffer;
     endheader = sf->filebuffer + sf->filebuffersize;

     return(sfFindLines(headbuf,endheader,string,lines,error));
}
Пример #8
0
/*********************************************************************
 *   Function:        long SfNoColumns( sf, index, error )
 *
 *   Description:    Gets number of columns in a scan
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Number of scan columns.(From #N line !)
 *            ( -1 ) if errors occured.
 *   Possible errors:
 *            SF_ERR_MEMORY_ALLOC    | => readHeader()
 *            SF_ERR_LINE_NOT_FOUND
 *            SF_ERR_FILE_READ
 *            SF_ERR_SCAN_NOT_FOUND
 *
 *********************************************************************/
DllExport long
SfNoColumns( SpecFile *sf, long index, int *error )
{
     long   col = -1;
     char  *buf=NULL;

     if ( sfSetCurrent(sf,index,error) == -1)
          return(-1);

     if ( sfGetHeaderLine( sf, FROM_SCAN, SF_COLUMNS, &buf, error) == -1)
          return(-1);
     col   = atol( buf );
     free(buf);
     return( col );
}
Пример #9
0
/*********************************************************************
 *   Function:        long SfTitle( sf, index, error )
 *
 *   Description:    Gets spec title information from the last file header
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            Title.(From 1st #C line !)
 *            NULL => errors.
 *   Possible errors:
 *            SF_ERR_LINE_EMPTY
 *            SF_ERR_MEMORY_ALLOC
 *            SF_ERR_LINE_NOT_FOUND    |
 *            SF_ERR_FILE_READ    |
 *            SF_ERR_SCAN_NOT_FOUND    | =>  getFirstFileC()
 *            SF_ERR_HEADER_NOT_FOUND    |
 *
 *********************************************************************/
DllExport char *
SfTitle( SpecFile *sf, long index, int *error )
{
     char        *line=NULL;
     char        *title;
     char        *ptr;
     long         i;

     if (sfSetCurrent(sf,index,error) == -1)
          return((char *)NULL);

     if (sfGetHeaderLine( sf, FROM_FILE, SF_COMMENT, &line, error) == -1)
          return((char *)NULL);

     /*
      * Get title.( first word )
      */
     ptr = line;

     for ( i=0,ptr=line ; *ptr!='\t' && *ptr!='\n' && *ptr!='\0' ; i++ ) {
        if ( *ptr==' ' ) {
              if ( *(++ptr)==' ' ) {
                 break;
              } else ptr--;
        }
        ptr++;
     }

     if ( i==0 ) {
      *error = SF_ERR_LINE_EMPTY;
       return( (char *)NULL );
     }

     title = (char *)malloc( sizeof(char) * ( i+1 ) );

     if ( title == (char *)NULL ) {
       *error = SF_ERR_MEMORY_ALLOC;
        return( title );
     }

     memcpy( title, line, sizeof(char) * i  );
     /* Next line added by Armando, it may be wrong */
     free(line);
     title[i] = '\0';

     return( title );
}
Пример #10
0
/*********************************************************************
 *   Function:        long SfEpoch( sf, index, error )
 *
 *   Description:     Gets epoch from the last file header.
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *                   (2) Index
 *        Output:
 *                   (3) error number
 *   Returns:
 *            Epoch.(From #E line !)
 *            ( -1 ) if errors occured.
 *   Possible errors:
 *            SF_ERR_MEMORY_ALLOC    | => readHeader()
 *            SF_ERR_LINE_NOT_FOUND
 *            SF_ERR_FILE_READ
 *            SF_ERR_HEADER_NOT_FOUND
 *            SF_ERR_SCAN_NOT_FOUND
 *
 *********************************************************************/
DllExport long
SfEpoch( SpecFile *sf, long index, int *error )
{
     char   *buf=NULL;
     long   epoch = -1;

     if ( sfSetCurrent(sf,index,error) == -1 )
          return(-1);

     if ( sfGetHeaderLine(sf,FROM_FILE,SF_EPOCH,&buf,error) == -1 )
          return(-1);

     epoch  = atol( buf );
     free(buf);

     return( epoch );
}
Пример #11
0
DllExport char *
SfMotor( SpecFile *sf, long index, long motnum, int *error )
{

     char   **motors=NULL;
     long     nb_mot;
     char    *motor=NULL;
     long     selection;

    /*
     * go to scan
     */
     if (sfSetCurrent(sf,index,error) == -1) {
          return((char *)NULL);
     }

     if ( sf->no_motor_names != -1 ) {
        nb_mot = sf->no_motor_names;
     } else {
        nb_mot = SfAllMotors(sf,index,&motors,error);
     }

     if (nb_mot == 0 || nb_mot == -1)  return((char *)NULL);

     if ( motnum < 0 ) {
           selection = nb_mot + motnum;   
     } else {
           selection = motnum - 1;
     }

     if (selection < 0 || selection > nb_mot - 1 ) {
         *error = SF_ERR_COL_NOT_FOUND;
          if (motors != (char **) NULL)
              freeArrNZ((void ***)&motors,nb_mot);
          return((char *)NULL);
     }

     if (motors != (char **) NULL) {
         motor = (char *)strdup(motors[selection]);
         freeArrNZ((void ***)&motors,nb_mot);
     } else {
         motor = (char *)strdup(sf->motor_names[selection]);
     }
     return( motor );
}
Пример #12
0
DllExport void
SfShowScan      (SpecFile *sf, long index) {
     int       error;
     SpecScan *scan;

     printf("<Showing Info>  - specfile: %s / idx %ld\n",sf->sfname,index);

     if (sfSetCurrent(sf,index,&error) == -1) {
         printf("Cannot get scan index %ld\n",index);
     }

     scan = (SpecScan *) sf->current->contents;

     printf("     - index:         %ld\n",scan->index);
     printf("     - scan_no:       %ld\n",scan->scan_no);
     printf("     - offset:        %ld\n",scan->offset);
     printf("     - data_offset:   %ld\n",scan->data_offset);
}
Пример #13
0
DllExport double
SfMotorPos( SpecFile *sf, long index, long motnum, int *error )
{

     double  *motorpos=NULL;
     long     nb_mot;
     double   retpos;
     long     selection;

     if (sfSetCurrent(sf,index,error) == -1)
          return(HUGE_VAL);

     if (sf->no_motor_pos != -1 ) {
       nb_mot = sf->no_motor_pos;
     } else {
       nb_mot = SfAllMotorPos(sf,index,&motorpos,error);
     }

     if (nb_mot == 0 || nb_mot == -1)  return(HUGE_VAL);

     if ( motnum < 0 ) {
           selection = nb_mot + motnum;   
     } else {
           selection = motnum - 1;
     }

     if (selection < 0 || selection > nb_mot - 1 ) {
         *error = SF_ERR_COL_NOT_FOUND;
          if (motorpos != (double *)NULL) 
              free(motorpos);
          return(HUGE_VAL);
     }

     if (motorpos != (double *)NULL) {
         retpos = motorpos[selection];
         free(motorpos);
     } else {
         retpos = sf->motor_pos[selection];
     }
     return( retpos );
}
Пример #14
0
/*********************************************************************
 *   Function:		char *SfLabel( sf, index, column, error )
 *
 *   Description:	Reads one label.
 *
 *   Parameters:
 *		Input :	(1) SpecScan pointer
 *			(2) Scan index
 *			(3) Column number
 *		Output:	(4) Error number 
 *   Returns:
 *			Pointer to the label ,
 *			or NULL if errors occured.			
 *   Possible errors:
 *			SF_ERR_MEMORY_ALLOC	| => getStrFromArr()
 *			SF_ERR_LABEL_NOT_FOUND
 *			SF_ERR_LINE_EMPTY	|
 *			SF_ERR_LINE_NOT_FOUND	|
 *			SF_ERR_SCAN_NOT_FOUND	| => SfAllLabels()
 *			SF_ERR_FILE_READ	|
 *
 *   Remark:  The memory allocated should be freed by the application
 *
 *********************************************************************/
DllExport char *
SfLabel( SpecFile *sf, long index, long column, int *error )
{

     char   **labels=NULL;
     long     no_labels;
     char    *label=NULL;
     long     selection;

     if (sfSetCurrent(sf,index,error) == -1)
          return((char *)NULL);

     if (sf->no_labels != -1 ) {
        no_labels = sf->no_labels;
     } else {
        no_labels = SfAllLabels(sf,index,&labels,error);
     }

     if (no_labels == 0 || no_labels == -1)  return((char *)NULL);

     if ( column < 0 ) {
           selection = no_labels + column;   
     } else {
           selection = column - 1;
     }

     if (selection < 0 || selection > no_labels - 1 ) {
         *error = SF_ERR_COL_NOT_FOUND;
          if (labels != (char **) NULL )
              freeArrNZ((void ***)&labels,no_labels);
          return((char *)NULL);
     }

     if (labels != (char **)NULL) {
         label = (char *)strdup(labels[selection]);
         freeArrNZ((void ***)&labels,no_labels);
     } else {
         label = (char *) strdup(sf->labels[selection]);
     }
     return( label );
}
Пример #15
0
DllExport long
SfHeader ( SpecFile *sf, long index, char *string, char ***lines, int *error)
{
     char   *headbuf,
            *endheader;

     long nb_found;

     if (sfSetCurrent(sf,index,error) == -1)
          return(-1);

     headbuf   = sf->scanbuffer;
     endheader = sf->scanbuffer + sf->scansize;

     nb_found = sfFindLines(headbuf, endheader,string, lines,error);

     if (nb_found == 0) {
          return SfFileHeader(sf,index,string,lines,error);
     } else {
          return nb_found;
     }
}
Пример #16
0
DllExport double 
SfMotorPosByName( SpecFile *sf, long index, char *name, int *error )
{
     char **motors=NULL;

     long  nb_mot,
           idx,
           selection;
     short tofree=0;

     if (sfSetCurrent(sf,index,error) == -1)
          return(HUGE_VAL);

     if ( sf->no_motor_names != -1 ) {
        nb_mot = sf->no_motor_names;
        motors = sf->motor_names;
     } else {
        nb_mot = SfAllMotors(sf,index,&motors,error);
        tofree=1;
     }

     if (nb_mot == 0 || nb_mot == -1)  return(HUGE_VAL);

     for (idx = 0;idx<nb_mot;idx++) {
         if (!strcmp(name,motors[idx])) break;
     }

     if (idx == nb_mot) {
           if (tofree) freeArrNZ((void ***)&motors,nb_mot);
          *error = SF_ERR_MOTOR_NOT_FOUND;
           return(HUGE_VAL);
     }

     selection = idx+1; 

     return(SfMotorPos(sf,index,selection,error)); 
}
Пример #17
0
/*********************************************************************
 *   Function:        char *SfCommand( sf, index, error )
 *
 *   Description:    Reads '#S' line ( without #S and scan number ).
 *
 *   Parameters:
 *        Input :    (1) File pointer
 *            (2) Index
 *        Output:
 *            (3) error number
 *   Returns:
 *            String pointer,
 *            NULL => errors.
 *   Possible errors:
 *            SF_ERR_MEMORY_ALLOC
 *            SF_ERR_FILE_READ
 *            SF_ERR_SCAN_NOT_FOUND
 *            SF_ERR_LINE_NOT_FOUND
 *
 *   Remark:  The memory allocated should be freed by the application
 *
 *********************************************************************/
DllExport char *
SfCommand( SpecFile *sf, long index, int *error )
{
     char    *ret_line=NULL;
     long     cnt,start,length;
     char    *ptr;

     /*
      * Choose scan
      */
     if (sfSetCurrent(sf,index,error) == -1)
          return(ret_line);

     cnt = 3;
     for ( ptr = sf->scanbuffer + cnt; *ptr != ' ' ; ptr++,cnt++);
     for ( ptr = sf->scanbuffer + cnt; *ptr == ' ' || *ptr == '\t'; ptr++,cnt++);

     start = cnt;
     for ( ptr = sf->scanbuffer + cnt; *ptr != '\n' ; ptr++,cnt++);

     length = cnt - start;

     /*
      * Return the rest .
      */
     ret_line = (char *) malloc ( sizeof(char) * ( length + 1) );
     if (ret_line == (char *)NULL) {
          *error = SF_ERR_MEMORY_ALLOC;
          return(ret_line);
     }

     ptr = sf->scanbuffer + start;
     memcpy(ret_line,ptr,sizeof(char) * length );
     ret_line[length] = '\0';

     return( ret_line );
}
Пример #18
0
DllExport long   
SfAllMotorPos ( SpecFile *sf, long index, double **retpos, int *error )
{
     char **lines;
     char  *thisline,
           *endline;

     double *posarr;

     static double pos[200];
     static char   posstr[40];

     char  *ptr;

     long      motct = 0;
     long      no_lines;
     short     i,j;

#ifndef _GNU_SOURCE
#ifdef PYMCA_POSIX
	char *currentLocaleBuffer;
	char localeBuffer[21];
#endif
#endif

     if (sfSetCurrent(sf,index,error) == -1) {
         *retpos = (double *) NULL;
          return(0);
     }

    /*
     * if motors position for this scan have already been read
     */
     if (sf->motor_pos != (double *)NULL) {
         posarr = (double *)malloc(sizeof(double) * sf->no_motor_pos);
         for (i=0;i<sf->no_motor_pos;i++) {
             posarr[i] = sf->motor_pos[i];
         }
        *retpos = posarr;
         return(sf->no_motor_pos);
     }

    /*
     * else
     */
     no_lines =  SfHeader(sf, index,"P",&lines,error);

     if (no_lines == -1 || no_lines == 0 ) {
         *retpos = (double *) NULL;
          return(-1);
     }

     motct = 0;
#ifndef _GNU_SOURCE
#ifdef PYMCA_POSIX
	currentLocaleBuffer = setlocale(LC_NUMERIC, NULL);
	strcpy(localeBuffer, currentLocaleBuffer);
	setlocale(LC_NUMERIC, "C\0");
#endif
#endif
     for (j=0;j<no_lines;j++) {
         thisline = lines[j] + 4;
         endline  = thisline + strlen(thisline);
         for(ptr=thisline;*ptr == ' ';ptr++);
         for (i=0;ptr < endline -1;ptr++,i++) {
            if (*ptr==' ') { 
               posstr[i] = '\0';

               pos[motct]  = PyMcaAtof(posstr);

               motct++; 
               i=-1; 
               for(;*(ptr+1) == ' ' && ptr < endline -1;ptr++);
            } else {
               posstr[i] = *ptr;
            }
         }
         if (*ptr != ' ') {
            posstr[i]   = *ptr; 
            i++;
         }
         posstr[i]   = '\0';
         pos[motct]  = PyMcaAtof(posstr);

         motct++; 

	 }

#ifndef _GNU_SOURCE
#ifdef PYMCA_POSIX
	setlocale(LC_NUMERIC, localeBuffer);
#endif
#endif

     /*
      * Save in specfile structure
      */
      sf->no_motor_pos = motct;
      sf->motor_pos    = (double *)malloc(sizeof(double) * motct);
      memcpy(sf->motor_pos,pos,motct * sizeof(double));

     /*
      * and return
      */
      posarr = (double *) malloc ( sizeof(double) * motct ) ;
      memcpy(posarr,pos,motct * sizeof(double));

     *retpos = posarr;

      return( motct );
}
Пример #19
0
/*********************************************************************
 *   Function:		long SfAllLabels( sf, index, labels, error )
 *
 *   Description:	Reads all labels in #L lines
 *
 *   Parameters:
 *		Input :	(1) SpecScan pointer
 *			(2) Scan index
 *		Output:	(3) Labels  
 *			(4) Error number 
 *   Returns:
 *			Number of labels
 *			( -1 ) if error.		
 *   Possible errors:
 *			SF_ERR_MEMORY_ALLOC	||=> cpyStrArr(),lines2words()
 *			SF_ERR_SCAN_NOT_FOUND	| => SfHeader()
 *			SF_ERR_FILE_READ	|
 *			SF_ERR_LINE_EMPTY
 *			SF_ERR_LINE_NOT_FOUND
 *   Remark:  The memory allocated should be freed by the application
 *
 *********************************************************************/
DllExport long
SfAllLabels( SpecFile *sf, long index, char ***labels, int *error )
{
     static char tmplab[40];

     char **labarr;
     char  *onelabel;

     char  *ptr,
           *buf=NULL;

     long      no_labels = 0;
     short     i;
     
    /*
     * select scan
     */
     if (sfSetCurrent(sf,index,error) == -1) {
         *labels = NULL;
          return(0);
     }

    /*
     * Do not do it if already done
     */
     if (sf->labels != (char **)NULL ) {
         labarr = (char **)malloc(sizeof(char *) * sf->no_labels);
         for ( i=0;i<sf->no_labels;i++)
             labarr[i] = (char *)strdup(sf->labels[i]);
        *labels = labarr;
         return(sf->no_labels);
     }

    /*
     * else..
     */
     if (sfGetHeaderLine(sf,FROM_SCAN,SF_LABEL,&buf,error) == -1) {
         *labels = NULL;
          return(0);
     }
     
     if ( buf[0] == '\0') {
        *labels = NULL;
         return(0);
     }

     if ( (labarr = (char **)malloc( sizeof(char *))) == (char **)NULL) {
         *error = SF_ERR_MEMORY_ALLOC;
          return(-1);
     } 

     no_labels = 0;
     i = 0;

     /* 
      * avoid problem of having too many spaces at the beginning
      * with bad written macros -> added check for empty string 
      *
      *   get rid of spaces at the beginning of the string buffer
      */

     ptr = buf;
     while((ptr < buf + strlen(buf) -1) && (*ptr == ' ')) ptr++;

     for (i=0;ptr < buf + strlen(buf) -1;ptr++,i++) {
         if (*ptr==' ' && *(ptr+1) == ' ') { /* two spaces delimits one label */
             tmplab[i] = '\0';

             labarr = (char **)realloc( labarr, (no_labels+1) * sizeof(char *));
             onelabel = (char *) malloc (i+2);
             strcpy(onelabel,tmplab);
             labarr[no_labels]  = onelabel; 

             no_labels++; 
             i=-1; 
             for(;*(ptr+1) == ' ' && ptr < buf+strlen(buf)-1;ptr++);
         } else {
             tmplab[i] = *ptr;
         }
     }

     if (*ptr != ' ') {
        tmplab[i]   = *ptr; 
        i++;
     }
     tmplab[i] = '\0';

     labarr = (char **)realloc( labarr, (no_labels+1) * sizeof(char *));
     onelabel = (char *) malloc (i+2);
     strcpy(onelabel,tmplab);
     labarr[no_labels]  = onelabel; 

     no_labels++; 

    /*
     * Save in specfile structure
     */
     sf->no_labels = no_labels;
     sf->labels    = (char **) malloc( sizeof(char *) * no_labels);
     for (i=0;i<no_labels;i++)
           sf->labels[i] = (char *) strdup(labarr[i]);
    
    *labels = labarr;
     return( no_labels );
}
Пример #20
0
/*********************************************************************
 *   Function:		long SfAllMotors( sf, index, names, error )
 *
 *   Description:	Reads all motor names in #O lines (in file header)
 *
 *   Parameters:
 *		Input :	(1) SpecScan pointer
 *			(2) Scan index
 *		Output:	(3) Names  
 *			(4) Error number 
 *   Returns:
 *			Number of found names
 *			( -1 ) if errors.		
 *   Possible errors:
 *			SF_ERR_SCAN_NOT_FOUND	  
 *			SF_ERR_LINE_NOT_FOUND	
 *			SF_ERR_LINE_EMPTY	
 *			SF_ERR_MEMORY_ALLOC    || => cpyStrArr(),lines2words()
 *			SF_ERR_FILE_READ	|
 *			SF_ERR_HEADER_NOT_FOUND	| => SfFileHeader()
 *
 *   Remark:  The memory allocated should be freed by the application
 *
 *********************************************************************/
DllExport long
SfAllMotors( SpecFile *sf, long index, char ***names, int *error )
{
     char **lines;
     char  *thisline,
           *endline;

     char **motarr;
     char  *onemot;

     static char tmpmot[40];

     char  *ptr;

     long      motct = 0;
     long      no_lines;
     short     i,j;
     
    /*
     * go to scan
     */
     if (sfSetCurrent(sf,index,error) == -1) {
         *names = NULL;
          return(0);
     }

    /*
     * if motor names for this scan have already been read
     */
     if (sf->motor_names != (char **)NULL) {
         motarr = (char **)malloc(sizeof(char *) * sf->no_motor_names);
         for (i=0;i<sf->no_motor_names;i++) {
             motarr[i] = (char *) strdup (sf->motor_names[i]);
         }
        *names = motarr;
         return(sf->no_motor_names);
     }

    /*
     * else
     */
     no_lines =  SfFileHeader(sf, index,"O",&lines,error);
     if (no_lines == -1 || no_lines == 0 ) {
         *names = (char **) NULL;
          return(-1);
     }

     if ( (motarr = (char **)malloc( sizeof(char *))) == (char **)NULL) {
         *error = SF_ERR_MEMORY_ALLOC;
          return(-1);
     } 

     motct = 0;

     for (j=0;j<no_lines;j++) {
         thisline = lines[j] + 4;
         endline  = thisline + strlen(thisline);
         for(ptr=thisline;*ptr == ' ';ptr++);
         for (i=0;ptr < endline -2;ptr++,i++) {
            if (*ptr==' ' && *(ptr+1) == ' ') { 
               tmpmot[i] = '\0';

               motarr = (char **)realloc( motarr, (motct+1) * sizeof(char *));
               onemot = (char *) malloc (i+2);
               strcpy(onemot,tmpmot);
               motarr[motct]  = onemot; 

               motct++; 
               i=-1; 
               for(;*(ptr+1) == ' ' && ptr < endline -1;ptr++);
            } else {
               tmpmot[i] = *ptr;
            }
        }
        if (*ptr != ' ') { tmpmot[i]   = *ptr; i++; }
        ptr++;
        if (*ptr != ' ') { tmpmot[i]   = *ptr; i++; }

        tmpmot[i] = '\0';
        motarr = (char **)realloc( motarr, (motct+1) * sizeof(char *));

        onemot = (char *) malloc (i+2);
        strcpy(onemot,tmpmot);
        motarr[motct]  = onemot; 

        motct++; 

   }

  /*
   * Save in specfile structure
   */
   sf->no_motor_names = motct;
   sf->motor_names = (char **)malloc(sizeof(char *) * motct);
   for (i=0;i<motct;i++) {
        sf->motor_names[i] = (char *)strdup(motarr[i]);
   }

  *names = motarr;
   return( motct );

}