swfdec_player_manager.c

Swfdec still is development software, but has also followed a rigid no-crashes-allowed policy. I b

}

const char *
parse_string (const char *input, char **output)
{
  const char *start = input;

  g_assert (output);
  if (input == NULL)
    return NULL;

  while (*input && !g_ascii_isspace (*input))
    input++;
  if (input == start)
    return NULL;
  *output = g_strndup (start, input - start);
  return parse_skip (input);
}

const char *
parse_uint (const char *input, guint *output)
{
  char *end;
  guint result;

  g_assert (output);
  if (input == NULL)
    return NULL;

  result = strtoul (input, &end, 10);
  if (input == end || (*end != '\0' && !g_ascii_isspace (*end)))
    return NULL;
  *output = result;
  return parse_skip (end);
}

static void
breakpoint_hit_cb (SwfdecDebugger *debugger, guint id, SwfdecPlayerManager *manager)
{
  if (id == 0) {
    if (!swfdec_debugger_get_current (debugger,
	  &manager->interrupt_script, &manager->interrupt_line)) {
      g_assert_not_reached ();
    }
  } else {
    if (!swfdec_debugger_get_breakpoint (debugger, id,
	  &manager->interrupt_script, &manager->interrupt_line)) {
      g_assert_not_reached ();
    }
    swfdec_player_manager_output (manager, "Breakpoint %u", id);
  }
  swfdec_player_manager_do_interrupt (manager);
}

static void
command_run (SwfdecPlayerManager *manager, const char *arg)
{
  const char *s;

  if (arg == NULL) {
    swfdec_player_manager_error (manager, "Must give something to run");
  }
  s = swfdec_debugger_run (SWFDEC_DEBUGGER (manager->player), arg);
  if (s)
    swfdec_player_manager_output (manager, "%s", s);
  else
    swfdec_player_manager_error (manager, "Error running given command");
}

static void
command_play (SwfdecPlayerManager *manager, const char *arg)
{
  swfdec_player_manager_set_playing (manager, TRUE);
}

static void
command_stop (SwfdecPlayerManager *manager, const char *arg)
{
  swfdec_player_manager_set_playing (manager, FALSE);
}

static void
command_iterate (SwfdecPlayerManager *manager, const char *arg)
{
  guint msecs = swfdec_player_manager_iterate (manager);

  if (msecs == 0) {
    swfdec_player_manager_error (manager, "Cannot iterate this player");
  } else {
    swfdec_player_manager_error (manager, "advanced player %u.%03us",
	msecs / 1000, msecs % 1000);
  }
}

static void
command_continue (SwfdecPlayerManager *manager, const char *arg)
{
  if (swfdec_player_manager_get_interrupted (manager))
    swfdec_player_manager_continue (manager);
  else
    swfdec_player_manager_error (manager, "Not interrupted, cannot continue");
}

static void
set_breakpoint (gpointer script, gpointer debugger)
{
  swfdec_debugger_set_breakpoint (debugger, script, 0);
}

static void
command_next (SwfdecPlayerManager *manager, const char *arg)
{
  if (!swfdec_player_manager_get_interrupted (manager))
    swfdec_player_manager_error (manager, "Not interrupted, cannot continue");
  else 
    swfdec_player_manager_next (manager);
}

static void
command_break (SwfdecPlayerManager *manager, const char *arg)
{
  char *str;
  const char *next;
  guint line;

  next = parse_uint (arg, &line);
  if (next) {
    if (swfdec_player_manager_get_interrupted (manager)) {
      if (line < manager->interrupt_script->n_commands) {
	guint id = swfdec_debugger_set_breakpoint (SWFDEC_DEBUGGER (manager->player),
	    manager->interrupt_script, line);
	swfdec_player_manager_output (manager, "%u: %s line %u: %s",
	    id, manager->interrupt_script->script->name, line, 
	    manager->interrupt_script->commands[line].description);
      } else {
	swfdec_player_manager_error (manager, 
	    "Can't set breakpoint at line %u, script only has %u lines",
	    line, manager->interrupt_script->n_commands);
      }
    } else {
      swfdec_player_manager_error (manager, "Not interrupted");
    }
    return;
  }
  next = parse_string (arg, &str);
  if (next) {
    if (strcasecmp (str, "start") == 0) {
      swfdec_debugger_foreach_script (SWFDEC_DEBUGGER (manager->player), 
	  set_breakpoint, manager->player);
      swfdec_player_manager_output (manager, "set breakpoint at start of every script");
    } else {
      swfdec_player_manager_error (manager, "FIXME: implement");
    }
  }
}

static void
command_breakpoints (SwfdecPlayerManager *manager, const char *arg)
{
  guint i, n, line;
  SwfdecDebugger *debugger;
  SwfdecDebuggerScript *script;

  debugger = SWFDEC_DEBUGGER (manager->player);
  n = swfdec_debugger_get_n_breakpoints (debugger);
  for (i = 1; i <= n; i++) {
    if (swfdec_debugger_get_breakpoint (debugger, i, &script, &line)) {
      swfdec_player_manager_output (manager, "%u: %s line %u: %s",
	  i, script->script->name, line, script->commands[line].description);
    }
  }
}

static void
command_delete (SwfdecPlayerManager *manager, const char *arg)
{
  guint id;

  if (arg == NULL) {
    guint i, n;
    SwfdecDebugger *debugger = SWFDEC_DEBUGGER (manager->player);
    n = swfdec_debugger_get_n_breakpoints (debugger);
    for (i = 1; i <= n; i++) {
      swfdec_debugger_unset_breakpoint (debugger, i);
    }
  } else if (parse_uint (arg, &id)) {
    swfdec_debugger_unset_breakpoint (SWFDEC_DEBUGGER (manager->player), id);
  } else {
    swfdec_player_manager_error (manager, "no breakpoint '%s'", arg);
  }
}

