sesl_tcl.c

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

   }
#endif

int writestr(Tcl_Interp *interp, ParseInfo *pip, char *str)
{
   VA addr;
   int st;

   if (!pip->sym) {
       ASSERT(0);
   }
       
   st = SESL_GetTargetType(pip->sym);
   
   if ((st != SESL_TYPE_CHAR) && (st != SESL_TYPE_UCHAR)) {
      return NO;
   }

   GET_VALUE(*pip, addr, VA);

   while (1) {
      if (CPUVec.PutMemory(CPUVec.CurrentCpuNum(), addr, 1,
                        (char *)str) != SUCCESS) {
         return ERROR;
      }
      if (*str == '\0') break;
      str++;
      addr++;
   }

   return OK;

error:
   return ERROR;
}

int symTclSet(Tcl_Interp *interp, int argc, char *argv[])
{
   ParseInfo pi;
   
   bzero((char*)&pi, sizeof(pi));

   if (SymParse(argv[2], &pi) != SYM_OK) {
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   }

   if (pi.constant) {
      Tcl_AppendResult(interp, "cannot set this type, its a constant", NULL);
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   } else if (pi.internal) {
      Tcl_AppendResult(interp, "can't write to simulator memory (?)", NULL);
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   }
   
   switch (SESL_GetType(pi.sym)) {
   case SESL_TYPE_CHAR:
   case SESL_TYPE_UCHAR: {
      char c = 0;
      int i = 0;
      if (sscanf(argv[3], "%d", &i) != 1) {
         Tcl_AppendResult(interp, "expected an int", NULL);
         SESL_FreeSymbol(pi.sym);
         return TCL_ERROR;
      }

      c = (char)i;
      
      SET_VALUE(pi, c, char);
      break;
   }
   case SESL_TYPE_SHORT:
   case SESL_TYPE_USHORT: {
      int i = 0;
      short s;
      if (sscanf(argv[3], "%i", &i) != 1) {
         Tcl_AppendResult(interp, "expected an int", NULL);
         SESL_FreeSymbol(pi.sym);
         return TCL_ERROR;
      }

      s = i;
      SET_VALUE(pi, s, short);
      break;
   }
   case SESL_TYPE_INT:
   case SESL_TYPE_LONG:
   case SESL_TYPE_UINT:
   case SESL_TYPE_ULONG: {
      int i = 0;
      if (sscanf(argv[3], "%i", &i) != 1) {
         Tcl_AppendResult(interp, "expected an int", NULL);
         SESL_FreeSymbol(pi.sym);
         return TCL_ERROR;
      }

      SET_VALUE(pi, i, int);
      break;
   }
   case SESL_TYPE_FLOAT: {
      float f = 0;
      if (sscanf(argv[3], "%f", &f) != 1) {
         Tcl_AppendResult(interp, "expected a float", NULL);
         SESL_FreeSymbol(pi.sym);
         return TCL_ERROR;
      }

      SET_VALUE(pi, f, float);
      break;
   }
   case SESL_TYPE_DOUBLE: {
      double d = 0;
      if (sscanf(argv[3], "%lf", &d) != 1) {
         Tcl_AppendResult(interp, "expected a double", NULL);
         SESL_FreeSymbol(pi.sym);
         return TCL_ERROR;
      }

      SET_VALUE(pi, d, double);
      break;
   }
   case SESL_TYPE_PTR: {
      int code = writestr(interp, &pi, argv[3]);
      if (code == OK) {
      } else if (code == NO) {
         int i = 0;
         if (sscanf(argv[3], "%i", &i) != 1) {
            Tcl_AppendResult(interp, "expected an int", NULL);
            SESL_FreeSymbol(pi.sym);
            return TCL_ERROR;
         }
         
         SET_VALUE(pi, i, int);
      } else {
         goto error;
      }
      break;
   }
   case SESL_TYPE_ARRAY: {
      int code = writestr(interp, &pi, argv[3]);
      if (code == OK) {
      } else if (code == NO) {
         /* XXX change ? */
         Tcl_AppendResult(interp, "can't write an array", NULL);
         SESL_FreeSymbol(pi.sym);
         return TCL_ERROR;
      } else {
         goto error;
      }
      break;
   }
   case SESL_TYPE_ENUM: {
      /* XXX change */
      Tcl_AppendResult(interp, "cannot set this type", NULL);
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   }
   case SESL_TYPE_STRUCT:
   case SESL_TYPE_UNION: {
      Tcl_AppendResult(interp, "cannot set this type", NULL);
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   }
   case SESL_TYPE_LABEL:
   case SESL_TYPE_FUNC:
   case SESL_TYPE_UNKNOWN:
   default:
       SESL_FreeSymbol(pi.sym);
       ASSERT(0);
       break;
   }

   SESL_FreeSymbol(pi.sym);
   return TCL_OK;

error:
   SIM_DEBUG(('t', "addr2 0x%x\n\r", pi.value));
   Tcl_AppendResult(interp, "addr not mapped", NULL);
   SESL_FreeSymbol(pi.sym);
   return TCL_ERROR;
}


/*
 *   symTclType
 */

