}
      break;


    /* syscall SS_SYS_execve() 4010 is not implemented for simplescalar */  

    
    case SS_SYS_chdir:
      {
	char buf[MAXBUFSIZE];

	/* copy filename to host memory */
	mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[4], buf);

	/* change the working directory */
	/*result*/regs->regs_R[2] = chdir(buf);

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
      }
      break;


	/* get the system time */
	case SS_SYS_time:
	  {
	  	time_t * tloc;
	  	tloc = (time_t *)malloc(sizeof(time_t));
	  	if (!tloc)
	  	  fatal("out of virtual memory in SYS_SS_time");
	  	
		/* copy the arguments to the host memory */
	  	mem_bcopy(mem_fn, mem, Read, regs->regs_R[4],
		  tloc, sizeof(time_t));

		/* get the system time */
		regs->regs_R[2] = time(tloc);
		
		/* copy the result to the target memory */
		mem_bcopy(mem_fn, mem, Write, regs->regs_R[4],
		  tloc, sizeof(time_t));

		/* check for an error condition */
		if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	    /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	    free(tloc);
	  }
	break;


	case SS_SYS_mknod:
	  {
	  	char buf[MAXBUFSIZE];

	  	/* copy filename to host memory */
	    mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[4], buf);

	  	/*result*/regs->regs_R[2] = mknod(buf, regs->regs_R[5], regs->regs_R[6]);
		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;


    case SS_SYS_chmod:
      {
	char buf[MAXBUFSIZE];

	/* copy filename to host memory */
	mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[4], buf);

	/* chmod the file */
	/*result*/regs->regs_R[2] = chmod(buf, /*mode*/regs->regs_R[5]);

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
      }
      break;


case SS_SYS_lchown:
#ifdef _MSC_VER
      warn("syscall chown() not yet implemented for MSC...");
      regs->regs_R[7] = 0;
#else /* !_MSC_VER */
      {
	char buf[MAXBUFSIZE];

	/* copy filename to host memory */
	mem_strcpy(mem_fn, mem, Read, /*fname*/regs->regs_R[4], buf);

	/* chown the file */
	/*result*/regs->regs_R[2] = lchown(buf, /*owner*/regs->regs_R[5],
				    /*group*/regs->regs_R[6]);

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
      }
#endif /* _MSC_VER */
      break;


     case SS_SYS_stat:
      {
#if 0 /* mips mark it as unimplemented */
	char buf[MAXBUFSIZE];
	struct ss_old_statbuf ss_old_sbuf;
	struct __old_kernel_stat old_sbuf;
	
	/* copy filename to host memory */
	mem_strcpy(mem_fn, mem, Read, /*fName*/regs->regs_R[4], buf);

	/* stat() the file */
	/*result*/regs->regs_R[2] = stat(buf, &old_sbuf);
	
	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }

	/* translate from host stat structure to target format */
	ss_old_sbuf.ss_st_dev = (word_t)MD_SWAPH(old_sbuf.st_dev);
	ss_old_sbuf.ss_st_ino = (word_t)MD_SWAPH(old_sbuf.st_ino);
	ss_old_sbuf.ss_st_mode = (word_t)MD_SWAPH(old_sbuf.st_mode);
	ss_old_sbuf.ss_st_nlink = (word_t)MD_SWAPH(old_sbuf.st_nlink);
	ss_old_sbuf.ss_st_uid = (word_t)MD_SWAPH(old_sbuf.st_uid);
	ss_old_sbuf.ss_st_gid = (word_t)MD_SWAPH(old_sbuf.st_gid);
	ss_old_sbuf.ss_st_rdev = (word_t)MD_SWAPH(old_sbuf.st_rdev);
	ss_old_sbuf.ss_st_size = (long)MD_SWAPW(old_sbuf.st_size);
	ss_old_sbuf.ss_st_atime = (word_t)MD_SWAPW(old_sbuf.st_atime);
	ss_old_sbuf.ss_st_mtime = (word_t)MD_SWAPW(old_sbuf.st_mtime);
	ss_old_sbuf.ss_st_ctime = (word_t)MD_SWAPW(old_sbuf.st_ctime);

	ss_old_sbuf.ss_st_res1 = ss_old_sbuf.ss_st_res2 = ss_old_sbuf.ss_st_res3 = 0;
	ss_old_sbuf.ss_st_blksize = 0;
	ss_old_sbuf.ss_st_blocks = 0;
	ss_old_sbuf.ss_st_unused[0] = 0;
	ss_old_sbuf.ss_st_unused[1] = 0;
	
	/* copy stat() results to simulator memory */
	mem_bcopy(mem_fn, mem, Write, /*old_sbuf*/regs->regs_R[5],
		  &ss_old_sbuf, sizeof(struct ss_old_statbuf));
