int_parser.c

LastWave

  name++;
  while (*name != '\0' && IsValidSymbolChar(*name)) name++;
  if (*name == '\0') return(YES);
  return(NO);
}


char ParseSymbol_(char *arg, char *defVal, char **str)
{
  *str = defVal;
  
  if (arg == NULL) {
    SetErrorf("ParseSymbol_() : NULL string cannot be converted to a symbol");
    return(NO);
  }
  
  if (!IsValidSymbol(arg)) {
    SetErrorf("ParseSymbol_() : '%s' not a valid symbol",arg);
    return(NO);
  }

  *str = arg;
  return(YES);
}

/* Same as above but generate an error (no default value) */
void ParseSymbol(char *arg, char **i)
{
  if (ParseSymbol_(arg,NULL,i) == NO) Errorf1("");
}


/***********************************************************************************
 *
 *  Parsing a variable name just check that it starts with the right character
 *
 ***********************************************************************************/

char ParseVName_(char *arg, char *defVal, char **str)
{
  *str = defVal;
  
  if (arg == NULL) {
    SetErrorf("ParseVName_() : NULL string cannot be converted to a variable name");
    return(NO);
  }
  
  if (!IsValidSymbolChar1(*arg)) {
    SetErrorf("ParseVName_() : '%s' not a valid variable name",arg);
    return(NO);
  }

  *str = arg;
  return(YES);
}

/* Same as above but generate an error (no default value) */
void ParseVName(char *arg, char **i)
{
  if (ParseVName_(arg,NULL,i) == NO) Errorf1("");
}


/***********************************************************************************
 *
 *  Parsing a string evaluated (no allocation)  
 *
 ***********************************************************************************/

char ParseStrValueLevel_(LEVEL level, char *arg, STRVALUE defVal, STRVALUE *sc)
{
  char *type;
  LWFLOAT resFlt;
  VALUE resVC;

  *sc = defVal;
  
  if (arg == NULL) {
    SetErrorf("ParseStrLevel_() : NULL string cannot be converted to a string");
    return(NO);
  }
  
  resVC = NULL;
  type = TTEvalExpressionLevel_(level,arg,&resFlt,&resVC,StringType,NO,YES,AnyType,YES);
  if (type == NULL) return(NO);
  *sc = (STRVALUE) resVC;
  
  return(YES);
}

/* Same as above but generate an error (no default value) */
void ParseStrValueLevel(LEVEL level, char *arg, STRVALUE *sc)
{
  if (ParseStrValueLevel_(level,arg,NULL,sc) == NO) Errorf1("");
}


char ParseStrLevel_(LEVEL level, char *arg, char *defVal, char **str)
{
  char *type;
  LWFLOAT resFlt;
  VALUE resVC;

  *str = defVal;
  
  if (arg == NULL) {
    SetErrorf("ParseStrLevel_() : NULL cannot be converted to a string");
    return(NO);
  }
  
  resVC = NULL;
  type = TTEvalExpressionLevel_(level,arg,&resFlt,&resVC,StringType,NO,YES,AnyType,YES);  
  if (type == NULL) return(NO);

  *str = ((STRVALUE) resVC)->str;
  
  return(YES);
}

/* Same as above but generate an error (no default value) */
void ParseStrLevel(LEVEL level, char *arg, char **i)
{
  if (ParseStrLevel_(level,arg,NULL,i) == NO) Errorf1("");
}

char ParseStr_(char *arg, char *defVal, char **str)
{
  return(ParseStrLevel_(levelCur, arg,defVal,str));
}

/* Same as above but generate an error (no default value) */
void ParseStr(char *arg, char **i)
{
  if (ParseStr_(arg,NULL,i) == NO) Errorf1("");
}


/*
 * Parsing a LWFLOAT or a string
 *
 */

char ParseFloatStrLevel_(LEVEL level,char *arg,LWFLOAT *f, char **str)
{
  char *type;
  VALUE val;

  if (arg == NULL) {
    SetErrorf("ParseFloatStrLevel_() : NULL cannot be converted to a LWFLOAT or string");
    return(NO);
  }
  
  type = TTEvalExpressionLevel_(level,arg,f,&val,StringType | FloatType,NO,NO,AnyType,YES);
  
  if (type == NULL) return(NO);
  
  if (type == strType) *str = ((STRVALUE) val)->str;
  else {
    *str = NULL;
    if (val != NULL) *f = ((NUMVALUE) val)->f;
  }
  return(YES);
}
 
 
/*****************************************************************
 *
 *
 *
 *  Parsing of a list (with special characters " and {})
 *
 *
 *
 *****************************************************************/
 
/* Maximum number of imbricated brackets or quotes in a list */
#define maxNImbricatedBrackets 200

/* 
 * 'theLine' starts with a { or " and it returns the corresponding } or "
 * It returns NULL if none 
 */
char * LookForBracketList(char *theLine, char *line)
{
  static char *brackets[maxNImbricatedBrackets];  
  int nBrackets;
  char flagStop;

  nBrackets = 0;
  brackets[nBrackets++] = line++;
  flagStop = NO;
  
  while (!flagStop && *line && nBrackets != 0) {
    switch(*line) {
      case '\\' : 
        if (*(++line) != '\0') line++; 
        break;
      case '{': 
        if (nBrackets >= maxNImbricatedBrackets) {
          SetErrorf("Too many imbricated brackets");
          return(NULL);
        }
        brackets[nBrackets++] = line++;
        break;      
      case '}':         
        if (*(brackets[nBrackets-1]) != '{') flagStop = YES;
        else {
          line++;
          nBrackets--;
        }
        break;
      case '[': 
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '"' || *(brackets[nBrackets-1]) == '\'') {line++;break;}
        if (*(brackets[nBrackets-1]) == '{') line++;
        else brackets[nBrackets++] = line++;
        break;      
      case ']': 
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '"' || *(brackets[nBrackets-1]) == '\'') {line++;break;}
        if (*(brackets[nBrackets-1]) == '{') line++;
        else if (*(brackets[nBrackets-1]) == '[') {
          line++;
          nBrackets--;
        }
        else flagStop = YES;
        break;
      case '(': 
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '"' || *(brackets[nBrackets-1]) == '\'') {line++;break;}
        if (*(brackets[nBrackets-1]) == '{') line++;
        else brackets[nBrackets++] = line++;
        break;      
      case ')': 
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '"' || *(brackets[nBrackets-1]) == '\'') {line++;break;}
        if (*(brackets[nBrackets-1]) == '{') line++;
        else if (*(brackets[nBrackets-1]) == '(') {
          line++;
          nBrackets--;
        }
        else flagStop = YES;
        break;
      case '`':
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '"' || *(brackets[nBrackets-1]) == '\'') {line++;break;}
        if (*(brackets[nBrackets-1]) != '`') {
          if (nBrackets >= maxNImbricatedBrackets) {
            SetErrorf("Too many imbricated brackets");
            return(NULL);
          }
          brackets[nBrackets++] = line++;
        }
        else {
          line++;
          nBrackets--;
        }
        break;
      case '"':
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '\'') {line++;break;}
        if (*(brackets[nBrackets-1]) != '"') {
          if (nBrackets >= maxNImbricatedBrackets) {
            SetErrorf("Too many imbricated brackets");
            return(NULL);
          }
          brackets[nBrackets++] = line++;
        }
        else {
          line++;
          nBrackets--;
        }
        break;
      case '\'':
        if (*(brackets[nBrackets-1]) == '{') {line++; continue;}
        if (*(brackets[nBrackets-1]) == '"') {line++;break;}
        if (*(brackets[nBrackets-1]) != '\'') {
          if (nBrackets >= maxNImbricatedBrackets) {
            SetErrorf("Too many imbricated brackets");
            return(NULL);
          }
          brackets[nBrackets++] = line++;
        }
        else {
          line++;
          nBrackets--;
        }
        break;
      default: line++;
    }
  }
  
  if (nBrackets != 0) {
    if (*(brackets[nBrackets-1]) == '`') SyntaxError("Missing the corresponding `",theLine,brackets[nBrackets-1]);
    else if (*(brackets[nBrackets-1]) == '"') SyntaxError("Missing the corresponding \"",theLine,brackets[nBrackets-1]);
    else if (*(brackets[nBrackets-1]) == '\'') SyntaxError("Missing the corresponding '",theLine,brackets[nBrackets-1]);
    else if (*(brackets[nBrackets-1]) == '{') SyntaxError("Missing the corresponding }",theLine,brackets[nBrackets-1]);
    else if (*(brackets[nBrackets-1]) == '[') SyntaxError("Missing the corresponding ]",theLine,brackets[nBrackets-1]);
    return(NULL);
  }
  else return(line-1);
}
 

/* 
 * Get the corresponding character to an escape sequence in a list
 */
