toyparse.c

Go to the documentation of this file.

/***************************************************************************
                          toyparse.c  -  Core code for the Toy Memory
    Manager's parsing engine.  Both ToyLoad.c and ToyParseCmd.c use it.

                             -------------------
    begin                : Sat Jan 25 2003
    copyright            : (C) 2003 by Tyler Montbriand
    student #            : 200200370
    class                : CS330
    email                : tsm@accesscomm.ca
***************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <malloc.h>
#include <stdarg.h>
#include "toyparse.h"
#include "toyparse_internal.h"


/*#define PRINT_COMMENTS*/

int CheckLineSyntax(TokenType *tarray, ...)
{
  long int type=-1,subtype=-1;
  int pos=0;
  int syntaxok=0;
  va_list a;

  if(tarray==NULL)  return(-1);

  /*  Start getting arguments from the variable-arg part  */
  va_start(a,tarray);
  {
    /*  Loop while we're not done       */
    while((syntaxok==0)&&((type!=TYPE_ENDOPEN)||(type!=TYPE_ENDCLOSE)))
    {
      type=va_arg(a,int);       /*      Get next argument       */
      if((type==TYPE_ENDOPEN)||(type==TYPE_ENDCLOSE))
      {
        /*  Last argument */
        break;
      }

      subtype=va_arg(a,int);  /*  Get next argument     */
      if((subtype==TYPE_ENDOPEN)||(subtype==TYPE_ENDCLOSE))
      {
        /*  Last argument in wrong place! */
        syntaxok=-1;
        break;
      }

      /*  Check if syntax matches */
      if((tarray[pos].token==NULL)||(tarray[pos].type!=type)||(tarray[pos].subtype==-1))
      {
        syntaxok=-1;
      }
      else if((subtype!=-1)&&(tarray[pos].subtype!=subtype))
      {
        syntaxok=-1;
      }
      /*  Increment position in array */
      pos++;
    }
  }
  va_end(a);

  if(syntaxok!=0)                   return(-1);
  else if(type==TYPE_ENDOPEN)       return( 0);
  else if(tarray[pos].token==NULL)  return( 0);
  else                              return(-1);
}


TokenType *LineToTypes(const char *str, const char **table[])
{
  TokenType *tarray=NULL;
  /*  Create array of token-strings  */
  char **strList=NULL;

  if((str==NULL)||(table==NULL)) return(NULL);
  
  strList=Explode(str);

  if(strList==NULL)
  {
    return(NULL);
  }

  /*  Convert token strings to array of types */
  tarray=TokensToType((const char **)strList,table);
  /*  Note that this is **NOT**  FreeStrList().  We want
      to free the array containing the strings, but not the
      strings themselves - that way, the strings in tarray
      are still valid and freeable.                         */
  free(strList);
  /*  Return array of types */
  return(tarray);
}

void FreeType(TokenType *types)
{
  int n;
  if(types==NULL) return;

  for(n=0; types[n].token!=NULL; n++)
  {
    free((void *)types[n].token);
  }
  free(types);
}

TokenType *TokensToType(const char **tokens, const char **table[])
{
  int size=-1, n=-1;
  TokenType *tarray;

  if(tokens==NULL)
  {
    tarray=(TokenType *)malloc(sizeof(TokenType));
    tarray->type=-1;
    tarray->subtype=-1;
    tarray->token=NULL;
    return(tarray);
  }

  /*  Count # strings in token list */
  for(size=0; tokens[size]!=NULL; size++);

  /*  Allocate array of token descriptors */
  tarray=(TokenType *)malloc((size+1)*sizeof(TokenType));

  /*  Loop through token strings and array  */
  for(n=0; n<size; n++)
  {
    /*  Get the base type, if any */
    int type=DetermineType(tokens[n],table);
    /*  Set string in array to match  */
    tarray[n].token=(char *)tokens[n];
    tarray[n].type=type;
    if(type==-1)
    { /*  If type is unknown, subtype is too  */
      tarray[n].subtype=-1;
    }
    else
    {
      /*  Look up and set subtype */
      tarray[n].subtype=DetermineSubType(type,tokens[n],table);
    }
  }

  /*  Terminate it, to mark end */
  tarray[size].type=-1;
  tarray[size].subtype=-1;
  tarray[size].token=NULL;

  return(tarray);
}

int DetermineSubType(int type,const char *str, const char **args[])
{
  int n=-1;
  if((args==NULL)||(type<0))  return(-1);

  /*  Ensure that 'type' is actually in the list  */
  for(n=0; (n<type)&&(args[n]!=NULL); n++);

  /*  Went past the end of the list */
  if(args[n]==NULL)  return(-1);

  return(FindInList(str,args[n]));
}

