int_listv.c

LastWave

  }
  
  /* Otherwise we loop on the elements */
  for (i = 0;i<n;i++) {
    
    SkipCharsStream(stream,YES);  
    
    if (fscanf(stream,"type = %s",&type) != 1) Errorf("ReadListvStream() : Expect 'type' specification for element %d",i);
    SkipCharsStream(stream,NO);  
    
    
    /* Case of a string */
    if (!strcmp(type,strType)) {
      if (fscanf(stream,"size = %d",&size) != 1) Errorf("ReadListvStream() : size error while reading element %d which should be a string",i);
      SkipCharsStream(stream,NO);
      fgetc(stream);
      str = CharAlloc(size+1);
      if (size != 0 && fread(str,sizeof(char),size,stream) != size)
        Errorf("ReadListvStream() : Error while trying to read the element %d which should be a string",i);
      str[size] = '\0';  
      fgetc(stream);
      TempPtr(str);
      AppendStr2Listv(lv,str);      
    }
    
    /* Case of a number */
    else if (!strcmp(type,numType)) {
      if (!flagBinary) {
#ifdef NUMDOUBLE	
        fscanf(stream,"%lf",&g);
#else
        fscanf(stream,"%f",&g);
#endif
        AppendFloat2Listv(lv,g);
      }
      else {
        if (sizeof(float) == floatSize) {
          fread(&f,sizeof(float),1,stream);      
          if ((endmode == BinaryLittleEndian && IsCPUBigEndian) || ((endmode == BinaryBigEndian && IsCPULittleEndian)))
            BigLittleValues(&f,1,floatSize);
          AppendFloat2Listv(lv,f);  
        }
        else if (sizeof(double) == floatSize) {
          fread(&d,sizeof(double),1,stream);      
          if ((endmode == BinaryLittleEndian && IsCPUBigEndian) || ((endmode == BinaryBigEndian && IsCPULittleEndian)))
            BigLittleValues(&d,1,floatSize);
          AppendFloat2Listv(lv,(LWFLOAT) d);   
        }
        else Errorf("ReadListvStream() : sorry, do not know how to read binary numbers coded on %d bytes",floatSize);
      }
    }
    
    /* Case of a signal */
    else if (!strcmp(type,signalType) || !strcmp(type,signaliType)) {
      sig = TNewSignal();
      ReadSigStream(sig,s,-1,-1,0,0);
      AppendValue2Listv(lv,(VALUE) sig);
    }
    
    /* Case of an image */
    else if (!strcmp(type,imageType) || !strcmp(type,imageiType)) {
      im = TNewImage();
      ReadImageStream(im,s,-1,-1,NO,NO,NO,0);
      AppendValue2Listv(lv,(VALUE) im);
    }
    
    /* Case of an listv */
    else if (!strcmp(type,listvType)) {
      lv1 = TNewListv();
      ReadListvStream(lv1,s);
      AppendValue2Listv(lv,(VALUE) lv1);
    }
    
    /* Other types --> error */
    else {
      Errorf("ReadListvStream() : Invalid %dth element type '%s' : %s",i,type);  
      return;
    }
  }
}   


/*
 * Write a Listv made of strings or numbers ONLY into a column file
 *
 *   - each column will be separated by the string 'sep'
 *   - the 'formatArray' array indicates how the formatting of each column should be same syntax as printf)
 *     It must be either a NULL array (default format) or an array of size == the number of column.
 *     If a format is NULL then default foramt is used. 
 */