static void
command_stack (SwfdecPlayerManager *manager, const char *arg)
{
  JSStackFrame *frame = NULL;
  guint i, min, max;

  if (!swfdec_player_manager_get_interrupted (manager)) {
    swfdec_player_manager_error (manager, "Not interrupted");
    return;
  }
  JS_FrameIterator (manager->player->jscx, &frame);
  min = 1;
  max = frame->sp - frame->spbase;
  for (i = min; i <= max; i++) {
    const char *s = swfdec_js_to_string (manager->player->jscx, frame->sp[-i]);
    swfdec_player_manager_output (manager, "%2u: %s", i, s);
  }
}

typedef struct {
  SwfdecPlayerManager *manager;
  const char *	       string;
} FindData;

static void
do_find (gpointer scriptp, gpointer datap)
{
  SwfdecDebuggerScript *script = scriptp;
  FindData *data = datap;
  guint i;

  for (i = 0; i < script->n_commands; i++) {
    if (strstr (script->commands[i].description, data->string)) {
      swfdec_player_manager_output (data->manager, "%s %u: %s",
	  script->script->name, i, script->commands[i].description);
    }
  }
}

static void
command_find (SwfdecPlayerManager *manager, const char *arg)
{
  FindData data = { manager, arg };
  if (arg == NULL) {
    swfdec_player_manager_error (manager, "What should be found?");
  }
  swfdec_debugger_foreach_script (SWFDEC_DEBUGGER (manager->player), do_find, &data);
}

static void
command_enumerate (SwfdecPlayerManager *manager, const char *arg)
{
  jsval rval;
  JSObject *obj;
  JSIdArray *array;
  const char *s, *t;
  guint i;

  if (!swfdec_js_run (manager->player, arg, &rval)) {
    swfdec_player_manager_error (manager, "Invalid command");
    return;
  }
  if (!JSVAL_IS_OBJECT (rval)) {
    swfdec_player_manager_error (manager, "Given expression is not an object");
    return;
  }
  obj = JSVAL_TO_OBJECT (rval);
  array = JS_Enumerate (manager->player->jscx, obj);
  if (array == NULL) {
    swfdec_player_manager_error (manager, "Error enumerating");
    return;
  }
  s = swfdec_js_to_string (manager->player->jscx, rval);
  if (s == NULL) {
    swfdec_player_manager_error (manager, "Cannot convert object to string");
  }
  swfdec_player_manager_output (manager, "properties for %s:", s);
  for (i = 0; i < array->length; i++) {
    if (!JS_IdToValue (manager->player->jscx, array->vector[i], &rval))
      continue;
    s = swfdec_js_to_string (manager->player->jscx, rval);
    if (s == NULL)
      continue;
    if (!JS_GetProperty (manager->player->jscx, obj, s, &rval) ||
	!(t = swfdec_js_to_string (manager->player->jscx, rval)))
      t = "<error querying value>";
    swfdec_player_manager_output (manager, "  %s: %s", s, t);
  }
  JS_DestroyIdArray (manager->player->jscx, array);
}

static void command_help (SwfdecPlayerManager *manager, const char *arg);
/* NB: the first word in the command string is used, partial matches are ok */
struct {
  const char *	name;
  void		(* func)	(SwfdecPlayerManager *manager, const char *arg);
  const char *	description;
} commands[] = {
  { "help",	command_help,		"print all available commands and a quick description" },
  { "run",	command_run,	  	"run the argument as a JavaScript script" },
  { "play",	command_play,		"play the movie" },
  { "stop",	command_stop,	 	"stop the movie" },
  { "iterate",	command_iterate,	"iterate the movie once" },
  { "break",	command_break,	  	"add breakpoint at [start]" },
  { "breakpoints", command_breakpoints,	"show all breakpoints" },
  { "delete",	command_delete,		"delete a breakpoint" },
  { "continue",	command_continue,	"continue when stopped inside a breakpoint" },
  { "next",	command_next,		"step forward one command when stopped inside a breakpoint" },
  { "stack",	command_stack,		"print the arguments on the stack" },
  { "find",	command_find,		"find the given argument verbatim in all scripts" },
  { "enumerate",command_enumerate,    	"enumerate all properties of the given object" },
};

static void
command_help (SwfdecPlayerManager *manager, const char *arg)
{
  guint i;
  swfdec_player_manager_output (manager, "The following commands are available:");
  for (i = 0; i < G_N_ELEMENTS (commands); i++) {
    swfdec_player_manager_output (manager, "%s: %s", commands[i].name, commands[i].description);
  }
}

void
swfdec_player_manager_execute (SwfdecPlayerManager *manager, const char *command)
{
  guint i;
  const char *args;
  char *run;

  g_return_if_fail (SWFDEC_IS_PLAYER_MANAGER (manager));
  g_return_if_fail (command != NULL);

  parse_skip (command);
  swfdec_player_manager_send_message (manager, SWFDEC_MESSAGE_INPUT, "%s", command);
  args = parse_string (command, &run);
  if (args == NULL)
    return;
  for (i = 0; i < G_N_ELEMENTS(commands); i++) {
    if (g_ascii_strncasecmp (commands[i].name, run, strlen (run)) == 0) {
      commands[i].func (manager, *args == '\0' ? NULL : args);
      g_free (run);
      return;
    }
  }
  swfdec_player_manager_error (manager, "No such command '%s'", run);
  g_free (run);
}