int_expr.c

LastWave

    if (!strncmp(begin,*op,*opSize) && !IsValidSymbolChar(begin[*opSize])) break; 
  }
  opIndex = op-opArray4+1;
    
  if (*op != NULL) {    

    /* Check some types */
    if (!(flagType & SignalType)) {
      SetErrorf("Expecting a signal !");
      Clean(*resVC);
      return(0);
    }

    /* Skip operator */ 
    begin2= begin; 
    begin  += *opSize; 
    ParamSkipSpace(begin);
    *left = begin;

    /* Check '(' */
    if (*begin != '(') {
      *left = begin;
      SetErrorf("Missing a parenthesis '('");
      Clean(*resVC);
      return(0);
    }
    begin1 = begin;
    begin++;
    *left = begin;
    
    /* Get first argument */
    oldFlagSpace = defParam->flagSpace;
    defParam->flagSpace = YES;
    oldFlagEmptySI = defParam->flagEmptySI;
    defParam->flagEmptySI = NO;
    if (!(r1=TTExpr1(begin,left,resFlt,resVC,SignalType | RangeType,defParam))) return(0);
    defParam->flagEmptySI = oldFlagEmptySI;

    vc1 = *resVC;
   
    /* Read 'op(expr0_Sig,expr0_Sig)' */
    begin = *left;
    if (*begin != ',') {
      SetErrorf("Missing a comma ','");
      Clean(*resVC);
      return(0);
    }
    s1 = NULL;
    rg1 = NULL;
    if (r1 == SignalType) {s1 = (SIGNAL) vc1; size1 = s1->size;}
    else {rg1 = (RANGE) vc1; size1 = rg1->size;}
    begin++;
    *left = begin;
        
    /* Get second argument */
    SetDefaultX(defParam,vc1);
    vc2 = NULL;
    oldFlagEmptySI = defParam->flagEmptySI;
    defParam->flagEmptySI = NO;
    if (!(r2 = TTExpr1(begin,left,&f2,&vc2,SignalType | RangeType,defParam))) {
      Clean(*resVC);
      return(0);
    }
    defParam->flagEmptySI = oldFlagEmptySI;
    SetDefaultX(defParam,NULL);
    s2 = NULL;
    rg2 = NULL;
    if (r2 == SignalType) {s2 = (SIGNAL) vc2; size2 = s2->size;}
    else {rg2 = (RANGE) vc2;  size2 = rg2->size;}
    if (size1 != size2) {
      *left = begin2;
      SetErrorf("Signals/Ranges have different size");
      Clean(vc1);
      Clean(vc2);
      *resVC = NULL;
      return(0);
    }

    /* Closing parenthesis */
    if (**left != ')') {
      SetErrorf("Expecting a parenthesis ')'"); 
      Clean(vc1);
      Clean(vc2);
      *resVC = NULL;
      return(0);
    }
    (*left)++;
    begin = (*left);

    defParam->flagSpace = oldFlagSpace;

    s3 = TNewSignal();
    if (rg1 && rg1->step > 0) {
      SizeSignal(s3,rg1->size,YSIG);
      if (s2) for (j=0;j<rg1->size;j++) {s3->Y[j] = s2->Y[j];}
      else  for (j=0;j<rg1->size;j++) {s3->Y[j] = RangeVal(rg2,j);}
      s3->dx = rg1->step;
      s3->x0 = rg1->first;
    }
    else {
      SizeSignal(s3,size1,XYSIG);
      if (rg1  && s2) for (j=0;j<rg1->size;j++) {s3->X[j] = RangeVal(rg1,j);s3->Y[j] = s2->Y[j];}
      else if (rg1  && rg2) for (j=0;j<rg1->size;j++) {s3->X[j] = RangeVal(rg1,j);s3->Y[j] = RangeVal(rg2,j);}
      else if (s1 && rg2) for (j=0;j<s1->size;j++) {s3->X[j] = s1->Y[j];s3->Y[j] = RangeVal(rg2,j);}
      else  for (j=0;j<s1->size;j++) {s3->X[j] = s1->Y[j];s3->Y[j] = s2->Y[j];}
    }
    Clean(vc1);
    Clean(vc2);
    *resVC = (VALUE) s3;
    if (s3->type == XYSIG) SortSig(s3);
    return(SignalType);
  }
             

  /***********************************************************
   * 
   * Operators "X","der","prim"
   * 
   * 'op(expr0_Sig)'
   *
   ***********************************************************/

  /* Fifth array */
  arrayIndex = 5;
  for (op = opArray5, opSize = opSizeArray5 ;;op++,opSize++) {                                                         
    if (*op == NULL) break; 
    if (!strncmp(begin,*op,*opSize) && !IsValidSymbolChar(begin[*opSize])) break; 
  }
  opIndex = op-opArray5+1;
    
  if (*op != NULL && (opIndex != 1 || begin[*opSize] == '(')) {    

    /* Check some types */
    if (!(flagType & SignalType)) {
      SetErrorf("Not expecting a signal");
      Clean(*resVC);
      return(0);
    }

    /* Skip operator */ 
    begin2= begin; 
    begin  += *opSize; 
    ParamSkipSpace(begin);
    *left = begin;

    /* Check '(' */
    if (*begin != '(') {
      SetErrorf("Missing a parenthesis '('");
      Clean(*resVC);
      return(0);
    }
    begin1= begin; 
    begin++;
    *left = begin;
    
    /* Get argument */
    oldFlagSpace = defParam->flagSpace;
    defParam->flagSpace = YES;
    oldFlagEmptySI = defParam->flagEmptySI;
    defParam->flagEmptySI = NO;
    if (!(r=TTExpr1(begin,left,resFlt,resVC,SignalType | RangeType,defParam))) return(0);
    defParam->flagEmptySI = oldFlagEmptySI;

    /* Closing parenthesis of op(expr0_Int) */
    if (**left != ')') {
      SetErrorf("Expecting a parenthesis ')'"); 
      Clean(*resVC);
      return(0);
    }
    (*left)++;
    begin = (*left);
    
    defParam->flagSpace = oldFlagSpace;

    /* Set output */
    if (opIndex != 1 && opIndex != 4) TTSetOutput1(r,*resVC,&vc3);
    else if (opIndex == 1) {
      AddRefValue(*resVC);
      TTSetOutput1(r,*resVC,&vc3);
      RemoveRefValue(*resVC);
    }
    s = NULL;
    rg = NULL;
    if (r == SignalType) s = (SIGNAL) *resVC;
    else rg = (RANGE) *resVC;
    if (opIndex != 4) s3 = (SIGNAL) vc3;
    else {
      i3 = TNewImage();
      if (rg) SizeImage(i3,rg->size,rg->size);
      else SizeImage(i3,s->size,s->size);
      vc3 = (VALUE) i3;
    }

    /* Computation */
    switch(opIndex) {
    
      /* X */
      case 1 : 
        if (rg) for (j=0;j<s3->size;j++) s3->Y[j] = j;
        else for (j=0;j<s3->size;j++) s3->Y[j] = XSig(s,j); 
        break;
        
      /* der */
      case 2 : 
        if (rg) {
          temp = s3->Y[0] = RangeVal(rg,0);
          for (j=1;j<s3->size;j++) {
            temp1 = RangeVal(rg,j);
            s3->Y[j] = temp1-temp;
            temp = temp1;
          }
        }
        else {
          temp = s3->Y[0] = s->Y[0];
          for (j=1;j<s3->size;j++) {
            temp1 = s->Y[j];
            s3->Y[j] = temp1-temp;
            temp = temp1;
          }
        }
        break;

      /* prim */
      case 3 : 
        if (rg) {
          s3->Y[0] = RangeVal(rg,0);
          for (j=1;j<s3->size;j++) s3->Y[j] = RangeVal(rg,j) + s3->Y[j-1];
        }
        else {
          s3->Y[0] = s->Y[0];
          for (j=1;j<s3->size;j++) {
          s3->Y[j] = s->Y[j] + s3->Y[j-1];
          }
        }
        break;

      /* diag */
      case 4 : 
        ZeroImage(i3);
        if (rg) {
          for (j=0;j<rg->size;j++) i3->pixels[j*(i3->ncol+1)] = RangeVal(rg,j);
        }
        else {
          for (j=0;j<s->size;j++) i3->pixels[j*(i3->ncol+1)] = s->Y[j];
        }
        break;
        
      default : Errorf("Expr9() : Weired error Array3");
    }

    if (*resVC != vc3) {
      Clean(*resVC);
      *resVC = vc3;
    }
    return(r);
  }
  
 
   /***********************************************************
   * 
   * Operators "type"
   * 
   * 'op(expr)'
   *
   ***********************************************************/

  /* Sixth array */
  arrayIndex = 6;
  for (op = opArray6, opSize = opSizeArray6 ;;op++,opSize++) {                                                         
    if (*op == NULL) break; 
    if (!strncmp(begin,*op,*opSize) && !IsValidSymbolChar(begin[*opSize])) break; 
  }
  opIndex = op-opArray6+1;
    
  if (*op != NULL && (opIndex != 1 || begin[*opSize] == '(')) {    

    /* Check some types */
    if (!(flagType & StringType)) {
      SetErrorf("Not expecting a string");
      Clean(*resVC);
      return(0);
    }

    /* Skip operator */ 
    begin2= begin; 
    begin  += *opSize; 
    ParamSkipSpace(begin);
    *left = begin;

    /* Check '(' */
    if (*begin != '(') {
      SetErrorf("Missing a parenthesis '('");
      Clean(*resVC);
      return(0);
    }
    begin1= begin; 
    begin++;
    *left = begin;
    
    /* Get argument */
    oldFlagSpace = defParam->flagSpace;
    defParam->flagSpace = YES;
    if (!(r=TTExpr1(begin,left,resFlt,resVC,AnyType,defParam))) return(0);

    /* Closing parenthesis of op(expr) */
    if (**left != ')') {
      SetErrorf("Expecting a parenthesis ')'"); 
      Clean(*resVC);
      return(0);
    }
    (*left)++;
    begin = (*left);
    
    defParam->flagSpace = oldFlagSpace;
    
    /* Computation */
    switch(opIndex) {
    
      /* type */
      case 1 : 
        sc = TNewStrValue();
        if (*resVC == NULL) SetStrValue(sc,numType);
        else SetStrValue(sc,GetTypeValue(*resVC));
        *resVC = (VALUE) sc;        
        r = StringType;
        break;

      /* btype */
      case 2 : 
        sc = TNewStrValue();
        if (*resVC == NULL) SetStrValue(sc,numType);
        else SetStrValue(sc,GetBTypeContent(*resVC));
        *resVC = (VALUE) sc;        
        r = StringType;
        break;
        
      default : Errorf("Expr9() : Weired error Array6");
    }

    return(r);
  }

  /***********************************************************
   * 
   * Operators "min","max"
   * 
   * 'op' 'op(expression)' 'op(num,num)' 
   *
   ***********************************************************/

  /* Seventh array */
  arrayIndex = 7;
  for (op = opArray7, opSize = opSizeArray7 ;;op++,opSize++) {                                                         
    if (*op == NULL) break; 
    if (!strncmp(begin,*op,*opSize) && !IsValidSymbolChar(begin[*opSize])) break; 
  }
  opIndex = op-opArray7+1;
    
  if (*op != NULL) {    

    /* Check some types */
    if (!(flagType & (FloatType | SignalType | ImageType))) {
      SetErrorf("Not expecting a number, a signal or an image");
      Clean(*resVC);
      return(0);
    }

    /* Skip operator */
    begin2= begin; 
    begin  += *opSize; 
    ParamSkipSpace(begin); 
    *left = begin;


    /* test (... */
    if (*begin != '(') {
      SetErrorf("Expecting a '('");
      *left = begin;
      Clean(*resVC);
      return(0);
    }
    begin2 = begin;
    
    /* Read expression */
    i3 = NULL;
    begin1 = begin;
    begin++;
    *left = begin;
    oldFlagSpace = defParam->flagSpace;
    defParam->flagSpace = YES;
    if (!(r=TTExpr1(begin,left,resFlt,resVC,FloatType | RangeType | ImageType | SignalType,defParam))) return(0);
    defParam->flagSpace = oldFlagSpace;
    
    /* Case of op(expression) */
    if (**left == ')') {
      (*left)++;
      if (!(flagType & FloatType)) {
        SetErrorf("Not expecting a number");
        *left = begin;
        Clean(*resVC);
        return(0);
      }
      if (r == FloatType) {
        Clean(*resVC);
        return(FloatType);
      }
      if (r != RangeType) {
        if (r == SignalType) {
          s3 = (SIGNAL) *resVC;
          array3 = s3->Y;
          size3 = s3->size;
          if (size3 == 0 && opIndex != 3) {
            SetErrorf("Not expecting empty signal");
            *left = begin2+1;
            Clean(*resVC);
            return(0);
          }
        }
        else if (r == FloatType) {
          array3 = resFlt;
          size3 = 1;
        }
        else {
          i3 = (IMAGE) *resVC;
          array3 = i3->pixels;
          size3 = i3->ncol*i3->nrow;
          if (size3 == 0 && opIndex != 3) {
            SetErrorf("Not expecting emty image");
            *left = begin2+1;
            Clean(*resVC);
            return(0);
          }
        }

        switch(opIndex) {
        
        /* min */
        case 1:
          *resFlt = array3[0];
          for(j=1;j<size3;j++) *resFlt = MIN(*resFlt,array3[j]);
          break;
        
        /* max */
        case 2:
          *resFlt = array3[0];
          for(j=1;j<size3;j++) *resFlt = MAX(*resFlt,array3[j]);
          break;

        /* sum */
        case 3:
          if (size3 == 0) {*resFlt = 0; break;}
          *resFlt = array3[0];