int FindInList(const char *str, const char *list[])
{
  int n;
  for(n=0; list[n]!=NULL; n++)
    if(CompareType(str,list[n])>=0) return(n);

  return(-1);
}

int DetermineType(const char *str, const char **table[])
{
  int i;

  for(i=0; table[i]!=NULL; i++)
  {
    if(table[i]!=NULL)
    if(FindInList(str,table[i])>=0)  return(i);
  }
  return(-1);
}

int CompareType(const char *str, const char *typestr)
{
  int error=0,strpos=0,typepos=0;
  if((str==NULL)||(typestr==NULL))  return -1;

  /* Loop until entire string is parsed */
  while(!error&&(str[strpos]!='\0')&&(typestr[typepos]!='\0'))
  {
    /* Case sensitive string matching. */
    while(typestr[typepos]==str[strpos])
    {
      if((typestr[typepos]=='\0')||(str[strpos]=='\0')||(typestr[typepos]=='%'))
        break;

        typepos++;
        strpos++;
    }

    /* Three cases:   1) Both strings ended, which is OK.
                      2) One did, the other didn't.  Bad.
                      3) A variable argument was encountered in typestr.  */

    /* Strings match */
    if((typestr[typepos]=='\0')&&(str[strpos]=='\0'))
    {     return(0);    }
    else if((typestr[typepos]=='\0')||(str[strpos]=='\0'))
    {
      /* Strings didn't match. */
      return(-1);
    }
    else if(typestr[typepos]=='%')
      switch(toupper(typestr[typepos+1]))
      {
      case 'S':
        /* Anything goes, so just return true */
        return(0);
        break;

      case 'U':
        while(isdigit(str[strpos]))  strpos++;
        /* Advance past "%u" */
        typepos+=2;
        break;

      default:
        /* End of string or invalid type */
        return(-1);
      }
    else
    {
      return(-1);
    }
  }

  /* Type matches */

  if((str[strpos]=='\0')&&(typestr[typepos]=='\0'))
    return 0;
  else /* types don't match */
    return(-1);
}


void *AllocateArray(void *in, int size, int num);


char **Explode(const char *strIn)
{
  char **strList=NULL;
  int pos=0,numStr=0;

  /*  Ignore whitespace */
  while(isspace(strIn[pos]))    pos++;

  while(strIn[pos]!='\0')
  {
    /* Ignore whitespace */
    while(isspace(strIn[pos])) pos++;

    /* If we haven't reached the end of the string, must be another
       word.                                                          */
    if(strIn[pos]!='\0')
    {
      char buf[100];
      int bufPos=0;

      /* If we find a comment, stop parsing the line */
      if((strIn[pos]=='/')&&(strIn[pos+1]=='/'))
      {
        pos+=2;
#ifdef PRINT_COMMENTS
        /*  Prints comments for debugging */
        printf("//");
        while((strIn[pos]!='\0')&&(strIn[pos]!='\n')&&(strIn[pos]!='\r'))
        {
          /* Print the string, except for CR/LF stuff at the end  */
          printf("%c",strIn[pos++]);
        }
        printf("\n"); /* Print one linefeed */
#endif
        /* Fast-forward to end of string  */
        while(strIn[pos]!='\0') pos++;

        continue;
      }
      strList=(char **)AllocateArray(strList,sizeof(char *),numStr+1);
      numStr++;
      while(!isspace(strIn[pos])&&(strIn[pos]!='\0')&&(bufPos<(100-1)))
      {
        /* Add letters to the end of our string */
        buf[bufPos++]=strIn[pos++];
      }

      buf[bufPos++]='\0'; /* NULL terminator */
      /* Allocate memory for string */
      strList[numStr-1]=(char *)malloc(bufPos);
      /* Copy string into new memory */
      strcpy(strList[numStr-1],buf);
    }
  }

  if(strList==NULL)
  {
    /* Don't bother returning any mem if the list is empty */
    return(NULL);
  }
  else
  {
    /* Tack a NULL onto the end of the list so we can tell where it ends
       */
    strList=(char **)AllocateArray(strList,sizeof(char *),numStr+1);
    strList[numStr]=NULL;
    return(strList);

  }
}

void *AllocateArray(void *in, int size, int num)
{
  if(in==NULL)  return(malloc(size*num));
  else          return(realloc(in,size*num));

}

void FreeStrList(char **strList)
{
  int n;
  if(strList==NULL) return;

  for(n=0; strList[n]!=NULL; n++)
  {
    free(strList[n]);
  }

  free(strList);
}

---