---

ToyParseCmd.c

/***************************************************************************
                          ToyParseCmd.c  -  Code to parse Toy Memory
    Manager command files.
                             -------------------
    begin                : Sat Jan 25 2003
    copyright            : (C) 2003 by Tyler Montbriand
    student #            : 200200370
    class                : CS330
    email                : monttyle@heavyspace.ca
***************************************************************************/

#include <stdio.h>
#include <string.h>

#include "ToyMem.h"
#include "ToyMemPage.h"
#include "ToySegment.h"
#include "ToyMem_Internal.h"
#include "toyparse.h"
#include "ToyMemType.h"
#include "ToyLoad.h"
#include "ToyParseCmd.h"
#include "ToyMemPage.h"

/*  These lists of strings are carefully crafted to
    match their enumerated types.  So searching the
    tree of strings will return the proper value. */

const char *ArgType_Process[]={"P%u",NULL};
const char *ArgType_String[]={"\"%s",NULL};
const char *ArgType_Address[]={"@%u","@H%u","@D%u","@S%u","@C%u",NULL};
const char *ArgType_Integer[]={"#%u",NULL};
const char *ArgType_Command[]={ "LoadFile"              ,
                                "PrintProcessTable"     ,
                                "PrintProcessMemory"    ,
                                "STORE"                 ,
                                "TerminateProcess"      ,
                                "PrintAllMemory"        ,
                                "END"                   ,
                                "AllocateHeap"          ,
                                "ReallocateHeap"        ,
                                "FreeHeap"              ,
                                "PrintProcessHeap"      ,
                                "EnablePaging"          ,
                                "PrintInvertedPageTable",
                                "PrintPageTable"        ,
                                "WatchPaging"           ,
                                "PrintFrames"           ,
                                "PrintPages"            ,
                                NULL                                  };
const char **Arguments[]={  ArgType_Process,ArgType_Command,ArgType_Address,
                            ArgType_Integer,ArgType_String,NULL               };



int ReadFromType(ToyMM *tmm, int process, ArgType_e type, const char *str, void *buffer)
{
  int subtype=DetermineSubType(type,str,Arguments);

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

  switch(type)
  {
  case TYPE_STRING:
    if(strlen(str+1)>MAX_STRLEN)  return -1;
    strcpy((char *)buffer,str+1);
    return(0);

    /* All the same kind of integer - unsigned 32 bit */
  case TYPE_PROCESS:
  case TYPE_INTEGER:
    sscanf(str+1,"%d",(int *)buffer);
    return(0);

  case TYPE_ADDRESS:
  switch(subtype)
  {
  int relpos;

  case ADDRESS_ABSOLUTE:  /* Absolute address - @130*/
    /* sscanf should read one value */
    if(sscanf(str+1,"%d",(int *)buffer)!=1)
    {
      return(-1);
    }
    else
    {
      return(0);
    }

  case ADDRESS_HEAP:      /* Address relative to heap - @H30 */
    relpos=TMM_GetSegmentAddr(tmm,process,SEG_HEAP);

    if(relpos<0)
    {   return(-1); }
    /* sscanf should read one value */
    else if(sscanf(str+2,"%u",(unsigned int *)buffer)!=1)
    {   return(-1);  }

    (*(unsigned int *)buffer)+=relpos;
    return(0);

  case ADDRESS_CODE:       /* Address relative to code - @C3 */
    relpos=TMM_GetSegmentAddr(tmm,process,SEG_CODE);

    if(relpos<0)
    {   return(-1);    }
    /* sscanf should read one value */
    else if(sscanf(str+2,"%u",(unsigned int *)buffer)!=1)
    {   return(-1);    }

    (*(unsigned int *)buffer)+=relpos;
    return(0);

  case ADDRESS_STACK:     /* Address relative to stack - @S4 */
    relpos=TMM_GetSegmentAddr(tmm,process,SEG_STACK);
    if(relpos<0)
    {   return(-1);   }
    /* sscanf should read one value */
    else if(sscanf(str+2,"%u",(unsigned int *)buffer)!=1)
    {   return(-1);   }

    (*(unsigned int *)buffer)+=relpos;
    return(0);

  case ADDRESS_DATA:     /* Address relative to data - @S5 */
    relpos=TMM_GetSegmentAddr(tmm,process,SEG_DATA);
    if(relpos<0)
    {   return(-1);   }
    /* sscanf should read one value */
    else if(sscanf(str+2,"%u",(unsigned int *)buffer)!=1)
    {   return(-1);   }

    (*(unsigned int *)buffer)+=relpos;
    return(0);

  default:
    return(-1);
  }

  default:
    return(-1);
  }
}

