decomp_action.c

我自己写的flash player decompiler,不是幡汇编器

                            action==SWFACTION_MULTIPLY ||\
                            action==SWFACTION_DIVIDE ||\
                            action==SWFACTION_SUBTRACT||\
                            action==SWFACTION_INCREMENT||\
                            action==SWFACTION_DECREMENT||\
                            action==SWFACTION_TONUMBER||\
                            action==SWFACTION_MODULO ||\
                            action==SWFACTION_SHIFTLEFT ||\
                            action==SWFACTION_SHIFTRIGHT ||\
                            action==SWFACTION_SHIFTRIGHT2 ||\
                            action==SWFACTION_BITWISEAND ||\
                            action==SWFACTION_BITWISEOR ||\
                            action==SWFACTION_BITWISEXOR ||\
                            action==SWFACTION_MBLENGTH ||\
                            action==SWFACTION_STRINGLENGTH||\
                            action==SWFACTION_RANDOM) {
                        /*运算操作新的节点的取值类型设置为数字类型*/
                        set_my_type(&tmp,IS_EXPRESSION,VALUE_NUMBER);
                    } else
                        if(action==SWFACTION_VAR) {
                            /*根据var操作推断出left节点属性为变量*/
                            if(left)
                                set_stack(left,IS_VARIABLE,VALUE_UNDEF);
                            set_my_type(&tmp,IS_EXPRESSION,VALUE_UNDEF);
                        } else
                            if(action==SWFACTION_GETMEMBER) {
                                /*根据get member操作推断出right节点为member属性，left为object属性*/
                                set_my_type(&tmp,right->t.flags,right->t.value_type);
                                set_stack(right,IS_MEMBER,right->t.value_type);
                                set_stack(left,IS_OBJECT,VALUE_UNDEF);
                            } else
                                if(action==SWFACTION_GETPROPERTY) {
                                    /*Get property操作推断出right为property属性,left为target属性*/
                                    if(!(left&&right))
                                        err_debug(ERR_TREE,"int test_descendiblity: parameter is NULL");

                                    set_stack(right,IS_PROPERTY,property_type(right->data.prop));
                                    set_my_type(&tmp,IS_EXPRESSION,property_type(right->data.prop));
                                    set_stack(left,IS_TARGET,VALUE_UNDEF);
                                } else
                                    if(action==SWFACTION_SETPROPERTY) {
                                        /*set property操作，新构件的节点树的取值将被遗传为right节点的取值类型*/
                                        if(!(left&&right))
                                            err_debug(ERR_TREE,"int test_descendiblity: parameter is NULL");
                                        set_my_type(&tmp,IS_EXPRESSION,right->t.value_type);
                                    } else
                                        if(action==SWFACTION_DELETE) {
                                            /*根据detele判断出left的类型为对象或者变量(根据left节点是tree还是string),*/
                                            if(left) {
                                                if(left->type=='t')
                                                    set_stack(left,IS_OBJECT,left->t.value_type);
                                                else
                                                    set_stack(left,IS_VARIABLE,left->t.value_type);
                                            }
                                            set_my_type(&tmp,IS_EXPRESSION,VALUE_UNDEF);
                                        } else
                                            if(action==SWFACTION_SETREGISTER) {
                               //              set_stack(right,IS_VARIABLE,right->t.value_type);
                               //              set_my_type(&tmp,IS_VARIABLE,right->t.value_type);
                                            }
    return(tmp);
}

//////////////////////////////////////////////////////////
//  根据target.property判断计算结果的类型(串还是数字)   //
//////////////////////////////////////////////////////////

uint8_t property_type(uint8_t this_index) {
    switch(this_index) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 14:
    case 16:
    case 17:
    case 19:
    case 20:
    case 21:
        return VALUE_NUMBER;
    default:
        return VALUE_STRING;
    }
}

///////////////////////////////////////////////////////////////////
//        新树构建函数,该函数取4个参数,left为左子树节点,         //
// right为右子树节点,Action为树的action节点,这三个参数构成       //
// 一棵新的表达式树节点,并返回该节点指针                         //
// flags用于指明左右子树的内存结构,以便释放内存时使用            //
//并调用test_descendiblity判断新树的取值类型和,根据action        //
//判断left和right的节点属性                                      //
///////////////////////////////////////////////////////////////////

