gbx_trace.c

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

  *len = sprintf(COMMON_buffer, "%ld", value->_integer.value);
  *addr = COMMON_buffer;

  return;

__DATE:

  LOCAL_format_date(DATE_split(value), LF_STANDARD, NULL, 0, addr, len);
  return;

__FLOAT:

  LOCAL_format_number(value->_float.value, LF_STANDARD, NULL, 0, addr, len, TRUE);
  return;

__STRING:

  {
    int i;
    char *d;
    const char *s;
    uchar c;

    s = value->_string.addr + value->_string.start;
    d = COMMON_buffer;

    *d++ = '"';

    for (i = 0; i < value->_string.len; i++)
    {
      if (i > 128)
      {
        strcpy(d, "...");
        d += 3;
        break;
      }

      c = s[i];

      if (c < 32)
      {
        *d++ = '\\';

        if (c == 10)
          *d++ = 'n';
        else if (c == 13)
          *d++ = 'r';
        else if (c == 9)
          *d++ = 't';
        else
          d += sprintf(d, "x%02X", c);
      }
      else if (c == '\"')
      {
        *d++ = '\\';
        *d++ = c;
      }
      else
      {
        *d++ = c;
      }
    }

    *d++ = '"';

    *addr = COMMON_buffer;
    *len = d - COMMON_buffer;
  }

  return;

__OBJECT:

  if (VALUE_is_null(value))
    goto __NULL;

  *more = !CLASS_is_native(OBJECT_class(value->_object.object));

  *len = sprintf(COMMON_buffer, "%s %p", OBJECT_class(value->_object.object)->name, value->_object.object);
  *addr = COMMON_buffer;
  return;

__VARIANT:

  conv = *value;
  value = &conv;
  VARIANT_undo(value);
  goto __CONV;

__VOID:

  *addr = "(void)";
  *len = 6;
  return;

__CLASS:

  {
    CLASS *class = value->_class.class;
    *more = (!CLASS_is_native(class) && class->load->n_stat > 0);

    *len = sprintf(COMMON_buffer, "%s %p", class->name, class);
    *addr = COMMON_buffer;
    return;
  }

__ARRAY:

  *len = sprintf(COMMON_buffer, "ARRAY %p", value->_array.addr);
  *addr = COMMON_buffer;
  return;

__LONG:
__STRUCT:
__FUNCTION:

  THROW(E_TYPE, TYPE_get_name(T_STRING), TYPE_get_name(value->type));
}


PUBLIC void print_value(VALUE *value, bool format)
{
  char *pval;
  long lpval;
  boolean more;

  if (format)
    to_string(value, &pval, &lpval, &more);
  else
    VALUE_to_string(value, &pval, &lpval);

  fprintf(_out, "%.*s\n", (int)lpval, pval);
}


PRIVATE void command_local(const char *cmd)
{
  int i;
  LOCAL_SYMBOL *lp;
  bool nl = TRUE;

  if (FP)
  {
    if (cmd[1] == 0)
    {
      for (i = 0; i < FP->debug->n_local; i++)
      {
        lp = &FP->debug->local[i];
        fprintf(_out, "%.*s ", lp->sym.len, lp->sym.name);
      }
    }
    else
    {
      cmd++;

      for (i = 0; i < FP->debug->n_local; i++)
      {
        lp = &FP->debug->local[i];
        if (lp->sym.len == strlen(cmd) && strncasecmp(lp->sym.name, cmd, lp->sym.len) == 0)
        {
          fprintf(_out, "=");
          print_value(&BP[lp->value], TRUE);
          nl = FALSE;
          break;
        }
      }
    }
  }

  if (nl)
    new_line();
}


PRIVATE void print_symbol(GLOBAL_SYMBOL *gp, bool is_static, bool is_public)
{
  if (CTYPE_get_kind(gp->ctype) != TK_VARIABLE)
    return;

  if (CTYPE_is_static(gp->ctype) && !is_static)
    return;

  if (!CTYPE_is_static(gp->ctype) && is_static)
    return;

  if (CTYPE_is_public(gp->ctype) && !is_public)
    return;

  if (!CTYPE_is_public(gp->ctype) && is_public)
    return;

  fprintf(_out, "%.*s ", gp->sym.len, gp->sym.name);
}


