---

ToyLoad.c

/***************************************************************************
                          ToyLoad.c

    Contains the code for processing .lod files.
                             -------------------
    begin                : Sat Jan 25 2003
    copyright            : (C) 2003 by Tyler Montbriand
    student #            : 200200370
    class                : CS330
    email                : monttyle@heavyspace.ca

   TODO - convert from from Explodee calls to LineToType calls
    
 ***************************************************************************/

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

#include "ToySegment.h"
#include "ToySegmentList.h"
#include "ToyProcess.h"
#include "ToyMemType.h"
#include "ToyMem.h"
#include "ToyMemPage.h"
#include "ToyVirtualMem.h"
#include "ToyMem_Internal.h"
#include "toyparse.h"
#include "ToyLoad.h"
#include "ToySwap.h"

const char  *DataType_Magic[]       = {  "8585",NULL           };
const char  *DataType_Integer[]     = {  "%u","#%u",NULL       };
const char  *DataType_String[]      = {  "\"%s",NULL           };
const char  *DataType_Instruction[] = {  "RUN","HALT",NULL     };
const char **DataType_List[]        = { DataType_Magic,
                                        DataType_Integer,
                                        DataType_String,
                                        DataType_Instruction,
                                        NULL                  };

 
TokenType *GetTokenLine(FILE *fp, int *n);

