decompile5.c

flash swf file player

  {
    if(left->type == 's' &&
       strcmp(left->data.string, "-1") == 0)
    {
      putchar('-');
      listItem(right, SWFACTION_MULTIPLY);
      return;
    }
    else if(right->type == 's')
    {
      if(strcmp(right->data.string, "-1") == 0)
      {
	putchar('-');
	listItem(left, SWFACTION_MULTIPLY);
	return;
      }
      else
      {
	/* put constant first: a*2 ==> 2*a */

	Stack tmp = left;
	left = right;
	right = tmp;
      }
    }
  }

  /* parenthesization rule */
  parens = (precedence(parent) > precedence(t->action) ||
	    (t->action == SWFACTION_MULTIPLY && parent == SWFACTION_DIVIDE) ||
	    (t->action == SWFACTION_ADD && parent == SWFACTION_SUBTRACT) ||
	    (t->action == SWFACTION_LOGICALAND && parent == SWFACTION_LOGICALOR) ||
	    (t->action == SWFACTION_LOGICALOR && parent == SWFACTION_LOGICALAND));

  if(parens)
    putchar('(');

  listItem(left, t->action);
  puts(op);
  listItem(right, t->action);

  if(parens)
    putchar(')');
}

static void listItem(Stack s, Action parent)
{
  Tree t;

  if(s->type == 's')
  {
    if(parent == SWFACTION_GETVARIABLE ||
       parent == SWFACTION_SETVARIABLE ||
       parent == SWFACTION_GETPROPERTY ||
       parent == SWFACTION_SETPROPERTY ||
       parent == SWFACTION_GETMEMBER ||
       parent == SWFACTION_SETMEMBER ||
       parent == SWFACTION_DUPLICATECLIP ||
       parent == SWFACTION_NEW ||
       parent == SWFACTION_VAR ||
       parent == SWFACTION_VAREQUALS ||
       parent == SWFACTION_CALLMETHOD ||
       parent == SWFACTION_CALLFUNCTION ||
       isNum(s->data.string))
      puts(s->data.string);
    else
    {
      putchar('\'');
      puts(s->data.string);
      putchar('\'');
    }
  }
  else if(s->type == 'p')
  {
    listProperty(s->data.prop);
  }
  else if(s->type == 'd')
  {
    /* XXX - should prolly check for integerness, too */
    if(s->data.dnum == 0)
      putchar('0');
    else
      printf("%f", s->data.dnum);
  }
  else if(s->type == 'i')
  {
    printf("%i", s->data.inum);
  }
  else if(s->type == 't')
  {
    t = s->data.tree;

    switch(t->action)
      {
      case SWFACTION_POP: /* ignore */
	break;

	/* two args */
      case SWFACTION_ADD:
      case SWFACTION_SUBTRACT:
      case SWFACTION_MULTIPLY:
      case SWFACTION_DIVIDE:
      case SWFACTION_EQUAL:
      case SWFACTION_LOGICALAND:
      case SWFACTION_LOGICALOR:
      case SWFACTION_STRINGEQ:
      case SWFACTION_STRINGCOMPARE:
	listArithmetic(s, parent);
	break;

      case SWFACTION_STRINGCONCAT:
	if(parent == SWFACTION_GETVARIABLE ||
	   parent == SWFACTION_GETPROPERTY)
	{
	  puts("valueOf(");
	  listArithmetic(s, parent);
	  putchar(')');
	}
	else
	  listArithmetic(s, parent);
	break;

      case SWFACTION_SETVARIABLE:
	listAssign(s);
	break;

      case SWFACTION_LESSTHAN:
	listLessThan(s, NONEGATE);
	break;

      case SWFACTION_GETPROPERTY:
	if(t->left->type == 's' &&
	   t->left->data.string[0] == '\0')
	  puts("this");
	else
	  listItem(t->left, SWFACTION_GETPROPERTY);

	putchar('.');

	if(t->right->type == 'i')
	  listProperty(t->right->data.inum);
	else
	  listItem(t->right, SWFACTION_GETPROPERTY);

	break;

      case SWFACTION_SETPROPERTY:
	if(t->left->type == 's' &&
	   t->left->data.string[0] == '\0')
	  puts("this");
	else
	  listItem(t->left, SWFACTION_SETPROPERTY);

	putchar('.');
	listItem(t->right, SWFACTION_SETPROPERTY);
	break;

      case SWFACTION_MBSUBSTRING:
      case SWFACTION_SUBSTRING:
	puts("substr(");
	listItem(t->left, t->action);
	puts(", ");
	listItem(t->right->data.tree->left, t->action);
	puts(", ");
	listItem(t->right->data.tree->right, t->action);
	putchar(')');
	break;
      
	/* one-arg */
      case SWFACTION_LOGICALNOT:
	listNot(t->left, SWFACTION_LOGICALNOT);
	break;

      case SWFACTION_STRINGLENGTH:
	puts("strlen(");
	listItem(t->left, SWFACTION_STRINGLENGTH);
	putchar(')');
	break;

      case SWFACTION_INT:
	puts("int(");
	listItem(t->left, SWFACTION_INT);
	putchar(')');
	break;

      case SWFACTION_RANDOM:
	puts("random(");
	listItem(t->left, SWFACTION_RANDOM);
	putchar(')');
	break;

      case SWFACTION_MBLENGTH:
	puts("mbstrlen(");
	listItem(t->left, SWFACTION_MBLENGTH);
	putchar(')');
	break;

      case SWFACTION_ORD:
	puts("ord(");
	listItem(t->left, SWFACTION_ORD);
	putchar(')');
	break;

      case SWFACTION_CHR:
	puts("chr(");
	listItem(t->left, SWFACTION_CHR);
	putchar(')');
	break;

      case SWFACTION_MBORD:
	puts("mbord(");
	listItem(t->left, SWFACTION_MBORD);
	putchar(')');
	break;

      case SWFACTION_MBCHR:
	puts("mbchr(");
	listItem(t->left, SWFACTION_MBCHR);
	putchar(')');
	break;

      case SWFACTION_TONUMBER:
	puts("Number(");
	listItem(t->left, SWFACTION_TONUMBER);
	putchar(')');
	break;

      case SWFACTION_TOSTRING:
	puts("String(");
	listItem(t->left, SWFACTION_TOSTRING);
	putchar(')');
	break;

      case SWFACTION_GETVARIABLE:
	listItem(t->left, SWFACTION_GETVARIABLE);
	break;

      case SWFACTION_GETTIMER:
	puts("getTimer()");
	break;

	/* statements */
      case SWFACTION_DUPLICATECLIP:
	puts("duplicateClip(");
	listItem(t->left, SWFACTION_DUPLICATECLIP);
	puts(", ");
	listItem(t->right->data.tree->left, SWFACTION_DUPLICATECLIP);
	puts(", ");
	listItem(t->right->data.tree->right, SWFACTION_DUPLICATECLIP);
	putchar(')');
	break;

      case SWFACTION_STARTDRAGMOVIE:
	puts("startDrag(");
	listItem(t->right->data.tree->right, SWFACTION_STARTDRAGMOVIE);
	puts(", ");
	listItem(t->right->data.tree->left, SWFACTION_STARTDRAGMOVIE);

	if(t->left->type == 't')
	{
	  Tree root = t->left->data.tree;
	  puts(", ");
	  listItem(root->left->data.tree->left, SWFACTION_STARTDRAGMOVIE);
	  puts(", ");
	  listItem(root->right->data.tree->left, SWFACTION_STARTDRAGMOVIE);
	  puts(", ");
	  listItem(root->left->data.tree->right, SWFACTION_STARTDRAGMOVIE);
	  puts(", ");
	  listItem(root->right->data.tree->right, SWFACTION_STARTDRAGMOVIE);
	}
	putchar(')');
	break;

      case SWFACTION_REMOVECLIP:
	puts("removeClip(");
	listItem(t->left, SWFACTION_REMOVECLIP);
	putchar(')');
	break;
      case SWFACTION_TRACE:
	puts("trace(");
	listItem(t->left, SWFACTION_TRACE);
	putchar(')');
	break;
      case SWFACTION_SETTARGETEXPRESSION:
	puts("setTarget(");
	listItem(t->left, SWFACTION_SETTARGETEXPRESSION);
	putchar(')');
	break;
      case SWFACTION_STOPDRAGMOVIE:
	puts("stopDrag()");
	break;
      case SWFACTION_NEXTFRAME:
	puts("nextFrame()");
	break;
      case SWFACTION_PREVFRAME:
	puts("prevFrame()");
	break;
      case SWFACTION_PLAY:
	puts("play()");
	break;
      case SWFACTION_STOP:
	puts("stop()");
	break;
      case SWFACTION_TOGGLEQUALITY:
	puts("toggleQuality()");
	break;
      case SWFACTION_STOPSOUNDS:
	puts("stopSounds()");
	break;

      case SWFACTION_GOTOFRAME:
	printf("gotoFrame(%i)", (int)t->left);
	break;

      case SWFACTION_GETURL:
      {
	printf("getURL(%s, %s)", (char *)t->left, (char *)t->right);
	break;
      }

      case SWFACTION_WAITFORFRAMEEXPRESSION:
	printf("Wait For Frame Expression, skip %i", (int)t->left);
	break;

      case SWFACTION_GETURL2:
      {
	int type = (int)t->left;

	puts("getURL2(");
	listItem(t->right->data.tree->left, SWFACTION_GETURL2);
	puts(", ");
	listItem(t->right->data.tree->right, SWFACTION_GETURL2);

	switch(type)
	{
	  case 0: putchar(')'); break;
	  case 1: puts(", GET)"); break;
	  case 2: puts(", POST)"); break;
	  default: printf(", type=%i (?))", type); break;
	}
	break;
      }

      case SWFACTION_CALLFRAME:
	puts("callFrame(");
	listItem(t->left, SWFACTION_CALLFRAME);
        putchar(')');
	break;

      case SWFACTION_GOTOEXPRESSION:
	puts("gotoFrame(");
	listItem(t->left, SWFACTION_GOTOEXPRESSION);
        putchar(')');

	if((int)t->right == 1)
	  puts(";\nplay()");
	break;

      case SWFACTION_SETTARGET:
	if(((char *)t->left)[0] == '\0')
	  puts("setTarget(this)");
	else
	  printf("setTarget('%s')", (char *)t->left);
	break;

      case SWFACTION_GOTOLABEL:
	printf("gotoFrame('%s')", (char *)t->left);
	break;

	/* branches - shouldn't see these (but is good for debugging) */
      case SWFACTION_BRANCHIFTRUE:
	puts("if(");
	listItem(t->left, SWFACTION_BRANCHIFTRUE);
	printf(") branch %i", (int)t->right);
	break;

      case SWFACTION_BRANCHALWAYS:
	printf("branch %i", (int)t->right);
	break;

      case SWFACTION_WAITFORFRAME:
	printf("Wait for frame %i ", (int)t->left);
	printf(" else skip %i", (int)t->right);
	break;


    /* v5 ops */
      case SWFACTION_VAR:
	puts("var ");
	listItem(t->left, SWFACTION_VAR);
	break;

      case SWFACTION_VAREQUALS:
	puts("var ");
	listItem(t->left, SWFACTION_VAREQUALS);
	puts(" = ");
	listItem(t->right, SWFACTION_VAREQUALS);
	break;

      case SWFACTION_DELETE:
	puts("delete ");
	listItem(t->left, SWFACTION_DELETE);
	break;

      case SWFACTION_CALLFUNCTION:
      {
	int nargs, i;

	listItem(t->left, SWFACTION_CALLFUNCTION);
	putchar('(');

	t = t->right->data.tree;
	nargs = (int)t->left;

	for(i=0; i<nargs; ++i)
	{
	  t = t->right->data.tree;
	  if(i>0)
	    puts(", ");
	  listItem(t->left, SWFACTION_CALLFUNCTION);
	}

	putchar(')');

	break;
      }

      case SWFACTION_RETURN:
	puts("return ");
	listItem(t->left, SWFACTION_RETURN);
	break;

      case SWFACTION_NEWEQUAL:
      case SWFACTION_NEWADD:
      case SWFACTION_SHIFTLEFT:
      case SWFACTION_SHIFTRIGHT:
      case SWFACTION_SHIFTRIGHT2:
      case SWFACTION_BITWISEAND:
      case SWFACTION_BITWISEOR:
      case SWFACTION_BITWISEXOR:
      case SWFACTION_MODULO:
	listArithmetic(s, parent);
	break;

      case SWFACTION_NEW:
	puts("new ");
	listItem(t->right, SWFACTION_NEW);
	putchar('(');
	listItem(t->left, SWFACTION_NEW);
	putchar(')');
	break;

      case SWFACTION_TYPEOF:
	puts("typeof(");
	listItem(t->left, SWFACTION_TYPEOF);
	putchar(')');
	break;

      case SWFACTION_NEWLESSTHAN:
	listLessThan(s, NONEGATE);
	break;

      case SWFACTION_GETMEMBER:
	listItem(t->left, SWFACTION_GETMEMBER);
	putchar('.');
	listItem(t->right, SWFACTION_GETMEMBER);
	break;

      case SWFACTION_SETMEMBER:
	listItem(t->left, SWFACTION_SETMEMBER);
	putchar('.');
	listItem(t->right->data.tree->left, SWFACTION_SETMEMBER);
	puts(" = ");
	listItem(t->right->data.tree->right, SWFACTION_SETMEMBER);
	break;

      case SWFACTION_INCREMENT:
	listItem(t->left, SWFACTION_INCREMENT);
	puts("+1");
	break;

      case SWFACTION_DECREMENT:
	listItem(t->left, SWFACTION_DECREMENT);
	puts("-1");
	break;

      case SWFACTION_CALLMETHOD:
      {
	int nargs, i;

	listItem(t->right->data.tree->left, SWFACTION_CALLMETHOD);
	putchar('.');

	listItem(t->left, SWFACTION_CALLMETHOD);
	putchar('(');

	t = t->right->data.tree->right->data.tree;
	nargs = (int)t->left;

	for(i=0; i<nargs; ++i)
	{
	  t = t->right->data.tree;
	  if(i>0)
	    puts(", ");
	  listItem(t->left, SWFACTION_CALLMETHOD);
	}

	putchar(')');

	break;
      }

      /* dealt with on parse */
      case SWFACTION_DECLARENAMES:
	error("Shouldn't get declareNames in listItem!");
	break;

      case SWFACTION_WITH:
      {
	int n = (int)t->right->data.tree->left;
	Stack *statements = (Stack *)t->right->data.tree->right;

	puts("with(");
	puts((char *)t->left->data.tree);
	puts(")\n{\n");
	decompileStatements(statements, n);
	puts("}");
	break;
      }

      case SWFACTION_DEFINEFUNCTION:
      {
	int n = (int)t->right->data.tree->left;
	Stack *statements = (Stack *)t->right->data.tree->right;

	int first = 1;
	Stack args = t->left->data.tree->right;

	puts("function ");
	puts((char *)t->left->data.tree->left);
	putchar('(');

	while(args != NULL)
	{
	  if(!first)
	    puts(", ");

	  first = 0;
	  puts((char *)args->data.tree->left);
	  args = args->data.tree->right;
	}

	puts(")\n{\n");
	decompileStatements(statements, n);
	puts("}");

	break;
      }

      case SWFACTION_ENUMERATE:
	puts("iterate over "); /* XXX */
	listItem(t->left, SWFACTION_ENUMERATE);
	break;

      case SWFACTION_SETREGISTER:
      {
	/* XXX - shouldn't ever see this.. */
	int n = (int)t->left;
	puts("(_tmp");
	putchar('0'+n);
	puts(" = ");
	listItem(t->right, SWFACTION_SETREGISTER);
	putchar(')');

	break;
      }

      case SWFACTION_DUP:
	listItem(t->left, SWFACTION_DUP);
	break;


      case SWFACTION_INITOBJECT:
      {
	int i, nEntries = (int)t->left;
	Stack *names = (Stack *)t->right->data.tree->left;
	Stack *values = (Stack *)t->right->data.tree->right;

	puts("{ ");

	for(i=0; i<nEntries; ++i)
	{