PRIVATE void command_object(const char *cmd)
{
  int i;
  GLOBAL_SYMBOL *gp;

  if (CP)
  {
    fprintf(_out, "S: ");

    for (i = 0; i < CP->load->n_global; i++)
    {
      gp = &CP->load->global[i];
      print_symbol(gp, TRUE, TRUE);
    }

    fprintf(_out, "s: ");

    for (i = 0; i < CP->load->n_global; i++)
    {
      gp = &CP->load->global[i];
      print_symbol(gp, TRUE, FALSE);
    }
  }

  if (OP)
  {
    fprintf(_out, "D: ");

    for (i = 0; i < CP->load->n_global; i++)
    {
      gp = &CP->load->global[i];
      print_symbol(gp, FALSE, TRUE);
    }

    fprintf(_out, "d: ");

    for (i = 0; i < CP->load->n_global; i++)
    {
      gp = &CP->load->global[i];
      print_symbol(gp, FALSE, FALSE);
    }
  }

  new_line();
}

/*
PRIVATE void old_command_local(char *cmd)
{
  int i;
  VALUE value;
  int index;
  LOCAL_SYMBOL *lp;

  if (CP == NULL)
    return;

  if (OP)
  {
    value.type = T_OBJECT;
    value._object.class = CP;
    value._object.object = OP;
    print_value("ME", 0, &value);
  }
  else
  {
    value.type = T_CLASS;
    value._class.class = CP;
    print_value("CLASS", 0, &value);
  }

  if (FP == NULL)
    return;

  for (i = 0; i < FP->debug->n_local; i++)
  {
    lp = &FP->debug->local[i];
    index = lp->value;
    value = BP[index];
    print_value(lp->sym.name, lp->sym.len, &value);
  }
}
*/

#if 0
PRIVATE void command_print(char *cmd)
{
  OBJECT *object;
  CLASS *class;
  int i;
  VALUE value;
  GLOBAL_SYMBOL *gp;
  CLASS_VAR *var;
  char *addr;

  if (CP == NULL)
    return;

  if (sscanf(cmd, "?%p", &object) != 1)
  {
    printf("Syntax error\n");
    return;
  }

  if (object == NULL)
  {
    printf("Null pointer\n");
    return;
  }

  class = OBJECT_class(object);
  if (class == CLASS_Class)
  {
    class = (CLASS *)object;
    object = NULL;
  }
  else
  {
    value.type = T_CLASS;
    value._class.class = class;
    print_value("CLASS", 0, &value);
  }

  if (CLASS_is_native(class))
    return;

  if (object == NULL)
  {
    for (i = 0; i < class->load->n_global; i++)
    {
      gp = &class->load->global[i];

      if (CTYPE_get_kind(gp->ctype) != TK_VARIABLE)
        continue;

      if (!CTYPE_is_static(gp->ctype))
        continue;

      var = &class->load->stat[gp->value];
      addr = (char *)class->stat + var->pos;

      VALUE_class_read(class, &value, addr, var->type);
      print_value(gp->sym.name, gp->sym.len, &value);
    }
  }
  else
  {
    for (i = 0; i < class->load->n_global; i++)
    {
      gp = &class->load->global[i];

      if (CTYPE_get_kind(gp->ctype) != TK_VARIABLE)
        continue;

      if (CTYPE_is_static(gp->ctype))
        continue;

      /*if ((object == NULL) ^ (CTYPE_is_static(gp->ctype)))
        continue;*/

      if (!CTYPE_is_static(gp->ctype))
      {
        var = &class->load->dyn[gp->value];
        addr = (char *)object + var->pos;
      }
      else
      {
        var = &class->load->stat[gp->value];
        addr = (char *)class->stat + var->pos;
      }

      VALUE_class_read(class, &value, addr, var->type);
      print_value(gp->sym.name, gp->sym.len, &value);
    }
  }
}
#endif

PRIVATE void command_error(const char *cmd)
{
  if (Error)
    ERROR_print_at(stdout);
  else
    fprintf(_out, "OK\n");
}

/*
PRIVATE void command_info(char *cmd)
{
  printf("w:\n");
  command_where(cmd);
  printf("l:\n");
  command_local(cmd);
  printf("e:\n");
  command_error(cmd);
}
*/

PRIVATE void command_print(const char *cmd)
{
  EXPRESSION *expr;
  ERROR_INFO save;

  ERROR_save(&save);

  EVAL.New((void **)&expr, &cmd[1], strlen(&cmd[1]));

  if (EVAL.Compile(expr))
    goto __ERROR;

  TRACE.bp = BP;
  TRACE.fp = FP;
  TRACE.op = OP;
  TRACE.cp = CP;

  /*EVAL_debug = TRUE;*/

  if (EVAL.Run(expr, get_value))
    goto __ERROR;

  if (*cmd == '?')
    fprintf(_out, "=");

  print_value(&TEMP, *cmd == '?');

  goto __FREE;

__ERROR:
  fprintf(_out, "%s\n", ERROR_info.msg);

__FREE:
  EVAL.Free((void **)&expr);

  TRACE.cp = NULL;

  ERROR_restore(&save);
}

