int_str.c

LastWave

  SetStrVariable(name,str);
}


/*
 * Setting a string variable with a list
 */

void SetStrVariableListLevel(LEVEL level,char *name,char **list,char flagBracket)
{
  VARIABLE v;
  HASHTABLE t;
  char *left,flag,*type;
  VALUE *pcont,value;
  STRVALUE sc;
  int size,l;
  char **list1 = list;
  
  while (level->levelVar != level) level = level->levelVar;
  t = level->theVariables;
  
  /* Get the variable (eventually creates it) */
  v = GetVariableHT(&t, YES, name, &left, &flag);
  if (v==NULL || flag != 0 || *left != '\0') Errorf1("");

  /* Get a pointer to the content and the type */
  pcont =  GetVariablePContent(v, NO);
  value = *pcont;
  type = GetTypeValue(value);
  
  /* Check overwriting */
  if (!DoesTypeOverwrite(type,listType)) 
    Errorf("SetStrVariableListLevel() : Cannot overwrite variable '%s' of type '%s' with '%s' typed value",name,type,listType);

  /* If the content is a strType can we use it ? */
  if (type == strType && (*pcont)->nRef == 1) {}
  else {
    /* Delete the content */
    DeleteValue(*pcont);
    /* Create it */
    *pcont = (VALUE) NewStrValue();
    value = *pcont;
  }

  sc = (STRVALUE) value;
  
  
  /* Computing the size the result will take */
  l = 0;
  size = 0;
  list1 = list;
  while(*list1 != NULL) {
    size += strlen(*list1) + 3;
    list1++;
  }
   
  /* Allocation ? */
  if (size > l && size > MinStringSize-1) {
    Free(sc->str);
    sc->str = StrValueStrAlloc(size);
  }
  if (sc->list) {
    Free(sc->list);
    sc->list = NULL;
  }

  /* Setting the result ???????? optimiser */
  sc->str[0] = '\0';
  list1 = list;
  while(*list1 != NULL) {
    if (!flagBracket || **list1 != '\0' && !IsList(*list1)) strcat(sc->str,*list1);
    else {
      strcat(sc->str,"{");
      strcat(sc->str,*list1);
      strcat(sc->str,"}");
    }
    if (*(list1+1) != NULL) strcat(sc->str," ");
    list1++;
  }
  sc->list = CopyList(list);
  
}


void SetStrVariableList(char *name,char **list, char flagBracket)
{
  SetStrVariableListLevel(levelCur,name,list,YES);
}


 
/******************************************
 * 
 * The string command and string regexp
 *
 ******************************************/




/*
 * Subroutine pour le matching d'une chaine par une regexp
 *
 * Cherche a matcher le debut de la chaine et renvoie 
 * la chaine matchee la plus grande possible !
 *
 * renvoie le dernier caractere non matche
 */

static char *start;
static char *end;
 
