Subversion Repositories spk

Rev

Rev 121 | Rev 126 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 121 Rev 125
Line 687... Line 687...
687 
		return false;
 687 
		return false;
688 
 
 688 
 
689 
	if ( file->GetDir() != m_sDir )
 689 
	if ( file->GetDir() != m_sDir )
690 
		return false;
 690 
		return false;
691 
 
 691 
 
692 
	if ( file->GetName() != m_sName ) {
 692 
	if ( file->GetName() != m_sName )
- 
 
 693 
	{
- 
 
 694 
		// check if the base name matches, but only for certain file extensions
693 
		// check alternate filename
 695 
		if (file->shouldCheckBaseName())
- 
 
 696 
		{
694 
		Utils::String baseName = CFileIO(file->GetName()).dir() + "/" + CFileIO(file->GetName()).baseName();
 697 
			Utils::String baseName = CFileIO(file->GetName()).dir() + "/" + CFileIO(file->GetName()).baseName();
695 
		Utils::String compareBaseName = CFileIO(m_sName).dir() + "/" + CFileIO(m_sName).baseName();
 698 
			Utils::String compareBaseName = CFileIO(m_sName).dir() + "/" + CFileIO(m_sName).baseName();
696 
		if ( !baseName.Compare(compareBaseName) )
 699 
			if (baseName.Compare(compareBaseName))
- 
 
 700 
				return true;
- 
 
 701 
		}
697 
			return false;
 702 
		return false;
698 
	}
 703 
	}
699 
 
 704 
 
700 
	return true;
 705 
	return true;
701 
}
 706 
}
702 
 
 707 
 
Line 831... Line 836...
831 
					unsigned char *retData = new unsigned char[comprLen];
 836 
					unsigned char *retData = new unsigned char[comprLen];
832 
					(*outSize) = comprLen;
 837 
					(*outSize) = comprLen;
833 
					memcpy(retData, compr, comprLen);
 838 
					memcpy(retData, compr, comprLen);
834 
					free(compr);
 839 
					free(compr);
835 
					return retData;
 840 
					return retData;
836 
				}
 841 
				}
837 
 
 842 
 
838 
				free(compr);
 843 
				free(compr);
839 
				return NULL;
 844 
				return NULL;
840 
			}
 845 
			}
841 
			break;
 846 
			break;
842 
	}
 847 
	}
843 
 
 848 
 
844 
	return NULL;
 849 
	return NULL;
845 
}
 850 
}
846 
 
 851 
 
847 
bool C_File::CompressData ( int compressionType, CProgressInfo *progress, int level )
 852 
bool C_File::CompressData ( int compressionType, CProgressInfo *progress, int level )
848 
{
 853 
{
849 
	// no data to try to compress
 854 
	// no data to try to compress
850 
	if ( (!m_sData) || (!m_lDataSize) )
 855 
	if ( (!m_sData) || (!m_lDataSize) )
851 
		return false;
 856 
		return false;
852 
 
 857 
 
853 
	// if comopression is set to noe, dont bother
 858 
	// if comopression is set to noe, dont bother
854 
	if ( compressionType == SPKCOMPRESS_NONE )
 859 
	if ( compressionType == SPKCOMPRESS_NONE )
855 
		return true;
 860 
		return true;
856 
 
 861 
 
857 
	if ( compressionType == SPKCOMPRESS_7ZIP )
 862 
	if ( compressionType == SPKCOMPRESS_7ZIP )
Line 914... Line 919...
914 
			DeleteData ();
 919 
			DeleteData ();
915 
			m_sData = bestCompr;
 920 
			m_sData = bestCompr;
916 
			m_bUsedMalloc = false;
 921 
			m_bUsedMalloc = false;
917 
			m_lDataSize = bestSize;
 922 
			m_lDataSize = bestSize;
918 
			m_iDataCompression = bestCompress;
 923 
			m_iDataCompression = bestCompress;
919 
			return true;
 924 
			return true;
920 
		}
 925 
		}
921 
 
 926 
 
922 
		if ( bestCompr )
 927 
		if ( bestCompr )
923 
			delete bestCompr;
 928 
			delete bestCompr;
924 
	}
 929 
	}
Line 964... Line 969...
964 
		{
 969 
		{
965 
			DeleteData ();
 970 
			DeleteData ();
966 
			m_iDataCompression = SPKCOMPRESS_NONE;
 971 
			m_iDataCompression = SPKCOMPRESS_NONE;
967 
			m_lDataSize = uncomprLen;
 972 
			m_lDataSize = uncomprLen;
968 
			m_sData = uncompr;
 973 
			m_sData = uncompr;
969 
			return true;
 974 
			return true;
970 
		}
 975 
		}
971 
 
 976 
 
972 
		if ( uncompr )
 977 
		if ( uncompr )
973 
			delete [] uncompr;
 978 
			delete [] uncompr;
974 
	}
 979 
	}
975 
	else if ( m_iDataCompression == SPKCOMPRESS_LZMA )
 980 
	else if ( m_iDataCompression == SPKCOMPRESS_LZMA )
