decomp_action.c

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

            *(p++) = '\\';
            *(p++) = 'r';
            ++len;
            break;
        default:
            *(p++) = c;
        }

        ++len;
    }

    *p = 0;

    return buf;
}


/*-----------------------My_readSInt16()---------------------------------*/
///////////////////////////////////////////////////////////////////////////
//                       丛输入的P-code中读入2字节的有符号数             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////
int16_t My_readSInt16() {
    if(!TEST_SPACE(sizeof(int16_t))) {
        err_debug(ERR_INPUT,"My_readSInt16:no enough input");
    }
    return(my_readSInt16());
}

/*-----------------------My_readUInt16()--------------------------------*/

///////////////////////////////////////////////////////////////////////////
//                       丛输入的P-code中读入2字节的无符号数             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////
uint16_t My_readUInt16() {
    if(!TEST_SPACE(sizeof(uint16_t))) {
        err_debug(ERR_INPUT,"My_readUInt16:no enough input");
    }
    return(my_readUInt16());
}

/*--------------------------My_readSInt32---------------------------------*/
///////////////////////////////////////////////////////////////////////////
//                       丛输入的P-code中读入4字节的有符号数             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////
int32_t My_readSInt32() {
    if(!TEST_SPACE(sizeof(int32_t))) {
        err_debug(ERR_INPUT,"My_readSInt32:no enough input");
    }
    return(my_readSInt32());
}

/*-------------------------My_readUInt32-------------------------------*/
///////////////////////////////////////////////////////////////////////////
//                       丛输入的P-code中读入4字节的无符号数             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

uint32_t My_readUInt32() {
    if(!TEST_SPACE(sizeof(int32_t))) {
        err_debug(ERR_INPUT,"My_readUInt32:no enough input");
    }
    return(my_readUInt32());
}


/*----------------------My_readUInt8-------------------------------*/
///////////////////////////////////////////////////////////////////////////
//                       丛输入的P-code中读入1字节的无符号数             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

uint8_t My_readUInt8() {
    int tmp_debug;
    if(!TEST_SPACE(sizeof(uint8_t))) {
        err_debug(ERR_INPUT,"My_readUInt8:no enough input,action_len=%d,ptr_offset=%d",action_len,ptr_offset);
    }
    tmp_debug=action_block[ptr_offset];
    /*
     fprintf(stderr,"read=%x ",tmp_debug);
      	tmp_i++;
      	if(tmp_i%10==0)
      		fprintf(stderr,"\n");
      		*/
    ptr_offset++;
    return (tmp_debug);
}

/*-----------------------My_readSInt8-------------------------------*/
///////////////////////////////////////////////////////////////////////////
//                       丛输入的P-code中读入1字节的有符号数             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////
int8_t My_readSInt8() {
    if(!TEST_SPACE(sizeof(int8_t))) {
        err_debug(ERR_INPUT,"My_readSInt8:no enough input");
    }
    return(my_readSInt8());
}




/*---------------------------Warning---------------------------------*/
///////////////////////////////////////////////////////////////////////////
//                    显示警告信息的函数,err参数用于设置出错             //
//                    代码                                               //
//           只有当定义DEBUG_COMPILE宏时,该函数才有效                    //
///////////////////////////////////////////////////////////////////////////
void Warning(const char *fmt, ...) {
#ifdef 	DEBUG_COMPILE
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr,fmt, ap);
    va_end(ap);
    fprintf(stderr,"\n");
#endif
}

/*----------------------------my_debug----------------------------*/
////////////////////////////////////////////////////////////////////
//                           打印函数                             //
////////////////////////////////////////////////////////////////////


void my_debug(const char *s, ...) {
    va_list ap;
    va_start(ap, s);
    vfprintf(stderr,s, ap);
    va_end(ap);
    fprintf(stderr,"\n");
}


/*------------------------freeReg--------------------------------*/
///////////////////////////////////////////////////////////////////
//              寄存器结构清理函数                               //
// 该函数只清理reglist结构而不真正清理reglist包含的栈节点        //
// 因为这些栈节点几乎都被其他的表达式树引用,当清理表达式数组     //
// 时,这些节点会被清理,                                          //
//                                                               //
///////////////////////////////////////////////////////////////////

int freeReg(reg_array * ptr) {
    reg_array *tmp_reg;

    if(ptr==NULL)
        return(0);
    tmp_reg=ptr;
    if(tmp_reg->reglist) {
        free(tmp_reg->reglist);
    }
    return (0);
}


/*------------------------------------------------------------*/


////////////////////////////////////////////////////////////////
//                       内存清理函数                         //
//        在正常退出或异常退出时被调用,它包括释放栈节点       //
//        释放临时内存链表,以及输入的p-code块                 //
//        释放栈节点的工作是调用destroyTree函数完成的         //
////////////////////////////////////////////////////////////////

void clean_proc() {
    Stack sptr,osptr;
    struct mem_chain *tmp,*tmp1;
    Stack *statements;
    my_dictionary *tmp_dict;
    int n=0,i;
    /*释放栈节点,因为异常退出时栈节点可能没有完全得到处理*/

    sptr=stack;
    while(sptr) {
        osptr=sptr->next;
        destroyTree(sptr);
        sptr=osptr;
    }
    stack=NULL;
    /*释放临时内存链表,因为内存链表上挂接的都是动态申请的内存*/
    tmp=mem_head;
    while(tmp) {
        if(tmp->ptr) {
            n=tmp->size;
            /*释放临时链表中挂接的常量池*/
            if(tmp->type==TYPE_DICTIONARY) {
                tmp_dict=(my_dictionary *)tmp->ptr;
                for(i=0;i<n;i++) {
                    if(tmp_dict[i].ptr)
                        free(tmp_dict[i].ptr);
                }
                /*释放临时链表中的节点数组*/
            } else
                if(tmp->type==TYPE_STATEMENTS) {
                    statements=(Stack *)tmp->ptr;
                    for(i=0;i<n;i++) {
                        if(statements[i]!=NULL)
                            destroyTree(statements[i]);
                    }
                } else
                    if(tmp->type==TYPE_REGISTER) {
                        /*释放临时链表中的寄存器数组*/
                        freeReg((reg_array *)tmp->ptr);
                    }
            free(tmp->ptr);
        }
        tmp1=tmp->next;
        free(tmp);
        tmp=tmp1;
    }
    mem_head=NULL;

}