int symTclType(Tcl_Interp *interp, int argc, char *argv[])
{
   ParseInfo pi;
   char *str;
   
   bzero((char*)&pi, sizeof(pi));

   if (SymParse(argv[2], &pi) != SYM_OK) {
       SESL_FreeSymbol(pi.sym);
       return TCL_ERROR;
   }

   str = SESL_GetTypeName(pi.sym);

   Tcl_SetResult(interp, str, TCL_STATIC);
   SESL_FreeSymbol(pi.sym);
   return TCL_OK;
}


/*
 *   symInt
 */

int SymInt(Tcl_Interp *interp, char *expr, uint64 *val)
{
   ParseInfo pi;
   char op[16];
   uint64 offset;
   char *str;

   bzero((char*)&pi, sizeof(pi));

   /* check for int first */
#ifdef __alpha
   if (sscanf(expr, "%li", val) == 1) {
      return TCL_OK;
   }
   if (sscanf(expr,"0x%lx%[-+]0x%lx",val,op,&offset)==3) { 
      if (*op == '+') {
	*val += offset;
      } else {
	*val -= offset;
      }
      return TCL_OK;
   }
   if (sscanf(expr,"0x%lx%[-+]%li",val,op,&offset)==3) { 
      if (*op == '+') {
	*val += offset;
      } else {
	*val -= offset;
      }
      return TCL_OK;
   }
   if (sscanf(expr,"0x%lx",val)==1) { 
      return TCL_OK;
   }
#else
   if (sscanf(expr, "%lli", val) == 1) {
      return TCL_OK;
   }
   if (sscanf(expr,"0x%llx%[-+]0x%llx",val,op,&offset)==3) { 
      if (*op == '+') {
	*val += offset;
      } else {
	*val -= offset;
      }
      return TCL_OK;
   }
   if (sscanf(expr,"0x%llx%[-+]%lli",val,op,&offset)==3) { 
      if (*op == '+') {
	*val += offset;
      } else {
	*val -= offset;
      }
      return TCL_OK;
   }
   if (sscanf(expr, "0x%llx", val) == 1) {
      return TCL_OK;
   }
#endif
   ASSERT(interp);
   
   if (SymParse(expr, &pi) != SYM_OK) {
       SESL_FreeSymbol(pi.sym);
       return TCL_ERROR;
   }

   switch (SESL_GetType(pi.sym)) {
   case SESL_TYPE_LABEL:
   case SESL_TYPE_FUNC:
   case SESL_TYPE_ARRAY: 
   {
      ASSERT(pi.constant);
      *val = (uint64)pi.value;
      break;
   }
   case SESL_TYPE_CHAR:
   case SESL_TYPE_UCHAR: {
      unsigned char c = 0;
      GET_VALUE(pi, c, unsigned char);
      *val = (uint64)c;
      break;
   }
   case SESL_TYPE_SHORT:
   case SESL_TYPE_USHORT: {
      unsigned short s = 0;
      GET_VALUE(pi, s, unsigned short);
      *val = (uint64)s;
      break;
   }
   case SESL_TYPE_INT:
   case SESL_TYPE_LONG:
   case SESL_TYPE_UINT:
   case SESL_TYPE_ULONG:
   case SESL_TYPE_PTR: 
   {
      uint i = 0;
      GET_VALUE(pi, i, uint);
      *val = (uint64)i;
      break;
   }
   case SESL_TYPE_ENUM: {
      Tcl_AppendResult(interp, "type not supported yet", NULL);
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   }
   case SESL_TYPE_FLOAT:
   case SESL_TYPE_DOUBLE:
   case SESL_TYPE_STRUCT:
   case SESL_TYPE_UNION: {
      Tcl_AppendResult(interp, "type not supported", NULL);
      SESL_FreeSymbol(pi.sym);
      return TCL_ERROR;
   }
   case SESL_TYPE_UNKNOWN:
   default:
      SIM_DEBUG(('t', "violating type = %d\n\r", SESL_GetType(pi.sym)));
      SESL_FreeSymbol(pi.sym);
      ASSERT(0);
      break;
   }

   SESL_FreeSymbol(pi.sym);
   return TCL_OK;

error:
   Tcl_AppendResult(interp, "addr not mapped", NULL);
   SESL_FreeSymbol(pi.sym);
   return TCL_ERROR;
}


/*
 *   symTclType
 */

int symTclFind(Tcl_Interp *interp, int argc, char *argv[])
{
   Reg addr;
   char *cptr;
   
   if (String2Reg(interp, argv[3], &addr) != TCL_OK) {
      return TCL_ERROR;
   }
   
   if (!(cptr = SESL_Addr2Symbolic(argv[2], addr))) {
      return TCL_ERROR;
   }

   Tcl_SetResult(interp, cptr, TCL_STATIC);
   
   return TCL_OK;
}


/* insultate rest of symbol stuff from tcl */
void SymReportError(char *first, ...)
{
   va_list ap;
   char *next;

   Tcl_SetResult(TCLInterp, first, TCL_STATIC);
   
   va_start(ap, first);

   while ((next = va_arg(ap, char *))) {
      Tcl_AppendResult(TCLInterp, next, NULL);
   }

   va_end(ap);
}