int_variable.c

LastWave

  char *end,*type,**pos,*str,*tempStr,flag,**list;
  HASHTABLE ht;
  char flagDollar,flagBrace,flagEventVar,flagEval,flagProc,flagProcAn,flagScript;
  char flagErr;
  unsigned char answer;
  int i,j,i0,k;
  SCRIPT script;
  SCRIPTLINE sl;
  LWFLOAT f;
  char string[MaxNameLength];
  char oldFlagSpace;
  char oldFlagEmptySI;
  
  /* Init */
  Clean(*resVC);
  sc = NULL;
  value = NULL;
  *left = begin;
  oldFlagEmptySI = defParam->flagEmptySI;
  defParam->flagEmptySI = YES;
  if (nc == NULL) nc = NewNumValue();

    
  /* Get the level the content must be looked at */
  while (level->levelVar != level) level = level->levelVar;
  ht = level->theVariables;
  
  /*
   * Substitution ?
   * Look for $ or ${}
   */
  flagDollar = NO;
  flagBrace = NO;
  if (*begin == '$') {
    if (defParam->flagSubst) {
      flagDollar = YES;
      if (begin[1] == '{') {flagBrace = YES; begin+=2;}
      else {begin++;}
    }
    else {
      Clean(*resVC);
      SetErrorf("Syntax error");
      return(0);
    }
  }
  
  /* set end to begin */
  end = begin;


  /*************************************************************************
   *
   * We want to get the content 'value' and have it temporary referenced
   *
   *************************************************************************/
    
  
  /*
   * Event variable ?
   * Look for @
   */
  if (*begin == '@') {flagEventVar = YES; end++;}
  else flagEventVar = NO;
   
  /*
   * Pointer variable
   */
   if (*begin == '&') {
     if (!(flagType & OtherType)) {
       SetErrorf("Do not expect '&variable' type");
       *left = begin;
       Clean(*resVC);
       return(0);
     }
     begin++;
     var = GetVariableHT(&ht,0,begin,left,&flag);
     if (flag != 0) {
       Clean(*resVC);
       return(0);
     }
     *resVC = (VALUE) var;
     var->nRef++;
     TempValue( var);
     return(OtherType);
   }
   
  /*
   * % procedure
   */
   flagProcAn = NO;
   if (*begin == '%' && begin[1] != '%') {
     if (!(flagType & OtherType)) {
       SetErrorf("Do not expect '&proc' type");
       *left = begin;
       Clean(*resVC);
       return(0);
     }
     flagProc = YES;
     end++;
     if (*end == '{') flagProcAn = YES;
     begin++;
   }
   else flagProc = NO;   

  /*
   * %%script
   */
   if (*begin == '%' && begin[1] == '%') {
     if (!(flagType & OtherType)) {
       SetErrorf("Do not expect '&script' type");
       *left = begin;
       Clean(*resVC);
       return(0);
     }
     flagScript = YES;
     end+=2;
     begin+=2;
   }
   else flagScript = NO;   
     
  /*
   * Command ?
   * Look for []
   */
  if (*begin == '[') {flagEval = YES; end++;}
  else flagEval = NO;
  
  /* 
   * If not a command line and not a script get the variable name.
   */  
  if (flagEval == NO && flagScript==NO && !flagProcAn) {
    if (IsValidSymbolChar1(*end) || *end == '\\' && flagProc) {
      end++;
      while (*end != '\0' && IsValidSymbolChar(*end) && *end != '.') end++;
    }
    /* If we didn't get anything --> error */
    if (end == begin && !isdigit(*begin) && *begin != '.') {
      *left = begin;
      SetErrorf("Syntax Error");
      return(0);
    }
    
    /* The name/line will just correspond to begin */
    if (MaxNameLength +2 < end-begin) Errorf("TGetVariableContentLevelExpr() : Variable name is too long");
    strncpy(string,begin,end-begin);
    string[end-begin] = '\0';
  }


  /* 
   * Get the variable if 10a or 10
   */ 
  if (isdigit(begin[0]) || begin[0]=='.') {
    answer = GetNumberExtraction(begin,left,resFlt,resVC,defParam);
    if (answer==0) return(0);
    value = *resVC;
    end = *left;
  }
  
  /* 
   * Get procedure
   */ 
  else if (flagProc) {
    /* Case of an anonymous command */
    if (flagProcAn == YES) {
      list = NULL;
      script = NULL;
      str= LookForBracketList(NULL,begin);
      if (str != NULL) {
        *str = '\0';
        ParseWordList_(begin+1,NULL,&list);
        *str = '}';
        if (list != NULL) {
          str++;
          ParseStrScript_(&str,NULL,&script);
        }
      }
      if (script == NULL) {
        *left = begin;
        Clean(*resVC);
        return(0);
      }
      Clean(*resVC);
      *resVC = (VALUE) SetProc(NULL,list,NULL,script);
      *left = begin+strlen(begin);
      return(OtherType);
    }
    /* Other case */
    else {
      if (*string == '\\') value = (VALUE) GetCProc(string+1);
      else value = (VALUE) GetProc(string);
      if (value == NULL) {
        SetErrorf("Unknown procedure name '%s'",string);
        *left = begin;
        Clean(*resVC);
        return(0);
      }     
      AddRefValue(value);
      TempValue(value);
    }
  }

  /* 
   * Get script
   */ 
  else if (flagScript) {
    script = NULL;
    if (!ParseCompiledScript_(&end,&script,NO,NO,&flagErr)) {
      *left = begin;
      Clean(*resVC);
      return(0);
    }
    *resVC = (VALUE) script;
    *left = end+strlen(end);
    return(OtherType);
  }
  
  /* 
   * Get the variable if regular variable (add a ref)
   */ 
  else if (!flagEventVar && !flagEval) {
    var = GetSimpleVariableHT(ht,string,0);
    pcont = GetVariablePContent(var,NULL);   
    if (pcont == NULL || *pcont == NULL) {
      SetErrorf("Variable does not exist");
      *left = begin;
      return(0);
    }
    value = *pcont;
    AddRefValue(value);
    TempValue(value);
  }


  /* 
   * Get the variable if event variable (store it in nc or sc)
   */ 
  else if (!flagEval) {
    flag = GetEventVariable2(string+1,&tempStr,&f);
    if (flag == NO) {
      SetErrorf("Bad event variable");
      *left = begin;
      return(0);
    }
    if (tempStr != NULL) {
      sc = NewStrValue();
      SetStrValue(sc,tempStr);
      value = (VALUE) sc;
      TempValue(value);
   /*   Warningf("On peut accelerer ca...\n"); *//* ????? */
    }
    else {
      SetNumValue(nc,f);
      value = (VALUE) nc;
    }
  }

  
  /* 
   * Get the variable if command line 
   */ 
  else {
    
    /* Try to find the compiled script */
    script = NULL;
    if (levelCur->scriptline && levelCur->scriptline->cs != NULL) {
      sl = levelCur->scriptline;
      if (defParam->nWord == -1) {i0=0; j = 0; k=0;}
      else {i0 = defParam->nWord; j = defParam->nPos; k = defParam->nScript;}
      for (i=i0;i<sl->nWords;i++) {
        if (sl->cs[i] == NULL || sl->cs[i]->pos.bracket == NULL) {j=k=0;continue;}
        for (pos = sl->cs[i]->pos.bracket+j; *pos != NULL; j++, pos++) {
          if (!flagDollar) { /* Loop when it is not a $[..] script line */
            if (*pos > begin || **pos == '$') break;
            if (*pos < begin) {
              k++;j++;pos++;
              continue;
            }
          }
          else {  /* Loop when it is a $[..] script line */
            if (*pos > begin-1 || **pos == '[') break;
            if (*pos < begin-1) {
              if (*(*pos+1) == '[') {k++;j++;pos++;}
              continue;
            }
          }          

          /* We found it !! */          
          defParam->nWord = i;
          defParam->nPos = j;
          defParam->nScript = k;
          script = sl->cs[i]->scripts.bracket[k];
          break;
        }
        j=k=0;
        if (script || *pos != NULL) break;
      }
    }

    /* Case we could not find any compiled script */    
    if (script == NULL) {
      /* Get the script line */
/*      Printf("TGetVariableContentLevelExpr() : Pas de compil\n"); */
      end = LookForBracketScript(begin,end-1);
      if (end == NULL) {
        *left = begin;
        return(0);
      }
      /* Get the script ??????????? attention peut etre pb !!!!!  
        ++ FAIRE UNE COPIE au cas ou chaine est statique */
      *end = '\0';
      str = begin+1;
      if (ParseStrScript_(&str,NULL,&script) != YES) {
        *end = ']';
        return(0);
      }
      *end = ']';
      EvalScriptLevel(level,script,YES); /* ??? mettre ici le levelVar --> ouvrir un nouveau level */
    }
    
    /* Case we found a compiled script */
    else {
      EvalScriptLevel(level,script,YES);
      end = sl->cs[defParam->nWord]->pos.bracket[defParam->nPos+1];
    }
    
    type = GetResultType();
    if (type == numType) {
      SetNumValue(nc,GetResultFloat());
      value = (VALUE) nc;
    }
    else {
      value = GetResultValue();
      AddRefValue(value);
      TempValue(value);
    }
    end++;
    InitResult();
  }
     
    
  /*
   * Manage extraction/getfield messages if any and get the type of the so-obtained variable
   */
  if (!flagSimple && (*end == '[' || *end == '.')) {
    answer = TGetFieldOrExtractContentExpr(level,value,end,left,resFlt,resVC,flagType,defParam,flagDollar);
    if (answer != 0) {
      if (*resVC == NULL) type = floatType;
      else type = GetTypeValue(*resVC);
    }
    else { 
      Clean(*resVC);
      return(0);
    }
  }
  
  /*
   * Otherwise just get the type
   */
  else {
    *left = end;
    type = GetTypeValue(value);
    if (type == numType) {
      *resFlt = ((NUMVALUE) value)->f;
      if (value != (VALUE) nc) *resVC = value;
      else *resVC = NULL;
      answer = FloatType;
    }
    else {
      *resVC = value;
      if (type == strType) answer = StringType;
      else if (type == signalType || type == signaliType) answer = SignalType;
      else if (type == imageType || type == imageiType) answer = ImageType;
      else if (type == listvType) answer = ListvType;
      else if (type == rangeType) answer = RangeType;
      else if (type == nullType) answer = NullType;
      else answer = OtherType;
    }
  }
  
  /*
   * We are ready to perform some checkings
   */  
  if (flagBrace) {
    if (**left != '}') {
      Clean(*resVC);
      SetErrorf("Missing the corresponding '}'");
      return(0);
    }
    else *left += 1;
  }
  defParam->flagEmptySI =  oldFlagEmptySI;

  if (!(answer  & flagType)) {
    *left = begin;
    Clean(*resVC);
    SetErrorf("Do not expect type '%s'",type);
    return(0);
  }

  if (type == signalType && !defParam->flagEmptySI) {
    *left = begin;
    Clean(*resVC);
    SetErrorf("Signal is empty");
    return(0);
  }
  if (type == imageType && !defParam->flagEmptySI) {
    *left = begin;
    Clean(*resVC);
    SetErrorf("Image is empty");
    return(0);
  }

  ParamSkipSpace(*left);
  
  /* Just return */
  return(answer);
}