#else
	/* got an error, return details */
	regs->regs_R[2] = -ENOSYS;
	regs->regs_R[7] = 1;
#endif
      }
      break;

    
    case SS_SYS_lseek:
      /* seek into file */
      regs->regs_R[2] =
	lseek(/*fd*/regs->regs_R[4],
	      /*off*/regs->regs_R[5], /*dir*/regs->regs_R[6]);

      /* check for an error condition */
      if (regs->regs_R[2] != -1)
	regs->regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs->regs_R[2] = errno;
	  regs->regs_R[7] = 1;
	}
      break;

      
    case SS_SYS_getpid:
#ifdef _MSC_VER
      warn("syscall getuid() not yet implemented for MSC...");
#else /*!_MSC_VER*/
      /* get the simulator process id */
      /*result*/regs->regs_R[2] = getpid();

      /* check for an error condition */
      if (regs->regs_R[2] != -1)
	regs->regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs->regs_R[2] = errno;
	  regs->regs_R[7] = 1;
	}
#endif /*_MSC_VER*/
      break;


#if 0
    case SS_SYS_mount:
    {
		char dev_name[MAXBUFSIZE], dir_name[MAXBUFSIZE], type[MAXBUFSIZE];
		unsigned long *data, addr;

		data = (unsigned long *)malloc(sizeof(unsigned long));
		if (!data)
		  fatal ("out of virtual memory in SS_SYS_mount");
		
    	/* copy arguments to the host memory and translate it to the host format */
    	mem_strcpy(mem_fn, mem, Read, /*dev_name*/regs->regs_R[4], dev_name);
        mem_strcpy(mem_fn, mem, Read, /*dir_name*/regs->regs_R[5], dir_name);
        mem_strcpy(mem_fn, mem, Read, /*type*/regs->regs_R[6], type);
        /* locate the argument first and then copy it to the host memory */ 
        mem_bcopy(mem_fn, mem, Read, regs->regs_R[29]+16,
          &addr, sizeof(unsigned long));
        addr = MD_SWAPW(addr);
        mem_bcopy(mem_fn, mem, Read, /*data*/addr, data, sizeof(unsigned long));
		*data = MD_SWAPW(*data);
		
		/*result*/regs->regs_R[2] = mount(dev_name, dir_name, type, 
			regs->regs_R[7], data);
		
		/* check for an error condition */
        if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
        else
	    {
	    /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
        free(data);
    }	
    break;


	case SS_SYS_oldumount:
	{
		char name[MAXBUFSIZE];

		/* copy arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*name*/regs->regs_R[4], name);

		/*result*/regs->regs_R[2] = umount(name, 0);
		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
    break;
#endif


    case SS_SYS_setuid:
#ifdef _MSC_VER_
	warn("syscall setuid() not yet implemented for MSC...");
	regs->regs_R[7] = 0;
#else
	{
		half_t uid;

    	/* copy arguments to the host memory */
    	uid = (half_t)regs->regs_R[4];

    	regs->regs_R[2] = setuid(uid);

    	/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
#endif /*_MSC_VER_*/
    break;


    case SS_SYS_getuid:
#ifdef _MSC_VER
      warn("syscall getuid() not yet implemented for MSC...");
      regs->regs_R[7] = 0;
#else /* !_MSC_VER */
      /* get current user id */
      /* result */regs->regs_R[2] = getuid();

      /* check for an error condition */
      if (regs->regs_R[2] != -1)
	    regs->regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs->regs_R[2] = errno;
	  regs->regs_R[7] = 1;
	}
#endif /* _MSC_VER */
      break;


    case SS_SYS_stime:
	{
		/*long*/time_t * tptr;

		tptr = (time_t*)malloc(sizeof(time_t));
		if (!tptr)
		  fatal("out of virtual memory in SS_SYS_stime");

		/* copy arguments to the host memory */
		mem_bcopy(mem_fn, mem, Read, regs->regs_R[4],
		  tptr, sizeof(time_t));

		/* translate from host time_t structure to target format */
		*tptr = MD_SWAPW(*tptr);
		
		/*result*/regs->regs_R[2] = stime(tptr);
		
		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	    free(tptr);
    }
	break;


#if 0
	case SS_SYS_ptrace:
	{
		/*result*/regs->regs_R[2] = ptrace(/*request*/regs->regs_R[4], /*pid*/regs->regs_R[5], 
			                              /*addr*/regs->regs_R[6], /*data*/regs->regs_R[7]);

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;
#endif


	case SS_SYS_alarm:
    {
		/*result*/regs->regs_R[2] = alarm(/*seconds*/regs->regs_R[4]);    

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
    break;


case SS_SYS_fstat:
      {
#if 0 /* linux/mips have not implement this */
	struct ss_old_statbuf ss_old_sbuf;
	struct __old_kernel_stat old_sbuf;

	/* fstat() the file */
	/*result*/regs->regs_R[2] = fstat(/*fd*/regs->regs_R[4], &old_sbuf);

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }

	/* translate from host stat structure to target format */
	ss_old_sbuf.ss_st_dev = (word_t)MD_SWAPH(old_sbuf.st_dev);
	ss_old_sbuf.ss_st_ino = (word_t)MD_SWAPH(old_sbuf.st_ino);
	ss_old_sbuf.ss_st_mode = (word_t)MD_SWAPH(old_sbuf.st_mode);
	ss_old_sbuf.ss_st_nlink = (word_t)MD_SWAPH(old_sbuf.st_nlink);
	ss_old_sbuf.ss_st_uid = (word_t)MD_SWAPH(old_sbuf.st_uid);
	ss_old_sbuf.ss_st_gid = (word_t)MD_SWAPH(old_sbuf.st_gid);
	ss_old_sbuf.ss_st_rdev = (word_t)MD_SWAPH(old_sbuf.st_rdev);
	ss_old_sbuf.ss_st_size = (long)MD_SWAPW(old_sbuf.st_size);
	ss_old_sbuf.ss_st_atime = (word_t)MD_SWAPW(old_sbuf.st_atime);
	ss_old_sbuf.ss_st_mtime = (word_t)MD_SWAPW(old_sbuf.st_mtime);
	ss_old_sbuf.ss_st_ctime = (word_t)MD_SWAPW(old_sbuf.st_ctime);

	ss_old_sbuf.ss_st_res1 = ss_old_sbuf.ss_st_res2 = ss_old_sbuf.ss_st_res3 = 0;
	ss_old_sbuf.ss_st_blksize = 0;
	ss_old_sbuf.ss_st_blocks = 0;
	ss_old_sbuf.ss_st_unused[0] = 0;
	ss_old_sbuf.ss_st_unused[1] = 0;

	/* copy fstat() results to simulator memory */
	mem_bcopy(mem_fn, mem, Write, /*old_sbuf*/regs->regs_R[5],
		  &ss_old_sbuf, sizeof(struct ss_old_statbuf));
#else
	      regs->regs_R[2] = -ENOSYS;
	      regs->regs_R[7] = 1;
#endif
      }
      break;


	  case SS_SYS_pause:
	  {
		/*result*/regs->regs_R[2] = pause();

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	  }
	  break;
	  

	case SS_SYS_utime:
	{
		char buf[MAXBUFSIZE];
		struct utimbuf times;
		struct ss_utimbuf ss_times;

		/* copy arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*filename*/regs->regs_R[4], buf);
		mem_bcopy(mem_fn, mem, Read, /*times*/regs->regs_R[5],
			&ss_times, sizeof(struct ss_utimbuf));

		/* translate from target utimbuf structure to host format */
		times.actime = MD_SWAPW(ss_times.ss_actime);
		times.modtime = MD_SWAPW(ss_times.ss_modtime);
	
		/*result*/regs->regs_R[2] = utime(buf, &times);

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;


	case SS_SYS_access:
      {
	char buf[MAXBUFSIZE];

	/* copy filename to host memory */
	mem_strcpy(mem_fn, mem, Read, /*fName*/regs->regs_R[4], buf);

	/* check access on the file */
	/*result*/regs->regs_R[2] = access(buf, /*mode*/regs->regs_R[5]);