void CWriteListvStream(LISTV lv,STREAM s, char *sep, char **formatArray)
{
  int i,j,n,length;
  VALUE val;
  LWFLOAT f;
  char *type;
  LISTV lv1;
  SIGNAL sig;
  char *str;
  FILE *stream;
  char **typeArray,*format;
  
  /* 
   * Some basic tests on the stream 
   */
  if (s->mode != StreamWrite) Errorf("CWriteListvStream() : The stream should be an output stream and not an input stream"); 
  stream = s->stream;   
  
  if (lv->length == 0) return;
  i = 0;
  
  /* Let's check the size */
  length= -1;
  for (j=0;j<lv->length;j++) {
    if ((type = GetListvNth(lv,j,&val,&f)) == listvType) {
      lv1 = (LISTV) val;
      n = lv1->length;
    }
    else if (type == signaliType || type == signalType) {
      sig = (SIGNAL) val;
      n = sig->size;
    }
    else Errorf("CWriteListvStream() : The listv must be made of listv or signals only");
    if (length == -1) length = n;
    else if (length != n) Errorf("CWriteListvStream() : The listv/signals must have the same size");
  }
  
  /* Let's check the formatArray and convert it to a typeArray */
  if (formatArray == NULL) typeArray = NULL;
  else {
    typeArray = (char **) Malloc(sizeof(char *)*lv->length);
    TempPtr(typeArray);
    for (j=0;j<lv->length;j++) {
      if (formatArray[j] == NULL || !strcmp(formatArray[j],"")) typeArray[j] = NULL;
      else {
        
        /* Get the format main character */
        format = formatArray[j];
        if (strlen(format)<2 && format[0] != '%') Errorf("CWriteListvStream() : Bad format '%s'",format);
        format++;
        while(*format != '\0' && *format != '%' && !isalpha(*format)) format++;
        if (*format == '\0' || *format == '%') Errorf("CWriteListvStream() : Bad format '%s'",formatArray[j]);
        
        /* Case of an int */
        if (*format == 'd' || *format == 'i' || *format == 'o' ||
            *format == 'x' || *format == 'X' || *format == 'u') typeArray[j] = intType;
        
        /* Case of an double */
        else if (*format == 'f' || *format == 'e' || *format == 'E' ||
                 *format == 'g' || *format == 'G') typeArray[j] = floatType;
        
        /* Case of a string */
        else if (*format == 's') typeArray[j] = strType;
        
        /* Error */
        else Errorf("CWriteListvStream() : Bad format '%s'",formatArray[j]);
      }
    }
  }
  
  /* The loop on the lines */      
  while (1) {
    
    /* The loop on the columns */
    for (j=0;j<lv->length;j++) {
      
      /* Print separator if needed */
      if (j != 0) fprintf(stream,"%s",sep);
      
      /* Case the column is a list */
      if ((type = GetListvNth(lv,j,&val,&f)) == listvType) {
        /* Get the list and get the jth element */
        lv1 = (LISTV) val;
        type = GetListvNth(lv1,i,&val,&f);
        if (type == numType) {}
        else if (type == strType) str = GetStrFromStrValue((STRVALUE) val);
        else Errorf("CWriteListvStream() : listv must be made of floats/strings only");
      }
      
      /* case the column is a signal */
      else if (type == signaliType || type == signalType) {
        /* Get the signal and the jth element */
        sig = (SIGNAL) val;
        type = numType;
        f = sig->Y[i];
      }
      
      /*
       * case we must print a number 
       */
      if (type == numType) {
        /* Case no format specified */        
        if (typeArray == NULL || typeArray[j] == NULL || typeArray[j] == strType) {
#ifdef NUMDOUBLE      
          format = "%.16g";
#else
          format = "%.8g";
#endif
          fprintf(stream,format,f);
        }
        /* case of float */
        else if (typeArray[j] == floatType) fprintf(stream,formatArray[j],f);
        /* case of int */
#ifdef NUMDOUBLE      
        else fprintf(stream,formatArray[j],(long int) f);
#else
        else fprintf(stream,formatArray[j],(int) f);
#endif        
      }
      
      
      /*
       * case we must print a string 
       */
      else {
        if (typeArray == NULL || typeArray[j] == NULL || typeArray[j] != strType) format = "%s";
        else format = formatArray[j];
        fprintf(stream,format,str);
      }
      
    }
    
    /* Print a new line */
    fprintf(stream,"\n");
    
    /* Change line */
    i++;
    
    /* Should we stop ? */
    if (length == i) break;
  }
}