static char *MatchStr_(char *str,char *expr)
{
  int i;
  char *expr1,*expr0,*str1,*res;
  static char tok[100];
  char flag0Repeat,flag1Repeat,flag01Repeat,flagInclude;
  char *start1,*end1;
  
  while (1) {

    switch(*expr) {

    /* end of string */
    case '$' :  
      if (str[0] != '\0') return(NULL);
      if (expr[1] != '\0') Errorf("MatchStr_ : the character '$' must be at the end of the regexp");
      return(str);
    

    /* Case of a '*' character */
    case '*' : 
      switch (expr[1]) {
      case '\0' : return(str+strlen(str));        
      default :
        i = strlen(str);
        while(1) {
          start1 = start;
          end1 = end;
          res = MatchStr_(str+i,expr+1);
          if (res) return(res);
          start = start1;
          end = end1;
          if (i == 0) return(NULL);
          i--;
        }    
      }

    /* Case of a '+' character */
    case '+' : 
      switch (expr[1]) {
      case '\0' : 
        if (*str == '\0') return(NULL);
        return(str);
      default : 
        i = strlen(str);
        while(1) {
          res = MatchStr_(str+i,expr+1);
          start1 = start;
          end1 = end;
          if (res) return(res);
          start = start1;
          end = end1;
          if (i == 1) return(NULL);
          i--;
        }    
      }

    /* Case of a "[", "[*", "[^" and "[*^" string */
    case '[' :
    
      /* Get the flags */
      expr0 = expr;     /* expr0 --> '[' */
      expr++;
      flag0Repeat = flag1Repeat = flag01Repeat = NO;
      switch (*expr) {
      case '*' : flag0Repeat = YES; expr++; break;
      case '#' : flag01Repeat = YES; expr++; break;
      case '+' : flag1Repeat = YES; expr++; break;
      }
      if (*expr == '^') {flagInclude = NO; expr++;}
      else flagInclude = YES;
      
      /* Get the set of characters */
      expr1 = expr;     /* expr1 --> first character */
      if (*expr == ']') expr++;
      while (*expr != ']' && *expr != '\0') expr++;  /* expr --> ] */
      if (*expr == '\0') Errorf("MatchStr_() : Missing matching '[' in regexp '...%s'",expr0);
      if (expr-expr1>90) Errorf("MatchStr_() : regexp between [] is too long");
      strncpy(tok,expr1,expr-expr1);
      tok[expr-expr1] = '\0';
      expr++;
      
      if (*str == '\0') {
        if (flag0Repeat || flag01Repeat) continue;
        return(NULL);
      }
      
      if (!flag0Repeat && !flag01Repeat) {
        if (flagInclude) {
          if (strchr(tok,*str) == NULL) return(NULL);          
        }
        else {
          if (strchr(tok,*str) != NULL) return(NULL);          
        }
        str++;
        if (!flag1Repeat) continue;
        flag0Repeat = YES;
      }

      /* We must look for all the characters it could match */
      str1 = str;
      if (flag0Repeat) {
        if (flagInclude) while(*str1 != '\0' && strchr(tok,*str1)) str1++;
        else while(*str1 != '\0' && !strchr(tok,*str1)) str1++;
      }
      else {
        if (flagInclude && *str1 != '\0' && strchr(tok,*str1)) str1++;
        else if (!flagInclude && *str1 != '\0' && !strchr(tok,*str1)) str1++;
      }
        
      /* Then call recursively */
      while (str<=str1) {
        start1 = start;
        end1 = end;
        res = MatchStr_(str1,expr);
        if (res) return(res);
        start = start1;
        end = end1;
        str1--;
      }
      return(NULL);

    /* Case of a '?' character */
    case '?' :
      if (str[0] == '\0') return(NULL);
      str++;
      expr++;
      continue;

    /* Case of a '|' character */
    case '|' :
      if (start == NULL) start = str;
      else if (end == NULL) {
        end = str;
      }
      else Errorf("MatchStr_ : Too many '|' (there must be at most 2 of them"); 
      expr++;
      continue;
    

    /* ! */
    case '!' :
      expr++;
      while (*str != '\0' && *expr != '\0' && *expr != '!') {
        if (*expr == '\\' && expr[1] == '!') expr++;
        if (*str != *expr) return(NULL);
        expr++;
        str++;
        continue;
      }
      if (*expr == '\0') Errorf("MatchStr_ : bad regexp, missing a '!'");
      if (*expr != '!') return(NULL);
      expr++;
      continue;

    /* End of expr */
    case '\0' :
      return(str);    
    
    /* Match a character */    
    default :
      if (*str != *expr) return(NULL);
      str++;
      expr++;
      continue;
    }
    
  }
}

LISTV MatchStrN(char *str,char *expr, int nOcc)
{
  char *res,*str0;
  LISTV lv;
  RANGE rg;
  char *expr0;
  
  expr0 = expr;
    
  if (*expr == '^') expr++;

  str0 = str;
  lv = TNewListv();

  while (1) {
    if (*str == '\0') return(lv);

    /* To go a little faster */
    if (*expr0 != '|' && *expr0 != '^' && *expr != '\0' && *expr != '[' && *expr != '*' && *expr != '?'  && *expr != '+' && *expr != '$') {
      if (*expr == '!') res = strchr(str,expr[1]);
      else res = strchr(str,*expr);
      if (res == NULL) return(lv);
      str = res;
    }

    start = end = NULL;
    res = MatchStr_(str,expr);
    if (start == NULL) start = str;
    if (end == NULL) end = res;
    if (end == start+1 || end == start) {
      AppendFloat2Listv(lv,start-str0);
      nOcc--;
    }
    else if (end>start) {
      rg = TNewRange();
      rg->first = start-str0;
      rg->size = end-start;
      AppendValue2Listv(lv,(VALUE) rg);
      nOcc--;
    }
    if (nOcc == 0) return(lv);    
    if (str[1] == '\0' || *expr0 == '^') return(lv);
    if (res == NULL || res <= str) res = str+1;
    str = res;
  }
}    

