decomp_action.c

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

/*--------------------------------DEBUG---------------------------------*/
/////////////////////////////////////////////////////////////////////////
//                  错误处理函数                                       //
//    如果发生错误远跳回my_decompile函数的结束清理段                   //
//    如果编译时定义了DEBUG_COMPILE宏,则打印出错信息至控制台           //
//    该函数的第一个参数是出错代码,该代码用来设置静态变量this_errno    //
//    this_errno的值将作为my_decompile的最终返回值返回给调用函数       //
/////////////////////////////////////////////////////////////////////////

void err_debug(int err,const char *fmt,...) {


#ifdef 	DEBUG_COMPILE
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr,fmt, ap);
    va_end(ap);
    fprintf(stderr,"\n");
#endif

    /*设置错误代码*/
    this_errno=err;
    /*远跳回my_decompile的清理函数*/
    siglongjmp(jmpbuf,1);
}


///////////////////////////////////////////////////////////////////
//                       核查字节序                              //
///////////////////////////////////////////////////////////////////

/*
void checkByteOrder()
{
  unsigned int thisx;
  unsigned char *thisp;
 
  thisx = 0x01020304;
  thisp = (unsigned char *)&thisx;
 
  if(*thisp == 1)
    byteorder = FLASM_BIG_ENDIAN;
  else
    byteorder = FLASM_LITTLE_ENDIAN;
}
*/

///////////////////////////////////////////////////////////////////
//                    串比较函数                                 //
//              如果内存重叠则不再比较                           //
///////////////////////////////////////////////////////////////////
int my_strcmp(char *str1,char *str2) {
    int i,m;
    if(! str1 || !str2 )
        err_debug(ERR_ARGUMENT,"in my_strcmp: str1 or str2 is NULL!");
    if(str1==str2)
        return 0;
    m=MIN(strlen(str1),strlen(str2));
    for(i=0;i<=m;i++) {
        if(str1[i]!=str2[i])
            return(str1[i]-str2[i]);
    }
    if(strlen(str1)!=strlen(str2))
        return(strlen(str1)-strlen(str2));
    return(0);
}

/////////////////////////////////////////////////////////////////
//                   忽略大小写的串比较函数                    //
/////////////////////////////////////////////////////////////////

int my_strcmp_l(char *str1,char *str2) {
    int i,m;
    if(! str1 || !str2 )
        err_debug(ERR_ARGUMENT,"in my_strcmp: str1 or str2 is NULL!");
    if(str1==str2)
        return 0;
    m=MIN(strlen(str1),strlen(str2));
    for(i=0;i<=m;i++) {
        if(tolower(str1[i])!=tolower(str2[i]))
            return(tolower(str1[i])-tolower(str2[i]));
    }
    if(strlen(str1)!=strlen(str2))
        return(strlen(str1)-strlen(str2));
    return(0);
}



/////////////////////////////////////////////////////////////////////
//                 越过空格,制表符等空白子符                       //
/////////////////////////////////////////////////////////////////////

char *over_space(char *over_str) {
    char *str=over_str;
    if(str==NULL)
        return(NULL);
    while(isspace(*str) && *str!='\0') {
        str++;
    }
    return(str);
}




////////////////////////////////////////////////////////////
//                打印p-code,用于打印不能识别的p-code     //
////////////////////////////////////////////////////////////




void dumpBytes(int length) {
    int j=0, i, k, l=0;
    unsigned char buf[16];

    if(length<=0)
        return;

    fprintf(stderr,"\n");

    for(;; ++l) {
        my_debug("%03x0: ", l);
        for(i=0; i<16; ++i) {
            if(i==8)
                fprintf(stderr," ");

            my_debug("%02x ", buf[i] = My_readUInt8());
            ++j;

            if(j==length)
                break;
        }

        if(j==length) {
            for(k=i+1; k<16; ++k)
                fprintf(stderr,"   ");

            if(k==8)
                fprintf(stderr," ");

            ++i;
        }

        fprintf(stderr,"   ");

        for(k=0; k<i; ++k) {
            if(k==8)
                fprintf(stderr," ");

            if((buf[k] > 31) && (buf[k] < 128))
                fprintf(stderr,"%d",buf[k]);
            else
                fprintf(stderr,".");
        }

        fprintf(stderr,"\n");

        if(j==length)
            break;
    }
    fprintf(stderr,"\n\n");
}

/*-----------------------Atoi-----------------------------*/

/////////////////////////////////////////////////////////////
//                转换一个字符串->整数,不能转换则          //
//                返回错误                                 //
/////////////////////////////////////////////////////////////

int Atoi(const char *Atoi_ptr) {
    int n;
    errno=0;
    n=atoi(Atoi_ptr);
    if(errno!=0)
        err_debug(ERR_VALUE,"Atoi,cannot conversion string to a integer");
    return(n);
}


///////////////////////////////////////////////////////////
//         将节点中包含的数字返回                        //
//     如果节点是一个字符串则尝试转换成数字              //
///////////////////////////////////////////////////////////

int intVal(Stack s) {
    if(s->type == 'i')
        return s->data.inum;

    if(s->type == 'd')
        return (int)floor(s->data.dnum);

    if(s->type == 's')
        return Atoi(s->data.string);

    if(s->type == 't')
        err_debug(ERR_STACK,"Can't call intVal on a tree!");

    return 0;
}


/////////////////////////////////////////////////////////////
//               建立一个新的栈节点,并初始化它             //
/////////////////////////////////////////////////////////////

static Stack newStack() {
    Stack s = (Stack)malloc(sizeof(struct _stack));
    memset(s, 0, sizeof(struct _stack));
    /*跳转目标数组设置为NULL*/
    s->target = NULL;
    /*跳转目标数组长度设置为零*/
    s->ntarget=0;
    /*在常量池中的引索设置为-1*/
    s->index=-1;
    /*BREAK和CONTINUE标记设置为0*/
    s->loop_flags=0;
    s->offset=-1;
    s->loop_index=0;
    /*将该节点初始化成常量属性,取值为未定义*/
    set_stack(s,IS_CONSTANT,VALUE_UNDEF);
    return s;
}

///////////////////////////////////////////////////////////////
//                简单的节点销毁函数,非递归                  //
///////////////////////////////////////////////////////////////


static void destroy(Stack s) {
    if(!s)
        return;

    if(s->ntarget>0&&s->target)
        free(s->target);

    if(s->type == 't')
        free(s->data.tree);
    else if(s->type == 's')
        free(s->data.string);

    free(s);
}

#define min(a,b) (((a)<(b))?(a):(b))
////////////////////////////////////////////////////////////////
//     如果节点的值类型或属性发生变化时,调用该函数以更新      //
//     该节点在常量池中的属性和值类型                         //
////////////////////////////////////////////////////////////////
int set_dictionary(Stack a) {
    if(a && a->type=='s'&& (a->index >=0))
        if(dictionary[a->index].ptr==a->data.string) {
            dictionary[a->index].t=a->t;
            return (a->index);
        }

    return(-1);
}
//////////////////////////////////////////////////////////////////
//       用于设置属性和值类型,该函数被set_stack函数调用         //
//////////////////////////////////////////////////////////////////

my_type * set_my_type(my_type * a,uint8_t thisflags,uint8_t thisvalue) {
    if(!a)
        return(NULL);
    a->flags|=thisflags;
    a->value_type=thisvalue;
    return(a);
}
//////////////////////////////////////////////////////////////////
//          设置一个节点的值类型和节点属性,并同时更新该节点在   //
//                       常量池中的属性和值类型                 //
//////////////////////////////////////////////////////////////////
Stack set_stack(Stack a,uint8_t thisflags,uint8_t thisvalue) {
    if(!a)
        return(NULL);
    set_my_type(&(a->t),thisflags,thisvalue);
    set_dictionary(a);
    return(a);
}


#define TEST_BIT(a,b)	((a)->t.flags & (b))
#define TEST_VALUE(a,b) ((a)->t.value_type & (b))
#define TEST_EQUAL(a,b)	((a)->t.flags==(unsigned char)(b))

/////////////////////////////////////////////////////////////////////
//    当一个Action操作符和2个或1个节点构成一个新的表达式树时,      //
//    该函数根据参与操作的节点属性和操作符推断出新构成树的取值     //
//    类型,并且根据操作符推测和设置参与操作的节点属性              //
//    该函数被newTree函数调用                                      //
/////////////////////////////////////////////////////////////////////

my_type test_descendiblity(Stack left,Action action,Stack right) {
    my_type tmp;
    /*根据set variable或varable equal操作:                      */
    /*推断和设置参与操作的left节点是IS_VARIABLE属性,它的值      */
    /*将被赋予right节点的取值类型,新构成的树则被设置成表达式属性*/
    /*和right节点的取值类型                    */


    set_my_type(&tmp,IS_EXPRESSION,VALUE_UNDEF);
    if(action==SWFACTION_SETVARIABLE ||\
            action==SWFACTION_VAREQUALS) {
        if(!left || !right)
            err_debug(ERR_TREE,"int test_descendiblity: parameter is NULL");
        set_stack(left,IS_VARIABLE,right->t.value_type);
        set_stack(left,right->t.flags,right->t.value_type);
        set_my_type(&tmp,IS_EXPRESSION,right->t.value_type);
    } else
        if(action==SWFACTION_SETMEMBER) {
            /*如果是Set Member操作则新树取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_SUBSTRING||\
                    action==SWFACTION_TOSTRING||\
                    action==SWFACTION_EQUAL ||\
                    action==SWFACTION_LESSTHAN ||\
                    action==SWFACTION_LOGICALAND ||\
                    action==SWFACTION_LOGICALOR ||\
                    action==SWFACTION_STRINGEQ ||\
                    action==SWFACTION_STRINGCONCAT ||\
                    action==SWFACTION_STRINGCOMPARE ||\
                    action==SWFACTION_LOGICALNOT ||\
                    action==SWFACTION_MBSUBSTRING ||\
                    action==SWFACTION_SUBSTRING ||\
                    action==SWFACTION_NEWEQUAL ||\
                    action==SWFACTION_NEWLESSTHAN) {
                /*对于以上的逻辑操作符，新构成的树节点赋予bool值类型*/
                set_my_type(&tmp,IS_EXPRESSION,VALUE_BOOL);
            } else
                if(action==SWFACTION_GETVARIABLE ) {
                    /*根据Get varable操作,则据此推断并更新left节点为变量属性*/
                    if(left) {
                        set_stack(left,IS_VARIABLE,left->t.value_type);
                        set_my_type(&tmp,left->t.flags,left->t.value_type);
                    } else
                        set_my_type(&tmp,IS_EXPRESSION,VALUE_UNDEF);
                } else
                    if(action==SWFACTION_ADD ||\