Show
Ignore:
Timestamp:
07/11/05 19:25:38 (3 years ago)
Author:
zoeloelip
Message:

* ea_store.c and ea_restore.c functions clean up
* extraced restore_class_parent and restore_class_methods from

restore_class_entry to share code with loader.c

* extracted opcode handling in encode/decode_op_array into

encode/decode_op to make code more readable

* make decode_class_entry use new functions in ea_restore.c
* readded line-number encoding
* bumped up encoder version to 4 until new loader is in place

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • eaccelerator/trunk/encoder.c

    r123 r124  
    748748#endif 
    749749 
     750static void encode_op(zend_op_array* from, zend_op* opline, unsigned int ops) { 
     751    encode(opline->opcode); 
     752    encode32(opline->lineno); 
     753    switch (ops & EXT_MASK) { 
     754        case EXT_UNUSED: 
     755            break; 
     756        case EXT_STD: 
     757        case EXT_FCALL: 
     758        case EXT_ARG: 
     759        case EXT_IFACE: 
     760            encode32(opline->extended_value); 
     761            break; 
     762        case EXT_SEND: 
     763        case EXT_SEND_NOREF: 
     764        case EXT_INIT_FCALL: 
     765        case EXT_FETCH: 
     766        case EXT_CAST: 
     767        case EXT_DECLARE: 
     768        case EXT_FCLASS: 
     769        case EXT_BIT: 
     770        case EXT_ISSET: 
     771        case EXT_ASSIGN: 
     772            encode((unsigned char)opline->extended_value); 
     773            break; 
     774        case EXT_FE: 
     775            encode((unsigned char)opline->extended_value); 
     776            break; 
     777        case EXT_OPLINE: 
     778            encode_opline(opline->extended_value, from->last); 
     779            break; 
     780        case EXT_CLASS: 
     781            encode_var(opline->extended_value, from->T); 
     782            break; 
     783        default: 
     784            zend_bailout(); 
     785            break; 
     786    } 
     787    switch (ops & RES_MASK) { 
     788        case RES_UNUSED: 
     789            break; 
     790        case RES_TMP: 
     791        case RES_CLASS: 
     792            encode_var(opline->result.u.var, from->T); 
     793            break; 
     794        case RES_VAR: 
     795            encode_var(opline->result.u.var, from->T); 
     796            if ((opline->result.u.EA.type & EXT_TYPE_UNUSED) != 0) { 
     797                encode(1); 
     798            } else { 
     799                encode(0); 
     800            } 
     801            break; 
     802        case RES_STD: 
     803            encode_znode(&opline->result, from->T); 
     804            if (opline->result.op_type == IS_VAR) { 
     805                if ((opline->result.u.EA.type & EXT_TYPE_UNUSED) != 0) { 
     806                    encode(1); 
     807                } else { 
     808                    encode(0); 
     809                } 
     810            } 
     811            break; 
     812        default: 
     813            zend_bailout(); 
     814            break; 
     815    } 
     816    switch (ops & OP1_MASK) { 
     817        case OP1_UNUSED: 
     818            break; 
     819        case OP1_OPLINE: 
     820            encode_opline(opline->op1.u.opline_num,from->last); 
     821            break; 
     822        case OP1_BRK: 
     823        case OP1_CONT: 
     824            encode_opline(opline->op1.u.opline_num, from->last_brk_cont); 
     825            break; 
     826        case OP1_CLASS: 
     827        case OP1_TMP: 
     828        case OP1_VAR: 
     829            encode_var(opline->op1.u.var, from->T); 
     830            break; 
     831        case OP1_UCLASS: 
     832            encode((unsigned char)opline->op1.op_type); 
     833            if (opline->op1.op_type != IS_UNUSED) { 
     834                encode_var(opline->op1.u.var, from->T); 
     835            } 
     836            break; 
     837        case OP1_ARG: 
     838            encode32(opline->op1.u.constant.value.lval); 
     839            break; 
     840#ifdef ZEND_ENGINE_2 
     841        case OP1_JMPADDR: 
     842            encode_opline(opline->op1.u.jmp_addr - from->opcodes, from->last); 
     843            break; 
     844#endif 
     845        case OP1_STD: 
     846            encode_znode(&opline->op1, from->T); 
     847            break; 
     848        default: 
     849            zend_bailout(); 
     850            break; 
     851    } 
     852    switch (ops & OP2_MASK) { 
     853        case OP2_UNUSED: 
     854            break; 
     855        case OP2_OPLINE: 
     856            encode_opline(opline->op2.u.opline_num, from->last); 
     857            break; 
     858        case OP2_ARG: 
     859            encode32(opline->op2.u.opline_num); 
     860            break; 
     861        case OP2_ISSET: 
     862        case OP2_INCLUDE: 
     863            encode((unsigned char)opline->op2.u.constant.value.lval); 
     864            break; 
     865        case OP2_FETCH: 
     866#ifdef ZEND_ENGINE_2 
     867            encode((unsigned char)opline->op2.u.EA.type); 
     868            if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) { 
     869                encode_var(opline->op2.u.var, from->T); 
     870            } 
     871#else 
     872            encode((unsigned char)opline->op2.u.fetch_type); 
     873#endif 
     874            break; 
     875        case OP2_CLASS: 
     876        case OP2_TMP: 
     877        case OP2_VAR: 
     878            encode_var(opline->op2.u.var, from->T); 
     879            break; 
     880#ifdef ZEND_ENGINE_2 
     881        case OP2_JMPADDR: 
     882            encode_opline(opline->op2.u.jmp_addr - from->opcodes, from->last); 
     883            break; 
     884#endif 
     885        case OP2_STD: 
     886            encode_znode(&opline->op2, from->T); 
     887            break; 
     888        default: 
     889            zend_bailout(); 
     890            break; 
     891    } 
     892 
     893} 
     894 
    750895static void encode_op_array(zend_op_array* from) { 
    751896  zend_op *opline; 
    …… 
    840985        zend_bailout(); 
    841986      } else { 
    842         unsigned int ops = op_dsc->ops; 
    843         encode(opline->opcode); 
    844 #if EA_ENCODER_VERSION < 2 
    845         encode32(opline->lineno); 
    846 #endif 
    847         switch (ops & EXT_MASK) { 
    848           case EXT_UNUSED: 
    849              break; 
    850           case EXT_STD: 
    851           case EXT_FCALL: 
    852           case EXT_ARG: 
    853           case EXT_IFACE: 
    854             encode32(opline->extended_value); 
    855             break; 
    856           case EXT_SEND: 
    857           case EXT_SEND_NOREF: 
    858           case EXT_INIT_FCALL: 
    859           case EXT_FETCH: 
    860           case EXT_CAST: 
    861           case EXT_DECLARE: 
    862           case EXT_FCLASS: 
    863           case EXT_BIT: 
    864           case EXT_ISSET: 
    865           case EXT_ASSIGN: 
    866             encode((unsigned char)opline->extended_value); 
    867             break; 
    868           case EXT_FE: 
    869 #if EA_ENCODER_VERSION >= 3 
    870             encode((unsigned char)opline->extended_value); 
    871 #endif 
    872             break; 
    873           case EXT_OPLINE: 
    874             encode_opline(opline->extended_value, from->last); 
    875             break; 
    876           case EXT_CLASS: 
    877             encode_var(opline->extended_value, from->T); 
    878             break; 
    879           default: 
    880             zend_bailout(); 
    881             break; 
    882         } 
    883         switch (ops & RES_MASK) { 
    884           case RES_UNUSED: 
    885             break; 
    886           case RES_TMP: 
    887           case RES_CLASS: 
    888             encode_var(opline->result.u.var, from->T); 
    889             break; 
    890           case RES_VAR: 
    891             encode_var(opline->result.u.var, from->T); 
    892             if ((opline->result.u.EA.type & EXT_TYPE_UNUSED) != 0) { 
    893               encode(1); 
    894             } else { 
    895               encode(0); 
    896             } 
    897             break; 
    898           case RES_STD: 
    899             encode_znode(&opline->result, from->T); 
    900             if (opline->result.op_type == IS_VAR) { 
    901               if ((opline->result.u.EA.type & EXT_TYPE_UNUSED) != 0) { 
    902                 encode(1); 
    903               } else { 
    904                 encode(0); 
    905               } 
    906             } 
    907             break; 
    908           default: 
    909             zend_bailout(); 
    910             break; 
    911         } 
    912         switch (ops & OP1_MASK) { 
    913           case OP1_UNUSED: 
    914             break; 
    915           case OP1_OPLINE: 
    916             encode_opline(opline->op1.u.opline_num,from->last); 
    917             break; 
    918           case OP1_BRK: 
    919           case OP1_CONT: 
    920             encode_opline(opline->op1.u.opline_num, from->last_brk_cont); 
    921             break; 
    922           case OP1_CLASS: 
    923           case OP1_TMP: 
    924           case OP1_VAR: 
    925             encode_var(opline->op1.u.var, from->T); 
    926             break; 
    927           case OP1_UCLASS: 
    928             encode((unsigned char)opline->op1.op_type); 
    929             if (opline->op1.op_type != IS_UNUSED) { 
    930               encode_var(opline->op1.u.var, from->T); 
    931             } 
    932             break; 
    933           case OP1_ARG: 
    934             encode32(opline->op1.u.constant.value.lval); 
    935             break; 
    936 #ifdef ZEND_ENGINE_2 
    937           case OP1_JMPADDR: 
    938             encode_opline(opline->op1.u.jmp_addr - from->opcodes, from->last); 
    939             break; 
    940 #endif 
    941           case OP1_STD: 
    942             encode_znode(&opline->op1, from->T); 
    943             break; 
    944           default: 
    945             zend_bailout(); 
    946             break; 
    947         } 
    948         switch (ops & OP2_MASK) { 
    949           case OP2_UNUSED: 
    950             break; 
    951           case OP2_OPLINE: 
    952             encode_opline(opline->op2.u.opline_num, from->last); 
    953             break; 
    954           case OP2_ARG: 
    955             encode32(opline->op2.u.opline_num); 
    956             break; 
    957           case OP2_ISSET: 
    958           case OP2_INCLUDE: 
    959             encode((unsigned char)opline->op2.u.constant.value.lval); 
    960             break; 
    961           case OP2_FETCH: 
    962 #ifdef ZEND_ENGINE_2 
    963             encode((unsigned char)opline->op2.u.EA.type); 
    964             if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) { 
    965               encode_var(opline->op2.u.var, from->T); 
    966             } 
    967 #else 
    968             encode((unsigned char)opline->op2.u.fetch_type); 
    969 #endif 
    970             break; 
    971           case OP2_CLASS: 
    972           case OP2_TMP: 
    973           case OP2_VAR: 
    974             encode_var(opline->op2.u.var, from->T); 
    975             break; 
    976 #ifdef ZEND_ENGINE_2 
    977           case OP2_JMPADDR: 
    978             encode_opline(opline->op2.u.jmp_addr - from->opcodes, from->last); 
    979             break; 
    980 #endif 
    981           case OP2_STD: 
    982             encode_znode(&opline->op2, from->T); 
    983             break; 
    984           default: 
    985             zend_bailout(); 
    986             break; 
    987         } 
     987        encode_op(from, opline, op_dsc->ops); 
    988988      } 
    989989    }