static Stack newTreeBase(Stack left, Action action, Stack right,int flags) {
    /*分配树节点内存*/
    Tree t = (Tree)malloc(sizeof(struct _tree));
    /*分配栈节点内存*/
    Stack s = newStack();

    t->left = left;
    t->right = right;
    t->action = action;
    t->flags=flags;
    /*设置栈节点包含的内容类型为树类型't'*/
    s->type = 't';
    /*将栈节点的data.tree指针指向树*/
    s->data.tree = t;
    /*进行属性和取值类型判断*/
    s->t=test_descendiblity(left,action,right);
    s->offset=-1;
    return s;
}

///////////////////////////////////////////////////////////////////////
//      该函数调用newTree函数构成新的树节点，并且设置节点在文件中的  //
//偏移量,偏移量未将成为以后跳转语句的判断依据                        //
//新构成树的偏移量取左子树和右子树的偏移量的较小值                   //
///////////////////////////////////////////////////////////////////////
static Stack newTree(Stack left, Action action, Stack right,int flags) {
    Stack s = newTreeBase(left, action, right,flags);



    if(left == NULL) {
        if(right == NULL)
            s->offset = -1;
        else
            s->offset = right->offset;
    } else {
        if(right == NULL)
            s->offset = left->offset;
        else
            s->offset = min(left->offset, right->offset);
    }

    return s;
}
/////////////////////////////////////////////////////////////////
//            构成一个新的字符串节点                           //
/////////////////////////////////////////////////////////////////
static Stack newString(const char *string) {
    /*创建栈节点*/
    Stack s = newStack();

    s->type = 's';
    /*用data.string指向该串*/
    s->data.string = (char *) string;
    /*设置栈节点包含的内容类型为字符串类型*/
    set_stack(s,IS_CONSTANT,VALUE_STRING);
    return s;
}
///////////////////////////////////////////////////////
//         创建一个包含double数据的节点              //
///////////////////////////////////////////////////////
static Stack newDouble(double d) {
    Stack s = newStack();
    /*设置栈节点包含的内容类型为double类型*/
    s->type = 'd';
    s->data.dnum = d;
    set_stack(s,IS_CONSTANT,VALUE_DOUBLE);
    return s;
}
///////////////////////////////////////////////////////
//         创建一个包含integer数据的节点             //
///////////////////////////////////////////////////////
static Stack newInteger(int i) {
    Stack s = newStack();
    /*设置栈节点包含的内容类型为integer类型'i'*/
    s->type = 'i';
    s->data.inum = i;
    set_stack(s,IS_CONSTANT,VALUE_INTEGER);
    return s;
}
///////////////////////////////////////////////////////
//         创建一个包含property数据的节点            //
///////////////////////////////////////////////////////
static Stack newProperty(Property prop) {
    Stack s = newStack();
    /*设置栈节点包含的内容类型为property类型'p'*/
    s->type = 'p';
    s->data.prop = prop;
    set_stack(s,IS_PROPERTY,VALUE_NUMBER);
    return s;
}


/////////////////////////////////////////////////////////
//               从栈中弹出栈顶节点                    //
/////////////////////////////////////////////////////////

static Stack pop() {
    Stack s = stack;

    if(!stack)
        err_debug(ERR_STACK,"blown stack!");
    stack = stack->next;

    return s;
}
////////////////////////////////////////////////////////////
//               向栈顶压入一个新节点                     //
//               该节点将成为新的栈顶                     //
////////////////////////////////////////////////////////////
static void push(Stack s) {
    s->next = stack;
    stack = s;
}
////////////////////////////////////////////////////////////
//                        负数打印预处理操作              //
////////////////////////////////////////////////////////////
static char *negateString(char *s) {
    int i, l = strlen(s)+1;
    /*重新分配原有字符串+1个空间以容纳负号*/
    char *New = realloc(s, l+1);

    for(i=l; i>0; --i)
        New[i] = New[i-1];
    /*第一个子符设置为负号*/
    New[0] = '-';

    return New;
}

///////////////////////////////////////////////////////////
//      根据Action判断是否为表达式,因为真正的表达式作对于//
//set member和get member时则判断为数组下标[xxx]而非.xxx, //
//除了几个串操作action外其他Action均认为是表达式         //
///////////////////////////////////////////////////////////