void C_Listv(char **argv)
{
  char *action,*sep,**formatArray,*type,commentChar;
  LWPROC proc;
  LISTV lv,lv1,lv2;
  LWFLOAT f;
  VALUE val;
  int j,n,i;
  char flagInverse,opt;
  char *filename;
  colType ct[300];
  int nCols;
  int first, sizeToRead,skip;
  STREAM stream;
  char flagBinary;
  char *separators;
  
  argv = ParseArgv(argv,tWORD,&action,-1);
  
  if (!strcmp(action,"map")) {
    argv = ParseArgv(argv,tLISTV,&lv,-1);
    argv = ParseArgv(argv,tPROC,&proc,0);
    lv1 = TNewListv();
    lv2 = TNewListv();
    SetLengthListv(lv2,1);
    for (j=0;j<lv->length;j++) {
      GetListvNth(lv,j,&val,&f);
      if (val) SetListvNthValue(lv2,0,val);
      else SetListvNthFloat(lv2,0,f);
      ApplyProc2Listv(proc,lv2);
      if (GetResultType() != NULL) {
        if (GetResultType() == numType) AppendFloat2Listv(lv1,GetResultFloat());
        else AppendValue2Listv(lv1,GetResultValue());
      }
    }
    SetResultValue(lv1);
    return;
  }
  
  /* sort action */
  if (!strcmp(action,"sort")) {
    argv = ParseArgv(argv,tLISTV,&lv,-1);
    argv = ParseArgv(argv,tPROC_,NULL,&proc,-1);
    flagInverse = NO;
    while(opt = ParseOption(&argv)) { 
      switch(opt) {
        case 'i': flagInverse = YES; break;
        default: ErrorOption(opt);
      }
    }    
    NoMoreArgs(argv);
    lv = SortListv(lv,proc,flagInverse);
    if (lv == NULL) Errorf1("");
    SetResultValue(lv);  
    return;  
  }
  
  /* niceprint action */
  if (!strcmp(action,"niceprint")) {
    argv = ParseArgv(argv,tLISTV,&lv,-1);
    argv = ParseArgv(argv,tINT_,0,&n,0);
    PrintListvColumn(lv,n); 
    return;
  }
  
  /* cwrite action */
  if (!strcmp(action,"cwrite")) {
    argv = ParseArgv(argv,tLISTV,&lv,-1);
    
    /* Get the stream or the filaneme */
    filename = NULL;
    argv = ParseArgv(argv,tSTREAM_,NULL,&stream,-1);
    if (stream == NULL) {
      argv = ParseArgv(argv,tSTR,&filename,-1);
      stream = OpenFileStream(filename,"w");
      if (stream == NULL) Errorf("Can't open file '%s'",filename);
    }
    
    /* options */
    sep = "\t";
    formatArray = NULL;
    while(opt = ParseOption(&argv)) { 
      switch(opt) {
        case 's': argv = ParseArgv(argv,tSTR,&sep,-1); break;
        case 'f': 
          argv = ParseArgv(argv,tLISTV,&lv2,-1); 
          formatArray = (char **) Malloc(sizeof(char*)*lv2->length);
          TempPtr(formatArray);
          for (i=0;i<lv2->length;i++) {
            type = GetListvNth(lv2,i,&val,&f);
            if (type != strType) Errorf("Bad format type '%s' (should be string)",type);
            formatArray[i] = GetStrFromStrValue((STRVALUE) val);
          }        
          if (i != lv->length) Errorf("You must specify a format for each column (there are %d)",lv->length); 
          break;
          default: ErrorOption(opt);
      }
    }    
    NoMoreArgs(argv);
    
    CWriteListvStream(lv,stream,sep,formatArray);
    if (filename != NULL) CloseStream(stream);
    
    return;
  }
  
  /* write action */
  if (!strcmp(action,"write")) {
    argv = ParseArgv(argv,tLISTV,&lv,-1);
    
    /* Get the stream or the filaneme */
    filename = NULL;
    argv = ParseArgv(argv,tSTREAM_,NULL,&stream,-1);
    if (stream == NULL) {
      argv = ParseArgv(argv,tSTR,&filename,-1);
      stream = OpenFileStream(filename,"w");
      if (stream == NULL) Errorf("Can't open file '%s'",filename);
    }
    
    /* options */
    flagBinary = YES;
    while(opt = ParseOption(&argv)) { 
      switch(opt) {
        case 'a': flagBinary = NO; break;
        default: ErrorOption(opt);
      }
    }    
    NoMoreArgs(argv);
    
    WriteListvStream(lv,stream,flagBinary);
    
    if (filename != NULL) CloseStream(stream);
    
    return;
  }
  
  /* cread action */
  if (!strcmp(action,"cread")) {
    
    /* Get the stream or the filaneme */
    filename = NULL;
    argv = ParseArgv(argv,tSTREAM_,NULL,&stream,-1);
    if (stream == NULL) {
      argv = ParseArgv(argv,tSTR,&filename,-1);
      stream = OpenFileStream(filename,"r");
      if (stream == NULL) Errorf("Can't open file '%s'",filename);
    }
    
    nCols = 0;
    while (*argv != NULL) {
      if (!strcmp(*argv,"x")) ct[nCols++] = skipCol;
      else if (!strcmp(*argv,"s")) ct[nCols++] = strCol;
      else if (!strcmp(*argv,"f")) ct[nCols++] = numCol;
      else if (!strcmp(*argv,"F")) ct[nCols++] = signalCol;
      else if (!strcmp(*argv,"?")) ct[nCols++] = bestCol;
      else break;
      argv++;
    }
    
    if (nCols == 0) ErrorUsage();
    
    /* options */
    skip = 0;
    first = 0;
    sizeToRead = -1;
    commentChar = 0;
    separators = " \t";
    while(opt = ParseOption(&argv)) { 
      switch(opt) {
        case 'c': argv = ParseArgv(argv,tCHAR,&commentChar,-1); break;
        case 's': argv = ParseArgv(argv,tINT,&skip,-1); break;
        case 'f': argv = ParseArgv(argv,tINT,&first,-1); break;
        case 'n': argv = ParseArgv(argv,tINT,&sizeToRead,-1); break;
        case 'S': argv = ParseArgv(argv,tSTR,&separators,-1); break;
        default: ErrorOption(opt);
      }
    }    
    
    NoMoreArgs(argv);
    
    lv = TNewListv();
    
    CReadListvStream(lv,stream,nCols,ct,skip,first,sizeToRead,commentChar,separators);
    
    if (filename != NULL) CloseStream(stream);
    
    SetResultValue(lv);
    
    return;
  }
  
  /* read action */
  if (!strcmp(action,"read")) {
    
    /* Get the stream or the filaneme */
    filename = NULL;
    argv = ParseArgv(argv,tSTREAM_,NULL,&stream,-1);
    if (stream == NULL) {
      argv = ParseArgv(argv,tSTR,&filename,-1);
      stream = OpenFileStream(filename,"r");
      if (stream == NULL) Errorf("Can't open file '%s'",filename);
    }
    NoMoreArgs(argv);
    
    lv = TNewListv();
    
    ReadListvStream(lv,stream);
    if (filename != NULL) CloseStream(stream);
    
    SetResultValue(lv);
    
    return;
  }
  
  Errorf("Bad action '%s'",action);
}


