int Locale::Load( MemBuffer &file ) {
unsigned short langs = file.Read16();
for ( int i = 0; i < langs; ++i ) {
Language lang;
int rc = lang.ReadCatalog( file );
if ( rc >= 0 ) AddLanguage( lang );
else return -1;
}
if ( lib.size() == 0 ) return -1;
if ( !SetDefaultLanguage( CF_LANG_DEFAULT ) ) {
// no english translation found, use something we have
SetDefaultLanguage( lib.begin()->first );
}
return lib.size();
}
void PackTmt::pack(OutputFile *fo)
{
big_relocs = 0;
Packer::handleStub(fi,fo,adam_offset);
const unsigned usize = ih.imagesize;
const unsigned rsize = ih.relocsize;
ibuf.alloc(usize+rsize+128);
obuf.allocForCompression(usize+rsize+128);
MemBuffer wrkmem;
wrkmem.alloc(rsize+EXTRA_INFO); // relocations
fi->seek(adam_offset+sizeof(ih),SEEK_SET);
fi->readx(ibuf,usize);
fi->readx(wrkmem+4,rsize);
const unsigned overlay = file_size - fi->tell();
if (find_le32(ibuf,128,get_le32("UPX ")) >= 0)
throwAlreadyPacked();
if (rsize == 0)
throwCantPack("file is already compressed with another packer");
checkOverlay(overlay);
unsigned relocsize = 0;
//if (rsize)
{
for (unsigned ic=4; ic<=rsize; ic+=4)
set_le32(wrkmem+ic,get_le32(wrkmem+ic)-4);
relocsize = ptr_diff(optimizeReloc32(wrkmem+4,rsize/4,wrkmem,ibuf,1,&big_relocs), wrkmem);
}
wrkmem[relocsize++] = 0;
set_le32(wrkmem+relocsize,ih.entry); // save original entry point
relocsize += 4;
set_le32(wrkmem+relocsize,relocsize+4);
relocsize += 4;
memcpy(ibuf+usize,wrkmem,relocsize);
// prepare packheader
ph.u_len = usize + relocsize;
// prepare filter
Filter ft(ph.level);
ft.buf_len = usize;
// compress
upx_compress_config_t cconf; cconf.reset();
// limit stack size needed for runtime decompression
cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
compressWithFilters(&ft, 512, &cconf);
const unsigned lsize = getLoaderSize();
const unsigned s_point = getLoaderSection("TMTMAIN1");
int e_len = getLoaderSectionStart("TMTCUTPO");
const unsigned d_len = lsize - e_len;
assert(e_len > 0 && s_point > 0);
// patch loader
linker->defineSymbol("original_entry", ih.entry);
defineDecompressorSymbols();
defineFilterSymbols(&ft);
linker->defineSymbol("bytes_to_copy", ph.c_len + d_len);
linker->defineSymbol("copy_dest", 0u - (ph.u_len + ph.overlap_overhead + d_len - 1));
linker->defineSymbol("copy_source", ph.c_len + lsize - 1);
//fprintf(stderr,"\nelen=%x dlen=%x copy_len=%x copy_to=%x oo=%x jmp_pos=%x ulen=%x c_len=%x \n\n",
// e_len,d_len,copy_len,copy_to,ph.overlap_overhead,jmp_pos,ph.u_len,ph.c_len);
linker->defineSymbol("TMTCUTPO", ph.u_len + ph.overlap_overhead);
relocateLoader();
MemBuffer loader(lsize);
memcpy(loader,getLoader(),lsize);
patchPackHeader(loader,e_len);
memcpy(&oh,&ih,sizeof(oh));
oh.imagesize = ph.c_len + lsize; // new size
oh.entry = s_point; // new entry point
oh.relocsize = 4;
// write loader + compressed file
fo->write(&oh,sizeof(oh));
fo->write(loader,e_len);
fo->write(obuf,ph.c_len);
fo->write(loader+lsize-d_len,d_len); // decompressor
char rel_entry[4];
set_le32(rel_entry,5 + s_point);
fo->write(rel_entry,sizeof (rel_entry));
// verify
verifyOverlappingDecompression();
// copy the overlay
copyOverlay(fo, overlay, &obuf);
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
unsigned char * LoadPVRBuffer( const char * fileName, int & width, int & height )
{
width = 0;
height = 0;
MemBufferFile bufferFile( fileName );
MemBuffer buffer = bufferFile.ToMemBuffer( );
if ( buffer.Length < ( int )( sizeof( OVR_PVR_HEADER ) ) )
{
LOG( "Invalid PVR file" );
buffer.FreeData( );
return NULL;
}
const OVR_PVR_HEADER & header = *( OVR_PVR_HEADER * )buffer.Buffer;
if ( header.Version != 0x03525650 )
{
LOG( "Invalid PVR file version" );
buffer.FreeData( );
return NULL;
}
int format = 0;
switch ( header.PixelFormat )
{
case 578721384203708274llu: format = Texture_RGBA; break;
default:
LOG( "Unknown PVR texture format %llu, size %ix%i", header.PixelFormat, width, height );
buffer.FreeData( );
return NULL;
}
// skip the metadata
const UInt32 startTex = sizeof( OVR_PVR_HEADER ) + header.MetaDataSize;
if ( ( startTex < sizeof( OVR_PVR_HEADER ) ) || ( startTex >= buffer.Length ) )
{
LOG( "Invalid PVR header sizes" );
buffer.FreeData( );
return NULL;
}
size_t mipSize = GetOvrTextureSize( format, header.Width, header.Height );
const int outBufferSizeBytes = buffer.Length - startTex;
if ( mipSize > outBufferSizeBytes )
{
buffer.FreeData();
return NULL;
}
width = header.Width;
height = header.Height;
// skip the metadata
unsigned char * outBuffer = ( unsigned char * )malloc( outBufferSizeBytes );
memcpy( outBuffer, ( unsigned char * )buffer.Buffer + startTex, outBufferSizeBytes );
buffer.FreeData( );
return outBuffer;
}
void HtmlParser::outputHtmlNode(MemBuffer& buffer, const HtmlNode* pNode)
{
int attributeIndex = 0;
if(pNode == NULL)
return;
switch(pNode->type)
{
case NODE_CONTENT:
if(pNode->flags & FLAG_CDATA_BLOCK)
{
buffer.appendText("<![CDATA[", 9);
buffer.appendText(pNode->text);
buffer.appendText("]]>", 3);
}
else
buffer.appendText(pNode->text);
break;
case NODE_START_TAG:
buffer.appendChar('<');
buffer.appendText(pNode->tagName);
if(pNode->attributeCount > 0)
buffer.appendChar(' ');
for(attributeIndex = 0; attributeIndex < pNode->attributeCount; attributeIndex++)
{
const HtmlAttribute* pAttribute = getAttribute(pNode, attributeIndex);
buffer.appendText(pAttribute->name);
if(pAttribute->value)
{
bool hasQuoteChar = (strchr(pAttribute->value, '\"') != NULL);
buffer.appendChar('=');
buffer.appendChar(hasQuoteChar ? '\'' : '\"');
buffer.appendText(pAttribute->value);
buffer.appendChar(hasQuoteChar ? '\'' : '\"');
}
if(attributeIndex < pNode->attributeCount - 1)
buffer.appendChar(' ');
}
if(pNode->attributeCount == 0 && pNode->text) //比如 <!DOCTYPE ...>
{
buffer.appendChar(' ');
buffer.appendText(pNode->text);
}
if(pNode->flags & FLAG_SELF_CLOSING_TAG)
buffer.appendText(" /"); //自封闭
buffer.appendChar('>');
break;
case NODE_END_TAG:
buffer.appendText("</");
buffer.appendText(pNode->tagName);
buffer.appendChar('>');
break;
case NODE_REMARKS:
buffer.appendText("<!--");
buffer.appendText(pNode->text);
buffer.appendText("-->");
break;
case NODE_UNKNOWN:
default:
fprintf(stderr, "HtmlParser.outputHtmlNode(): NODE_UNKNOWN\n");
break;
} //end switch
}
void HtmlParser::parseExtraAttributes(const char* szAttributesText, HtmlNode* pTargetNode, const char* szNamePrefix)
{
assert(pTargetNode);
const char* p = szAttributesText;
const char* ps = NULL;
MemBuffer mem;
bool inQuote1 = false, inQuote2 = false;
unsigned char c;
while(c = *p)
{
if(c == '\'')
inQuote1 = !inQuote1;
else if(c == '\"')
inQuote2 = !inQuote2;
bool notInQuote = (!inQuote1 && !inQuote2);
if(notInQuote && (c == '\"' || c == '\'') && !isspace(p[1]))
{
//处理属性值引号后面没有空白分隔符的情况：a="v1"b=v2 （这种错误写法不少见，应兼容之）
if(ps)
{
mem.appendPointer(duplicateStrAndUnquote(ps, p - ps + 1));
ps = NULL;
}
p++;
continue;
}
if(notInQuote && (c == '=' || isspace(c)))
{
if(ps)
{
mem.appendPointer(duplicateStrAndUnquote(ps, p - ps));
ps = NULL;
}
if(c == '=')
mem.appendPointer(NULL);
}
else
{
if(ps == NULL)
ps = p;
}
p++;
}
if(ps)
mem.appendPointer(duplicateStrAndUnquote(ps, p - ps));
mem.appendPointer(NULL);
mem.appendPointer(NULL);
char** pp = (char**) mem.getData();
//下面把解析出来的属性值存入pTargetNode->attributes
MemBuffer* attributes = pTargetNode->attributes;
if(attributes == NULL)
{
attributes = new MemBuffer();
pTargetNode->attributes = attributes;
}
for(int i = 0, n = mem.getDataSize() / sizeof(char*) - 2; i < n; i++)
{
if(!szNamePrefix)
{
attributes->appendPointer(pp[i]); //attribute name
} else {
char* newAttributeName = duplicateStr(pp[i], -1, szNamePrefix);
attributes->appendPointer(newAttributeName); //attribute name
freeDuplicatedStr(pp[i]);
}
if(pp[i+1] == NULL)
{
attributes->appendPointer(pp[i+2]); //attribute value
i += 2;
}
else
attributes->appendPointer(NULL); //attribute vlalue
//标记需free属性名称和属性值文本
//TODO: 将来优化到尽量少复制文本
attributes->appendInt(FLAG_NEED_FREE_NAME | FLAG_NEED_FREE_VALUE); //attribute flags
}
attributes->shrink();
pTargetNode->attributeCount = attributes->getDataSize() / sizeof(HtmlAttribute);
}
void PackWcle::decodeFixups()
{
upx_byte *p = oimage + soimage;
iimage.dealloc();
MemBuffer tmpbuf;
unsigned fixupn = unoptimizeReloc32(&p,oimage,&tmpbuf,1);
MemBuffer wrkmem(8*fixupn+8);
unsigned ic,jc,o,r;
for (ic=0; ic<fixupn; ic++)
{
jc=get_le32(tmpbuf+4*ic);
set_le32(wrkmem+ic*8,jc);
o = soobject_table;
r = get_le32(oimage+jc);
virt2rela(oobject_table,&o,&r);
set_le32(wrkmem+ic*8+4,OOT(o-1,my_base_address));
set_le32(oimage+jc,r);
}
set_le32(wrkmem+ic*8,0xFFFFFFFF); // end of 32-bit offset fixups
tmpbuf.dealloc();
// selector fixups and self-relative fixups
const upx_byte *selector_fixups = p;
const upx_byte *selfrel_fixups = p;
while (*selfrel_fixups != 0xC3)
selfrel_fixups += 9;
selfrel_fixups++;
unsigned selectlen = ptr_diff(selfrel_fixups, selector_fixups)/9;
ofixups = New(upx_byte, fixupn*9+1000+selectlen*5);
upx_bytep fp = ofixups;
for (ic = 1, jc = 0; ic <= opages; ic++)
{
// self relative fixups
while ((r = get_le32(selfrel_fixups))/mps == ic-1)
{
fp[0] = 8;
set_le16(fp+2,r & (mps-1));
o = 4+get_le32(oimage+r);
set_le32(oimage+r,0);
r += o;
o = soobject_table;
virt2rela(oobject_table,&o,&r);
fp[4] = (unsigned char) o;
set_le32(fp+5,r);
fp[1] = (unsigned char) (r > 0xFFFF ? 0x10 : 0);
fp += fp[1] ? 9 : 7;
selfrel_fixups += 4;
dputc('r',stdout);
}
// selector fixups
while (selectlen && (r = get_le32(selector_fixups+5))/mps == ic-1)
{
fp[0] = 2;
fp[1] = 0;
set_le16(fp+2,r & (mps-1));
unsigned x = selector_fixups[1] > 0xD0 ? oh.init_ss_object : oh.init_cs_object;
fp[4] = (unsigned char) x;
fp += 5;
selector_fixups += 9;
selectlen--;
dputc('s',stdout);
}
// 32 bit offset fixups
while (get_le32(wrkmem+4*jc) < ic*mps)
{
if (jc > 1 && ((get_le32(wrkmem+4*(jc-2))+3) & (mps-1)) < 3) // cross page fixup?
{
r = get_le32(oimage+get_le32(wrkmem+4*(jc-2)));
fp[0] = 7;
fp[1] = (unsigned char) (r > 0xFFFF ? 0x10 : 0);
set_le16(fp+2,get_le32(wrkmem+4*(jc-2)) | ~3);
set_le32(fp+5,r);
o = soobject_table;
r = get_le32(wrkmem+4*(jc-1));
virt2rela(oobject_table,&o,&r);
fp[4] = (unsigned char) o;
fp += fp[1] ? 9 : 7;
dputc('0',stdout);
}
o = soobject_table;
r = get_le32(wrkmem+4*(jc+1));
virt2rela(oobject_table,&o,&r);
r = get_le32(oimage+get_le32(wrkmem+4*jc));
fp[0] = 7;
fp[1] = (unsigned char) (r > 0xFFFF ? 0x10 : 0);
set_le16(fp+2,get_le32(wrkmem+4*jc) & (mps-1));
fp[4] = (unsigned char) o;
set_le32(fp+5,r);
fp += fp[1] ? 9 : 7;
jc += 2;
}
set_le32(ofpage_table+ic,ptr_diff(fp,ofixups));
}
for (ic=0; ic < FIXUP_EXTRA; ic++)
*fp++ = 0;
sofixups = ptr_diff(fp, ofixups);
}
EVENT emul::menu_main()
{
int menuExit = 0;
static int menufocus = 0;
EVENT action = EVENT_NONE;
system::set_cpu_speed(CPU_SPEED_IN_MENU);
system::init_frames_counter(100);
video::init(VM_FAST);
menu::setup_bg_scrolling();
menu::msg_box("Please wait...", MMB_MESSAGE);
// Prepare states screenshots
MemBuffer currState;
printf("SAVE CURRENT STATE TO TEMPORARY BUFFER\n");
core::save_load_state(NULL, &currState, false); // save current state to memory
_get_state_screenshot(stateCurrent); // get screenshot for current state
if(slotNumber < 0)
{
slotNumber = 0;
printf("LOAD STATE FROM SLOT 0\n");
core::save_load_state(mSaveState[slotNumber].filePath, NULL, true); // load selected slot state
_get_state_screenshot(stateSaved); // get screenshot for selected slot state
printf("RESTORE CURRENT STATE FROM TEMPORARY BUFFER\n");
core::save_load_state(NULL, &currState, true); // restore current state
}
// Begin menu loop
menu::open();
_update_text_menu_main();
while (!menuExit)
{
// Draw screen:
video::bind_framebuffer();
menu::select_bg_texture(true);
menu::render_menu(MM_count, menufocus);
bool showSavedState = (menufocus == MM_SAVE_STATE || menufocus == MM_LOAD_STATE) && !settings.oldSchoolMode;
menu::render_stateshot(
HW_SCREEN_WIDTH - 8 - SCREENSHOT_WIDTH, 32, SCREENSHOT_WIDTH, SCREENSHOT_HEIGHT,
showSavedState ? (mSaveState[slotNumber].inUse ? 2 : 1) : 0, slotNumber, stateCurrent, stateSaved);
menu::select_bg_texture(false);
video::term_framebuffer();
video::flip(0);
switch(menu::update(MM_count, menufocus))
{
case MA_CANCEL:
action = EVENT_RUN_ROM;
menuExit = 1;
break;
case MA_DECREASE:
switch(menufocus)
{
case MM_SAVE_STATE:
case MM_LOAD_STATE:
if(--slotNumber < 0) slotNumber = 9;
if(mSaveState[slotNumber].inUse) {
core::save_load_state(mSaveState[slotNumber].filePath, NULL, true);
_get_state_screenshot(stateSaved);
core::save_load_state(NULL, &currState, true);
}
break;
case MM_SKIP_FRAMES:
if(--settings.frameSkip > 6) settings.frameSkip = 6;
break;
case MM_FULLSCREEN:
settings.fullScreen ^= 1;
break;
case MM_SOUND_VOLUME:
if(--settings.soundVolume > 10) settings.soundVolume = 10;
break;
}
_update_text_menu_main();
break;
case MA_INCREASE:
switch(menufocus)
{
case MM_SAVE_STATE:
case MM_LOAD_STATE:
if(++slotNumber > 9) slotNumber = 0;
if(mSaveState[slotNumber].inUse) {
core::save_load_state(mSaveState[slotNumber].filePath, NULL, true);
_get_state_screenshot(stateSaved);
core::save_load_state(NULL, &currState, true);
}
break;
case MM_SKIP_FRAMES:
if(++settings.frameSkip > 6) settings.frameSkip = 0;
break;
case MM_FULLSCREEN:
settings.fullScreen ^= 1;
break;
case MM_SOUND_VOLUME:
if(++settings.soundVolume > 10) settings.soundVolume = 0;
break;
}
_update_text_menu_main();
break;
case MA_SELECT:
switch(menufocus)
{
case MM_RESUME:
action = EVENT_RUN_ROM;
menuExit = 1;
break;
case MM_SAVE_STATE:
menu::msg_box("Save game state...", MMB_MESSAGE);
core::save_load_state(mSaveState[slotNumber].filePath, NULL, false);
mSaveState[slotNumber].inUse = true;
memcpy(stateSaved, stateCurrent, sizeof(stateCurrent));
break;
case MM_LOAD_STATE:
core::save_load_state(mSaveState[slotNumber].filePath, NULL, true);
action = EVENT_RUN_ROM;
menuExit = 1;
break;
#ifndef DISABLE_CHEATING
case MM_CHEATING:
menu_cheating();
break;
#endif
case MM_SKIP_FRAMES:
settings.frameSkip = 0;
break;
case MM_SOUND_VOLUME:
settings.soundVolume = 0;
break;
case MM_ADVANCED_SETS:
menu_advanced();
break;
case MM_RESET:
if(menu::msg_box("Are you sure want to reset the game?", MMB_YESNO))
{
action = EVENT_RESET_ROM;
menuExit = 1;
}
break;
case MM_EXIT:
action = EVENT_EXIT_APP;
menuExit = 1;
break;
}
_update_text_menu_main();
break;
case MA_NONE:
if(menufocus == MM_SAVE_STATE || menufocus == MM_LOAD_STATE)
{
if((input::poll() & HW_INPUT_X) && mSaveState[slotNumber].inUse)
{
char buf[256]; sprintf(buf, "Are you really want to delete the game state from the \"Slot %d\"?", slotNumber);
if(menu::msg_box(buf, MMB_YESNO))
{
fsys::kill(mSaveState[slotNumber].filePath);
mSaveState[slotNumber].inUse = false;
}
_update_text_menu_main();
}
}
break;
}
}
menu::close();
// Free used heap memory
printf("FREE CURRENT STATE TEMPORARY BUFFER\n");
currState.free();
return action;
}
static int test_MemBuffer (){
cout << "Go Testing" << __FILE__ << endl;
MemBuffer mem;
cout << "default capacity:" << mem.capacity () << endl;
mem.require (512);
cout << "now capacity:" << mem.capacity () << endl;
mem.require (513);
cout << "now capacity:" << mem.capacity () << endl;
cout << "not use=>" << mem.data () << endl;
mem.appendData ("hello", 5);
cout << "=>" << ( mem.data ()!=NULL?(char*) mem.data (): NULL) << endl;
mem.appendData (" world", 6);
cout << "=>" << ( mem.data ()!=NULL?(char*) mem.data (): NULL) << endl;
cout << "now size:" << mem.size () << " capacity:" << mem.capacity () << endl;
mem.shrink ();
cout << "now size:" << mem.size () << " capacity:" << mem.capacity () << endl;
mem.insertData (6, "code ", 5);
cout << "inserted size:" << mem.size () << " capacity:" << mem.capacity () << endl;
cout << "=>" << ( mem.data ()!=NULL?(char*) mem.data (): NULL) << endl;
mem.deleteData (6, 5);
cout << "deleted size:" << mem.size () << " capacity:" << mem.capacity () << endl;
cout << "=>" << ( mem.data ()!=NULL?(char*) mem.data (): NULL) << endl;
MemBuffer other;
other = mem;
cout << "other size:" << other.size () << " capacity:" << other.capacity () << endl;
cout << "other=>" << ( other.data ()!=NULL?(char*) other.data (): NULL) << endl;
size_t rs = other.saveToFile ("/tmp/temp_test");
cout << "write :" << rs << endl;
mem.empty ();
rs = mem.loadFromFile ("/tmp/temp_test");
cout << "read :" << rs << endl;
cout << "read size:" << mem.size () << " capacity:" << mem.capacity () << endl;
cout << "=>" << ( mem.data ()!=NULL?(char*) mem.data (): NULL) << endl;
unlink ("/tmp/temp_test");
cout << "=============================\n\n" << endl;
int i = 1;
long l = 1000;
char string[] = "hello world";
bool b = true;
float f = 2.0f;
double d = 100.1;
mem.empty ();
mem.pushInt ( &i );
mem.pushLong ( &l );
mem.pushString ( string, strlen(string) );
mem.pushBool ( &b );
mem.pushFloat ( &f );
mem.pushDouble ( &d );
cout << "push size:" << mem.size () << " capacity:" << mem.capacity () << endl;
other.empty ();
other = mem;
cout << "double:" << other.popDouble () << endl;
cout << "float:" << other.popFloat () << endl;
cout << "bool:" << other.popBool () << endl;
cout << "stirng:" << other.popString () << endl;
cout << "loing:" << other.popLong () << endl;
cout << "int:" << other.popInt () << endl;
return 0;
}
int Transport::Save( MemBuffer &file ) const {
Unit::Save( file );
file.Write16( t_crystals );
return 0;
}
void MemBuffer::copy(const MemBuffer& buffer)
{
int size = buffer.getSize();
alloc(size);
memcpy(getPtr(), buffer.getConstPtr(), size);
}