int test_expression(const int action) {

    switch(action) {
    case	SWFACTION_RANDOM:
    case	SWFACTION_MBLENGTH:
    case	SWFACTION_TONUMBER:
    case	SWFACTION_DECREMENT:
    case	SWFACTION_INCREMENT:
    case	SWFACTION_BITWISEAND:
    case	SWFACTION_BITWISEOR:
    case	SWFACTION_BITWISEXOR:
    case	SWFACTION_SHIFTLEFT:
    case	SWFACTION_SHIFTRIGHT:
    case	SWFACTION_SHIFTRIGHT2:
    case	SWFACTION_EVAL:
    case	SWFACTION_ENUMERATE:
    case	SWFACTION_TYPEOF:
    case	SWFACTION_NEWADD:
    case	SWFACTION_NEWLESSTHAN:
    case	SWFACTION_NEWEQUAL:
    case	SWFACTION_VAREQUALS:
    case	SWFACTION_CALLFUNCTION:
    case	SWFACTION_RETURN:
    case	SWFACTION_MODULO:
    case	SWFACTION_NEW:
    case	SWFACTION_VAR:
    case	SWFACTION_GETTIMER:
    case	SWFACTION_ADD:
    case	SWFACTION_SUBTRACT:
    case	SWFACTION_MULTIPLY:
    case	SWFACTION_DIVIDE:
    case	SWFACTION_EQUAL:
    case	SWFACTION_LESSTHAN:
    case	SWFACTION_LOGICALAND:
    case	SWFACTION_LOGICALOR:
    case	SWFACTION_LOGICALNOT:
    case	SWFACTION_STRINGEQ:
    case	SWFACTION_STRINGLENGTH:
    case	SWFACTION_GETVARIABLE:
    case	SWFACTION_SETVARIABLE:
    case	SWFACTION_GETPROPERTY:
    case	SWFACTION_SETPROPERTY:
    case	SWFACTION_SETTARGETEXPRESSION:
    case	SWFACTION_GETMEMBER:
    case	SWFACTION_SETMEMBER:
        return 1;
        break;
    default:
        return 0;
    }
    return 0;
}


///////////////////////////////////////////////////////////
//       将property引转换成属性引索                      //
///////////////////////////////////////////////////////////
static Property getSetProperty(int prop) {
    switch(prop) {
    case SWF_SETPROPERTY_X:
        return PROPERTY_X;
    case SWF_SETPROPERTY_Y:
        return PROPERTY_Y;
    case SWF_SETPROPERTY_XSCALE:
        return PROPERTY_XSCALE;
    case SWF_SETPROPERTY_YSCALE:
        return PROPERTY_YSCALE;
    case SWF_SETPROPERTY_ALPHA:
        return PROPERTY_ALPHA;
    case SWF_SETPROPERTY_VISIBILITY:
        return PROPERTY_VISIBLE;
    case SWF_SETPROPERTY_ROTATION:
        return PROPERTY_ROTATION;
    case SWF_SETPROPERTY_NAME:
        return PROPERTY_NAME;
    case SWF_SETPROPERTY_HIGHQUALITY:
        return PROPERTY_HIGHQUALITY;
    case SWF_SETPROPERTY_SHOWFOCUSRECT:
        return PROPERTY_FOCUSRECT;
    case SWF_SETPROPERTY_SOUNDBUFFERTIME:
        return PROPERTY_SOUNDBUFTIME;
    default:
        return -1;
    }
}

/////////////////////////////////////////////////////////////////////
//       读pcode,根据不同的action结合栈中元素够建树节点,并返回该树 //
//节点,该函数为前期处理操作中最重要的函数                          //
/////////////////////////////////////////////////////////////////////

static Stack readActionRecord() {
    int length = 0, type = My_readUInt8();
    Stack thistmp;
    /*如果action大于0x80则包含长度信息,下一个数据为长度信息*/
    if((type&0x80) == 0x80)
        length = My_readUInt16();

    switch(type) {
        /*pop操作,对于打印来说是无用操作*/
    case SWFACTION_POP:
        return newTree(NULL, type, NULL,0);


        /*以下action操作独立完成,无需弹出数据*/
    case SWFACTION_GETTIMER:
    case SWFACTION_STOPDRAGMOVIE: