void AsString_object::test<4>()
{
set_test_name("Equality test 2");
AsString_ref str1 = ASL("This is string");
AsString_ref str2 = ASL("This is string");
ensure(!(str1 != str2));
}
void AsString_object::test<3>()
{
set_test_name("Equality test 1");
AsString_ref str1 = ASL("This is string");
AsString_ref str2 = ASL("This is string");
ensure(str1 == str2);
}
void AsMultitouchInputMode::_as_static_init_AsMultitouchInputMode()
{
if (!_as_static_initialized_AsMultitouchInputMode)
{
_as_static_initialized_AsMultitouchInputMode = true;
NONE = ASL("none");
GESTURE = ASL("gesture");
TOUCH_POINT = ASL("touchPoint");
}
}
void AsKeyboardEvent::_as_static_init_AsKeyboardEvent()
{
if (!_as_static_initialized_AsKeyboardEvent)
{
_as_static_initialized_AsKeyboardEvent = true;
_as_static_init_AsEvent();
KEY_UP = ASL("keyUp");
KEY_DOWN = ASL("keyDown");
}
}
void AsStageDisplayState::_as_static_init_AsStageDisplayState()
{
if (!_as_static_initialized_AsStageDisplayState)
{
_as_static_initialized_AsStageDisplayState = true;
FULL_SCREEN = ASL("fullScreen");
FULL_SCREEN_INTERACTIVE = ASL("fullScreenInteractive");
NORMAL = ASL("normal");
}
}
void AsString_object::test<9>()
{
set_test_name("slice test");
AsString_ref str1 = ASL("This is string");
bool succeed = true;
succeed = succeed && str1->slice(5) == ASL("is string");
succeed = succeed && str1->slice(5, 7) == ASL("is");
ensure(succeed);
}
void AsString_object::test<11>()
{
set_test_name("substr test");
AsString_ref str1 = ASL("This is string");
bool succeed = true;
succeed = succeed && str1->substr(5) == ASL("is string");
succeed = succeed && str1->substr(5, 2) == ASL("is");
succeed = succeed && str1->substr(5, 0) == ASL("");
ensure(succeed);
}
void AsStageQuality::_as_static_init_AsStageQuality()
{
if (!_as_static_initialized_AsStageQuality)
{
_as_static_initialized_AsStageQuality = true;
LOW = ASL("low");
MEDIUM = ASL("medium");
HIGH = ASL("high");
BEST = ASL("best");
}
}
void AsStageScaleMode::_as_static_init_AsStageScaleMode()
{
if (!_as_static_initialized_AsStageScaleMode)
{
_as_static_initialized_AsStageScaleMode = true;
SHOW_ALL = ASL("showAll");
EXACT_FIT = ASL("exactFit");
NO_BORDER = ASL("noBorder");
NO_SCALE = ASL("noScale");
}
}
void AsIOErrorEvent::_as_static_init_AsIOErrorEvent()
{
if (!_as_static_initialized_AsIOErrorEvent)
{
_as_static_initialized_AsIOErrorEvent = true;
_as_static_init_AsEvent();
IO_ERROR = ASL("ioError");
NETWORK_ERROR = ASL("networkError");
DISK_ERROR = ASL("diskError");
VERIFY_ERROR = ASL("verifyError");
}
}
void AsString_object::test<6>()
{
set_test_name("charAt test");
AsString_ref str1 = ASL("This is string");
bool succeed = true;
succeed = succeed && str1->charAt(0) == ASL("T");
succeed = succeed && str1->charAt(5) == ASL("i");
succeed = succeed && str1->charAt(10) != ASL("!");
succeed = succeed && str1->charAt(100) == ASL("");
ensure(succeed);
}
void Apu1B()
{
// ASL dp+X
uint8_t Work8 = S9xAPUGetByteZ(OP1 + IAPU.Registers.X);
ASL(Work8);
S9xAPUSetByteZ(Work8, OP1 + IAPU.Registers.X);
IAPU.PC += 2;
}
void Apu0B()
{
// ASL dp
uint8_t Work8 = S9xAPUGetByteZ(OP1);
ASL(Work8);
S9xAPUSetByteZ(Work8, OP1);
IAPU.PC += 2;
}
void AsString_object::test<1>()
{
set_test_name("Length test 1");
AsString_ref str = ASL("1234567890");
int len = str->getLength();
ensure(len == 10);
}
void Apu0C()
{
// ASL abs
Absolute();
uint8_t Work8 = S9xAPUGetByte(IAPU.Address);
ASL(Work8);
S9xAPUSetByte(Work8, IAPU.Address);
IAPU.PC += 3;
}
void AsString_object::test<2>()
{
set_test_name("Length test 2");
AsString_ref str = ASL("");
int len = str->getLength();
ensure(len == 0);
}
void _aslAbsl(void)
{
word addr;
addr = fetch_word((word)(cpu.pc + 1));
ASL(addr);
cpu.pc += 3;
}
void _aslZpx(void)
{
byte zaddr;
zaddr = fetch_byte((word)(cpu.pc + 1));
ASL((word)(zaddr + cpu.x));
cpu.pc += 2;
}
void _aslZp(void)
{
byte zaddr;
zaddr = fetch_byte((word)(cpu.pc + 1));
ASL(zaddr);
cpu.pc += 2;
}
void _aslAbx(void)
{
word addr;
addr = fetch_word((word)(cpu.pc + 1));
ASL((word)(addr + cpu.x));
cpu.pc += 3;
}
void statics_object::test<1>()
{
set_test_name("Static init test");
AsStaticRefInitializer::init();
bool succeed = true;
_V_AsString_ref list = AsStaticFieldClass::list;
succeed = succeed && list != AS_NULL;
succeed = succeed && list->getLength() == 5;
succeed = succeed && list[0] == ASL("Dummy");
succeed = succeed && list[1] == ASL("FooBase");
succeed = succeed && list[2] == ASL("BarBase");
succeed = succeed && list[3] == ASL("Bar");
succeed = succeed && list[4] == ASL("Foo");
ensure(succeed);
}
void AsString_object::test<8>()
{
set_test_name("lastIndexOf test");
AsString_ref str1 = ASL("This is string");
bool succeed = true;
succeed = succeed && str1->lastIndexOf(ASL(" is ")) == 4;
succeed = succeed && str1->lastIndexOf(ASL(" iz ")) == -1;
succeed = succeed && str1->lastIndexOf(ASL(" string")) == 7;
succeed = succeed && str1->lastIndexOf(ASL("This ")) == 0;
succeed = succeed && str1->lastIndexOf(ASL("This "), 1) == -1;
succeed = succeed && str1->lastIndexOf(ASL("is"), 2) == 2;
succeed = succeed && str1->lastIndexOf(ASL("is"), 3) == 5;
succeed = succeed && str1->lastIndexOf(ASL("stra"), 3) == -1;
ensure(succeed);
}
void AsStaticFoo::_as_static_init_AsStaticFoo()
{
if (!_as_static_initialized_AsStaticFoo)
{
_as_static_initialized_AsStaticFoo = true;
_as_static_init_AsFooBase();
AsStaticFieldClass::_as_static_init_AsStaticFieldClass();
AsStaticDummy::_as_static_init_AsStaticDummy();
AsStaticBar::_as_static_init_AsStaticBar();
staticField = AS_NEW(AsStaticFieldClass,(AS_NEW(AsStaticDummy,(ASL("Foo")))));
staticBar = AS_NEW(AsStaticBar,());
}
void AsString_object::test<5>()
{
set_test_name("Equality test 3");
AsString_ref str1 = ASL("This is string");
AsString_ref str2 = AS_NULL;
AsString_ref str3 = AS_NULL;
bool succeed = true;
succeed = succeed && str1 != str2;
succeed = succeed && str2 != str1;
succeed = succeed && str2 == str3;
ensure(succeed);
}
void AsString_object::test<14>()
{
set_test_name("concat test 1");
AsString_ref str1 = ASL("This");
AsString_ref str2 = str1;
bool succeed = true;
succeed = succeed && (str1 += ASL(" is ")) == ASL("This is ");
succeed = succeed && (str1 += ASL("string")) == ASL("This is string");
succeed = succeed && str2 == ASL("This");
ensure(succeed);
}
virtual void fire()
{
Real AS( AS1->getMolarConc() );
Real Fum( Fum2->getMolarConc() );
Real Arg( Arg3->getMolarConc() );
Real ASL( ASL4->getMolarConc() );
Real size(ASL4->getSuperSystem()->getSize());
Real velocity = ( (k1 * k3 * k5 * AS) - (k2 * k4 * k6 * Fum * Arg) ) * ASL;
// -> M/s^3
Real DENOM = ( k5 * (k2 + k3) ) + ( AS * k1 * (k3 + k5) )
+ ( Fum * k2 * k4 ) + ( Arg * k6 * (k2 + k3) )
+ ( Fum * Arg * k4 * k6 ) + ( AS * Fum * k1 * k4 );
// -> 1/s^2
velocity /= DENOM;
velocity*=size*N_A;
//std::cout <<"velocity="<<velocity<<"\n";
setFlux(velocity);
}
////////////////////////////////////////////////////
// Run!
void Cpu::run(timestamp_t runto)
{
if(cpuJammed && (curCyc() < runto))
{
setMainTimestamp(runto);
}
while( curCyc() < runto )
{
/////////////////////////////////////
// Are we to take an interrupt
if(wantInterrupt)
{
performInterrupt(false);
continue;
}
if( *tracer )
tracer->traceCpuLine( cpu );
/////////////////////////////////////
// No interrupt, do an instruction
u8 opcode = rd( cpu.PC++ );
switch(opcode)
{
/* Branches */
case 0x10: adBranch( !cpu.getN() ); break; /* BPL */
case 0x30: adBranch( cpu.getN() ); break; /* BMI */
case 0x50: adBranch( !cpu.getV() ); break; /* BVC */
case 0x70: adBranch( cpu.getV() ); break; /* BVS */
case 0x90: adBranch( !cpu.getC() ); break; /* BCC */
case 0xB0: adBranch( cpu.getC() ); break; /* BCS */
case 0xD0: adBranch( !cpu.getZ() ); break; /* BNE */
case 0xF0: adBranch( cpu.getZ() ); break; /* BEQ */
/* Flag flip-flop */
case 0x18: adImplied(); cpu.setC(0); break; /* CLC */
case 0x38: adImplied(); cpu.setC(1); break; /* SEC */
case 0x58: adImplied(); cpu.setI(0); break; /* CLI */
case 0x78: adImplied(); cpu.setI(1); break; /* SEI */
case 0xB8: adImplied(); cpu.setV(0); break; /* CLV */
case 0xD8: adImplied(); cpu.setD(0); break; /* CLD */
case 0xF8: adImplied(); cpu.setD(1); break; /* SED */
/* Stack push/pull */
case 0x08: adPush( cpu.getStatus(true) ); break; /* PHP */
case 0x28: cpu.setStatus( adPull() ); break; /* PLP */
case 0x48: adPush( cpu.A ); break; /* PHA */
case 0x68: cpu.NZ( cpu.A = adPull() ); break; /* PLA */
/* Reg Xfer */
case 0xAA: adImplied(); cpu.NZ( cpu.X = cpu.A ); break; /* TAX */
case 0xA8: adImplied(); cpu.NZ( cpu.Y = cpu.A ); break; /* TAY */
case 0xBA: adImplied(); cpu.NZ( cpu.X = cpu.SP ); break; /* TSX */
case 0x8A: adImplied(); cpu.NZ( cpu.A = cpu.X ); break; /* TXA */
case 0x9A: adImplied(); cpu.SP = cpu.X; break; /* TXS */
case 0x98: adImplied(); cpu.NZ( cpu.A = cpu.Y ); break; /* TYA */
/* Misc */
case 0x00: performInterrupt(true); break; /* BRK */
case 0x4C: full_JMP(); break; /* JMP $xxxx */
case 0x6C: full_JMP_Indirect(); break; /* JMP ($xxxx) */
case 0x20: full_JSR(); break; /* JSR $xxxx */
case 0xEA: adImplied(); break; /* NOP */
case 0x40: full_RTI(); break; /* RTI */
case 0x60: full_RTS(); break; /* RTS */
/* ADC */
case 0x69: ADC( adRdIm() ); break;
case 0x65: ADC( adRdZp() ); break;
case 0x75: ADC( adRdZx() ); break;
case 0x6D: ADC( adRdAb() ); break;
case 0x7D: ADC( adRdAx() ); break;
case 0x79: ADC( adRdAy() ); break;
case 0x61: ADC( adRdIx() ); break;
case 0x71: ADC( adRdIy() ); break;
/* AND */
case 0x29: AND( adRdIm() ); break;
case 0x25: AND( adRdZp() ); break;
case 0x35: AND( adRdZx() ); break;
case 0x2D: AND( adRdAb() ); break;
case 0x3D: AND( adRdAx() ); break;
case 0x39: AND( adRdAy() ); break;
case 0x21: AND( adRdIx() ); break;
case 0x31: AND( adRdIy() ); break;
/* ASL */
case 0x0A: adImplied(); ASL(cpu.A); break;
case 0x06: adRWZp( &Cpu::ASL ); break;
case 0x16: adRWZx( &Cpu::ASL ); break;
case 0x0E: adRWAb( &Cpu::ASL ); break;
case 0x1E: adRWAx( &Cpu::ASL ); break;
/* BIT */
case 0x24: BIT( adRdZp() ); break;
case 0x2C: BIT( adRdAb() ); break;
/* CMP */
case 0xC9: CMP( adRdIm() ); break;
case 0xC5: CMP( adRdZp() ); break;
case 0xD5: CMP( adRdZx() ); break;
case 0xCD: CMP( adRdAb() ); break;
case 0xDD: CMP( adRdAx() ); break;
case 0xD9: CMP( adRdAy() ); break;
case 0xC1: CMP( adRdIx() ); break;
case 0xD1: CMP( adRdIy() ); break;
/* CPX */
case 0xE0: CPX( adRdIm() ); break;
case 0xE4: CPX( adRdZp() ); break;
case 0xEC: CPX( adRdAb() ); break;
/* CPY */
case 0xC0: CPY( adRdIm() ); break;
case 0xC4: CPY( adRdZp() ); break;
case 0xCC: CPY( adRdAb() ); break;
/* DEC */
case 0xCA: adImplied(); DEC(cpu.X); break; /* DEX */
case 0x88: adImplied(); DEC(cpu.Y); break; /* DEY */
case 0xC6: adRWZp( &Cpu::DEC ); break;
case 0xD6: adRWZx( &Cpu::DEC ); break;
case 0xCE: adRWAb( &Cpu::DEC ); break;
case 0xDE: adRWAx( &Cpu::DEC ); break;
/* EOR */
case 0x49: EOR( adRdIm() ); break;
case 0x45: EOR( adRdZp() ); break;
case 0x55: EOR( adRdZx() ); break;
case 0x4D: EOR( adRdAb() ); break;
case 0x5D: EOR( adRdAx() ); break;
case 0x59: EOR( adRdAy() ); break;
case 0x41: EOR( adRdIx() ); break;
case 0x51: EOR( adRdIy() ); break;
/* INC */
case 0xE8: adImplied(); INC(cpu.X); break; /* INX */
case 0xC8: adImplied(); INC(cpu.Y); break; /* INY */
case 0xE6: adRWZp( &Cpu::INC ); break;
case 0xF6: adRWZx( &Cpu::INC ); break;
case 0xEE: adRWAb( &Cpu::INC ); break;
case 0xFE: adRWAx( &Cpu::INC ); break;
/* LDA */
case 0xA9: cpu.NZ( cpu.A = adRdIm() ); break;
case 0xA5: cpu.NZ( cpu.A = adRdZp() ); break;
case 0xB5: cpu.NZ( cpu.A = adRdZx() ); break;
case 0xAD: cpu.NZ( cpu.A = adRdAb() ); break;
case 0xBD: cpu.NZ( cpu.A = adRdAx() ); break;
case 0xB9: cpu.NZ( cpu.A = adRdAy() ); break;
case 0xA1: cpu.NZ( cpu.A = adRdIx() ); break;
case 0xB1: cpu.NZ( cpu.A = adRdIy() ); break;
/* LDX */
case 0xA2: cpu.NZ( cpu.X = adRdIm() ); break;
case 0xA6: cpu.NZ( cpu.X = adRdZp() ); break;
case 0xB6: cpu.NZ( cpu.X = adRdZy() ); break;
case 0xAE: cpu.NZ( cpu.X = adRdAb() ); break;
case 0xBE: cpu.NZ( cpu.X = adRdAy() ); break;
/* LDY */
case 0xA0: cpu.NZ( cpu.Y = adRdIm() ); break;
case 0xA4: cpu.NZ( cpu.Y = adRdZp() ); break;
case 0xB4: cpu.NZ( cpu.Y = adRdZx() ); break;
case 0xAC: cpu.NZ( cpu.Y = adRdAb() ); break;
case 0xBC: cpu.NZ( cpu.Y = adRdAx() ); break;
/* LSR */
case 0x4A: adImplied(); LSR(cpu.A); break;
case 0x46: adRWZp( &Cpu::LSR ); break;
case 0x56: adRWZx( &Cpu::LSR ); break;
case 0x4E: adRWAb( &Cpu::LSR ); break;
case 0x5E: adRWAx( &Cpu::LSR ); break;
/* ORA */
case 0x09: ORA( adRdIm() ); break;
case 0x05: ORA( adRdZp() ); break;
case 0x15: ORA( adRdZx() ); break;
case 0x0D: ORA( adRdAb() ); break;
case 0x1D: ORA( adRdAx() ); break;
case 0x19: ORA( adRdAy() ); break;
case 0x01: ORA( adRdIx() ); break;
case 0x11: ORA( adRdIy() ); break;
/* ROL */
case 0x2A: adImplied(); ROL(cpu.A); break;
case 0x26: adRWZp( &Cpu::ROL ); break;
case 0x36: adRWZx( &Cpu::ROL ); break;
case 0x2E: adRWAb( &Cpu::ROL ); break;
case 0x3E: adRWAx( &Cpu::ROL ); break;
/* ROR */
case 0x6A: adImplied(); ROR(cpu.A); break;
case 0x66: adRWZp( &Cpu::ROR ); break;
case 0x76: adRWZx( &Cpu::ROR ); break;
case 0x6E: adRWAb( &Cpu::ROR ); break;
case 0x7E: adRWAx( &Cpu::ROR ); break;
/* SBC */
case 0xE9: SBC( adRdIm() ); break;
case 0xE5: SBC( adRdZp() ); break;
case 0xF5: SBC( adRdZx() ); break;
case 0xED: SBC( adRdAb() ); break;
case 0xFD: SBC( adRdAx() ); break;
case 0xF9: SBC( adRdAy() ); break;
case 0xE1: SBC( adRdIx() ); break;
case 0xF1: SBC( adRdIy() ); break;
/* STA */
case 0x85: adWrZp( cpu.A ); break;
case 0x95: adWrZx( cpu.A ); break;
case 0x8D: adWrAb( cpu.A ); break;
case 0x9D: adWrAx( cpu.A ); break;
case 0x99: adWrAy( cpu.A ); break;
case 0x81: adWrIx( cpu.A ); break;
case 0x91: adWrIy( cpu.A ); break;
/* STX */
case 0x86: adWrZp( cpu.X ); break;
case 0x96: adWrZy( cpu.X ); break;
case 0x8E: adWrAb( cpu.X ); break;
/* STY */
case 0x84: adWrZp( cpu.Y ); break;
case 0x94: adWrZx( cpu.Y ); break;
case 0x8C: adWrAb( cpu.Y ); break;
/////////////////////////////////////
// Unofficial ops
/* One offs */
case 0x0B: case 0x2B: ANC( adRdIm() ); break; /* ANC */
case 0x4B: ALR( adRdIm() ); break; /* ALR */
case 0x6B: ARR( adRdIm() ); break; /* ARR */
case 0xCB: AXS( adRdIm() ); break; /* AXS */
case 0xBB: LAS( adRdAy() ); break; /* LAS */
case 0xEB: SBC( adRdIm() ); break; /* alternative SBC */
case 0x9E: adWrAy_xxx( cpu.X ); break; /* SHX */
case 0x9C: adWrAx_xxx( cpu.Y ); break; /* SHY */
case 0x8B: XAA( adRdIm() ); break; /* XAA */
case 0x9B: cpu.SP = cpu.A & cpu.X; adWrAy_xxx( cpu.SP ); break; /* TAS */
/* AHX */
case 0x9F: adWrAy_xxx( cpu.A & cpu.X ); break;
case 0x93: adWrIy_xxx( cpu.A & cpu.X ); break;
/* DCP */
case 0xC7: adRWZp( &Cpu::DCP ); break;
case 0xD7: adRWZx( &Cpu::DCP ); break;
case 0xCF: adRWAb( &Cpu::DCP ); break;
case 0xDF: adRWAx( &Cpu::DCP ); break;
case 0xDB: adRWAy( &Cpu::DCP ); break;
case 0xC3: adRWIx( &Cpu::DCP ); break;
case 0xD3: adRWIy( &Cpu::DCP ); break;
/* ISC */
case 0xE7: adRWZp( &Cpu::ISC ); break;
case 0xF7: adRWZx( &Cpu::ISC ); break;
case 0xEF: adRWAb( &Cpu::ISC ); break;
case 0xFF: adRWAx( &Cpu::ISC ); break;
case 0xFB: adRWAy( &Cpu::ISC ); break;
case 0xE3: adRWIx( &Cpu::ISC ); break;
case 0xF3: adRWIy( &Cpu::ISC ); break;
/* LAX */
case 0xAB: LAX( adRdIm() ); break;
case 0xA7: LAX( adRdZp() ); break;
case 0xB7: LAX( adRdZy() ); break;
case 0xAF: LAX( adRdAb() ); break;
case 0xBF: LAX( adRdAy() ); break;
case 0xA3: LAX( adRdIx() ); break;
case 0xB3: LAX( adRdIy() ); break;
/* NOP */
case 0x1A: case 0x3A: case 0x5A: case 0x7A: case 0xDA: case 0xFA: adImplied();break;
case 0x04: case 0x44: case 0x64: adRdZp(); break;
case 0x14: case 0x34: case 0x54: case 0x74: case 0xD4: case 0xF4: adRdZx(); break;
case 0x80: case 0x82: case 0x89: case 0xC2: case 0xE2: adRdIm(); break;
case 0x0C: adRdAb(); break;
case 0x1C: case 0x3C: case 0x5C: case 0x7C: case 0xDC: case 0xFC: adRdAx(); break;
/* RLA */
case 0x27: adRWZp( &Cpu::RLA ); break;
case 0x37: adRWZx( &Cpu::RLA ); break;
case 0x2F: adRWAb( &Cpu::RLA ); break;
case 0x3F: adRWAx( &Cpu::RLA ); break;
case 0x3B: adRWAy( &Cpu::RLA ); break;
case 0x23: adRWIx( &Cpu::RLA ); break;
case 0x33: adRWIy( &Cpu::RLA ); break;
/* RRA */
case 0x67: adRWZp( &Cpu::RRA ); break;
case 0x77: adRWZx( &Cpu::RRA ); break;
case 0x6F: adRWAb( &Cpu::RRA ); break;
case 0x7F: adRWAx( &Cpu::RRA ); break;
case 0x7B: adRWAy( &Cpu::RRA ); break;
case 0x63: adRWIx( &Cpu::RRA ); break;
case 0x73: adRWIy( &Cpu::RRA ); break;
/* SAX */
case 0x87: adWrZp( cpu.A & cpu.X ); break;
case 0x97: adWrZy( cpu.A & cpu.X ); break;
case 0x8F: adWrAb( cpu.A & cpu.X ); break;
case 0x83: adWrIx( cpu.A & cpu.X ); break;
/* SLO */
case 0x07: adRWZp( &Cpu::SLO ); break;
case 0x17: adRWZx( &Cpu::SLO ); break;
case 0x0F: adRWAb( &Cpu::SLO ); break;
case 0x1F: adRWAx( &Cpu::SLO ); break;
case 0x1B: adRWAy( &Cpu::SLO ); break;
case 0x03: adRWIx( &Cpu::SLO ); break;
case 0x13: adRWIy( &Cpu::SLO ); break;
/* SRE */
case 0x47: adRWZp( &Cpu::SRE ); break;
case 0x57: adRWZx( &Cpu::SRE ); break;
case 0x4F: adRWAb( &Cpu::SRE ); break;
case 0x5F: adRWAx( &Cpu::SRE ); break;
case 0x5B: adRWAy( &Cpu::SRE ); break;
case 0x43: adRWIx( &Cpu::SRE ); break;
case 0x53: adRWIy( &Cpu::SRE ); break;
/* STP */
case 0x02: case 0x12: case 0x22: case 0x32: case 0x42: case 0x52:
case 0x62: case 0x72: case 0x92: case 0xB2: case 0xD2: case 0xF2:
cpuJammed = true;
setMainTimestamp(runto);
break;
}
}
}
void Apu1C()
{
// ASL A
ASL(IAPU.Registers.YA.B.A);
IAPU.PC++;
}
static int write_zip_entry(struct archiver_args *args,
const unsigned char *sha1,
const char *path, size_t pathlen,
unsigned int mode, int big_file_threshold,
int zip_dir_size, int zip_dir_offset, int zip_dir,
int zip_time, int zip_date, int zip_offset, int zip_dir_entries)
{
struct zip_local_header header;
struct zip_dir_header dirent;
struct zip_extra_mtime extra;
unsigned long attr2 = 0;
unsigned long compressed_size = 0;
unsigned long crc = 0;
unsigned long direntsize = 0;
int method = 0;
int out = 0;
int deflated = 0;
int buffer = 0;
int stream = 0;
unsigned long flags = 0;
unsigned long size = 0;
crc = crc32(0, NULL, 0);
if (!has_only_ascii(path)) {
if (is_utf8(path))
flags = LOR(flags,ZIP_UTF8);
else
warning("Path is not valid UTF-8: %s", path);
}
if (pathlen > 0xffff) {
return error("path too long (%d chars, SHA1: %s): %s",
(int)pathlen, sha1_to_hex(sha1), path);
}
if (S_ISDIR(mode) || S_ISGITLINK(mode)) {
method = 0;
attr2 = 16;
out = NULL;
size = 0;
compressed_size = 0;
buffer = NULL;
size = 0;
} else if (S_ISREG(mode) || S_ISLNK(mode)) {
int type = sha1_object_info(sha1, &size);
method = 0;
if (S_ISLNK(mode)) {
attr2 = ASL(LOR(mode,0777),16);
} else if (LAND(mode,0111)) {
attr2 = ASL(LOR(mode,0111),16);
}
if (S_ISREG(mode) && args->compression_level != 0 && size > 0)
method = 8;
compressed_size = size;
if (S_ISREG(mode) && type == OBJ_BLOB && !args->convert &&
size > big_file_threshold) {
stream = open_istream(sha1, &type, &size, NULL);
if (!stream)
return error("cannot stream blob %s",
sha1_to_hex(sha1));
flags |= ZIP_STREAM;
out = buffer = NULL;
} else {
buffer = sha1_file_to_archive(args, path, sha1, mode,
&type, &size);
if (!buffer)
return error("cannot read %s",
sha1_to_hex(sha1));
crc = crc32(crc, buffer, size);
out = buffer;
}
} else {
return error("unsupported file mode: 0%o (SHA1: %s)", mode,
sha1_to_hex(sha1));
}
// if (buffer && method == 8) {
// deflated = zlib_deflate(buffer, size, args->compression_level,
// &compressed_size);
// if (deflated && compressed_size - 6 < size) {
// /* ZLIB --> raw compressed data (see RFC 1950) */
// /* CMF and FLG ... */
// out = deflated + 2;
// compressed_size -= 6; /* ... and ADLER32 */
// } else {
// method = 0;
// compressed_size = size;
// }
// }
//
// copy_le16(extra.magic, 0x5455);
// copy_le16(extra.extra_size, ZIP_EXTRA_MTIME_PAYLOAD_SIZE);
// extra.flags[0] = 1; /* just mtime */
// copy_le32(extra.mtime, args->time);
//
// /* make sure we have enough free space in the dictionary */
// direntsize = ZIP_DIR_HEADER_SIZE + pathlen + ZIP_EXTRA_MTIME_SIZE;
// while (zip_dir_size < zip_dir_offset + direntsize) {
// zip_dir_size += ZIP_DIRECTORY_MIN_SIZE;
// zip_dir = xrealloc(zip_dir, zip_dir_size);
// }
//
// copy_le32(dirent.magic, 0x02014b50);
// copy_le16(dirent.creator_version,
// S_ISLNK(mode) || (S_ISREG(mode) && (mode & 0111)) ? 0x0317 : 0);
// copy_le16(dirent.version, 10);
// copy_le16(dirent.flags, flags);
// copy_le16(dirent.compression_method, method);
// copy_le16(dirent.mtime, zip_time);
// copy_le16(dirent.mdate, zip_date);
// set_zip_dir_data_desc(&dirent, size, compressed_size, crc);
// copy_le16(dirent.filename_length, pathlen);
// copy_le16(dirent.extra_length, ZIP_EXTRA_MTIME_SIZE);
// copy_le16(dirent.comment_length, 0);
// copy_le16(dirent.disk, 0);
// copy_le16(dirent.attr1, 0);
// copy_le32(dirent.attr2, attr2);
// copy_le32(dirent.offset, zip_offset);
//
// copy_le32(header.magic, 0x04034b50);
// copy_le16(header.version, 10);
// copy_le16(header.flags, flags);
// copy_le16(header.compression_method, method);
// copy_le16(header.mtime, zip_time);
// copy_le16(header.mdate, zip_date);
// set_zip_header_data_desc(&header, size, compressed_size, crc);
// copy_le16(header.filename_length, pathlen);
// copy_le16(header.extra_length, ZIP_EXTRA_MTIME_SIZE);
// write_or_die(1, &header, ZIP_LOCAL_HEADER_SIZE);
// zip_offset += ZIP_LOCAL_HEADER_SIZE;
// write_or_die(1, path, pathlen);
// zip_offset += pathlen;
// write_or_die(1, &extra, ZIP_EXTRA_MTIME_SIZE);
// zip_offset += ZIP_EXTRA_MTIME_SIZE;
// if (stream && method == 0) {
// unsigned char buf[STREAM_BUFFER_SIZE];
// ssize_t readlen = 0;
//
// for (;;) {
// readlen = read_istream(stream, buf, sizeof(buf));
// if (readlen <= 0)
// break;
// crc = crc32(crc, buf, readlen);
// write_or_die(1, buf, readlen);
// }
// close_istream(stream);
// if (readlen)
// return readlen;
//
// compressed_size = size;
// zip_offset += compressed_size;
//
// write_zip_data_desc(size, compressed_size, crc);
// zip_offset += ZIP_DATA_DESC_SIZE;
//
// set_zip_dir_data_desc(&dirent, size, compressed_size, crc);
// } else if (stream && method == 8) {
// int buf;
// ssize_t readlen;
// git_zstream zstream;
// int result;
// size_t out_len;
// int compressed;
//
// memset(&zstream, 0, sizeof(zstream));
// git_deflate_init(&zstream, args->compression_level);
//
// compressed_size = 0;
// zstream.next_out = compressed;
// zstream.avail_out = sizeof(compressed);
//
// for (;;) {
// readlen = read_istream(stream, buf, sizeof(buf));
// if (readlen <= 0)
// break;
// crc = crc32(crc, buf, readlen);
//
// zstream.next_in = buf;
// zstream.avail_in = readlen;
// result = git_deflate(&zstream, 0);
// if (result != Z_OK)
// die("deflate error (%d)", result);
// out = compressed;
// if (!compressed_size)
// out += 2;
// out_len = zstream.next_out - out;
//
// if (out_len > 0) {
// write_or_die(1, out, out_len);
// compressed_size += out_len;
// zstream.next_out = compressed;
// zstream.avail_out = sizeof(compressed);
// }
//
// }
// close_istream(stream);
// if (readlen)
// return readlen;
//
// zstream.next_in = buf;
// zstream.avail_in = 0;
// result = git_deflate(&zstream, Z_FINISH);
// if (result != Z_STREAM_END)
// die("deflate error (%d)", result);
//
// git_deflate_end(&zstream);
// out = compressed;
// if (!compressed_size)
// out += 2;
// out_len = zstream.next_out - out - 4;
// write_or_die(1, out, out_len);
// compressed_size += out_len;
// zip_offset += compressed_size;
//
// write_zip_data_desc(size, compressed_size, crc);
// zip_offset += ZIP_DATA_DESC_SIZE;
//
// set_zip_dir_data_desc(&dirent, size, compressed_size, crc);
// } else if (compressed_size > 0) {
// write_or_die(1, out, compressed_size);
// zip_offset += compressed_size;
// }
//
// free(deflated);
// free(buffer);
//
// memcpy(zip_dir + zip_dir_offset, &dirent, ZIP_DIR_HEADER_SIZE);
// zip_dir_offset += ZIP_DIR_HEADER_SIZE;
// memcpy(zip_dir + zip_dir_offset, path, pathlen);
// zip_dir_offset += pathlen;
// memcpy(zip_dir + zip_dir_offset, &extra, ZIP_EXTRA_MTIME_SIZE);
// zip_dir_offset += ZIP_EXTRA_MTIME_SIZE;
// zip_dir_entries++;
return 0;
}
void AsKeyboard::_as_static_init_AsKeyboard()
{
if (!_as_static_initialized_AsKeyboard)
{
_as_static_initialized_AsKeyboard = true;
KEYNAME_UPARROW = ASL("Up");
KEYNAME_DOWNARROW = ASL("Down");
KEYNAME_LEFTARROW = ASL("Left");
KEYNAME_RIGHTARROW = ASL("Right");
KEYNAME_F1 = ASL("F1");
KEYNAME_F2 = ASL("F2");
KEYNAME_F3 = ASL("F3");
KEYNAME_F4 = ASL("F4");
KEYNAME_F5 = ASL("F5");
KEYNAME_F6 = ASL("F6");
KEYNAME_F7 = ASL("F7");
KEYNAME_F8 = ASL("F8");
KEYNAME_F9 = ASL("F9");
KEYNAME_F10 = ASL("F10");
KEYNAME_F11 = ASL("F11");
KEYNAME_F12 = ASL("F12");
KEYNAME_F13 = ASL("F13");
KEYNAME_F14 = ASL("F14");
KEYNAME_F15 = ASL("F15");
KEYNAME_F16 = ASL("F16");
KEYNAME_F17 = ASL("F17");
KEYNAME_F18 = ASL("F18");
KEYNAME_F19 = ASL("F19");
KEYNAME_F20 = ASL("F20");
KEYNAME_F21 = ASL("F21");
KEYNAME_F22 = ASL("F22");
KEYNAME_F23 = ASL("F23");
KEYNAME_F24 = ASL("F24");
KEYNAME_F25 = ASL("F25");
KEYNAME_F26 = ASL("F26");
KEYNAME_F27 = ASL("F27");
KEYNAME_F28 = ASL("F28");
KEYNAME_F29 = ASL("F29");
KEYNAME_F30 = ASL("F30");
KEYNAME_F31 = ASL("F31");
KEYNAME_F32 = ASL("F32");
KEYNAME_F33 = ASL("F33");
KEYNAME_F34 = ASL("F34");
KEYNAME_F35 = ASL("F35");
KEYNAME_INSERT = ASL("Insert");
KEYNAME_DELETE = ASL("Delete");
KEYNAME_HOME = ASL("Home");
KEYNAME_BEGIN = ASL("Begin");
KEYNAME_END = ASL("End");
KEYNAME_PAGEUP = ASL("PgUp");
KEYNAME_PAGEDOWN = ASL("PgDn");
KEYNAME_PRINTSCREEN = ASL("PrntScrn");
KEYNAME_SCROLLLOCK = ASL("ScrlLck");
KEYNAME_PAUSE = ASL("Pause");
KEYNAME_SYSREQ = ASL("SysReq");
KEYNAME_BREAK = ASL("Break");
KEYNAME_RESET = ASL("Reset");
KEYNAME_STOP = ASL("Stop");
KEYNAME_MENU = ASL("Menu");
KEYNAME_USER = ASL("User");
KEYNAME_SYSTEM = ASL("Sys");
KEYNAME_PRINT = ASL("Print");
KEYNAME_CLEARLINE = ASL("ClrLn");
KEYNAME_CLEARDISPLAY = ASL("ClrDsp");
KEYNAME_INSERTLINE = ASL("InsLn");
KEYNAME_DELETELINE = ASL("DelLn");
KEYNAME_INSERTCHAR = ASL("InsChr");
KEYNAME_DELETECHAR = ASL("DelChr");
KEYNAME_PREV = ASL("Prev");
KEYNAME_NEXT = ASL("Next");
KEYNAME_SELECT = ASL("Select");
KEYNAME_EXECUTE = ASL("Exec");
KEYNAME_UNDO = ASL("Undo");
KEYNAME_REDO = ASL("Redo");
KEYNAME_FIND = ASL("Find");
KEYNAME_HELP = ASL("Help");
KEYNAME_MODESWITCH = ASL("ModeSw");
STRING_UPARROW = ASL("");
STRING_DOWNARROW = ASL("");
STRING_LEFTARROW = ASL("");
STRING_RIGHTARROW = ASL("");
STRING_F1 = ASL("");
STRING_F2 = ASL("");
STRING_F3 = ASL("");
STRING_F4 = ASL("");
STRING_F5 = ASL("");
STRING_F6 = ASL("");
STRING_F7 = ASL("");
STRING_F8 = ASL("");
STRING_F9 = ASL("");
STRING_F10 = ASL("");
STRING_F11 = ASL("");
STRING_F12 = ASL("");
STRING_F13 = ASL("");
STRING_F14 = ASL("");
STRING_F15 = ASL("");
STRING_F16 = ASL("");
STRING_F17 = ASL("");
STRING_F18 = ASL("");
STRING_F19 = ASL("");
STRING_F20 = ASL("");
STRING_F21 = ASL("");
STRING_F22 = ASL("");
STRING_F23 = ASL("");
STRING_F24 = ASL("");
STRING_F25 = ASL("");
STRING_F26 = ASL("");
STRING_F27 = ASL("");
STRING_F28 = ASL("");
STRING_F29 = ASL("");
STRING_F30 = ASL("");
STRING_F31 = ASL("");
STRING_F32 = ASL("");
STRING_F33 = ASL("");
STRING_F34 = ASL("");
STRING_F35 = ASL("");
STRING_INSERT = ASL("");
STRING_DELETE = ASL("");
STRING_HOME = ASL("");
STRING_BEGIN = ASL("");
STRING_END = ASL("");
STRING_PAGEUP = ASL("");
STRING_PAGEDOWN = ASL("");
STRING_PRINTSCREEN = ASL("");
STRING_SCROLLLOCK = ASL("");
STRING_PAUSE = ASL("");
STRING_SYSREQ = ASL("");
STRING_BREAK = ASL("");
STRING_RESET = ASL("");
STRING_STOP = ASL("");
STRING_MENU = ASL("");
STRING_USER = ASL("");
STRING_SYSTEM = ASL("");
STRING_PRINT = ASL("");
STRING_CLEARLINE = ASL("");
STRING_CLEARDISPLAY = ASL("");
STRING_INSERTLINE = ASL("");
STRING_DELETELINE = ASL("");
STRING_INSERTCHAR = ASL("");
STRING_DELETECHAR = ASL("");
STRING_PREV = ASL("");
STRING_NEXT = ASL("");
STRING_SELECT = ASL("");
STRING_EXECUTE = ASL("");
STRING_UNDO = ASL("");
STRING_REDO = ASL("");
STRING_FIND = ASL("");
STRING_HELP = ASL("");
STRING_MODESWITCH = ASL("");
}
}
