tcl_init.c

一个用在mips体系结构中的操作系统

            fp = fopen(fullFileName, "r");
            if (fp) { 
               fclose(fp);
               return fullFileName;
            }
         }
      }
   }
   
   return NULL;
}


/* Evaluate a file on a remote server. Code stolen from
 TclUnixUtil.c  Note that I don't modify tcl's concept
 of the current script, since that's only available as
 an internal slot.*/

static int 
EvalRemote(Tcl_Interp *interp, char *name) {
   FILE *fp = NULL;
   Tcl_DString buffer;
   int amountRead = 0;
   int result;
   Tcl_DStringInit(&buffer);
   
   if ((fp = Simrmt_RemoteFileOpen(name)) == NULL) {
      return TCL_ERROR;
   }
           
   do {
      char cmdBuffer[8192];
      amountRead = fread(cmdBuffer, 1, 8192, fp);
      Tcl_DStringAppend(&buffer, cmdBuffer, amountRead);
   } while (amountRead == 8192);

   /* Ready to evaluate. */
   result = Tcl_Eval(interp, Tcl_DStringValue(&buffer));
   if (result == TCL_RETURN) {
      result = TCL_OK;
   }
   if (result == TCL_ERROR) {
      char msg[200];
      sprintf(msg, "\n    (file \"%.150s\" line %d)", 
              Tcl_DStringValue(&buffer),
              interp->errorLine);
      Tcl_AddErrorInfo(interp, msg);
   }
   Tcl_DStringFree(&buffer);
   fclose(fp);
   return result;
}

static int
SourceCmd(ClientData clientData, Tcl_Interp *interp,
                 int argc, char *argv[])
{
   char *givenFile;
   char *filename;
   
   if (argc != 2) {
      Tcl_AppendResult(interp, "wrong # args: should be \"",
                       argv[0], " scriptName\"", NULL);
      return TCL_ERROR;
   }

   givenFile = argv[1];

   filename = SearchForFile(givenFile);
   if (filename) { 
      if (strchr(filename,':')) {
         return EvalRemote(interp, filename);
      } else {
         return Tcl_EvalFile(interp, filename);
      }
   }

   Tcl_AppendResult(interp, "can't find file to source", NULL);
   return TCL_ERROR;
}


static int
RandomCmd(ClientData clientData, Tcl_Interp *interp,
                 int argc, char *argv[])
{
   int value;
   int limit;
   char buf[32];
#if !defined(__alpha) && !defined(linux)
   extern long random(void);
#endif
#ifdef some_platform_maybe_sun
   extern int srandom(unsigned seed);
#endif
   
   if (argc < 2) {
      goto error;
   }
   
   if (!strcmp(argv[1], "seed")) {
      if (argc == 2) {
         value = time(0);

      } else if (argc == 3) {
         if (Tcl_GetInt(interp, argv[2], &value) != TCL_OK) {
            return TCL_ERROR;
         }

      } else {
         goto error;
      }

      srandom(value);
      
   } else {
      if (argc != 2) {
         goto error;
      }
      
      if (Tcl_GetInt(interp, argv[1], &limit) != TCL_OK) {
         return TCL_ERROR;
      }

      sprintf(buf, "%d", (int)(random() % limit));

      Tcl_AppendResult(interp, buf, NULL);
   }

   return TCL_OK;

error:
   Tcl_AppendResult(interp, "wrong # args: should be \"",
                    argv[0], " limit | seed ?value?\"", NULL);
   return TCL_ERROR;
}


/*
 * Tcl Error Handler
 */

int HandlerCmd(ClientData clientData, Tcl_Interp *interp,
               int argc, char *argv[])
{
   errorHandlingScript = SaveString(argv[1]);
   return TCL_OK;
}

void HandleError(Tcl_Interp *interp, char *script)
{
   char buf[64];

   if (errorHandlingScript) {
      sprintf(buf, "\n    (script line %d)", interp->errorLine);
      Tcl_AddErrorInfo(interp, buf);
      
      Tcl_AddErrorInfo(interp, "\n    invoked from within\n{");
      Tcl_AddErrorInfo(interp, (char*)script);
      Tcl_AddErrorInfo(interp, "}");
      
      if (Tcl_GlobalEval(interp, errorHandlingScript) != TCL_OK) {
         CPUWarning("Tcl ERROR in error handler: %s\n", interp->result);
      }
      
   } else {
      CPUWarning("Tcl ERROR: %s\n", interp->result);
   }
}