char MatchStr(char *str,char *expr)
{
  char *str1;
  char *f;
  
  SetTempAlloc();
  str1 = CharAlloc(strlen(expr)+2); /* ????? bof */
  TempPtr(str1);
  strcpy(str1,expr);
  str1[strlen(expr)]='$';
  str1[strlen(expr)+1]='\0';
  f = MatchStr_(str,str1);
  ClearTempAlloc();
  return(f!=NULL);  
}

  
LISTV FindStr(char *str, char *subStr, int nOcc)
{
  LISTV lv;
  char *str0;
  int n;
  RANGE rg;
  
  str0 = str;
  n = strlen(subStr);
  lv = NewListv();
  
  while (1) {
    
    while (1) {
      str = strchr(str,*subStr);
      if (str == NULL) break;
      if (!strncmp(str,subStr,strlen(subStr))) break;
      str++;
    }

    if (str==NULL) return(lv);

    if (n == 1) {
      AppendFloat2Listv(lv,str-str0);
      nOcc--;
    }
    else {
      rg = NewRange();
      rg->first = str-str0;
      rg->size = n;
      AppendValue2Listv(lv, (VALUE) rg);
      DeleteValue(rg);
      nOcc--;
    }
    
    if (nOcc == 0) return(lv);
    
    str += n;
    
  }
}


/************************************************
 *
 * Useful functions on strings
 *
 ************************************************/

/*
 * Managing allocations of strings
 */

/* Delete a string */ 
void DeleteStr(char *str)
{
  Free(str);
}

/* Copy a string */ 
char *CopyStr(char *str)
{
  char *strOut;
  
  if (str == NULL) Errorf("CopyStr() : cannot copy NULL string");
  
  strOut = CharAlloc(strlen(str)+1);
  strcpy(strOut,str);
  return(strOut);
}

/* Copy a string and make it temporary */ 
char *TCopyStr(char *str)
{
  char *strOut = CopyStr(str);
  TempStr(strOut);
  return(strOut);
}


 /* Make a string temporary */
void TempStr(char *str)
{
  TempPtr(str);
}

/* ??? */
#define LINELENGTH 80

 void PrintStrColumn(char *str,int size)
{
   static char spaces[]="                                                                                                        ";
   static int nspaces = 100;
   static int nspaces1 = 100;
   static int countLine;
  static int terminalLength = LINELENGTH;
  static int tab = 0;
  int length;
  static char theString[1000];
    
  if (str == NULL) {
    if (size <= 0) {
      Printf("%s\n",theString);
      theString[0] = '\0';
    }
    else {
      theString[0] = '\0';
      tab = size;
      countLine = 0;
    }
    return;
  }
  
  if (tab == 0) Errorf("PrintStrColumn() : you should initialize the call first");

  length = tab * (1 + (int) strlen(str) / tab);
  if (countLine+length >= terminalLength) {
     Printf("%s\n",theString);
     theString[0] = '\0';    
     countLine = 0;
  }
  countLine += length;
    
  strcat(theString,str);
  
  length -= strlen(str);
  
  if (nspaces != nspaces1) {
    spaces[nspaces1] = ' ';
    nspaces1 = nspaces;
  }
  
  while (length > nspaces) {
    strcat(theString,spaces);
    length-=nspaces;
  }
  if (length < 0) return;
  nspaces1 = length;
  spaces[nspaces1] = '\0';
  strcat(theString,spaces);
  if (nspaces != nspaces1) {
    spaces[nspaces1] = ' ';
    nspaces1 = nspaces;
  }
}


/************************************************
 *
 * Command on strings
 *
 ************************************************/

void C_Str(char **argv)
{
  char *action,*str,*str1,*str3;
  int i,n;
  char c;
  LISTV lv;
  LWFLOAT f;
  extern LWFLOAT GetListvNthFloat(LISTV lv,int n);

  argv = ParseArgv(argv,tWORD,&action,-1);
  
  if (!strcmp(action,"2ascii")) {
    argv = ParseArgv(argv,tSTR,&str,0);
    lv = TNewListv();
    for (i=0;i<strlen(str);i++) AppendInt2Listv(lv,(int) str[i]);
    SetResultValue(lv);
    return;
  } 

  /* ascii2 action */
  else if (!strcmp(action,"ascii2")) {
    argv = ParseArgv(argv,tLISTV,&lv,0);
    for (i=0;i<lv->length;i++) {
      f = GetListvNthFloat(lv,i);
      if (f != (int) f || f < 0 || f >=256) 
        Errorf("Bad ascii code '%g'",f);
      AppendResultf("%c",(char) f);
    }
    return;
  } 

  /* match action */
  else if (!strcmp(action,"match")) {
    argv = ParseArgv(argv,tSTR,&str,tSTR,&str1,tINT_,-1,&n,0);  
    lv = MatchStrN(str,str1,n);
    SetResultValue(lv);
    return;
  }
  
  /* substr action */
  else if (!strcmp(action,"substr")) {
    argv = ParseArgv(argv,tSTR,&str,tSTR,&str1,tINT_,-1,&n,0);
    lv = FindStr(str,str1,n);
    TempValue( lv);
    SetResultValue(lv);
    return;
  }

  /* inter action */
  else if (!strcmp(action,"inter")) {
    argv = ParseArgv(argv,tSTR,&str,tSTR,&str1,0);
    str3 = str;