ErrMessage_t TMM_ParseLine(const char *strIn, ToyMM *tm, int line)
{
  int process=-1,n=-1;
  TokenType *tarray=NULL;

  /*  Generate array of types from line of text */
  tarray=LineToTypes(strIn,Arguments);

  /*  Print the input, and Count # of arguments  */
  if(tarray[0].token!=NULL)
  {
    printf(LINE_NUMBER_FORMAT" ",line);    
    printf("%s",tarray[0].token);
    for(n=1; tarray[n].token!=NULL; n++) printf(" %s",tarray[n].token);
  }
  if(n>0) printf("\n");


  if(CheckLineSyntax(tarray,TYPE_PROCESS,-1,TYPE_COMMAND,-1,TYPE_ENDOPEN)<0)
  {
    FreeType(tarray);
    return(ERR_INVALIDINPUT);
  }

  ReadFromType(tm,-1,TYPE_PROCESS,tarray[0].token,&process);

  if((process>=MAX_PROCESSES)||(process<0))
  {   /*  Can't command nonexistent processes */
    FreeType(tarray);
    return(ERR_INVALIDINPUT);
  }

  switch(tarray[1].subtype)
  {
    /*  Scratchpad values */
    char string[100];
    int addr;
    int val;

    case COMMAND_PRINTPAGES:
      FreeType(tarray);
      return(TMM_PrintPages(tm,process));

    case COMMAND_PRINTFRAMES:
      FreeType(tarray);
      return(TMM_PrintFrames(tm));

    case COMMAND_WATCHPAGING:
      if(CheckLineSyntax(tarray+2,TYPE_INTEGER,-1,TYPE_ENDCLOSE)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }
      else if(ReadFromType(tm,process,TYPE_INTEGER,tarray[2].token,&val)<0)
      {
        FreeType(tarray);
        return(ERR_UNKNOWN);
      }
      else
      {
        FreeType(tarray);
        return(TMM_WatchPaging(tm,process,val));
      }
    

    case COMMAND_ENABLEPAGING:
      if(CheckLineSyntax(tarray+2,TYPE_INTEGER,-1,TYPE_ENDCLOSE)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }
      else if(ReadFromType(tm,process,TYPE_INTEGER,tarray[2].token,&val)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);        
      }      
      FreeType(tarray);
      return(TMM_EnablePaging(tm,process,val));      

    case COMMAND_PRINTINVERTEDPAGETABLE:
      FreeType(tarray);
      return(TMM_PrintInvertedPageTable(tm,process));

    case COMMAND_PRINTPAGETABLE:
      FreeType(tarray);
      return(TMM_PrintPageTable(tm,process));

    case COMMAND_ALLOCATE:
      if(CheckLineSyntax(tarray+2,TYPE_INTEGER,-1,TYPE_ENDCLOSE)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }

      val=-1;

      if(ReadFromType(tm,process,TYPE_INTEGER,tarray[2].token,&val)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }

      {
        ErrMessage_t retval=TMM_AllocateHeap(tm,process,val);
        return(retval);
      }

    case COMMAND_REALLOCATE:
      if(CheckLineSyntax(tarray+2,TYPE_ADDRESS,-1,TYPE_INTEGER,-1,TYPE_ENDCLOSE)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }

      ReadFromType(tm,process,TYPE_ADDRESS,tarray[2].token,&addr);
      ReadFromType(tm,process,TYPE_INTEGER,tarray[3].token,&val);
      FreeType(tarray);
      return(TMM_ReallocateHeap(tm,process,addr,val));

    case COMMAND_FREE:
      if(CheckLineSyntax(tarray+2,TYPE_ADDRESS,-1,TYPE_ENDCLOSE)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }
      ReadFromType(tm,process,TYPE_ADDRESS,tarray[2].token,&addr);
      FreeType(tarray);
      return(TMM_FreeHeap(tm,process,addr));
      
    case COMMAND_PRINTHEAP:
      if(tarray[2].token!=NULL)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }
      else
      {
        FreeType(tarray);
        return(TMM_PrintHeap(tm,process));
      }

    case COMMAND_END:
      if(tarray[2].token!=NULL)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }
      else
      {
        FreeType(tarray);
        return(ERR_PARSEEND);
      }
      
    case COMMAND_PRINTALLMEMORY:
      FreeType(tarray);
      /*  Should be only 2 arguments - process #, and command */
      if(n!=2)            return(ERR_INVALIDINPUT);
      else if(process!=0) return(ERR_NOPRIVILEGE);
      else                return(TMM_PrintAllMemory(tm));

    case COMMAND_LOADFILE:
      if(CheckLineSyntax(tarray+2,TYPE_ADDRESS,-1,TYPE_STRING,-1,TYPE_ENDCLOSE)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }

      /*  Read data from these types  */
      else if(ReadFromType(tm,process,TYPE_ADDRESS,tarray[2].token,&addr))
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }
      else if(ReadFromType(tm,process,TYPE_STRING,tarray[3].token,string)<0)
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }

      FreeType(tarray);

      /*  Out-of-range means a syntax error, not a memory one for some reason.  */
      if(addr>=tm->memSize) return(ERR_INVALIDINPUT);
      else                  return(TMM_Load(tm,process,string,addr));


    case COMMAND_PRINTPROCESSTABLE:
      FreeType(tarray);
      /*  Exactly 2 parameters - process ID, and the  command */
      if(n!=2)  return(ERR_INVALIDINPUT);
      else      return(TMM_PrintProcessTable(tm,process));

    case COMMAND_PRINTPROCESSMEMORY:
      FreeType(tarray);
      /*  Exactly 2 paramegers - process ID, and command  */
      if(n!=2)  return(ERR_INVALIDINPUT);
      else      return(TMM_PrintProcessMemory(tm,process));

    case COMMAND_STORE:
      /*  Exactly 4 parameters - process ID, command, address, and data */
      if(CheckLineSyntax(tarray+2,TYPE_ADDRESS,-1,TYPE_INTEGER,-1,TYPE_ENDCLOSE)==0)
      {
         if(ReadFromType(tm,process,TYPE_ADDRESS,tarray[2].token,&addr)<0)
         {
           FreeType(tarray);
           return(ERR_INVALIDINPUT);
         }
         else if(ReadFromType(tm,process,TYPE_INTEGER,tarray[3].token,&val)<0)
         {
           FreeType(tarray);
           return(ERR_INVALIDINPUT);
         }
         FreeType(tarray);

         if(addr>=tm->memSize)
         {
           FreeType(tarray);
           return(ERR_INVALIDINPUT);
         }
         else
         {
           return(TMM_StoreInteger(tm,process,addr,val));
         }
      }
      else if(CheckLineSyntax(tarray+2,TYPE_ADDRESS,-1,TYPE_STRING,-1,TYPE_ENDCLOSE)==0)
      {
         if(ReadFromType(tm,process,TYPE_ADDRESS,tarray[2].token,&addr)<0)
         {
           FreeType(tarray);
           return(ERR_INVALIDINPUT);
         }
         else if(ReadFromType(tm,process,TYPE_STRING,tarray[3].token,string)<0)
         {
           FreeType(tarray);
           return(ERR_INVALIDINPUT);
         }

         FreeType(tarray);

         if(addr>=tm->memSize)
         {
           FreeType(tarray);
           return(ERR_INVALIDINPUT);
         }
         else
         {
           return(TMM_StoreString(tm,process,addr,string));
         }
      }
      else
      {
        FreeType(tarray);
        return(ERR_INVALIDINPUT);
      }

    case COMMAND_TERMINATEPROCESS:
      /*  Must be precisely 2 parameters - process ID and command */
      FreeType(tarray);
      if(n!=2)  return(ERR_INVALIDINPUT);
      else      return(TMM_TerminateProcess(tm,process));

    default:
      /*  This should not happen under any circumstances. */
      printf("Email me @ monttyle@heavyspace.ca and tell me what you did please!\n");
      FreeType(tarray);
      return(ERR_UNKNOWN);
  }
}

---