PUBLIC void TRACE_main(boolean error)
{
  static TRACE_TYPE last_command = TC_NONE;

  static TRACE_COMMAND Command[] =
  {
    { "q", TC_NONE, command_quit, FALSE },
    { "n", TC_NEXT, command_next, FALSE },
    { "s", TC_STEP, command_step, FALSE },
    { "f", TC_FROM, command_from, FALSE },
    { "g", TC_GO, command_go, FALSE },
    { "+", TC_NONE, command_set_breakpoint, TRUE },
    { "-", TC_NONE, command_unset_breakpoint, TRUE },
    { "w", TC_NONE, command_where, TRUE },
    { "l", TC_NONE, command_local, TRUE },
    { "?", TC_NONE, command_print, TRUE },
    { "!", TC_NONE, command_print, TRUE },
    { "o", TC_NONE, command_object, TRUE },
    { "e", TC_NONE, command_error, TRUE },
    { NULL }
  };


  char cmd[256];
  int len;
  TRACE_COMMAND *tc = NULL;
  /*static int cpt = 0;*/

  Error = error;

  fflush(NULL);

  #ifdef DEBUG_ME
  fprintf(stderr, "TRACE_main {\n");
  #endif

  if (EXEC_fifo)
    fprintf(_out, "!\n");

  do
  {
    /*if (CP == NULL)
      printf("[]:");
    else
      printf("[%s%s]:", TRACE_get_current_position(), Error ? "*" : "");*/

    if (!EXEC_fifo)
    {
      command_where(NULL);
      if (Error)
        fprintf(_out, "*");
      else
        fprintf(_out, ":");
      fflush(NULL);
    }

    *cmd = 0;

    if (fgets(cmd, sizeof(cmd), _in) == NULL)
    {
      ERROR_panic("Debugger cannot read input: %s", strerror(errno));
    }

    len = strlen(cmd);
    if (len > 0 && cmd[len - 1] == '\n')
      cmd[len - 1] = 0;

    #ifdef DEBUG_ME
    fprintf(stderr, "--> %s\n", cmd);
    #endif

    if (*cmd == 0)
    {
      if (last_command == TC_NONE)
        continue;

      for (tc = Command; tc->pattern; tc++)
      {
        if (tc->type == last_command)
        {
          (*tc->func)(cmd);
          break;
        }
      }
    }
    else
    {
      for (tc = Command; tc->pattern; tc++)
      {
        if (strncasecmp(tc->pattern, cmd, strlen(tc->pattern)) == 0)
        {
          if (tc->type != TC_NONE)
            last_command = tc->type;
          (*tc->func)(cmd);
          break;
        }
      }
    }

    if (tc->pattern == NULL)
      fprintf(_out, "Unknown command: %s\n", cmd);

    fflush(_out);
  }
  while (last_command == TC_NONE || tc->pattern == NULL || tc->loop);

  #ifdef DEBUG_ME
  fprintf(stderr, "} TRACE_main\n");
  #endif
}



PUBLIC void TRACE_breakpoint(int id)
{
  TRACE_main(FALSE);
}


PUBLIC const char *TRACE_get_position(CLASS *cp, FUNCTION *fp, PCODE *pc)
{
#if DEBUG_MEMORY
  static char buffer[256];
#endif
  ushort line = 0;

  if (fp != NULL && fp->debug)
    calc_line_from_position(cp, fp, pc, &line);

#if DEBUG_MEMORY
  sprintf(buffer, "%s.%s.%d",
    cp ? cp->name : "?",
    (fp && fp->debug) ? fp->debug->name : "?",
    line);

  return buffer;
#else
  sprintf(COMMON_buffer, "%s.%s.%d",
    cp ? cp->name : "?",
    (fp && fp->debug) ? fp->debug->name : "?",
    line);

  return COMMON_buffer;
#endif
}


PUBLIC const char *TRACE_get_current_position(void)
{
  return TRACE_get_position(CP, FP, PC);
}


PUBLIC void TRACE_where(void)
{
  fprintf(_out ? _out : stdout, "%s: ", TRACE_get_current_position());
}


PUBLIC void TRACE_welcome(void)
{
  if (!EXEC_fifo)
    fprintf(_out, TRACE_WELCOME);
}