static int 
MachineSelectCmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[])
{
   int listArgc, count, retVal = TCL_OK;
   Tcl_IntValueType listVal;
   char **listArgv;
   int machineVecBackup[MAX_MACHINES];
   MachineScopeType machineScopeBackup;

   if (argc != 3) {
      interp->result = "wrong # args";
      return TCL_ERROR;
   }
   if (Tcl_SplitList(interp, argv[1], &listArgc, &listArgv) != TCL_OK) {
      return TCL_ERROR;
   }

   /* Save the vector for later */
   for (count = 0; count < MAX_MACHINES; count++) {
      machineVecBackup[count] = machineParamVec[count];
      machineParamVec[count] = FALSE;
   }
   machineScopeBackup = machineScope;
   machineScope = MACHINE_BLOCK;

   /* Update the vector for the current machine block */
   for (count = 0; (retVal == TCL_OK) && (count < listArgc); count++) {
      retVal = Tcl_ExprLong(interp, listArgv[count], &listVal);
      if ((retVal == TCL_OK) && (listVal < 0 || listVal >= MAX_MACHINES)) {
         interp->result = "machine number out of range";
         retVal = TCL_ERROR;
      }
      if ((retVal == TCL_OK) && !machineVecBackup[listVal]) {
         interp->result = "can only write to machines active in current machine scope";
         retVal = TCL_ERROR;
      }
      if (retVal == TCL_OK)
         machineParamVec[listVal] = TRUE;
   }

   if (retVal == TCL_OK)
      retVal = Tcl_GlobalEval(interp, argv[2]);

   /* Restore the vector (even if there was an error above) */
   for (count = 0; count < MAX_MACHINES; count++) {
      machineParamVec[count] = machineVecBackup[count];
   }
   machineScope = machineScopeBackup;

   return retVal;
}  

static int 
MachineValueCmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[])
{
   int count, retVal = TCL_OK;
   Tcl_IntValueType machineVal;
   int machineVecBackup[MAX_MACHINES];
   MachineScopeType machineScopeBackup;
   char *string;

   if (argc != 3) {
      interp->result = "wrong # args";
      return TCL_ERROR;
   }

   /* Update the vector for the current machine block */
   if (Tcl_ExprLong(interp, argv[1], &machineVal) != TCL_OK)
      return TCL_ERROR;
   if ((retVal == TCL_OK) && (machineVal < 0 || machineVal >= MAX_MACHINES)) {
      interp->result = "machine number out of range";
      return TCL_ERROR;
   }

   /* Save the vector for later */
   for (count = 0; count < MAX_MACHINES; count++) {
      machineVecBackup[count] = machineParamVec[count];
      machineParamVec[count] = (count==machineVal)?TRUE:FALSE;
   }
   machineScopeBackup = machineScope;
   machineScope = MACHINE_VAL;

   string = Tcl_GetVar(interp, argv[2], TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG);
   if (string == NULL)
      retVal = TCL_ERROR;
   else
      interp->result = string;

   /* Restore the vector (even if there was an error above) */
   for (count = 0; count < MAX_MACHINES; count++) {
      machineParamVec[count] = machineVecBackup[count];
   }
   machineScope = machineScopeBackup;

   return retVal;
}

static int
LogCmd(ClientData clientData, Tcl_Interp *interp,
              int argc, char *argv[])
{
   int i;
   int cnxt = VisualGetContext();
   
   if (cnxt > 0) { 
      Tcl_SetResult(interp, "",TCL_STATIC );

      for (i=1; i<argc; i++) {
         Tcl_AppendResult(interp, argv[i], 0);
      }
      VisualPushString(interp->result);
      Tcl_SetResult(interp,"OK",TCL_STATIC);

   } else {
      for (i=1; i<argc; i++) {
         CPUPrint("%s", argv[i]);
      }
   }
   
   return TCL_OK;
}

static int
ConsoleCmd(ClientData clientData, Tcl_Interp *interp,
                  int argc, char *argv[])
{
   int i;
   char *mark;
   
   for (i=1; i<argc; i++) {
      CPUPrint("%s", argv[i]);
      
      mark = argv[i];
      while (*mark) {
         fputc(*mark, stderr);
         if (*mark == '\n') {
            fputc('\r', stderr);
         }
         mark++;
      }
   }

   return TCL_OK;
}

static int
DebugCmd(ClientData clientData, Tcl_Interp *interp,
                int argc, char *argv[])
{
   int cpuid;
   if (argc == 1) {
      cpuid = -1;      /* code for any cpu */
   } else {
      if (Tcl_GetInt(interp, argv[1], &cpuid) != TCL_OK) {
         Tcl_AppendResult(interp, "Bad cpu number passed to debug command",
                          NULL);
         return TCL_ERROR;
      }

      ASSERT(TOTAL_CPUS);
      if (cpuid < 0 || cpuid >= TOTAL_CPUS) {
         Tcl_AppendResult(interp, "Bad cpu number passed to debug command",
                          NULL);
         return TCL_ERROR;
      }
   }
   
   CPUVec.Handle_Debug_Signal(cpuid, 0);
   return TCL_OK;
}