ErrMessage_t TMM_Load(ToyMM *tm, int process, const char *filename, int addr)
{
  int n           =-1;
  int numSegments =-1;
  int segSizes[4] ={-1,-1,-1,-1};
  FILE *fileIn    =NULL;
  TokenType *tarray=NULL;
  
  /*  Can't open nonexistent files,
      nor use nonexistent toy-mm's  */
  if((tm==NULL)||(filename==NULL))          return(ERR_UNKNOWN);
  else if((process<0)||(process>=MAX_PROCESSES))
  {
    return(ERR_UNKNOWN);
  }
  else if(tm->processList[process]!=NULL)
  {
    return(ERR_PROCESSEXISTS);
  }

  fileIn=fopen(filename,"r");

  if(fileIn==NULL)  return(ERR_NOFILE); /*  Couldn't open file*/

  /*  Get 1st line.  Should be magic #. */
  tarray=GetTokenLine(fileIn,&n);
  if(CheckLineSyntax(tarray,DATA_MAGIC,0,TYPE_ENDCLOSE)<0)
  {
    fclose(fileIn);    
    FreeType(tarray);
    return(ERR_INVALIDFILE);
  }
  FreeType(tarray);

  /*  Get 2nd line.  Should be # segments.  */
  tarray=GetTokenLine(fileIn,&n);
  if(CheckLineSyntax(tarray,DATA_INTEGER,0,TYPE_ENDCLOSE)<0)
  {
    fclose(fileIn);    
    FreeType(tarray);
    return(ERR_INVALIDFILE);
  }
  else if(sscanf(tarray[0].token,"%d",&numSegments)!=1)
  {
    fclose(fileIn);    
    FreeType(tarray);
    return(ERR_INVALIDFILE);
  }
  else if((numSegments<=0)||(numSegments>4))
  {
    fclose(fileIn);    
    FreeType(tarray);
    return(ERR_INVALIDFILE);
  }

  FreeType(tarray);

  /*  Get the segment sizes.  Should be like "1 3 8 4"  */
  tarray=GetTokenLine(fileIn,&n);
  if(tarray==NULL)  return(ERR_INVALIDFILE);
  else if(n!=numSegments)
  {
    fclose(fileIn);    
    FreeType(tarray);
    return(ERR_INVALIDINSTRUCTION);
  }
  
  for(n=0; n<numSegments; n++)
  {
    if(tarray[n].type!=DATA_INTEGER)
    {
      fclose(fileIn);      
      FreeType(tarray);
      return(ERR_INVALIDFILE);
    }
    else if(sscanf(tarray[n].token,"%d",&segSizes[n])!=1)
    {
      fclose(fileIn);      
      FreeType(tarray);
      return(ERR_INVALIDFILE);      
    }
    else if(segSizes[n]<=0)
    {
      fclose(fileIn);      
      FreeType(tarray);
      return(ERR_INVALIDFILE);      
    }
  }
  FreeType(tarray);

  /*  Allocate the process. */
  if(TMM_PagingEnabled(tm)<0)
  {
    /*  Different allocation functions for paged and non-paged. */
    if(TMM_AllocateProcessAt(tm,process,addr,numSegments,segSizes)!=ERR_NONE)
    {
      fclose(fileIn);
      return(ERR_INSUFFICIENTMEM);
    }
  }
  else
  {
    if(TMM_PagedAllocateProcess(tm,process,numSegments,segSizes)!=ERR_NONE)
    {
      fclose(fileIn);
      return(ERR_INSUFFICIENTMEM);
    }
  }

  { /*  OK, now we're cookin'.  Load stuff into memory! */
    int curseg    =-1;
    int i         =-1;
    int numStrings=-1;      /*  # of strings in list  */
    int segpos    =-1;      /*  Position in segment   */
    int abspos    =-1;      /*  absolute memory position  */
    SegList *list = NULL;   /*  Current segment       */
    
    segpos=0;
    curseg=0;
    list=tm->processList[process]->segments;  /*Get the list of segments*/
    list=TMM_SeekSegListHead(list);


    /*  Get the next line of input  */
    tarray=GetTokenLine(fileIn,&numStrings);    
    while(tarray)
    {
      for(i=0; i<numStrings; i++)
      {
        /*  If we've reached the end of this segment,
            advance to the next one.                */
        if(segpos>=list->seg.len)
        {
          segpos=0;
          list=list->next;
          curseg++;
        }

        /*  If there is no next segment, we're out of memory. */
        if(list==NULL)
        {
          /*  Out of segment space! */
          TMM_TerminateProcess(tm,process);
          FreeType(tarray);
          return(ERR_DATAOVERFLOW);
        }

        /* In paged mode, we have to allocate the frames as we go */
        if(TMM_PagingEnabled(tm)>=0)
        { /* Figure out what page we're on */
          int page=(segpos+list->seg.pos)/tm->pageSize;

          if(TMM_PageFree(tm,process,page)>=0)
          {
            int frame=TMM_FindFreeFrame(tm);
            if(frame<0)
            {
              printf("Error - Could not find a free page\n");
              printf("Email me at monttyle@heavyspace.ca - tell me what you did\n");
              abort();
            }
            else
            {
              TMM_AssignFrame(tm,process,frame,page);
            }
          }
        }


        /* Calculate our position in memory */
        abspos=TMM_GetRealAddress(tm,process,segpos+list->seg.pos);
        if(abspos<0)
        {
          printf("Virtual address fault!\n");
          TMM_TerminateProcess(tm,process);
          return(ERR_UNKNOWN);
        }

        switch(curseg)
        {
        case SEG_CODE:
          if(tarray[i].type!=DATA_INSTRUCTION)
          {
            FreeType(tarray);
            fclose(fileIn);
            TMM_TerminateProcess(tm,process);
            return(ERR_INVALIDINSTRUCTION);
          }
          break;

        case SEG_DATA:
          if((tarray[i].type!=DATA_INTEGER)&&(tarray[i].type!=DATA_STRING))
          {
            FreeType(tarray);
            fclose(fileIn);
            TMM_TerminateProcess(tm,process);
            return(ERR_INVALIDDATA);
          }
          break;

        default:
          FreeType(tarray);
          fclose(fileIn);
          TMM_TerminateProcess(tm,process);
          return(ERR_DATAOVERFLOW);
        }        

        if(tarray[i].type==DATA_ERROR)  /*  If the parser doesn't recognize it  */
        {
          FreeType(tarray);
          fclose(fileIn);
          return(ERR_INVALIDDATA);
        }

        tm->mem[abspos].type=(DataType_e)tarray[i].type;

        switch(tarray[i].type)
        {
        default:
          printf("Unknown type %d\n",tarray[i].type);
          printf("Email me at monttyle@heavyspace.ca and tell me how you did this.\n");
          abort();
          break;
          
        case DATA_INTEGER:
          {
            int val;
            sscanf(tarray[i].token+1,"%d",&val);
            tm->mem[abspos].integer.value=val;
          }
          break;
        case DATA_INSTRUCTION:
          tm->mem[abspos].integer.value=tarray[i].subtype;
          break;

        case DATA_STRING:
          tm->mem[abspos].string.value[0]='\0';
          if(strlen(tarray[i].token)>MAX_STRLEN)
          {
            FreeType(tarray);
            fclose(fileIn);
            return(ERR_INVALIDDATA);
            break;
          }

          strcpy(tm->mem[abspos].string.value,tarray[i].token+1);
          break;
        }

        segpos++;
      }
      FreeType(tarray);  
      tarray=GetTokenLine(fileIn,&numStrings);
    }


    /* Cleanup - if we're in paged mode, we might have to add in the
       last frames that didn't get allocated before.                 */
    if(TMM_PagingEnabled(tm)>=0)
    while(list)
    {
      for(segpos=list->seg.pos; segpos<list->seg.pos+list->seg.len; segpos+=tm->pageSize)
      {
        int page=segpos/tm->pageSize;
        if(TMM_PageFree(tm,process,page)>=0)
        {
          int frame=TMM_FindFreeFrame(tm);
          if(frame<0)
          {
            printf("Couldn't find a free page!\n");
            printf("Tell me how you did this at monttyle@heavyspace.ca\n");
            abort();
          }
          else
          {
            TMM_AssignFrame(tm,process,frame,page);
          }
        }
      }
      list=list->next;
    }

  }
  
  
  fclose(fileIn);
  return(ERR_NONE);
}


TokenType *GetTokenLine(FILE *fp, int *n)
{
  char buf[300];
  TokenType *tarray=NULL;
  buf[0]='\0';

  if(feof(fp))
  {
    if(n!=NULL) (*n)=0;
    return(NULL);
  }
  fgets(buf,300,fp);    /*  Get text                  */
  tarray=LineToTypes(buf,DataType_List);

  if((tarray!=NULL)&&(n!=NULL))
  {
    for((*n)=0; tarray[(*n)].token!=NULL; (*n)++);

    return(tarray);
  }
  else
  {
    (*n)=0;
    return(NULL);
  }
}

---