976 
	{
 981 
	{
977 
		size_t uncomprLen = m_lUncomprDataSize;
 982 
		size_t uncomprLen = m_lUncomprDataSize;
978 
		unsigned char *uncompr = new unsigned char[m_lUncomprDataSize];
 983 
		unsigned char *uncompr = new unsigned char[m_lUncomprDataSize];
979 
		SRes res = Lzma86_Decode(uncompr, &uncomprLen, m_sData, (size_t*)&m_lDataSize);
 984 
		SRes res = Lzma86_Decode(uncompr, &uncomprLen, m_sData, (size_t*)&m_lDataSize);
980 
		if ( res == SZ_OK )
 985 
		if ( res == SZ_OK )
981 
		{
 986 
		{
Line 1109... Line 1114...
1109 
 
 1114 
 
1110 
 
 1115 
 
1111 
bool C_File::WriteFilePointer ( unsigned char *cData, long len )
 1116 
bool C_File::WriteFilePointer ( unsigned char *cData, long len )
1112 
{
 1117 
{
1113 
	return WriteToFile ( GetFilePointer(), cData, len );
 1118 
	return WriteToFile ( GetFilePointer(), cData, len );
1114 
}
 1119 
}
1115 
 
 1120 
 
1116 
bool C_File::WriteToFile ( CyString filename, unsigned char *cData, long len )
 1121 
bool C_File::WriteToFile ( CyString filename, unsigned char *cData, long len )
1117 
{
 1122 
{
1118 
	unsigned char *data = cData;
 1123 
	unsigned char *data = cData;
1119 
	if ( (!len) || (!data) ) {
 1124 
	if ( (!len) || (!data) ) {
1120 
		len = m_lDataSize;
 1125 
		len = m_lDataSize;
Line 1667... Line 1672...
1667 
		if ( (unpckData) && (unpckSize) ) {
 1672 
		if ( (unpckData) && (unpckSize) ) {
1668 
			ret = ReadSignedFromData ( unpckData, (long)unpckSize );
 1673 
			ret = ReadSignedFromData ( unpckData, (long)unpckSize );
1669 
			delete unpckData;
 1674 
			delete unpckData;
1670 
		}
 1675 
		}
1671 
		return ret;
 1676 
		return ret;
1672 
	}
 1677 
	}
1673 
 
 1678 
 
1674 
	char tag[10000];
 1679 
	char tag[10000];
1675 
 
 1680 
 
1676 
	// work backwards
 1681 
	// work backwards
1677 
	int pos = size - 1;
 1682 
	int pos = size - 1;
1678 
	int max = size - 5000;
 1683 
	int max = size - 5000;
1679 
	if ( max < 0 ) max = 0;
 1684 
	if ( max < 0 ) max = 0;
Line 1687... Line 1692...
1687 
		while ( data[pos2] != '<' && pos2 > max ) pos2--;
 1692 
		while ( data[pos2] != '<' && pos2 > max ) pos2--;
1688 
		if ( data[pos2] != '<' ) break;
 1693 
		if ( data[pos2] != '<' ) break;
1689 
 
 1694 
 
1690 
		memcpy(tag, data + pos2, pos - pos2);
 1695 
		memcpy(tag, data + pos2, pos - pos2);
1691 
		tag[pos - pos2] = '\0';
 1696 
		tag[pos - pos2] = '\0';
1692 
 
 1697 
 
1693 
		Utils::String sTag(tag);
 1698 
		Utils::String sTag(tag);
1694 
		if ( sTag.Compare("</signature") || sTag.Compare("<signature") ) return true;
 1699 
		if ( sTag.Compare("</signature") || sTag.Compare("<signature") ) return true;
1695 
		if ( sTag.Compare("</codearray") || sTag.Compare("<codearray") ) return false;
 1700 
		if ( sTag.Compare("</codearray") || sTag.Compare("<codearray") ) return false;
1696 
		pos = pos2 - 1;
 1701 
		pos = pos2 - 1;
1697 
	}
 1702 
	}
Line 1809... Line 1814...
1809 
	else if ( ext == "pbd" )
 1814 
	else if ( ext == "pbd" )
1810 
		return true;
 1815 
		return true;
1811 
 
 1816 
 
1812 
	return false;
 1817 
	return false;
1813 
}
 1818 
}
- 
 
 1819 
 
- 
 
 1820 
bool C_File::shouldCheckBaseName() const
- 
 
 1821 
{
- 
 
 1822 
	Utils::String ext = CFileIO(m_sName).extension();
- 
 
 1823 
	if (ext == "xml" || ext == "txt" || ext == "pck")
- 
 
 1824 
		return true;
- 
 
 1825 
	if (ext == "bod" || ext == "bob" || ext == "pbb" || ext == "pbd")
- 
 
 1826 
		return true;
- 
 
 1827 
	return false;
- 
 
 1828 
}
- 
 
 1829 
 
1814 
 
 1830 
 
1815 
unsigned char *C_File::BobDecompile(size_t *size)
 1831 
unsigned char *C_File::BobDecompile(size_t *size)
1816 
{
 1832 
{
1817 
	(*size) = 0;
 1833 
	(*size) = 0;
1818 
 
 1834