/*
 * 'tosignal' field
 */

static char *tosignalDoc = "{} {Gets a signal made from a listv of numbers only}";

static void * GetTosignalListvV(LISTV lv, void **arg)
{
  SIGNAL sig;
  int i;
  
  /* Documentation */
  if (lv == NULL) return(tosignalDoc);
  
  sig = TNewSignal();
  SizeSignal(sig,lv->length,YSIG);
  
  for (i=0;i<lv->length;i++) {
    if (lv->values[i] == NULL) sig->Y[i] = lv->f[i];
    else if (GetTypeValue(lv->values[i]) != numType) {
      SetErrorf("A listv must contain only numbers to be converted to a signal");
      return(NULL);
    }
    else sig->Y[i] = CastValue(lv->values[i],NUMVALUE)->f;
  }
  
  return(GetValueField(sig,arg));
}


/*
 * The field list
 */
struct field fieldsListv[] = {
  
  "", GetExtractListvV, SetExtractListvV, GetExtractOptionsListvV, GetExtractInfoListvV,
  "length", GetLengthListvV, SetLengthListvV, NULL, NULL,
  "size", GetLengthListvV, SetLengthListvV, NULL, NULL,
  "nAlloc", GetNAllocListvV, NULL, NULL, NULL,
  "tosignal", GetTosignalListvV, NULL, NULL, NULL,
  
  NULL, NULL, NULL, NULL, NULL
};



/*
 * The type structure for LISTV
 */

TypeStruct tsListv = {
  
  "{{{&listv} {This type corresponds to list of values. \n \
  - ==,!= : test equality of all the elements \n \
  - Operator * : listv*n, repetition of the listv n times \n \
  - Operator + : listv+listv, Appending 2 listv \n \
  - Operator + : listv+value, (where value is not a listv), adding the value at the end of the listv  \n \
  - Constructor : syntax {value1 ... valueN}.}}}",  /* Documentation */
  
  &listvType,       /* The basic (unique) type name */
  NULL,     /* The GetType function */                       
  
  DeleteListv,     /* The Delete function */
  NewListv,     /* The New function */
  
  CopyListv,       /* The copy function */
  ClearListv,       /* The clear function */
  
  ToStrListv,       /* String conversion */
  PrintListv,   /* The Print function : print the object when 'print' is called */
  PrintInfoListv,   /* The PrintInfo function : called by 'info' */
  
  NULL,              /* The NumExtract function : used to deal with syntax like 10a */
  
  fieldsListv,      /* The list of fields */
};