| 760 | | wstring* pStr; |
|---|
| 761 | | wchar_t strBuffer[ 22 ]; //22=max value width of longlong |
|---|
| 762 | | switch( OperandType( iOperandType ) ) |
|---|
| 763 | | { |
|---|
| 764 | | case OPERAND_INT: |
|---|
| 765 | | case OPERAND_UNSIGNEDINT: |
|---|
| 766 | | swprintf( strBuffer, 22, L"%d", iValue ); |
|---|
| 767 | | pStr = new wstring( strBuffer ); |
|---|
| 768 | | break; |
|---|
| 769 | | case OPERAND_INT64: |
|---|
| 770 | | case OPERAND_UNSIGNEDINT64: |
|---|
| 771 | | swprintf( strBuffer, 22, L"%d", i64Value ); |
|---|
| 772 | | pStr = new wstring( strBuffer ); |
|---|
| 773 | | break; |
|---|
| 774 | | case OPERAND_FLOAT: |
|---|
| 775 | | swprintf( strBuffer, 22, L"%f", fValue ); |
|---|
| 776 | | pStr = new wstring( strBuffer ); |
|---|
| 777 | | cleanupFloatString( *pStr ); |
|---|
| 778 | | break; |
|---|
| 779 | | case OPERAND_DOUBLE: |
|---|
| 780 | | swprintf( strBuffer, 22, L"%f", dValue ); |
|---|
| 781 | | pStr = new wstring( strBuffer ); |
|---|
| 782 | | cleanupFloatString( *pStr ); |
|---|
| 783 | | break; |
|---|
| 784 | | case OPERAND_UNDEFINED: |
|---|
| 785 | | pStr = new wstring( STRING_INTERNAL_UNDEFINED ); |
|---|
| 786 | | break; |
|---|
| 787 | | case OPERAND_NULL: |
|---|
| 788 | | pStr = new wstring( STRING_INTERNAL_NULL ); |
|---|
| 789 | | break; |
|---|
| 790 | | case OPERAND_NAN: |
|---|
| 791 | | pStr = new wstring( STRING_INTERNAL_NAN ); |
|---|
| 792 | | break; |
|---|
| 793 | | case OPERAND_STRING: |
|---|
| 794 | | pStr = new wstring( *(wstring *)pString ); |
|---|
| 795 | | break; |
|---|
| 796 | | case OPERAND_BOOLEAN: |
|---|
| 797 | | switch( iValue ) |
|---|
| 798 | | { |
|---|
| 799 | | case 0: |
|---|
| 800 | | pStr = new wstring( STRING_INTERNAL_FALSE ); |
|---|
| | 760 | CVariable var = *this; |
|---|
| | 761 | var.convertToString( pVm, 10 ); |
|---|
| | 762 | wstring* pString = var.pString; |
|---|
| | 763 | var.pString = NULL; |
|---|
| | 764 | return pString; |
|---|
| | 765 | } |
|---|
| | 766 | |
|---|
| | 767 | /*************************************************************************** |
|---|
| | 768 | * CVariable::toString |
|---|
| | 769 | ***************************************************************************/ |
|---|
| | 770 | wstring* CVariable::toString( CCilVm* pVm, int32_t iRadix ) |
|---|
| | 771 | { |
|---|
| | 772 | CVariable var = *this; |
|---|
| | 773 | var.convertToString( pVm, iRadix ); |
|---|
| | 774 | wstring* pString = var.pString; |
|---|
| | 775 | var.pString = NULL; |
|---|
| | 776 | return pString; |
|---|
| | 777 | } |
|---|
| | 778 | |
|---|
| | 779 | /*************************************************************************** |
|---|
| | 780 | * CVariable::convertToString |
|---|
| | 781 | ***************************************************************************/ |
|---|
| | 782 | void CVariable::convertToString( CCilVm* pVm ) |
|---|
| | 783 | { |
|---|
| | 784 | convertToString( pVm, 10 ); |
|---|
| | 785 | } |
|---|
| | 786 | |
|---|
| | 787 | /*************************************************************************** |
|---|
| | 788 | * CVariable::convertToString |
|---|
| | 789 | ***************************************************************************/ |
|---|
| | 790 | void CVariable::convertToString( CCilVm* pVm, const int iRadix ) |
|---|
| | 791 | { |
|---|
| | 792 | assert( pVm ); |
|---|
| | 793 | assert( iRadix ); |
|---|
| | 794 | assert( iRadix <=16 ); |
|---|
| | 795 | |
|---|
| | 796 | const wchar_t tableChar[] = { |
|---|
| | 797 | L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7', |
|---|
| | 798 | L'8', L'9', L'a', L'b', L'c', L'd', L'e', L'f', |
|---|
| | 799 | }; |
|---|
| | 800 | |
|---|
| | 801 | wstring* pTmpString; |
|---|
| | 802 | int64_t i64Tmp; |
|---|
| | 803 | int32_t iIndex; |
|---|
| | 804 | float fIndex; |
|---|
| | 805 | double dIndex; |
|---|
| | 806 | int32_t iPrecision = 0; |
|---|
| | 807 | |
|---|
| | 808 | switch( OperandType( iOperandType ) ) |
|---|
| | 809 | { |
|---|
| | 810 | case OPERAND_INT: |
|---|
| | 811 | case OPERAND_UNSIGNEDINT: |
|---|
| | 812 | pTmpString = new wstring(); |
|---|
| | 813 | if( iValue < 0 ) |
|---|
| | 814 | { |
|---|
| | 815 | pTmpString->append( L"-" ); |
|---|
| | 816 | iValue = -iValue; |
|---|
| | 817 | } |
|---|
| | 818 | iIndex = (int32_t)pTmpString->size(); |
|---|
| | 819 | while( iValue ) |
|---|
| | 820 | { |
|---|
| | 821 | pTmpString->insert( iIndex, &tableChar[ iValue % iRadix ], 1 ); |
|---|
| | 822 | iValue = iValue / iRadix; |
|---|
| | 823 | } |
|---|
| | 824 | |
|---|
| | 825 | if( !pTmpString->length() ) pTmpString->append( L"0" ); |
|---|
| | 826 | pString = pTmpString; |
|---|
| | 827 | break; |
|---|
| | 828 | case OPERAND_INT64: |
|---|
| | 829 | case OPERAND_UNSIGNEDINT64: |
|---|
| | 830 | pTmpString = new wstring(); |
|---|
| | 831 | if( i64Value < 0 ) |
|---|
| | 832 | { |
|---|
| | 833 | pTmpString->append( L"-" ); |
|---|
| | 834 | i64Value = -i64Value; |
|---|
| | 835 | } |
|---|
| | 836 | iIndex = (int32_t)pTmpString->size(); |
|---|
| | 837 | while( i64Value ) |
|---|
| | 838 | { |
|---|
| | 839 | pTmpString->insert( iIndex, &tableChar[ i64Value % iRadix ], 1 ); |
|---|
| | 840 | i64Value = i64Value / iRadix; |
|---|
| | 841 | } |
|---|
| | 842 | if( !pTmpString->length() ) pTmpString->append( L"0" ); |
|---|
| | 843 | pString = pTmpString; |
|---|
| | 844 | break; |
|---|
| | 845 | case OPERAND_FLOAT: |
|---|
| | 846 | if( !_finite( fValue ) ) |
|---|
| | 847 | { |
|---|
| | 848 | if( fValue < 0 ) |
|---|
| | 849 | pString = new wstring( STRING_INTERNAL_NEGATIVE_INFINITY ); |
|---|
| | 850 | else |
|---|
| | 851 | pString = new wstring( STRING_INTERNAL_INFINITY ); |
|---|
| | 852 | break; |
|---|
| | 853 | } |
|---|
| | 854 | else if( fValue > LONG_LONG_MAX || fValue < LONG_LONG_MIN ) |
|---|
| | 855 | { |
|---|
| | 856 | //exponent |
|---|
| | 857 | int32_t iExponent = static_cast<int32_t>(log10( fabs( fValue ) )); |
|---|
| | 858 | double dMantissa = fValue / pow( 10.0, iExponent ); |
|---|
| | 859 | CVariable var( dMantissa ); |
|---|
| | 860 | pString = var.toString( pVm, iRadix ); |
|---|
| | 861 | pString->append( L"e" ); |
|---|
| | 862 | CVariable varExp( iExponent ); |
|---|
| | 863 | pTmpString = varExp.toString( pVm, iRadix ); |
|---|
| | 864 | pString->append( *pTmpString ); |
|---|
| | 865 | delete( pTmpString ); |
|---|
| | 866 | break; |
|---|
| | 867 | } |
|---|
| | 868 | else |
|---|
| | 869 | pTmpString = new wstring(); |
|---|
| | 870 | |
|---|
| | 871 | if( fValue < 0 ) |
|---|
| | 872 | { |
|---|
| | 873 | pTmpString->append( L"-" ); |
|---|
| | 874 | fValue = -fValue; |
|---|
| | 875 | } |
|---|
| | 876 | iIndex = static_cast<int32_t>(pTmpString->size()); |
|---|
| | 877 | i64Tmp = static_cast<int64_t>(floor( fValue )); |
|---|
| | 878 | if( !i64Tmp ) pTmpString->append( L"0" ); |
|---|
| | 879 | |
|---|
| | 880 | while( i64Tmp ) |
|---|
| | 881 | { |
|---|
| | 882 | pTmpString->insert( iIndex, &tableChar[ i64Tmp % iRadix ], 1 ); |
|---|
| | 883 | i64Tmp = i64Tmp / iRadix; |
|---|
| | 884 | } |
|---|
| | 885 | fValue = static_cast<float>(modf( fValue, &dIndex )); |
|---|
| | 886 | if( fValue ) pTmpString->append( L"." ); |
|---|
| | 887 | |
|---|
| | 888 | while( fValue ) |
|---|
| | 889 | { |
|---|
| | 890 | fValue *= iRadix; |
|---|
| | 891 | fValue = modff( fValue, &fIndex ); |
|---|
| | 892 | if( ++iPrecision >= TOSTRING_PRECISION_SINGLE ) |
|---|
| | 893 | { |
|---|
| | 894 | pTmpString->append( &tableChar[ (int32_t)fIndex ], 1 ); |
|---|
| | 895 | if( fValue >= 5.f / iRadix ) |
|---|
| | 896 | { |
|---|
| | 897 | wstring::reverse_iterator itBegin = pTmpString->rbegin(); |
|---|
| | 898 | wstring::reverse_iterator itEnd = pTmpString->rend(); |
|---|
| | 899 | while( itBegin != itEnd ) |
|---|
| | 900 | { |
|---|
| | 901 | if( *itBegin == L'.' || *itBegin == L'-' ) |
|---|
| | 902 | { |
|---|
| | 903 | itBegin++; |
|---|
| | 904 | continue; |
|---|
| | 905 | } |
|---|
| | 906 | if( *itBegin - L'0' + 1 < iRadix ) |
|---|
| | 907 | { |
|---|
| | 908 | *itBegin = (*itBegin)+1; |
|---|
| | 909 | itBegin = itEnd; |
|---|
| | 910 | } |
|---|
| | 911 | else |
|---|
| | 912 | { |
|---|
| | 913 | pTmpString = &pTmpString->erase( pTmpString->length() - 1, 1 ); |
|---|
| | 914 | itBegin = pTmpString->rbegin(); |
|---|
| | 915 | itEnd = pTmpString->rend(); |
|---|
| | 916 | } |
|---|
| | 917 | } |
|---|
| | 918 | } |
|---|
| | 919 | fValue = 0; |
|---|
| | 920 | } |
|---|
| | 921 | else |
|---|
| | 922 | pTmpString->append( &tableChar[ (int32_t)fIndex ], 1 ); |
|---|
| | 923 | } |
|---|
| | 924 | cleanupFloatString( *pTmpString ); |
|---|
| | 925 | pString = pTmpString; |
|---|
| | 926 | break; |
|---|
| | 927 | case OPERAND_DOUBLE: |
|---|
| | 928 | if( !_finite( dValue ) ) |
|---|
| | 929 | { |
|---|
| | 930 | if( fValue < 0 ) |
|---|
| | 931 | pString = new wstring( STRING_INTERNAL_NEGATIVE_INFINITY ); |
|---|
| | 932 | else |
|---|
| | 933 | pString = new wstring( STRING_INTERNAL_INFINITY ); |
|---|
| | 934 | break; |
|---|
| | 935 | } |
|---|
| | 936 | else if( dValue > LONG_LONG_MAX || dValue < LONG_LONG_MIN ) |
|---|
| | 937 | { |
|---|
| | 938 | //exponent |
|---|
| | 939 | int32_t iExponent = static_cast<int32_t>(log10( fabs( dValue ) )); |
|---|
| | 940 | double dMantissa = dValue / pow( 10.0, iExponent ); |
|---|
| | 941 | CVariable var( dMantissa ); |
|---|
| | 942 | pString = var.toString( pVm, iRadix ); |
|---|
| | 943 | pString->append( L"e" ); |
|---|
| | 944 | CVariable varExp( iExponent ); |
|---|
| | 945 | pTmpString = varExp.toString( pVm, iRadix ); |
|---|
| | 946 | pString->append( *pTmpString ); |
|---|
| | 947 | delete( pTmpString ); |
|---|
| | 948 | break; |
|---|
| | 949 | } |
|---|
| | 950 | else |
|---|
| | 951 | pTmpString = new wstring(); |
|---|
| | 952 | |
|---|
| | 953 | if( dValue < 0 ) |
|---|
| | 954 | { |
|---|
| | 955 | pTmpString->append( L"-" ); |
|---|
| | 956 | dValue = -dValue; |
|---|
| | 957 | } |
|---|
| | 958 | |
|---|
| | 959 | iIndex = static_cast<int32_t>(pTmpString->size()); |
|---|
| | 960 | |
|---|
| | 961 | i64Tmp = static_cast<int64_t>(floor( dValue )); |
|---|
| | 962 | if( !i64Tmp ) pTmpString->append( L"0" ); |
|---|
| | 963 | |
|---|
| | 964 | while( i64Tmp ) |
|---|
| | 965 | { |
|---|
| | 966 | pTmpString->insert( iIndex, &tableChar[ i64Tmp % iRadix ], 1 ); |
|---|
| | 967 | i64Tmp = i64Tmp / iRadix; |
|---|
| | 968 | } |
|---|
| | 969 | dValue = modf( dValue, &dIndex ); |
|---|
| | 970 | if( dValue ) pTmpString->append( L"." ); |
|---|
| | 971 | |
|---|
| | 972 | while( dValue ) |
|---|
| | 973 | { |
|---|
| | 974 | dValue *= iRadix; |
|---|
| | 975 | dValue = modf( dValue, &dIndex ); |
|---|
| | 976 | if( ++iPrecision >= TOSTRING_PRECISION_DOUBLE ) |
|---|
| | 977 | { |
|---|
| | 978 | pTmpString->append( &tableChar[ (int32_t)dIndex ], 1 ); |
|---|
| | 979 | if( dValue >= 5.f / iRadix ) |
|---|
| | 980 | { |
|---|
| | 981 | wstring::reverse_iterator itBegin = pTmpString->rbegin(); |
|---|
| | 982 | wstring::reverse_iterator itEnd = pTmpString->rend(); |
|---|
| | 983 | while( itBegin != itEnd ) |
|---|
| | 984 | { |
|---|
| | 985 | if( *itBegin == L'.' || *itBegin == L'-' ) |
|---|
| | 986 | { |
|---|
| | 987 | itBegin++; |
|---|
| | 988 | continue; |
|---|
| | 989 | } |
|---|
| | 990 | if( *itBegin - L'0' + 1 < iRadix ) |
|---|
| | 991 | { |
|---|
| | 992 | *itBegin = (*itBegin)+1; |
|---|
| | 993 | itBegin = itEnd; |
|---|
| | 994 | } |
|---|
| | 995 | else |
|---|
| | 996 | { |
|---|
| | 997 | pTmpString = &pTmpString->erase( pTmpString->length() - 1, 1 ); |
|---|
| | 998 | itBegin = pTmpString->rbegin(); |
|---|
| | 999 | itEnd = pTmpString->rend(); |
|---|
| | 1000 | } |
|---|
| | 1001 | } |
|---|
| | 1002 | } |
|---|
| | 1003 | dValue = 0; |
|---|
| | 1004 | } |
|---|
| | 1005 | else |
|---|
| | 1006 | pTmpString->append( &tableChar[ (int32_t)dIndex ], 1 ); |
|---|
| | 1007 | } |
|---|
| | 1008 | cleanupFloatString( *pTmpString ); |
|---|
| | 1009 | pString = pTmpString; |
|---|
| | 1010 | break; |
|---|
| | 1011 | case OPERAND_UNDEFINED: |
|---|
| | 1012 | pString = new wstring( STRING_INTERNAL_UNDEFINED ); |
|---|
| | 1013 | break; |
|---|
| | 1014 | case OPERAND_NULL: |
|---|
| | 1015 | pString = new wstring( STRING_INTERNAL_NULL ); |
|---|
| | 1016 | break; |
|---|
| | 1017 | case OPERAND_NAN: |
|---|
| | 1018 | pString = new wstring( STRING_INTERNAL_NAN ); |
|---|
| | 1019 | break; |
|---|
| | 1020 | case OPERAND_STRING: |
|---|
| | 1021 | break; |
|---|
| | 1022 | case OPERAND_BOOLEAN: |
|---|
| | 1023 | switch( iValue ) |
|---|
| | 1024 | { |
|---|
| | 1025 | case 0: |
|---|
| | 1026 | pString = new wstring( STRING_INTERNAL_FALSE ); |
|---|
| | 1027 | break; |
|---|
| | 1028 | default: |
|---|
| | 1029 | pString = new wstring( STRING_INTERNAL_TRUE ); |
|---|
| | 1030 | break; |
|---|
| | 1031 | } |
|---|
| | 1032 | break; |
|---|
| | 1033 | case OPERAND_OBJECTREF: |
|---|
| | 1034 | { |
|---|
| | 1035 | CVariable* pvar = refObject->lookupProperty( STRING_INTERNAL_TOSTRING ); |
|---|
| | 1036 | if( pvar != NULL && OperandType( pvar->iOperandType ) == OPERAND_OBJECTREF ) |
|---|
| | 1037 | { |
|---|
| | 1038 | //call toString? |
|---|
| | 1039 | //May push something to EvalStack, thus this pointer could be invalidated... |
|---|
| | 1040 | CVariable* pResult = pVm->invokeMethod( pvar->refObject->getCall(), |
|---|
| | 1041 | 1, |
|---|
| | 1042 | this ); |
|---|
| | 1043 | wstring* pConvertedString = new wstring(); |
|---|
| | 1044 | this->setStringPointer( pConvertedString ); |
|---|
| | 1045 | |
|---|
| | 1046 | if( pResult->iOperandType != OPERAND_STRING ) |
|---|
| | 1047 | { |
|---|
| | 1048 | |
|---|
| | 1049 | } |
|---|
| | 1050 | else |
|---|
| | 1051 | pConvertedString->append( *pResult->pString ); |
|---|
| | 1052 | delete( pResult ); |
|---|
| | 1053 | pString = pConvertedString; |
|---|
| | 1054 | break; |
|---|
| | 1055 | } |
|---|
| | 1056 | else |
|---|
| | 1057 | { |
|---|
| | 1058 | //No toString definition. |
|---|
| | 1059 | //Just put the result of getValue |
|---|
| | 1060 | pString = refObject->getValue().toString( pVm, iRadix ); |
|---|
| | 1061 | } |
|---|
| | 1062 | } |
|---|
| 805 | | } |
|---|
| 806 | | break; |
|---|
| 807 | | case OPERAND_OBJECTREF: |
|---|
| 808 | | { |
|---|
| 809 | | CVariable* pvar = refObject->lookupProperty( STRING_INTERNAL_TOSTRING ); |
|---|
| 810 | | if( pvar != NULL && OperandType( pvar->iOperandType ) == OPERAND_OBJECTREF ) |
|---|
| 811 | | { |
|---|
| 812 | | //call toString? |
|---|
| 813 | | CVariable* pResult = pVm->invokeMethod( pvar->refObject->getCall(), |
|---|
| 814 | | 1, |
|---|
| 815 | | this ); |
|---|
| 816 | | assert( pResult->iOperandType == OPERAND_STRING ); |
|---|
| 817 | | pStr = pResult->pString; |
|---|
| 818 | | pResult->pString = NULL; |
|---|
| 819 | | delete( pResult ); |
|---|
| 820 | | } |
|---|
| 821 | | else |
|---|
| 822 | | { |
|---|
| 823 | | //No toString definition. |
|---|
| 824 | | //Just put the result of getValue |
|---|
| 825 | | pStr = refObject->getValue().toString( pVm ); |
|---|
| 826 | | } |
|---|
| 827 | | } |
|---|
| 828 | | break; |
|---|
| 829 | | default: |
|---|
| 830 | | Debug_Fatal( "Not implemented yet" ); |
|---|
| 831 | | break; |
|---|
| 832 | | } |
|---|
| 833 | | return pStr; |
|---|
| 834 | | } |
|---|
| 835 | | |
|---|
| 836 | | /*************************************************************************** |
|---|
| 837 | | * CVariable::convertToString |
|---|
| 838 | | ***************************************************************************/ |
|---|
| 839 | | void CVariable::convertToString( CCilVm* pVm ) |
|---|
| 840 | | { |
|---|
| 841 | | wchar_t strBuffer[ 22 ]; //22=max value width of longlong |
|---|
| 842 | | switch( OperandType( iOperandType ) ) |
|---|
| 843 | | { |
|---|
| 844 | | case OPERAND_INT: |
|---|
| 845 | | swprintf( strBuffer, 22, L"%d", iValue ); |
|---|
| 846 | | pString = new wstring( strBuffer ); |
|---|
| 847 | | break; |
|---|
| 848 | | case OPERAND_UNSIGNEDINT: |
|---|
| 849 | | swprintf( strBuffer, 22, L"%u", iValue ); |
|---|
| 850 | | pString = new wstring( strBuffer ); |
|---|
| 851 | | break; |
|---|
| 852 | | case OPERAND_INT64: |
|---|
| 853 | | swprintf( strBuffer, 22, L"%I64d", i64Value ); |
|---|
| 854 | | pString = new wstring( strBuffer ); |
|---|
| 855 | | break; |
|---|
| 856 | | case OPERAND_UNSIGNEDINT64: |
|---|
| 857 | | swprintf( strBuffer, 22, L"%I64u", i64Value ); |
|---|
| 858 | | pString = new wstring( strBuffer ); |
|---|
| 859 | | break; |
|---|
| 860 | | case OPERAND_FLOAT: |
|---|
| 861 | | swprintf( strBuffer, 22, L"%f", fValue ); |
|---|
| 862 | | pString = new wstring( strBuffer ); |
|---|
| 863 | | cleanupFloatString( *pString ); |
|---|
| 864 | | break; |
|---|
| 865 | | case OPERAND_DOUBLE: |
|---|
| 866 | | swprintf( strBuffer, 22, L"%f", dValue ); |
|---|
| 867 | | pString = new wstring( strBuffer ); |
|---|
| 868 | | cleanupFloatString( *pString ); |
|---|
| 869 | | break; |
|---|
| 870 | | case OPERAND_UNDEFINED: |
|---|
| 871 | | pString = new wstring( STRING_INTERNAL_UNDEFINED ); |
|---|
| 872 | | break; |
|---|
| 873 | | case OPERAND_NULL: |
|---|
| 874 | | pString = new wstring( STRING_INTERNAL_NULL ); |
|---|
| 875 | | break; |
|---|
| 876 | | case OPERAND_NAN: |
|---|
| 877 | | pString = new wstring( STRING_INTERNAL_NAN ); |
|---|
| 878 | | break; |
|---|
| 879 | | case OPERAND_STRING: |
|---|
| 880 | | break; |
|---|
| 881 | | case OPERAND_BOOLEAN: |
|---|
| 882 | | switch( iValue ) |
|---|
| 883 | | { |
|---|
| 884 | | case 0: |
|---|
| 885 | | pString = new wstring( STRING_INTERNAL_FALSE ); |
|---|
| 886 | | break; |
|---|
| 887 | | default: |
|---|
| 888 | | pString = new wstring( STRING_INTERNAL_TRUE ); |
|---|
| 889 | | break; |
|---|
| 890 | | } |
|---|
| 891 | | break; |
|---|
| 892 | | case OPERAND_OBJECTREF: |
|---|
| 893 | | { |
|---|
| 894 | | CVariable* pvar = refObject->lookupProperty( STRING_INTERNAL_TOSTRING ); |
|---|
| 895 | | if( pvar != NULL && OperandType( pvar->iOperandType ) == OPERAND_OBJECTREF ) |
|---|
| 896 | | { |
|---|
| 897 | | //call toString? |
|---|
| 898 | | //May push something to EvalStack, thus this pointer could be invalidated... |
|---|
| 899 | | CVariable* pResult = pVm->invokeMethod( pvar->refObject->getCall(), |
|---|
| 900 | | 1, |
|---|
| 901 | | this ); |
|---|
| 902 | | wstring* pConvertedString = new wstring(); |
|---|
| 903 | | this->setStringPointer( pConvertedString ); |
|---|
| 904 | | |
|---|
| 905 | | if( pResult->iOperandType != OPERAND_STRING ) |
|---|
| 906 | | { |
|---|
| 907 | | |
|---|
| 908 | | } |
|---|
| 909 | | else |
|---|
| 910 | | pConvertedString->append( *pResult->pString ); |
|---|
| 911 | | delete( pResult ); |
|---|
| 912 | | pString = pConvertedString; |
|---|
| 913 | | break; |
|---|
| 914 | | } |
|---|
| 915 | | else |
|---|
| 916 | | { |
|---|
| 917 | | //No toString definition. |
|---|
| 918 | | //Just put the result of getValue |
|---|
| 919 | | pString = refObject->getValue().toString( pVm ); |
|---|
| 920 | | } |
|---|
| 921 | | } |
|---|
| 922 | | break; |
|---|
| 923 | | default: |
|---|
| 924 | | Debug_Fatal( "Not implemented yet" ); |
|---|
| 925 | | break; |
|---|
