/*
 * Copyright (C) 1996-1998 by the Board of Trustees
 *    of Leland Stanford Junior University.
 * 
 * This file is part of the SimOS distribution. 
 * See LICENSE file for terms of the license. 
 *
 */

/* Tcl interface to symbol commands.
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <netinet/in.h>
#include "tcl_init.h"
#include "cpu_interface.h"
#include "symexpr.h"
#include "symfile.h"
#include "symbols.h"
#include "sim_error.h"

#define OK 0
#define ERROR 1
#define NO 2

static int symTclLoad(Tcl_Interp *interp, int argc, char *argv[]);
static int symTclRead(Tcl_Interp *interp, int argc, char *argv[]);
static int symTclType(Tcl_Interp *interp, int argc, char *argv[]);
static int symTclSet(Tcl_Interp *interp, int argc, char *argv[]);
static int symTclFind(Tcl_Interp *interp, int argc, char *argv[]);

static tclcmd symcmds[] = {
{   "load",      4, symTclLoad,       " load exeName path"},
{   "read",      3, symTclRead,       " read symexp"},
{   "set",       4, symTclSet,        " set symexp value"},
{   "type",      3, symTclType,       " type symexp"},
{   "find",      4, symTclFind,       " find execname addr"},
{   NULL,        0, NULL,             NULL}
};


static int readstr(Tcl_Interp *interp, ParseInfo *pip);


void SymInit(Tcl_Interp *interp)
{
   Tcl_CreateCommand(interp, "symbol", DispatchCmd, (ClientData) symcmds, NULL);
}

int symTclLoad(Tcl_Interp *interp, int argc, char *argv[])
{
#ifdef DWARF2__not
   if (Dwarf_SymLoad(argv[3], argv[2]) != SYM_OK) {
      return TCL_ERROR;
   }
#else
   if (SymLoad(argv[3], argv[2]) != SYM_OK) {
      return TCL_ERROR;
   }
#endif
   return TCL_OK;
}

/*
 *    symTclRead
 */

#ifdef HOST_BIG_ENDIAN
#define GET_VALUE(_pi, _var, _type) \
    if ((_pi).constant) { \
       _var = (_type)(_pi).value; \
    } else if ((_pi).internal) { \
       _var = *(_type *)(_pi).value; \
    } else { \
       if (!CPUVec.GetMemory || \
           CPUVec.GetMemory(CPUVec.CurrentCpuNum(), \
                            (_pi).value, sizeof(_type), (char*)&(_var)) \
           != SUCCESS) { \
          goto error; \
       } \
    }
#endif
#ifdef HOST_LITTLE_ENDIAN
#define GET_VALUE(_pi, _var, _type) \
    if ((_pi).constant) { \
       _var = (_type)(_pi).value; \
    } else if ((_pi).internal) { \
       ASSERT (0); \
    } else { \
       if (!CPUVec.GetMemory || \
           CPUVec.GetMemory(CPUVec.CurrentCpuNum(), \
                            (_pi).value, sizeof(_type), (char*)&(_var)) \
           != SUCCESS) { \
          goto error; \
       } \
       if (sizeof(_type)==2) _var = BE2HO_2(_var); \
       if (sizeof(_type)==4) _var = BE2HO_4(_var); \
       if (sizeof(_type)==8) _var = BE2HO_8(_var); \
    }
#endif

int readstr(Tcl_Interp *interp, ParseInfo *pip)
{
   Tcl_DString dstr;
   char c = '\0';
   VA addr;
   Symb tmp = pip->sym;
   int st;
   
   if (SymSubtype(&tmp, SYM_RESOLVE) != SYM_OK) {
      ASSERT(0);
   }

   st = SymType(&tmp, SYM_RESOLVE);
   
   if ((st != tChar) && (st != tUChar)) {
      return NO;
   }

   GET_VALUE(*pip, addr, VA);


   Tcl_DStringInit(&dstr);
   
   while (1) {
      if (pip->internal) {
#if defined(sgi) || defined(sun)
         c = *(char*)addr;
#else
         ASSERT (0);
#endif
         
      } else if (CPUVec.GetMemory(CPUVec.CurrentCpuNum(), addr, 1,
                           (char *)&c) != SUCCESS) {
         return ERROR;
      }
      
      if (!c) {
         break;
      }

      Tcl_DStringAppend(&dstr, &c, 1);
      addr++;
   }

   Tcl_DStringResult(interp, &dstr);
   return OK;

error:
   Tcl_DStringFree(&dstr);
   return ERROR;
}

