symtcl.c

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

         return TCL_ERROR;
      }

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

      s = i;
      SET_VALUE(pi, s, short);
      break;
   }
   case tInt:
   case tLong:
   case tUInt:
   case tULong: {
      int i = 0;
      if (sscanf(argv[3], "%i", &i) != 1) {
         Tcl_AppendResult(interp, "expected an int", NULL);
         return TCL_ERROR;
      }

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

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

      SET_VALUE(pi, d, int64);
      break;
   }
   case tPtr: {
      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);
            return TCL_ERROR;
         }
         
         SET_VALUE(pi, i, int);
      } else {
         goto error;
      }
      break;
   }
   case tArray: {
      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);
         return TCL_ERROR;
      } else {
         goto error;
      }
      break;
   }
   case tEnum: {
      /* XXX change */
      Tcl_AppendResult(interp, "cannot set this type", NULL);
      return TCL_ERROR;
   }
   case tStruct:
   case tUnion: {
      Tcl_AppendResult(interp, "cannot set this type", NULL);
      return TCL_ERROR;
   }
   case tLabel:
   case tProc:
   case tAddr:
   case tNil:
   default:
      ASSERT(0);
      break;
   }

   return TCL_OK;

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


/*
 *   symTclType
 */

int symTclType(Tcl_Interp *interp, int argc, char *argv[])
{
   ParseInfo pi;
   char *str;
   
   if (SymParse(argv[2], &pi) != SYM_OK) {
      return TCL_ERROR;
   }

   switch (SymType(&pi.sym, 0)) {
   case tNil:
      str = "nil";
      break;
   case tLabel:
      str = "label";
      break;
   case tProc:
      str = "proc";
      break;
   case tStruct:
      /* XXX change */
      str = "struct";
      break;
   case tUnion:
      /* XXX change */
      str = "union";
      break;
   case tEnum:
      /* XXX change */
      str = "enum";
      break;
   case tChar:
      str = "char";
      break;
   case tUChar:
      str = "uchar";
      break;
   case tShort:
      str = "short";
      break;
   case tUShort:
      str = "ushort";
      break;
   case tInt:
      str = "int";
      break;
   case tUInt:
      str = "uint";
      break;
   case tLong:
      str = "long";
      break;
   case tULong:
      str = "ulong";
      break;
   case tFloat:
      str = "float";
      break;
   case tDouble:
      str = "double";
      break;
   case tTypedef:
      str = "typedef";
      break;
   case tAddr:
      /* XXX change */
      str = "addr";
      break;
   case tPtr:
      /* XXX change */
      str = "ptr";
      break;
   case tArray:
      /* XXX change */
      str = "array";
      break;
   default:
      ASSERT(0);
      str = "";  /* Quite compiler warning. */
      break;
   }

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


/*
 *   symInt
 */

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

   /* 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) {
      return TCL_ERROR;
   }

   switch (SymType(&pi.sym, SYM_RESOLVE)) {
   case tLabel:
   case tProc:
   case tAddr:
   case tArray: {
      ASSERT(pi.constant);
      *val = (uint64)pi.value;
      break;
   }
   case tChar:
   case tUChar: {
      unsigned char c = 0;
      GET_VALUE(pi, c, unsigned char);
      *val = (uint64)c;
      break;
   }
   case tShort:
   case tUShort: {
      unsigned short s = 0;
      GET_VALUE(pi, s, unsigned short);
      *val = (uint64)s;
      break;
   }
   case tInt:
   case tLong:
   case tUInt:
   case tULong:
   case tPtr: {
      uint i = 0;
      GET_VALUE(pi, i, uint);
      *val = (uint64)i;
      break;
   }
   case tEnum: {
      Tcl_AppendResult(interp, "type not supported yet", NULL);
      return TCL_ERROR;
   }
   case tFloat:
   case tDouble:
   case tStruct:
   case tUnion: {
      Tcl_AppendResult(interp, "type not supported", NULL);
      return TCL_ERROR;
   }
   case tNil:
   default:
      SIM_DEBUG(('t', "violating type = %d\n\r", SymType(&pi.sym, SYM_RESOLVE)));
      ASSERT(0);
      break;
   }

   return TCL_OK;

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


/*
 *   symTclType
 */

int symTclFind(Tcl_Interp *interp, int argc, char *argv[])
{
   Symb sym;
   int addr;
   char buf[32];
   
   if (Tcl_GetInt(interp, argv[3], &addr) != TCL_OK) {
      return TCL_ERROR;
   }
   
   if (SymAddr2Symbol(argv[2], addr, &sym) != SYM_OK) {
      return TCL_ERROR;
   }

   Tcl_SetResult(interp, sym.name, TCL_STATIC);
   
   if (sym.value != addr) { 
      sprintf(buf, "+%d", (uint)addr - (uint)sym.value);
      Tcl_AppendResult(interp, buf, NULL);
   }
   
   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);
}