/*
 * Basic function for getting variable's string value and making substitutions (with the $ sign)
 * 
 * We expect begin to start with $
 *
 * 'nw' is the word number (-1 if none) 
 *
 * Returns a temporary string
 */
 
char *GetStringExpr(LEVEL level, char *begin, char **left, int nw)
{  
  LWFLOAT resFlt;
  VALUE resVC;
  unsigned char type;
  char *str;
  ExprDefParam defParam;
  
  InitDefaults(&defParam,level,YES,NO);
  if (nw >= 0) {
    defParam.nWord = nw;
    defParam.nScript = 0;
    defParam.nPos = 0;
    defParam.flagSpace = NO;
  }
    
  /* Evaluation */
  resVC = NULL;
  type = TGetVariableContentLevelExpr(level, begin, left, &resFlt, &resVC, AnyType,NO,&defParam);
  
  /* Inits again */
  InitDefaults(&defParam,NULL,NO,NO);

  if (type == 0) {
    Clean(resVC);
    return(NULL);
  }
  
  if (type == StringType) {
    str = GetStrFromStrValue((STRVALUE) resVC);
    return(str);
  }
  else if (type == FloatType) {
    str = CharAlloc(30);
    TempPtr(str);  
    Flt2Str(resFlt,str);
    return(str);
  }
  else {
    SetErrorf("Bad variable type");
    Clean(resVC);
    return(NULL);
  }

}  


/********************************************************************************
 *
 *  Setting variables 
 *
 ********************************************************************************/