int symTclRead(Tcl_Interp *interp, int argc, char *argv[])
{
   ParseInfo pi;
   char buf[128];
   
   if (SymParse(argv[2], &pi) != SYM_OK) {
#ifdef notdef
      if ((pi.str - argv[2]) < 128) {
         strncpy(buf, argv[2], pi.str - argv[2]);
         buf[pi.str - argv[2]] = '\0';
         Tcl_AppendResult(interp, "\n  ", buf, NULL);
      }
#endif
      
      return TCL_ERROR;
   }

   switch (SymType(&pi.sym, SYM_RESOLVE)) {
   case tLabel:
   case tProc:
   case tAddr: {
      ASSERT(pi.constant);
      PrintLLX(buf,(uint64)pi.value);
      break;
   }
   case tChar: {
      char c = 0;
      GET_VALUE(pi, c, char);
      sprintf(buf, "%d", (int)c);
      break;
   }
   case tUChar: {
      unsigned char c = 0;
      GET_VALUE(pi, c, unsigned char);
      sprintf(buf, "%u", (unsigned)c);
      break;
   }
   case tShort: {
      short s = 0;
      GET_VALUE(pi, s, short);
      sprintf(buf, "%d", (int)s);
      break;
   }
   case tUShort: {
      unsigned short s = 0;
      GET_VALUE(pi, s, unsigned short);
      sprintf(buf, "%u", (unsigned)s);
      break;
   }
   case tInt: {
      int i = 0;
      GET_VALUE(pi, i, int);
      sprintf(buf, "%d", i);
      break;
   }

   case tLong: {
      /*
       * XXX Reg should be a long in the target system 
       */
      Reg_s i = 0;
      GET_VALUE(pi, i, Reg_s);
      PrintLLD(buf,(int64)i);
      break;
   }
   case tUInt:{
      unsigned i = 0;
      GET_VALUE(pi, i, unsigned);
      sprintf(buf, "%u", i);
      break;
   }
   case tULong: {
      Reg i = 0;
      GET_VALUE(pi, i, Reg);
      PrintLLU(buf,(uint64)i);
      break;
   }
   case tFloat: {
      uint f = 0;
      float *fptr = (float*)&f;
      GET_VALUE(pi, f, uint);
      sprintf(buf, "%f", *fptr);
      break;
   }
   case tDouble: {
      int64 d = 0;
      double *dptr = (double *)&d;
      GET_VALUE(pi, d, int64);
      sprintf(buf, "%f", *dptr);
      break;
   }
   case tPtr: {
      int code = readstr(interp, &pi);
      if (code == OK) {
         return TCL_OK;
      } else if (code == NO) {
         Reg p = 0;
         GET_VALUE(pi, p, Reg);
         PrintLLX(buf,(uint64)p);
      } else if (code == ERROR) {
         goto error;
      }
      break;
   }
   case tArray: {
      int code;
      ASSERT(pi.constant);
      code = readstr(interp, &pi);
      if (code == OK) {
         return TCL_OK;
      } else if (code == NO) {
         PrintLLX(buf, (uint64)pi.value);
      } else {
         goto error;
      }
      break;
   }
   case tStruct:
   case tUnion:
   case tEnum: {
      /* XXX change */
      ASSERT(!pi.constant);
      Tcl_AppendResult(interp, "type not impl yet", NULL);
      return TCL_ERROR;
   }
   case tNil:
   default:
      SIM_DEBUG(('t', "offending type %d\n\r", SymType(&pi.sym, SYM_RESOLVE)));
      CPUWarning("offending type %d\n\r", SymType(&pi.sym, SYM_RESOLVE));
      ASSERT(0);
      break;
   }
   Tcl_SetResult(interp, buf, TCL_VOLATILE);
   return TCL_OK;

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


/*
 *   symTclSet
 */

#if SAME_ENDIAN
#define SET_VALUE(_pi, _var, _type) \
    ASSERT(!(_pi).constant); \
    ASSERT(!(_pi).internal); \
    { _type x = _var;   \
     if (sizeof(_type)==2) x = BE2HO_2(x); \
     if (sizeof(_type)==4) x = BE2HO_4(x); \
     if (sizeof(_type)==8) x = BE2HO_8(x); \
    if (!CPUVec.PutMemory || \
        CPUVec.PutMemory(CPUVec.CurrentCpuNum(), \
                         (_pi).value, sizeof(_type), (char*)&x) \
        != SUCCESS) { \
        goto error; \
    } \
   }
#else
/*XXXblythe hack things up to handle float/double*/
#define SET_VALUE(_pi, _var, _type) \
    ASSERT(!(_pi).constant); \
    ASSERT(!(_pi).internal); \
    { _type x = _var;   \
     if (sizeof(_type)==2) { short* y = (short*)&x; *y = BE2HO_2(*y); } \
     if (sizeof(_type)==4) { int* y = (int*)&x; *y = BE2HO_4(*y); } \
     if (sizeof(_type)==8) { long long* y = (long long*)&x; *y = BE2HO_8(*y); } \
    if (!CPUVec.PutMemory || \
        CPUVec.PutMemory(CPUVec.CurrentCpuNum(), \
                         (_pi).value, sizeof(_type), (char*)&x) \
        != SUCCESS) { \
        goto error; \
    } \
   }
#endif

int writestr(Tcl_Interp *interp, ParseInfo *pip, char *str)
{
   int addr;
   Symb tmp = pip->sym;
   int st;
   
   if (SymSubtype(&tmp, 0) != SYM_OK) {
      ASSERT(0);
   }

   st = SymType(&tmp, SYM_RESOLVE);
   
   if ((st != tChar) && (st != tUChar)) {
      return NO;
   }

   GET_VALUE(*pip, addr, int);
   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;
   
   if (SymParse(argv[2], &pi) != SYM_OK) {
      return TCL_ERROR;
   }

   if (pi.constant) {
      Tcl_AppendResult(interp, "cannot set this type, its a constant", NULL);
      return TCL_ERROR;
   } else if (pi.internal) {
      Tcl_AppendResult(interp, "can't write to simulator memory (?)", NULL);
      return TCL_ERROR;
   }
   
   switch (SymType(&pi.sym, SYM_RESOLVE)) {
   case tChar:
   case tUChar: {
      char c = 0;
      int i = 0;
      if (sscanf(argv[3], "%d", &i) != 1) {
         Tcl_AppendResult(interp, "expected an int", NULL);
         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, float);
      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, double);
      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);
}