static int GetCharFromEscapeList(char c)
{
  switch (c) {
    case '\\' : return('\\');
    case '{' : return('{');
    case '}' : return('}');
    case '[' : return('[');
    case ']' : return(']');
    case '"' : return('"');
    case '\'' : return('\'');
    case 't' : return('\t');
    case 'r' : return('\r');
    case 'n' : return('\n');
    default : return(-1);
  }
}

/* Just test that we have enough allocation */
#define TestAlloc(n) \
  if ((n)+nNewLine > MaxLengthList) { \
    SyntaxError("Word is too long",theLine,line); \
    return(-1); \
  }

/* Just parses one character */
#define Parse1Char(parseStr) { \
   nNewLine++; \
   TestAlloc(0); \
   *newLine = *(parseStr); \
   newLine++; \
   parseStr++;}


/*
 *
 *  The Main function for parsing a list
 *
 *    'theLine' = the total line (used in case of error)
 *
 *  returns arrays of the begining/end of words an in the variables beg and end
 *  and it returns the number of words or -1 if an error occured
 *
 */

int ParseListBegEnd(char *theLine, char ***beg, char ***end)
{
  static char *theBegWords[MaxNumWords+1];
  static char *theEndWords[MaxNumWords+1];
  static char theNewLine[MaxLengthList+1],*newLine;

  int nWord;
  char *line,*bracket,*lineError,*line1,*braceBeg,*braceEnd;
  int nNewLine;
  char *str;
  char flagEscape,flagCreateWord,flagStop;
  int i;

  /* If line is NULL then error */
  if (theLine == NULL) return(-1);

  /* Set the result variables */    
  if (beg != NULL && end != NULL) {
    *beg = theBegWords;
    *end = theEndWords;
  }

  /* 
   * Some inits concerning the line 
   */
  line = theLine;
  while (*line == ' ' || *line == '\t' || (*line == '\\' && (line[1] == '\n' || line[1] == '\r'))) {
    if (*line == '\\') {
      if (line[1] == '\n' && line[2] == '\r' || line[1] == '\r' && line[2] == '\n') line += 3;
      else line+=2;
    }

    else  line++;
  }

  /* If empty line */
  if (*line == '\0') {
    theBegWords[0] = theEndWords[0] = NULL;
    return(0);
  }
  
  /* If {} surrounds the list we should set a flag */
  braceBeg = NULL;
  if (*line == '{') {
    braceEnd = LookForBracketList(theLine,line);
    if (braceEnd == NULL) return(-1);
    line1 = braceEnd+1;
    while (*line1 == ' ' || *line1 == '\t' || (*line1 == '\\' && (line1[1] == '\n' || line1[1] == '\r'))) line1++;
    if (*line1 != '\0') {braceBeg = NULL; braceEnd= NULL;}
    else {
      braceBeg = line;
      line1 = line+1;
      while (*line1 == ' ' || *line1 == '\t' || (*line1 == '\\' && (line1[1] == '\n' || line1[1] == '\r'))) {
        if (*line1 == '\\') {
          if (line1[1] == '\n' && line1[2] == '\r' || line1[1] == '\r' && line1[2] == '\n') line1 += 3;
          else line1+=2;
        }
        else line1++;
      }
      if (line1== braceEnd) {
        theBegWords[0] = theEndWords[0] = NULL;
        return(0);
      }
    }
  } 

  /* 
   * Some inits concerning the processed line 
   */
  *theNewLine = '\0';
  newLine = theNewLine;
  nNewLine = 0;

  /*
   * Other inits 
   */
  nWord = 0;
  flagEscape = 0;  
    
  flagStop = NO; 
  flagCreateWord = NO;
  
  theBegWords[nWord] = NULL;
  theEndWords[nWord] = NULL;


  
  /*
   * Let's loop on the characters 
   */
  while(1) {

    /* 
     * If we were asked to create a new word just do it 
     */
    if (flagCreateWord) {
    
      /* Let's end the word */       
      theEndWords[nWord] = (nNewLine != 0 ? newLine-1 : newLine);
      nWord++;
            
      /* And init the next one */
      theBegWords[nWord] = theEndWords[nWord] = NULL;

      /* Skip spaces and tabs or escaped new lines */
      while (*line == ' ' || *line == '\t' || (*line == '\\' && (line[1] == '\n' || line[1] == '\r'))) {
        if (*line == '\\') {
          if (line[1] == '\n' && line[2] == '\r' || line[1] == '\r' && line[2] == '\n') line += 3;
          else line+=2;
        }
        else  line++;
      }
      
      flagCreateWord = NO;
      
    }

    /*
     * Case we must exit the loop : 
     *   - end of the line
     */
    if (*line == '\0') {