static int
AssertCmd(ClientData clientData, Tcl_Interp *interp,
                 int argc, char *argv[])
{
   int result, code;
   
   if (argc == 1) {
      CPUError("Tcl assert failing (looping)\n");
   
   } else if (argc == 2) {
      if ((code = Tcl_ExprBoolean(interp, argv[1], &result)) != TCL_OK) {
         return code;
      }

      if (!result) {
         CPUError("Tcl assertion failed (looping): %s\n", argv[1]);
      }
      
   } else {
      Tcl_AppendResult(interp, "Bad number of args, should be: assert expr", NULL);
      return TCL_ERROR;
   }

   return TCL_OK;
}

static int
CPUEnterCmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[])
{
#if defined(SIM_MIPS32) || defined(SIM_MIPS64) || defined(SIM_ALPHA)
   CPUType newSimulator = NO_CPU;
   char buf[64];

   if ((argc < 2) || (argc > 3)) {
      Tcl_AppendResult(interp, "Wrong number of args, should be: "
                       "cpuEnter cpuModel ?cpuNum?\n", NULL);
      return TCL_ERROR;
   }
   /* Three argument version -- switch a specific CPU between MIPSY and MXS */
   if (argc == 3) {
      int cpuNum;
#if defined(SIM_ALPHA)
   ASSERT(0);
#else
      /* RPB hack -- calling directly into mipsy/MXS from common */
      extern void MXSSwitch(int cpu, int enterMXS);

      if (Tcl_GetInt(interp, argv[2], &cpuNum) != TCL_OK) {
         Tcl_AppendResult(interp, "Can't parse cpu number '%s' for cpuEnter\n",
                          argv[2], NULL);
         return TCL_ERROR;
      }

      ASSERT(TOTAL_CPUS);
      if ((cpuNum < 0) || (cpuNum >= TOTAL_CPUS)) {
         Tcl_AppendResult(interp, "Cpu number %s out of bounds for cpuEnter\n",
                          argv[2], NULL);
         return TCL_ERROR;
      }
      if (!strcmp(argv[1], "mipsy"))
         MXSSwitch(cpuNum, FALSE);
      else if (!strcmp(argv[1], "mxs"))
         MXSSwitch(cpuNum, TRUE);
      else {
         Tcl_AppendResult(interp, "Can't enter cpu type: %s\n", argv[1], NULL);
         return TCL_ERROR;
      }
#endif
   }
   /* Two argument version -- switch entire simulator between CPU models */
   else {
      int cpuType;
      for (cpuType = BASE; cpuType <= NO_CPU; cpuType++) {
         if (strcmp(argv[1], simName[cpuType]) == 0) {
         newSimulator = cpuType;
         break;
         }
      }
      if (cpuType >= NO_CPU) {
         sprintf(buf, "Can't enter cpu type: %s\n", argv[1]);
         Tcl_AppendResult(interp, buf, NULL);
         return TCL_ERROR;
      }

      free(machines.CpuModel);
      machines.CpuModel = SaveString(argv[1]);
      
      CPUVec.ExitSimulator(newSimulator);
   }
   return TCL_OK;

#endif
}

static int
SimosExitCmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[])
{
   CPUType newSimulator;

   if (argc != 1) {
      Tcl_AppendResult(interp, "Wrong number of args, should be: ", argv[0], NULL);
      return TCL_ERROR;
   }
   
   newSimulator = NO_CPU;
   CPUVec.ExitSimulator(newSimulator);

   return TCL_OK;
}

static int
ProfileCmd(ClientData clientData, Tcl_Interp *interp,
                  int argc, char *argv[])
{
   if (argc != 2) {
      Tcl_AppendResult(interp, "Wrong number of args, should be: profile start|stop\n",
                       NULL);
      return TCL_ERROR;
   }
   if (!strcmp(argv[1], "start")) {
      StartProfile();
   } else if (!strcmp(argv[1], "stop")) {
      StopProfile();
   } else {
      Tcl_AppendResult(interp, "Bad arg, should be: profile start|stop\n",
                       NULL);
      return TCL_ERROR;
   }
   return TCL_OK;
}

extern char *CheckpointID;

static int
DoCheckpointCmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[])
{
   ASSERT(CPUVec.DoCheckpoint);
   if (argc == 2) 
      CheckpointID = argv[1];
   CPUVec.DoCheckpoint(0);

   return TCL_OK;
}

static int
DisableCPUCmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[])
{
   int cpuNum;

   if (argc != 2) {
      Tcl_AppendResult(interp, "Bad arg, should be: disableCPU cpuNum\n",
                       NULL);
      return TCL_ERROR;  
   }
   cpuNum = atoi(argv[1]);
   ASSERT (CPUVec.FaultInject);
   CPUVec.FaultInject(cpuNum,SIMFAULT_DISABLECPU);