void windowcreate(struct arena* win)
{
win->type = hex32('w','i','n',0);
win->fmt = hex32('8','b','i','t');
win->width = win->stride = 320;
win->height = 200;
win->len = 320*200;
win->buf = (void*)(u64)0x2000000;
}
static void
dump_coff_header (MonoCOFFHeader *coff)
{
printf ("\nCOFF Header:\n");
hex16 (" Machine", coff->coff_machine);
hex16 (" Sections", coff->coff_sections);
hex32 (" Time stamp", coff->coff_time);
hex32 ("Pointer to Symbol Table", coff->coff_symptr);
hex32 (" Symbol Count", coff->coff_symcount);
hex16 (" Optional Header Size", coff->coff_opt_header_size);
hex16 (" Characteristics", coff->coff_attributes);
}
uint8_t *USBD_FS_SerialStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
char buf[25];
UNUSED(speed);
hex32(buf , *(uint32_t*)(UID_BASE ));
hex32(buf + 8, *(uint32_t*)(UID_BASE + 4));
hex32(buf + 16, *(uint32_t*)(UID_BASE + 8));
USBD_GetString(buf, USBD_StrDesc, length);
return USBD_StrDesc;
}
bool GBACheatAddLine(struct GBACheatSet* cheats, const char* line) {
uint32_t op1;
uint16_t op2;
uint16_t op3;
line = hex32(line, &op1);
if (!line) {
return false;
}
while (isspace((int) line[0])) {
++line;
}
line = hex16(line, &op2);
if (!line) {
return false;
}
if (!line[0] || isspace((int) line[0])) {
return GBACheatAddCodeBreaker(cheats, op1, op2);
}
line = hex16(line, &op3);
if (!line) {
return false;
}
uint32_t realOp2 = op2;
realOp2 <<= 16;
realOp2 |= op3;
return GBACheatAddAutodetect(cheats, op1, realOp2);
}
bool GBACheatAutodetectLine(struct GBACheatSet* cheats, const char* line) {
uint32_t op1;
uint32_t op2;
line = hex32(line, &op1);
if (!line) {
return false;
}
while (*line == ' ') {
++line;
}
line = hex32(line, &op2);
if (!line) {
return false;
}
return GBACheatAddAutodetect(cheats, op1, op2);
}
///////////////////////////////////////////////////////////////////////////////
//01 3E 020101 06083030303030303330 070430303036 080102 0A020100 0322 80 001F D4 AB B2 CD C6 9B B4 54 11 0E 82 74 41 21 3D DC 87 70 E9 3E A1 41 E1 FC 67 3E 01 7E 97 EA DC
int rdgd_sendecm_srv(struct cs_server_data *srv, ECM_DATA *ecm)
{
unsigned char buf[CWS_NETMSGSIZE];
buf[0] = 0x01;
//buf[1] = len;
int index = 2;
//Caid Byte Entry
buf[index]=2; buf[index+1]=1;
buf[index+2] = ecm->caid>>8;
index+=3;
//ProvID Entry
buf[index]=6; buf[index+1]=8;
hex32(ecm->provid, (char*)&buf[index+2]);
index+=10;
//KeyNo Entry
buf[index]=7; buf[index+1]=4;
buf[index+2]=0x30; buf[index+3]=0x30; buf[index+4]=0x30; buf[index+5]=0x36;
index+=6;
//Ecm process pid entry
buf[index]=8; buf[index+1]=1;
buf[index+2] = 2;
index+=3;
//Caid entry
buf[index]=0x0A; buf[index+1]=2;
buf[index+2] = ecm->caid>>8; buf[index+3] = ecm->caid & 0xff;
index+=4;
//Ecm entry
buf[index]=3; buf[index+1]=ecm->ecmlen;
memcpy(&buf[index+2],ecm->ecm, ecm->ecmlen);
index += 2+ecm->ecmlen;
buf[1] = index-2;
return rdgd_message_send(srv->handle, buf, index);
}
static void
dump_section_table (MonoSectionTable *st)
{
guint32 flags = st->st_flags;
printf ("\n\tName: %s\n", st->st_name);
hex32 (" Virtual Size", st->st_virtual_size);
hex32 ("Virtual Address", st->st_virtual_address);
hex32 (" Raw Data Size", st->st_raw_data_size);
hex32 (" Raw Data Ptr", st->st_raw_data_ptr);
hex32 (" Reloc Ptr", st->st_reloc_ptr);
hex32 (" LineNo Ptr", st->st_lineno_ptr);
hex16 (" Reloc Count", st->st_reloc_count);
hex16 (" Line Count", st->st_line_count);
printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n",
(flags & SECT_FLAGS_HAS_CODE) ? "code, " : "",
(flags & SECT_FLAGS_HAS_INITIALIZED_DATA) ? "data, " : "",
(flags & SECT_FLAGS_HAS_UNINITIALIZED_DATA) ? "bss, " : "",
(flags & SECT_FLAGS_MEM_DISCARDABLE) ? "discard, " : "",
(flags & SECT_FLAGS_MEM_NOT_CACHED) ? "nocache, " : "",
(flags & SECT_FLAGS_MEM_NOT_PAGED) ? "nopage, " : "",
(flags & SECT_FLAGS_MEM_SHARED) ? "shared, " : "",
(flags & SECT_FLAGS_MEM_EXECUTE) ? "exec, " : "",
(flags & SECT_FLAGS_MEM_READ) ? "read, " : "",
(flags & SECT_FLAGS_MEM_WRITE) ? "write" : "");
}
bool GBACheatAddCodeBreakerLine(struct GBACheatSet* cheats, const char* line) {
uint32_t op1;
uint16_t op2;
line = hex32(line, &op1);
if (!line) {
return false;
}
while (*line == ' ') {
++line;
}
line = hex16(line, &op2);
if (!line) {
return false;
}
return GBACheatAddCodeBreaker(cheats, op1, op2);
}
bool GBACheatAddLine(struct mCheatSet* set, const char* line, int type) {
struct GBACheatSet* cheats = (struct GBACheatSet*) set;
switch (type) {
case GBA_CHEAT_AUTODETECT:
break;
case GBA_CHEAT_CODEBREAKER:
return GBACheatAddCodeBreakerLine(cheats, line);
case GBA_CHEAT_GAMESHARK:
return GBACheatAddGameSharkLine(cheats, line);
case GBA_CHEAT_PRO_ACTION_REPLAY:
return GBACheatAddProActionReplayLine(cheats, line);
case GBA_CHEAT_VBA:
return GBACheatAddVBALine(cheats, line);
default:
return false;
}
uint32_t op1;
uint16_t op2;
uint16_t op3;
const char* lineNext = hex32(line, &op1);
if (!lineNext) {
return false;
}
if (lineNext[0] == ':') {
return GBACheatAddVBALine(cheats, line);
}
while (isspace((int) lineNext[0])) {
++lineNext;
}
lineNext = hex16(lineNext, &op2);
if (!lineNext) {
return false;
}
if (!lineNext[0] || isspace((int) lineNext[0])) {
return GBACheatAddCodeBreaker(cheats, op1, op2);
}
lineNext = hex16(lineNext, &op3);
if (!lineNext) {
return false;
}
uint32_t realOp2 = op2;
realOp2 <<= 16;
realOp2 |= op3;
return GBACheatAddAutodetect(cheats, op1, realOp2);
}
static void
dump_cli_header (MonoCLIHeader *ch)
{
printf ("\n");
printf (" CLI header size: %d\n", ch->ch_size);
printf (" Runtime required: %d.%d\n", ch->ch_runtime_major, ch->ch_runtime_minor);
printf (" Flags: %s, %s, %s, %s\n",
(ch->ch_flags & CLI_FLAGS_ILONLY ? "ilonly" : "contains native"),
(ch->ch_flags & CLI_FLAGS_32BITREQUIRED ? "32bits" : "32/64"),
(ch->ch_flags & CLI_FLAGS_TRACKDEBUGDATA ? "trackdebug" : "no-trackdebug"),
(ch->ch_flags & CLI_FLAGS_STRONGNAMESIGNED ? "strongnamesigned" : "notsigned"));
dent (" Metadata", ch->ch_metadata);
hex32 ("Entry Point Token", ch->ch_entry_point);
dent (" Resources at", ch->ch_resources);
dent (" Strong Name at", ch->ch_strong_name);
dent (" Code Manager at", ch->ch_code_manager_table);
dent (" VTableFixups at", ch->ch_vtable_fixups);
dent (" EAT jumps at", ch->ch_export_address_table_jumps);
}
static void
dump_pe_header (MonoPEHeader *pe)
{
printf ("\nPE Header:\n");
hex16 (" Magic (0x010b)", pe->pe_magic);
hex8 (" LMajor (6)", pe->pe_major);
hex8 (" LMinor (0)", pe->pe_minor);
hex32 (" Code Size", pe->pe_code_size);
hex32 (" Initialized Data Size", pe->pe_data_size);
hex32 ("Uninitialized Data Size", pe->pe_uninit_data_size);
hex32 (" Entry Point RVA", pe->pe_rva_entry_point);
hex32 (" Code Base RVA", pe->pe_rva_code_base);
hex32 (" Data Base RVA", pe->pe_rva_data_base);
printf ("\n");
}
bool GBACheatAddVBALine(struct GBACheatSet* cheats, const char* line) {
uint32_t address;
uint8_t op;
uint32_t value = 0;
int width = 0;
const char* lineNext = hex32(line, &address);
if (!lineNext) {
return false;
}
if (lineNext[0] != ':') {
return false;
}
++lineNext;
while (width < 4) {
lineNext = hex8(lineNext, &op);
if (!lineNext) {
break;
}
value <<= 8;
value |= op;
++width;
}
if (width == 0 || width == 3) {
return false;
}
struct mCheat* cheat = mCheatListAppend(&cheats->d.list);
cheat->address = address;
cheat->operandOffset = 0;
cheat->addressOffset = 0;
cheat->repeat = 1;
cheat->type = CHEAT_ASSIGN;
cheat->width = width;
cheat->operand = value;
return true;
}
static void
dump_nt_header (MonoPEHeaderNT *nt)
{
printf ("\nNT Header:\n");
hex32 (" Image Base (0x400000)", nt->pe_image_base);
hex32 ("Section Alignment (8192)", nt->pe_section_align);
hex32 (" File Align (512/4096)", nt->pe_file_alignment);
hex16 (" OS Major (4)", nt->pe_os_major);
hex16 (" OS Minor (0)", nt->pe_os_minor);
hex16 (" User Major (0)", nt->pe_user_major);
hex16 (" User Minor (0)", nt->pe_user_minor);
hex16 (" Subsys major (4)", nt->pe_subsys_major);
hex16 (" Subsys minor (0)", nt->pe_subsys_minor);
hex32 (" Reserverd", nt->pe_reserved_1);
hex32 (" Image Size", nt->pe_image_size);
hex32 (" Header Size", nt->pe_header_size);
hex32 (" Checksum (0)", nt->pe_checksum);
hex16 (" Subsystem", nt->pe_subsys_required);
hex16 (" DLL Flags (0)", nt->pe_dll_flags);
hex32 (" Stack Reserve Size (1M)", nt->pe_stack_reserve);
hex32 ("Stack commit Size (4096)", nt->pe_stack_commit);
hex32 (" Heap Reserve Size (1M)", nt->pe_heap_reserve);
hex32 (" Heap Commit Size (4096)", nt->pe_heap_commit);
hex32 (" Loader flags (0x1)", nt->pe_loader_flags);
hex32 (" Data Directories (16)", nt->pe_data_dir_count);
}
static void aidfont_start(
struct actor* leaf, struct pinid* lf,
struct arena* twig, struct style* tf,
struct arena* root, struct style* rf)
{
u8* buf;
struct glsrc* src;
struct datapair* mod;
buf = leaf->buf;
mod = root->gl_opaque;
//--------------------font3d-------------------
//[0000,3fff]
src = &mod[font3d0].src;
src->method = 'i';
src->geometry = 3;
src->vs = font3dvert;
src->fs = fontfrag;
src->shader_enq = 1;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
src->tex_name[0] = "tex0";
src->tex_data[0] = buf + 0;
src->tex_w[0] = 2048;
src->tex_h[0] = 2048;
src->tex_fmt[0] = hex32('o','n','e', 0);
src->tex_enq[0] = 1;
//[4000,7fff]
src = &mod[font3d1].src;
src->method = 'i';
src->geometry = 3;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
src->tex_name[0] = "tex0";
src->tex_data[0] = buf + 0x400000;
src->tex_w[0] = 2048;
src->tex_h[0] = 2048;
src->tex_fmt[0] = hex32('o','n','e', 0);
src->tex_enq[0] = 1;
//[8000,bfff]
src = &mod[font3d2].src;
src->method = 'i';
src->geometry = 3;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
src->tex_name[0] = "tex0";
src->tex_data[0] = buf + 0x800000;
src->tex_w[0] = 2048;
src->tex_h[0] = 2048;
src->tex_fmt[0] = hex32('o','n','e', 0);
src->tex_enq[0] = 1;
//[c000,ffff]
src = &mod[font3d3].src;
src->method = 'i';
src->geometry = 3;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
src->tex_name[0] = "tex0";
src->tex_data[0] = buf + 0xc00000;
src->tex_w[0] = 2048;
src->tex_h[0] = 2048;
src->tex_fmt[0] = hex32('o','n','e', 0);
src->tex_enq[0] = 1;
//--------------------font2d-------------------
//[0000,3fff]
src = &mod[font2d0].src;
src->method = 'i';
src->geometry = 3;
src->vs = font2dvert;
src->fs = fontfrag;
src->shader_enq = 1;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
//[4000,7fff]
src = &mod[font2d1].src;
src->method = 'i';
src->geometry = 3;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
//[8000,bfff]
src = &mod[font2d2].src;
src->method = 'i';
src->geometry = 3;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
//[c000,ffff]
src = &mod[font2d3].src;
src->method = 'i';
src->geometry = 3;
src->vbuf_len = 0x200000;
src->vbuf = memorycreate(src->vbuf_len);
src->vbuf_w = 4*3*3;
src->vbuf_h = (src->vbuf_len) / (src->vbuf_w);
src->vbuf_fmt = vbuffmt_333;
src->vbuf_enq = 1;
src->ibuf_len = 0x100000;
src->ibuf = memorycreate(src->ibuf_len);
src->ibuf_w = 2*3;
src->ibuf_h = (src->ibuf_len) / (src->ibuf_w);
src->ibuf_fmt = 0x222;
src->ibuf_enq = 1;
}
