Formats::Chiptune::Container::Ptr Parse(const Binary::Container& data, Builder& target)
{
if (!FastCheck(data))
{
return Formats::Chiptune::Container::Ptr();
}
try
{
Binary::InputStream stream(data);
stream.ReadField<SignatureType>();
target.SetTitle(DecodeString(stream.ReadCString(MAX_STRING_SIZE)));
target.SetAuthor(DecodeString(stream.ReadCString(MAX_STRING_SIZE)));
target.SetComment(DecodeString(stream.ReadCString(MAX_COMMENT_SIZE)));
const std::size_t fixedOffset = stream.GetPosition();
std::size_t totalFrames = 0;
for (;;)
{
const uint8_t val = stream.ReadField<uint8_t>();
if (val == FINISH)
{
break;
}
switch (val)
{
case BEGIN_FRAME:
++totalFrames;
target.BeginFrames(1);
break;
case SKIP_FRAMES:
{
const uint_t frames = 3 + stream.ReadField<uint8_t>();
totalFrames += frames;
target.BeginFrames(frames);
}
break;
case SELECT_SECOND_CHIP:
target.SelectChip(1);
break;
case SELECT_FIRST_CHIP:
target.SelectChip(0);
break;
case LOOP_MARKER:
target.SetLoop();
break;
default:
target.SetRegister(val, stream.ReadField<uint8_t>());
break;
}
}
Require(totalFrames >= MIN_FRAMES);
const std::size_t usedSize = stream.GetPosition();
const auto subData = stream.GetReadData();
return CreateCalculatingCrcContainer(subData, fixedOffset, usedSize - fixedOffset);
}
catch (const std::exception&)
{
return Formats::Chiptune::Container::Ptr();
}
}
void
URLSearchParams::ParseInput(const nsACString& aInput,
URLSearchParamsObserver* aObserver)
{
// Remove all the existing data before parsing a new input.
DeleteAll();
nsACString::const_iterator start, end;
aInput.BeginReading(start);
aInput.EndReading(end);
nsACString::const_iterator iter(start);
while (start != end) {
nsAutoCString string;
if (FindCharInReadable('&', iter, end)) {
string.Assign(Substring(start, iter));
start = ++iter;
} else {
string.Assign(Substring(start, end));
start = end;
}
if (string.IsEmpty()) {
continue;
}
nsACString::const_iterator eqStart, eqEnd;
string.BeginReading(eqStart);
string.EndReading(eqEnd);
nsACString::const_iterator eqIter(eqStart);
nsAutoCString name;
nsAutoCString value;
if (FindCharInReadable('=', eqIter, eqEnd)) {
name.Assign(Substring(eqStart, eqIter));
++eqIter;
value.Assign(Substring(eqIter, eqEnd));
} else {
name.Assign(string);
}
nsAutoCString decodedName;
DecodeString(name, decodedName);
nsAutoCString decodedValue;
DecodeString(value, decodedValue);
AppendInternal(NS_ConvertUTF8toUTF16(decodedName),
NS_ConvertUTF8toUTF16(decodedValue));
}
NotifyObservers(aObserver);
}
VolumeGC::ConvertedGCBanner VolumeGC::ExtractBannerInformation(const GCBanner& banner_file,
bool is_bnr1) const
{
ConvertedGCBanner banner;
u32 number_of_languages = 0;
Language start_language = Language::Unknown;
if (is_bnr1) // NTSC
{
number_of_languages = 1;
start_language = GetRegion() == Region::NTSC_J ? Language::Japanese : Language::English;
}
else // PAL
{
number_of_languages = 6;
start_language = Language::English;
}
banner.image_width = GC_BANNER_WIDTH;
banner.image_height = GC_BANNER_HEIGHT;
banner.image_buffer = std::vector<u32>(GC_BANNER_WIDTH * GC_BANNER_HEIGHT);
Common::Decode5A3Image(banner.image_buffer.data(), banner_file.image, GC_BANNER_WIDTH,
GC_BANNER_HEIGHT);
for (u32 i = 0; i < number_of_languages; ++i)
{
const GCBannerInformation& info = banner_file.information[i];
Language language = static_cast<Language>(static_cast<int>(start_language) + i);
std::string description = DecodeString(info.description);
if (!description.empty())
banner.descriptions.emplace(language, description);
std::string short_name = DecodeString(info.short_name);
if (!short_name.empty())
banner.short_names.emplace(language, short_name);
std::string long_name = DecodeString(info.long_name);
if (!long_name.empty())
banner.long_names.emplace(language, long_name);
std::string short_maker = DecodeString(info.short_maker);
if (!short_maker.empty())
banner.short_makers.emplace(language, short_maker);
std::string long_maker = DecodeString(info.long_maker);
if (!long_maker.empty())
banner.long_makers.emplace(language, long_maker);
}
return banner;
}
std::string CVolumeGC::GetCompany() const
{
if (!LoadBannerFile())
return "";
auto const pBanner = (GCBanner*)m_banner_file.data();
std::string company = DecodeString(pBanner->comment[0].longMaker);
if (company.empty())
company = DecodeString(pBanner->comment[0].shortMaker);
return company;
}
void CVolumeGC::ExtractBannerInformation(const GCBanner& banner_file, bool is_bnr1) const
{
u32 number_of_languages = 0;
Language start_language = Language::LANGUAGE_UNKNOWN;
if (is_bnr1) // NTSC
{
bool is_japanese = GetCountry() == Country::COUNTRY_JAPAN;
number_of_languages = 1;
start_language = is_japanese ? Language::LANGUAGE_JAPANESE : Language::LANGUAGE_ENGLISH;
}
else // PAL
{
number_of_languages = 6;
start_language = Language::LANGUAGE_ENGLISH;
}
m_image_width = GC_BANNER_WIDTH;
m_image_height = GC_BANNER_HEIGHT;
m_image_buffer = std::vector<u32>(m_image_width * m_image_height);
ColorUtil::decode5A3image(m_image_buffer.data(), banner_file.image, m_image_width,
m_image_height);
for (u32 i = 0; i < number_of_languages; ++i)
{
const GCBannerInformation& info = banner_file.information[i];
Language language = static_cast<Language>(static_cast<int>(start_language) + i);
std::string description = DecodeString(info.description);
if (!description.empty())
m_descriptions[language] = description;
std::string short_name = DecodeString(info.short_name);
if (!short_name.empty())
m_short_names[language] = short_name;
std::string long_name = DecodeString(info.long_name);
if (!long_name.empty())
m_long_names[language] = long_name;
std::string short_maker = DecodeString(info.short_maker);
if (!short_maker.empty())
m_short_makers[language] = short_maker;
std::string long_maker = DecodeString(info.long_maker);
if (!long_maker.empty())
m_long_makers[language] = long_maker;
}
}
GenAlgo::Fitness GenAlgo::CalculateFitness(INDIVIDUAL const &individual)
{
double *x = new double[nVAR],
result = 0;
Fitness rslt;
for (int i = 0; i < nVAR; i++)
{
x[i] = DecodeString(individual.fChromo , i);
}
//exit(EXIT_FAILURE);
test_func(x, &rslt, nVAR, 1, func_num);
//rslt = Objfunc(x);
if (x)
{
delete[] x;
x = NULL;
}
//rslt = (Minimizing_prob) ? (-1 * rslt) : rslt;
return rslt;
}
int GetPostString(const char *cBuffer,const char *sSearch,char *sReturn,int dReturnSize)
{
if(FindPostString(cBuffer,sSearch,sReturn,dReturnSize)<0) {
return -1;
}
DecodeString(sReturn);
return 0;
}
std::string CVolumeDirectory::GetInternalName() const
{
char name[0x60];
if (Read(0x20, 0x60, (u8*)name, false))
return DecodeString(name);
else
return "";
}
std::string VolumeGC::GetApploaderDate(const Partition& partition) const
{
char date[16];
if (!Read(0x2440, sizeof(date), reinterpret_cast<u8*>(&date), partition))
return std::string();
return DecodeString(date);
}
std::string VolumeGC::GetMakerID(const Partition& partition) const
{
char maker_id[2];
if (!Read(0x4, sizeof(maker_id), reinterpret_cast<u8*>(&maker_id), partition))
return std::string();
return DecodeString(maker_id);
}
std::string CVolumeWiiCrypted::GetInternalName() const
{
char name_buffer[0x60];
if (m_pReader != nullptr && Read(0x20, 0x60, (u8*)&name_buffer, false))
return DecodeString(name_buffer);
return "";
}
std::string CVolumeGC::GetInternalName() const
{
char name[0x60];
if (m_pReader != nullptr && Read(0x20, 0x60, (u8*)name))
return DecodeString(name);
return "";
}
std::string VolumeGC::GetInternalName(const Partition& partition) const
{
char name[0x60];
if (Read(0x20, sizeof(name), reinterpret_cast<u8*>(name), partition))
return DecodeString(name);
return "";
}
std::string CVolumeWAD::GetMakerID() const
{
char temp[2] = {1};
// Some weird channels use 0x0000 in place of the MakerID, so we need a check there
if (!Read(0x198 + m_tmd_offset, 2, (u8*)temp) || temp[0] == 0 || temp[1] == 0)
return "00";
return DecodeString(temp);
}
bool GenAlgo::ShowIndividual(INDIVIDUAL const &individual)
{
for (int j = 0; j < nVAR; j++)
{
std::cout << "Var " << j << " : " << DecodeString(individual.fChromo, j) << " " << std::endl;
}
std::cout << "Fittness : " << individual.fFitness << std::endl;
return SUCCESS;
}
std::map<IVolume::ELanguage, std::string> CVolumeGC::GetNames() const
{
std::map<IVolume::ELanguage, std::string> names;
if (!LoadBannerFile())
return names;
u32 name_count = 0;
IVolume::ELanguage language;
bool is_japanese = GetCountry() == IVolume::ECountry::COUNTRY_JAPAN;
switch (m_banner_file_type)
{
case BANNER_BNR1:
name_count = 1;
language = is_japanese ? IVolume::ELanguage::LANGUAGE_JAPANESE : IVolume::ELanguage::LANGUAGE_ENGLISH;
break;
case BANNER_BNR2:
name_count = 6;
language = IVolume::ELanguage::LANGUAGE_ENGLISH;
break;
case BANNER_INVALID:
case BANNER_NOT_LOADED:
break;
}
auto const banner = reinterpret_cast<const GCBanner*>(m_banner_file.data());
for (u32 i = 0; i < name_count; ++i)
{
auto& comment = banner->comment[i];
std::string name = DecodeString(comment.longTitle);
if (name.empty())
name = DecodeString(comment.shortTitle);
if (!name.empty())
names[(IVolume::ELanguage)(language + i)] = name;
}
return names;
}
std::string CVolumeGC::GetMakerID() const
{
if (m_pReader == nullptr)
return std::string();
char makerID[2];
if (!Read(0x4, 0x2, (u8*)&makerID))
return std::string();
return DecodeString(makerID);
}
std::string CVolumeGC::GetApploaderDate() const
{
if (m_pReader == nullptr)
return std::string();
char date[16];
if (!Read(0x2440, 0x10, (u8*)&date))
return std::string();
return DecodeString(date);
}
std::string CVolumeWAD::GetUniqueID() const
{
char GameCode[6];
if (!Read(m_offset + 0x01E0, 4, (u8*)GameCode))
return "0";
std::string temp = GetMakerID();
GameCode[4] = temp.at(0);
GameCode[5] = temp.at(1);
return DecodeString(GameCode);
}
std::string CVolumeWiiCrypted::GetUniqueID() const
{
if (m_pReader == nullptr)
return std::string();
char ID[6];
if (!Read(0, 6, (u8*)ID, false))
return std::string();
return DecodeString(ID);
}
std::string VolumeWAD::GetMakerID(const Partition& partition) const
{
char temp[2];
if (!Read(0x198 + m_tmd_offset, 2, (u8*)temp, partition))
return "00";
// Some weird channels use 0x0000 in place of the MakerID, so we need a check here
const std::locale& c_locale = std::locale::classic();
if (!std::isprint(temp[0], c_locale) || !std::isprint(temp[1], c_locale))
return "00";
return DecodeString(temp);
}
std::string VolumeGC::GetGameID(const Partition& partition) const
{
static const std::string NO_UID("NO_UID");
char id[6];
if (!Read(0, sizeof(id), reinterpret_cast<u8*>(id), partition))
{
PanicAlertT("Failed to read unique ID from disc image");
return NO_UID;
}
return DecodeString(id);
}
int sttSettingUgrader(const char *szSetting, LPARAM lParam)
{
SettingUgraderParam *param = (SettingUgraderParam*)lParam;
if (param->db->IsSettingEncrypted(param->szModule, szSetting)) {
DBVARIANT dbv = { DBVT_UTF8 };
if (!param->db->GetContactSettingStr(param->contactID, param->szModule, szSetting, &dbv)) {
if (dbv.type == DBVT_UTF8) {
DecodeString(dbv.pszVal);
param->pList->insert(new VarDescr(szSetting, (LPCSTR)dbv.pszVal));
}
param->db->FreeVariant(&dbv);
}
}
return 0;
}
std::string CVolumeGC::GetUniqueID() const
{
static const std::string NO_UID("NO_UID");
if (m_pReader == nullptr)
return NO_UID;
char ID[6];
if (!Read(0, sizeof(ID), reinterpret_cast<u8*>(ID)))
{
PanicAlertT("Failed to read unique ID from disc image");
return NO_UID;
}
return DecodeString(ID);
}
void main( void )
{
uchar str[80];
while ( 1 )
{
printf("Enter string:");
gets(str);
printf("\n");
EncodeString( str );
printf("Encoded:%s\n", str );
DecodeString( str );
printf("Decoded:%s\n\n", str );
}
}
string TorrentFile::ParseNext(unsigned short * buf, int * pos) {
int cur_pos = *pos;
unsigned short type = buf[cur_pos];
while(type > 0 && type < 255 && !isdigit(type)) {
if(type == 'i') {
int i = DecodeInt(buf, &cur_pos);
}
else (cur_pos)++;
type = buf[cur_pos];
}
if(type < 0) {
//WriteFile(buf, m_size);
}
*pos = cur_pos;
if(cur_pos > m_size) return "break";
return DecodeString(buf,pos);
}
long SjCPlugin::CallMaster(UINT msg, LPARAM param1, LPARAM param2, LPARAM param3)
{
wxASSERT( msg >= 20000 && msg <= 29999 );
if( g_mainFrame == NULL || g_tools == NULL )
return 0;
// thread-safe mesages
switch( msg )
{
case SJ_GET_VERSION:
return SjTools::VersionString2Long(SJ_VERSION_ASCII);
}
if( ! wxThread::IsMain() )
return 0;
// no thread-save message
switch( msg )
{
case SJ_EXECUTE:
#if SJ_USE_SCRIPTS
if( m_see == NULL )
{
m_see = new SjSee();
m_see->m_plugin = this;
m_see->SetExecutionScope(m_file);
}
m_see->Execute(DecodeString(param1)); // seems to work recursively ;-)
// ExecuteAsFunction() is no good idea - this avoids to define _any_ globals!
if( param2 )
return EncodeString(m_see->GetResultString());
else
return m_see->GetResultLong();
#else
return 0;
#endif
}
// not supported
return 0;
}
std::map<IVolume::ELanguage, std::string> CVolumeGC::GetDescriptions() const
{
std::map<IVolume::ELanguage, std::string> descriptions;
if (!LoadBannerFile())
return descriptions;
u32 desc_count = 0;
IVolume::ELanguage language;
bool is_japanese = GetCountry() == IVolume::ECountry::COUNTRY_JAPAN;
switch (m_banner_file_type)
{
case BANNER_BNR1:
desc_count = 1;
language = is_japanese ? IVolume::ELanguage::LANGUAGE_JAPANESE : IVolume::ELanguage::LANGUAGE_ENGLISH;
break;
case BANNER_BNR2:
language = IVolume::ELanguage::LANGUAGE_ENGLISH;
desc_count = 6;
break;
case BANNER_INVALID:
case BANNER_NOT_LOADED:
break;
}
auto banner = reinterpret_cast<const GCBanner*>(m_banner_file.data());
for (u32 i = 0; i < desc_count; ++i)
{
auto& data = banner->comment[i].comment;
std::string description = DecodeString(data);
if (!description.empty())
descriptions[(IVolume::ELanguage)(language + i)] = description;
}
return descriptions;
}
CAtom *Decode( const string &x, unsigned long iStart )
{
if( iStart < x.size( ) )
{
if( x[iStart] == 'i' )
return DecodeLong( x, iStart );
else if( isdigit( x[iStart] ) )
return DecodeString( x, iStart );
else if( x[iStart] == 'l' )
return DecodeList( x, iStart );
else if( x[iStart] == 'd' )
return DecodeDicti( x, iStart );
string temp = x.substr( iStart );
UTIL_LogPrint( "error decoding - found unexpected character %u, halting decode\n", (unsigned char)x[iStart] );
}
else
UTIL_LogPrint( "error decoding - out of range\n" );
return NULL;
}
String NTLMAuthClientMsgType3::GetLMHash() {
return DecodeString(12L);
}