/*------------------------destroyTree-------------------------------------*/
/////////////////////////////////////////////////////////////////////
//                 栈节点的内存释放函数                            //
//         输入的参数是要释放的栈节点指针                          //
/////////////////////////////////////////////////////////////////////
static void destroyTree(Stack s) {
    int flags=0,n=0,i;
    Stack *thislist;
    /*如果参数为空，则返回，这是递归出口*/
    if(!s)
        return;
    /*如果栈节点包含一棵树*/
    if(s->type == 't') {
        flags=s->data.tree->flags;
        /*如果是INITOBJECT的action树,需要特殊处理,因为树的左子树指针强制转换为是一个数字*/
        /*该数字是要初始化对象的个数n*/
        /*右子树是一个包含树的栈节点,该树的左子树指针强制指向有n个包含对象名的节点列表*/
        /*右子树指针强制指向一个有N个值的节点列表*/
        /*具体看readActionRecord函数对INITOBJECT动作的处理*/

        if(s->data.tree->action==SWFACTION_INITOBJECT &&
                (flags==LEFT_CANNOT_FREE)&&
                (n=(int)s->data.tree->left)>0 &&
                s->data.tree->right&&
                s->data.tree->right->type=='t'&&
                s->data.tree->right->data.tree->flags==(LEFT_IS_LIST|RIGHT_IS_LIST)) {
            if(((thislist=(Stack *)(s->data.tree->right->data.tree->left)))!=NULL) {
                for(i=0;i<n;i++) {
                    destroyTree(thislist[i]);
                }
                free(s->data.tree->right->data.tree->left);
            }

            if(((thislist=(Stack *)(s->data.tree->right->data.tree->right)))!=NULL) {
                for(i=0;i<n;i++) {
                    /*递归左子树列表释放列表的每个节点*/
                    destroyTree(thislist[i]);
                }
                free(s->data.tree->right->data.tree->right);
            }
            free(s->data.tree->right->data.tree);
            free(s->data.tree->right);
        } else {
            /*---------------process left--------------------------------*/
            /*如果左子树被标记为正常栈节点指针,则递归左子树节点*/
            if(!(flags & (LEFT_CANNOT_FREE | LEFT_CAN_FREE | LEFT_IS_LIST |LEFT_IS_REG_ARRAY)))
                destroyTree(s->data.tree->left);
            /*如果左子树指针被标记为可释放则直接调用free函数*/
            /*这针对左子树指针被强制指向一个字符串的情况*/
            else
                if(flags & LEFT_CAN_FREE)
                    free(s->data.tree->left);
            /*这针对左子树指针强制指向为一个节点列表,而右子树指针强制为(int)该列表的个数*/
                else
                    if((flags & LEFT_IS_LIST)&&(flags & RIGHT_CANNOT_FREE)&& s->data.tree->left!=NULL) {
                        thislist=(Stack *)s->data.tree->left;
                        if((n=(int)s->data.tree->right)>0) {
                            for(i=0;i<n;i++) {
                                destroyTree(thislist[i]);
                            }
                        }
                        free(s->data.tree->left);
                    }
            /*如果左子树包含一个寄存器数组,这种情况不会发生*/
                    else
                        if(flags & LEFT_IS_REG_ARRAY) {
                            freeReg((reg_array *)s->data.tree->left);
                            free(s->data.tree->left);
                        }

            /*---------------------process right------------------------------------*/
            /*如果右子树被标记为正常栈节点指针,则递归右子树节点*/
            if(!(flags & (RIGHT_CANNOT_FREE |RIGHT_CAN_FREE | RIGHT_IS_LIST | RIGHT_IS_REG_ARRAY)))
                destroyTree(s->data.tree->right);
            /*如果右子树指针被标记为可释放则直接调用free函数*/
            /*这针对右子树指针被强制指向一个字符串的情况*/
            else
                if(flags & RIGHT_CAN_FREE)
                    free(s->data.tree->right);
            /*这针对右子树指针强制指向为一个节点列表,而左子树指针强制为(int)该列表的个数*/
            /*例如readActionRecord对DEFINEFUNCTION动作的处理*/
                else
                    if((flags & RIGHT_IS_LIST)&&(flags & RIGHT_CANNOT_FREE)&& s->data.tree->right!=NULL) {
                        thislist=(Stack *)s->data.tree->right;
                        if((n=(int)s->data.tree->left)>0) {
                            for(i=0;i<n;i++) {
                                /*递归释放每一个列表节点*/
                                destroyTree(thislist[i]);
                            }
                        }
                        free(s->data.tree->right);
                    } else
                        if(flags & RIGHT_IS_REG_ARRAY) {
                            /*如果右子树包含一个寄存器数组,这种情况针对function2*/
                            freeReg((reg_array *)s->data.tree->right);
                            free(s->data.tree->right);
                        }
        }
        free(s->data.tree);
        /*如果栈节点包含一个字符串,并且该字符串不在常量池中*/
        /*并且该字符串不是"false"和"true"和"null","undefined"这4个常量字符串*/
        /*并且不是自动寄存器0~5中包含的字符串常量*/
        /*则调用free直接释放该字符串*/
    } else if(s->type == 's' &&\
              s->data.string!=NULL &&\
              s->index==-1 &&\
              s->data.string!=false_str &&\
              s->data.string!=true_str &&\
              s->data.string!=null_str &&\
              s->data.string!=undef_str&&\
              s->data.string!=arNames[REG_THIS]&&\
              s->data.string!=arNames[REG_ARGUMENT]&&\
              s->data.string!=arNames[REG_SUPER]&&\
              s->data.string!=arNames[REG_ROOT]&&\
              s->data.string!=arNames[REG_PARENT]&&\
              s->data.string!=arNames[REG_GLOBAL])
        free(s->data.string);
    /*释放跳转标志*/
    if(s->ntarget>0 && s->target) {
        free(s->target);
        s->target=NULL;
        s->ntarget=0;
    }

    return(free(s));
}