void Value::doConvert(Type newType) { switch (type) { case TYPE_I32: type = newType; switch (newType) { case TYPE_I8: constant.i8 = S08(constant.i32); return; case TYPE_I16: constant.i16 = S16(constant.i32); return; case TYPE_I32: constant.i32 = S32(constant.i32); return; case TYPE_I64: constant.i64 = S64(constant.i32); return; case TYPE_F32: constant.f32 = F32(constant.i32); return; case TYPE_F64: constant.f64 = F64(constant.i32); return; default: assert_always("Unimplemented case"); return; } case TYPE_I64: type = newType; switch (newType) { case TYPE_I8: constant.i8 = S08(constant.i64); return; case TYPE_I16: constant.i16 = S16(constant.i64); return; case TYPE_I32: constant.i32 = S32(constant.i64); return; case TYPE_I64: constant.i64 = S64(constant.i64); return; case TYPE_F32: constant.f32 = F32(constant.i64); return; case TYPE_F64: constant.f64 = F64(constant.i64); return; default: assert_always("Unimplemented case"); return; } case TYPE_F32: type = newType; switch (newType) { case TYPE_I8: constant.i8 = S08(constant.f32); return; case TYPE_I16: constant.i16 = S16(constant.f32); return; case TYPE_I32: constant.i32 = S32(constant.f32); return; case TYPE_I64: constant.i64 = S64(constant.f32); return; case TYPE_F32: constant.f32 = F32(constant.f32); return; case TYPE_F64: constant.f64 = F64(constant.f32); return; default: assert_always("Unimplemented case"); return; } case TYPE_F64: type = newType; switch (newType) { case TYPE_I8: constant.i8 = S08(constant.f64); return; case TYPE_I16: constant.i16 = S16(constant.f64); return; case TYPE_I32: constant.i32 = S32(constant.f64); return; case TYPE_I64: constant.i64 = S64(constant.f64); return; case TYPE_F32: constant.f32 = F32(constant.f64); return; case TYPE_F64: constant.f64 = F64(constant.f64); return; default: assert_always("Unimplemented case"); return; } default: assert_always("Unimplemented case"); return; } }
static struct elf_header * read_elf_header(const struct elf_header *p) { static struct elf_header hdr; hdr = *p; if (need_byteswap) { hdr.type = S16(hdr.type); hdr.machine = S16(hdr.machine); hdr.version = S32(hdr.version); hdr.entry = S32(hdr.entry); hdr.phoff = S32(hdr.phoff); hdr.shoff = S32(hdr.shoff); hdr.flags = S32(hdr.flags); hdr.ehsize = S16(hdr.ehsize); hdr.phentsize = S16(hdr.phentsize); hdr.phnum = S16(hdr.phnum); hdr.shentsize = S16(hdr.shentsize); hdr.shnum = S16(hdr.shnum); hdr.shtrndx = S16(hdr.shtrndx); } return &hdr; }
static void tx_kickstart(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); fcc_t __iomem *fccp = fep->fcc.fccp; S16(fccp, fcc_ftodr, 0x8000); }
static void napi_enable_rx(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); fcc_t __iomem *fccp = fep->fcc.fccp; S16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK); }
static void set_promiscuous_mode(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); scc_t __iomem *sccp = fep->scc.sccp; S16(sccp, scc_psmr, SCC_PSMR_PRO); }
void AtlasOldMesher::writeVertex(Stream *s, Vert *vert, const S8 level) { S16 x, y, z; const Point2I &vertPos = vert->pos; Point3F center; mBounds.getCenter(¢er); if (vert->special) z = vert->z; else z = mHeight->sampleRead(vertPos); S32 xTmp, yTmp; xTmp = (S32)mFloor(((vertPos.x * mHeight->mSampleSpacing - center.x) * mCompressionFactor.x) + 0.5); yTmp = (S32)mFloor(((vertPos.y * mHeight->mSampleSpacing - center.y) * mCompressionFactor.y) + 0.5); AssertFatal(S16(xTmp) == xTmp, "AtlasOldMesher::writeVertex - Overflow writing x-coordinate!"); AssertFatal(S16(yTmp) == yTmp, "AtlasOldMesher::writeVertex - Overflow writing y-coordinate!"); x = xTmp; y = yTmp; s->write(x); s->write(y); s->write(z); // Morph info. Calculate the difference between the // vert height, and the height of the same spot in the // next lower-LOD mesh. S16 morphHeight; if (vert->special) morphHeight = z; // special verts don't morph. else { morphHeight = mHeight->getHeightAtLOD(vertPos, level + 1); } S32 morphDelta = (S32(morphHeight) - S32(z)); s->write(S16(morphDelta)); if(morphDelta != S16(morphDelta)) Con::warnf("AtlasOldMesher::writeVertex - overflow in lerpedHeight!"); }
/// @brief Assigns to a member /// @note upvalue 1: Member descriptor, non-permissions, and lookup data static void NewIndexMember (lua_State * L) { // Point to the requested member. Uint8 * pData = GetFields(L); // data, key, value, D, D[key], offset, type // Assign the appropriate type. switch (U(L, 7)) { case Member_Reg::ePointer: *(void**)pData = UD(L, 3); break; case Member_Reg::eU8: case Member_Reg::eUChar: *(Uint8*)pData = U8(L, 3); break; case Member_Reg::eS8: case Member_Reg::eSChar: // *(Sint8*)pData = S8(L, 3); break; case Member_Reg::eU16: case Member_Reg::eUShort: *(Uint16*)pData = U16(L, 3); break; case Member_Reg::eS16: case Member_Reg::eSShort: *(Sint16*)pData = S16(L, 3); break; case Member_Reg::eU32: *(Uint32*)pData = U(L, 3); break; case Member_Reg::eS32: *(Sint32*)pData = S32(L, 3); break; case Member_Reg::eULong: break; case Member_Reg::eSLong: *(long*)pData = LI(L, 3); break; case Member_Reg::eUInt: break; case Member_Reg::eSInt: *(Sint32*)pData = S32(L, 3); break; case Member_Reg::eFSingle: *(float*)pData = F(L, 3); break; case Member_Reg::eFDouble: break; case Member_Reg::eString: break; case Member_Reg::eBoolean: *(bool*)pData = B(L, 3); break; } }
/// change touch input to stick input (Last_Actions) bool SBOnTouchEvent( unsigned short x, unsigned short y, unsigned short state ) { #ifdef SB_BUILD_VIRTUAL_PAD // dbg_msg("SBOnTouchEvent(): %d %d, %d \n", state, x,y); if (state == 2) //UP switch ( Scene_State ) { case SCENE_TITLE: // if ( key == ' ' || key == 62 ) { Sub_State++; return true; } break; case SCENE_PLAY: if ( game_paused ) { // SBOnTogglePause(); } break; case SCENE_END: // if ( sIsDebugStartScene(key) ) { // if( Sub_State==SUB_STATE0 ) // dbg_msg("SBOnTouchEvent() SCENE END: counter:%d \n", s_CountDownBeforeGoingToTitle); return true; } #if 0 //ifdef DEBUG if ( sIsDebugNextScene(key) ) { Is_GameOver = FALSE; Is_GameCleared = TRUE; } #endif break; } if ( s_touchPadMode == 0 ) { float TOUCH_OFFSET = 3.0f; unsigned short TOUCH_THRESHOLD = 0; if ( state == 1 ) // MOVE { if ( ABS(x-LastTouchX) >= TOUCH_THRESHOLD ) { float angleX = (x-LastTouchX) * TOUCH_OFFSET; Last_Actions[RIGHT] = angleX>0; Last_Actions[LEFT] = angleX<0; } if ( ABS(y-LastTouchY) >= TOUCH_THRESHOLD ) { float angleY = (y-LastTouchY) * TOUCH_OFFSET; Last_Actions[DOWN] = angleY<0; Last_Actions[UP] = angleY>0; } s_isTouchDown = true; } else if ( state == 2 ) //UP { for ( int i=UP; i <= RIGHT; i++ ) { // Last_Actions[i] = false; } s_isTouchDown = false; return true; } // DOWN LastTouchX = x; LastTouchY = y; } else if (s_touchPadMode == 1 ) { if ( state == 2 ) //UP { for ( int i=UP; i <= RIGHT; i++ ) { Last_Actions[i] = false; } s_isTouchDown = false; return true; } else { s_isTouchDown = true; } //convert x,y to DPAD game keys const S16 diffx = S16(x) - DPAD_X; const S16 diffy = Screen_H - S16(y) - DPAD_Y; //dbg_msg("SBOnTouchEvent(): %d %d, %d \n", state, diffx, diffy); if ( ABS(diffx) > DPAD_SIZE_OUT || ( ABS(diffy) > DPAD_SIZE_OUT ) ) { Last_Actions[LEFT] = Last_Actions[RIGHT] = false; Last_Actions[UP] = Last_Actions[DOWN] = false; } else { if (DPAD_SIZE_IN <= ABS(diffx)) { const char i = diffx > 0 ? RIGHT:LEFT; const char j = i==LEFT? RIGHT:LEFT; Last_Actions[i] = true; Last_Actions[j] = false; //dbg_msg("SBOnTouchEvent() DIFF: %d %d, %d \n", state, diffx, x); } if ( DPAD_SIZE_IN <= ABS(diffy) ) { const char i = diffy > 0 ? DOWN:UP; const char j = i==UP? DOWN:UP; Last_Actions[i] = true; Last_Actions[j] = false; } } } else if ( s_touchPadMode==2 ) { for ( int i=UP; i <= RIGHT; i++ ) { Last_Actions[i] = false; } if ( state == 1 ) // MOVE { float p[2]; // map screen coor to our coor p[0] = CHAN_X * x / Screen_W + (-CHAN_X*0.5); p[1] = - CHAN_Y * y / Screen_H + (CHAN_Y*0.5); //dbg_msg("SBOnTouchEvent(): res: %.2f %.2f \n", p[0], p[1] ); //calculate vectors and then map it to Last_Actions[] for ( char i=0; i<2; ++i ) { const float diff = p[i] - Dream_State.pos[i]; if ( fabs(diff) > 0.2 ) { const char dir = i==0 ? LEFT : UP; Last_Actions[dir] = diff < 0; Last_Actions[dir+1] = !Last_Actions[dir]; } } s_isTouchDown = true; } else //if ( state == 2 ) //UP { s_isTouchDown = false; } } #endif return true; }
// // New and improved sweep // void Sweep(UnitObj *u) { ASSERT(sysInit); ASSERT(u); //ASSERT(u->GetTeam()); ASSERT(u->OnMap()); START(sweepTime); r = u->GetSeeingRange(); unit = u; cellX = u->cellX; cellZ = u->cellZ; ASSERT(r < MAXR) // Get sight map and mask maskLo = u->sightMap->GetBitMask(Map::LV_LO); mapLo = u->sightMap->GetByteMap(Map::LV_LO); // Reset max radius seen u->sightMap->lastR = S16_MIN; // Set teams that this sweep will provide LOS for Team *myTeam = u->GetTeam(); teamBits = 0; if (myTeam) { for (U32 team = 0; team < Game::MAX_TEAMS; ++team) { Team *other = Team::Id2Team(team); if (other) { if ( // Other team is an ally Team::TestUnitRelation(u, other, Relation::ALLY) || // Other team is giving us line of sight myTeam->GivingSightTo(other->GetId()) ) { ASSERT(teamRemap[team] < teamCount) Game::TeamSet(teamBits, teamRemap[team]); } } } } // Dirty cells that line of sight has changed in DirtyCells(cellX - r, cellZ - r, cellX + r, cellZ + r, teamBits); // Set up viewing radius if (r > 0) { r2 = r * r; r2Inv = 1.0f / F32(r2); // Get eye position eyePos = EyePosition(u); // In the code below the row and column of cells with the // same y and x value of the unit are processed twice but // their viewing information is only updated once. Stuff // the slight inneficiency (2*r extra comparisons). This // way we require 1/4 the memory and the code is more // elegant. // scan ++ quadrant quadrantX = POS; quadrantZ = POS; FillGradMap(); FillMaxGradMapPosZ(); CompareGradPosPos(); // Scan -+ quadrant quadrantX = NEG; FillGradMapRotated(); FillMaxGradMapPosZ(); CompareGradNegPos(); // Scan -- quadrant quadrantZ = NEG; FillGradMap(); FillMaxGradMapNegZ(); CompareGradNegNeg(); // Scan +- quadrant quadrantX = POS; FillGradMapRotated(); FillMaxGradMapNegZ(); CompareGradPosNeg(); } // Can always see cell that unit is occupying CanSee(cellX, cellZ, 0, 0, mapLo, maskLo, teamBits, Map::LV_LO); // Update scan info in unit's sight map u->sightMap->lastTeam = teamBits; u->sightMap->lastR = S16(r); u->sightMap->lastX = cellX; u->sightMap->lastZ = cellZ; u->sightMap->lastAlt = eyePos; STOP(sweepTime); }
void test(int M, int N, int O, int P, int Q, int R) { /* Scattering iterators. */ int p1, p3, p5; /* Original iterators. */ int i, j, k; if (M == 1) { S1() ; S2() ; S3() ; S4() ; S5() ; S6() ; S7() ; S8() ; S9() ; S10() ; S11() ; S12() ; S13() ; S14() ; S15() ; S16() ; S17() ; S18() ; S19() ; S20() ; S21() ; S22() ; S23() ; S24() ; S25() ; S26() ; S27() ; } if (M == 1) { for (p1=1;p1<=N;p1++) { for (p3=1;p3<=N;p3++) { S28(p1,p3) ; S29(p1,p3) ; S30(p1,p3) ; } S31(p1) ; } } if (M == 1) { S32() ; S33() ; S34() ; } if ((M == 1) && (O <= 1)) { S35() ; } if (M == 1) { S36() ; S37() ; } if ((M == 1) && (N >= 1) && (Q >= 1) && (R >= 1)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; for (p3=1;p3<=Q;p3++) { for (p5=1;p5<=R;p5++) { S40(p1,p3,p5) ; S41(p1,p3,p5) ; S42(p1,p3,p5) ; S43(p1,p3,p5) ; } } for (p3=1;p3<=Q;p3++) { S44(p1,p3) ; S45(p1,p3) ; S46(p1,p3) ; S47(p1,p3) ; } for (p3=1;p3<=R;p3++) { S48(p1,p3) ; S49(p1,p3) ; S50(p1,p3) ; S51(p1,p3) ; } S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; for (p3=1;p3<=Q;p3++) { for (p5=1;p5<=R;p5++) { S59(p1,p3,p5) ; S60(p1,p3,p5) ; S61(p1,p3,p5) ; } } for (p3=1;p3<=Q;p3++) { S62(p1,p3) ; S63(p1,p3) ; S64(p1,p3) ; } for (p3=1;p3<=R;p3++) { S65(p1,p3) ; S66(p1,p3) ; S67(p1,p3) ; } S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; for (p3=1;p3<=N;p3++) { for (p5=1;p5<=N;p5++) { S95(p1,p3,p5) ; S96(p1,p3,p5) ; S97(p1,p3,p5) ; } S98(p1,p3) ; } S99(p1) ; S100(p1) ; S101(p1) ; for (p3=1;p3<=Q;p3++) { for (p5=1;p5<=R;p5++) { S102(p1,p3,p5) ; S103(p1,p3,p5) ; S104(p1,p3,p5) ; S105(p1,p3,p5) ; S106(p1,p3,p5) ; S107(p1,p3,p5) ; } } for (p3=1;p3<=Q;p3++) { S108(p1,p3) ; S109(p1,p3) ; S110(p1,p3) ; S111(p1,p3) ; S112(p1,p3) ; S113(p1,p3) ; } for (p3=1;p3<=R;p3++) { S114(p1,p3) ; S115(p1,p3) ; S116(p1,p3) ; S117(p1,p3) ; S118(p1,p3) ; S119(p1,p3) ; } S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N <= 0) && (Q >= 1) && (R >= 1)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; for (p3=1;p3<=Q;p3++) { for (p5=1;p5<=R;p5++) { S40(p1,p3,p5) ; S41(p1,p3,p5) ; S42(p1,p3,p5) ; S43(p1,p3,p5) ; } } for (p3=1;p3<=Q;p3++) { S44(p1,p3) ; S45(p1,p3) ; S46(p1,p3) ; S47(p1,p3) ; } for (p3=1;p3<=R;p3++) { S48(p1,p3) ; S49(p1,p3) ; S50(p1,p3) ; S51(p1,p3) ; } S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; for (p3=1;p3<=Q;p3++) { for (p5=1;p5<=R;p5++) { S59(p1,p3,p5) ; S60(p1,p3,p5) ; S61(p1,p3,p5) ; } } for (p3=1;p3<=Q;p3++) { S62(p1,p3) ; S63(p1,p3) ; S64(p1,p3) ; } for (p3=1;p3<=R;p3++) { S65(p1,p3) ; S66(p1,p3) ; S67(p1,p3) ; } S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; S99(p1) ; S100(p1) ; S101(p1) ; for (p3=1;p3<=Q;p3++) { for (p5=1;p5<=R;p5++) { S102(p1,p3,p5) ; S103(p1,p3,p5) ; S104(p1,p3,p5) ; S105(p1,p3,p5) ; S106(p1,p3,p5) ; S107(p1,p3,p5) ; } } for (p3=1;p3<=Q;p3++) { S108(p1,p3) ; S109(p1,p3) ; S110(p1,p3) ; S111(p1,p3) ; S112(p1,p3) ; S113(p1,p3) ; } for (p3=1;p3<=R;p3++) { S114(p1,p3) ; S115(p1,p3) ; S116(p1,p3) ; S117(p1,p3) ; S118(p1,p3) ; S119(p1,p3) ; } S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N >= 1) && (Q <= 0) && (R >= 1)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; for (p3=1;p3<=R;p3++) { S48(p1,p3) ; S49(p1,p3) ; S50(p1,p3) ; S51(p1,p3) ; } S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; for (p3=1;p3<=R;p3++) { S65(p1,p3) ; S66(p1,p3) ; S67(p1,p3) ; } S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; for (p3=1;p3<=N;p3++) { for (p5=1;p5<=N;p5++) { S95(p1,p3,p5) ; S96(p1,p3,p5) ; S97(p1,p3,p5) ; } S98(p1,p3) ; } S99(p1) ; S100(p1) ; S101(p1) ; for (p3=1;p3<=R;p3++) { S114(p1,p3) ; S115(p1,p3) ; S116(p1,p3) ; S117(p1,p3) ; S118(p1,p3) ; S119(p1,p3) ; } S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N <= 0) && (Q <= 0) && (R >= 1)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; for (p3=1;p3<=R;p3++) { S48(p1,p3) ; S49(p1,p3) ; S50(p1,p3) ; S51(p1,p3) ; } S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; for (p3=1;p3<=R;p3++) { S65(p1,p3) ; S66(p1,p3) ; S67(p1,p3) ; } S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; S99(p1) ; S100(p1) ; S101(p1) ; for (p3=1;p3<=R;p3++) { S114(p1,p3) ; S115(p1,p3) ; S116(p1,p3) ; S117(p1,p3) ; S118(p1,p3) ; S119(p1,p3) ; } S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N >= 1) && (Q <= 0) && (R <= 0)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; for (p3=1;p3<=N;p3++) { for (p5=1;p5<=N;p5++) { S95(p1,p3,p5) ; S96(p1,p3,p5) ; S97(p1,p3,p5) ; } S98(p1,p3) ; } S99(p1) ; S100(p1) ; S101(p1) ; S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N <= 0) && (Q <= 0) && (R <= 0)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; S99(p1) ; S100(p1) ; S101(p1) ; S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N >= 1) && (Q >= 1) && (R <= 0)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; for (p3=1;p3<=Q;p3++) { S44(p1,p3) ; S45(p1,p3) ; S46(p1,p3) ; S47(p1,p3) ; } S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; for (p3=1;p3<=Q;p3++) { S62(p1,p3) ; S63(p1,p3) ; S64(p1,p3) ; } S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; for (p3=1;p3<=N;p3++) { for (p5=1;p5<=N;p5++) { S95(p1,p3,p5) ; S96(p1,p3,p5) ; S97(p1,p3,p5) ; } S98(p1,p3) ; } S99(p1) ; S100(p1) ; S101(p1) ; for (p3=1;p3<=Q;p3++) { S108(p1,p3) ; S109(p1,p3) ; S110(p1,p3) ; S111(p1,p3) ; S112(p1,p3) ; S113(p1,p3) ; } S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } if ((M == 1) && (N <= 0) && (Q >= 1) && (R <= 0)) { for (p1=2;p1<=P;p1++) { S38(p1) ; S39(p1) ; for (p3=1;p3<=Q;p3++) { S44(p1,p3) ; S45(p1,p3) ; S46(p1,p3) ; S47(p1,p3) ; } S52(p1) ; S53(p1) ; S54(p1) ; S55(p1) ; S56(p1) ; S57(p1) ; S58(p1) ; for (p3=1;p3<=Q;p3++) { S62(p1,p3) ; S63(p1,p3) ; S64(p1,p3) ; } S68(p1) ; S69(p1) ; S70(p1) ; S71(p1) ; S72(p1) ; S73(p1) ; S74(p1) ; S75(p1) ; S76(p1) ; S77(p1) ; S78(p1) ; S79(p1) ; S80(p1) ; S81(p1) ; S82(p1) ; S83(p1) ; S84(p1) ; S85(p1) ; S86(p1) ; S87(p1) ; S88(p1) ; S89(p1) ; S90(p1) ; S91(p1) ; S92(p1) ; S93(p1) ; S94(p1) ; S99(p1) ; S100(p1) ; S101(p1) ; for (p3=1;p3<=Q;p3++) { S108(p1,p3) ; S109(p1,p3) ; S110(p1,p3) ; S111(p1,p3) ; S112(p1,p3) ; S113(p1,p3) ; } S120(p1) ; S121(p1) ; S122(p1) ; S123(p1) ; S124(p1) ; S125(p1) ; } } }
int main() { u8 *buf = NULL, *newContentBuf = NULL; FILE *f = fopen("title.cia","rb"); if(!f) { puts("Unable to open title.cia!"); goto end; } fseek(f,0,SEEK_END); size_t fsize = ftell(f); fseek(f,0,SEEK_SET); buf = malloc(fsize); if(!buf) { printf("Unable to allocate %i bytes!\n",fsize); goto end; } fread(buf,1,fsize,f); fclose(f); f = NULL; u32 certsize = A64(*(u32*)(buf+0x8)), tiksize=A64(*(u32*)(buf+0xC)), tmdsize=A64(*(u32*)(buf+0x10)), metasize=A64(*(u32*)(buf+0x14)), contentsize=A64(*(u32*)(buf+0x18)); printf("Cert Size:%x, Tik Size: %x, TMD Size: %x\nMeta Size: %x, Total Content Size:%x\n", certsize,tiksize,tmdsize,metasize,contentsize); u32 tmdstart = 0x2040+certsize+tiksize; printf("TMD Start: %x\n",tmdstart); u32 sigtype = S32(*(u32*)(buf+tmdstart)); u32 tmdsigsize = 0x100; if(sigtype != RSA_2048_SHA256) { printf("Signature Type not supported:0x%08x\n",sigtype); goto end; } u32 tmdhdr = A64(tmdstart+4+tmdsigsize); u32 tmdverpos = tmdhdr+0x40; int tmdver = *(buf+tmdverpos); if(tmdver != 1) { printf("Unknown tmd ver:%i\n",tmdver); goto end; } printf("Title ID: %016I64x\n",S64(*(u64*)(buf+tmdhdr+0x4C))); u32 numcontentpos = tmdhdr+0x9E; u16 numcontents = S16(*(u16*)(buf+numcontentpos)); printf("Num Contents: %i\n",numcontents); u32 infoshapos = numcontentpos+6; //has sha1 of 0x900 inforecords u32 inforecords = infoshapos+0x20; //has sha1 of each chunkrecord f = fopen("content.bin","rb"); fseek(f,0,SEEK_END); size_t newContentSize = ftell(f); fseek(f,0,SEEK_SET); newContentBuf = malloc(newContentSize); fread(newContentBuf,newContentSize,1,f); fclose(f); memcpy(buf+0x18,&newContentSize,4); printf("New Content Size: %x\n",A64(*(u32*)(buf+0x18))); u32 chunkrecords = inforecords+(0x40*0x24); //has sha1 of each content u32 chunkrecordsSize = chunkrecords+(numcontents*0x30); u32 content = A64(chunkrecordsSize); printf("Content starts at 0x%x\n",content); int i; for(i = 0; i < numcontents; i++) { *(u64*)(buf+(chunkrecords+(i*0x30))+0x8) = S64(newContentSize); u64 thisContentSize = S64(*(u64*)(buf+(chunkrecords+(i*0x30))+0x8)); printf("Content %i Size: %I64x\n", S16(*(u16*)(buf+(chunkrecords+(i*0x30))+0x4)), thisContentSize); sha2(newContentBuf,(u32)thisContentSize,buf+(chunkrecords+(i*0x30))+0x10,0); } sha2(buf+chunkrecords,0x30,buf+inforecords+4,0); sha2(buf+inforecords,(0x40*0x24),buf+infoshapos,0); printf("Signing TMD, RsaSignVerify=%i\n", RsaSignVerify(buf+tmdstart+0x140,0xC4,buf+tmdstart+4,mod,priv_exp,RSA_2048_SHA256,CTR_RSA_SIGN)); f = fopen("titleNew.cia","wb"); fwrite(buf,content,1,f); fwrite(newContentBuf,newContentSize,1,f); if(metasize > 0) { u32 metastart = 0x2040+certsize+tiksize+tmdsize+contentsize; fwrite(buf+metastart,metasize,1,f); } fclose(f); puts("Wrote titleNew.cia"); end: if(buf) free(buf); if(f) fclose(f); return 0; }
enum parseType S() { char *save = next; if (!S01()) { next = save; if (!S02()) { next = save; if (!S03()) { next = save; if (!S04()) { next = save; if (!S05()) { next = save; goto S06_above; } else return tS05; } else return tS04; } else return tS03; } else return tS02; } else return tS01; S06_above: if (!S06()) { next = save; if (!S07()) { next = save; if (!S08()) { next = save; if (!S09()) { next = save; if (!S10()) { next = save; goto S11_above; } else return tS10; } else return tS09; } else return tS08; } else return tS07; } else return tS06; S11_above: if (!S11()) { next = save; if (!S12()) { next = save; if (!S13()) { next = save; if (!S14()) { next = save; if (!S15()) { next = save; goto S16_above; } else return tS15; } else return tS14; } else return tS13; } else return tS12; } else return tS11; S16_above: if (!S16()) { next = save; if (!S17()) { next = save; if (!S18()) { next = save; if (!S19()) { next = save; if (!S20()) { goto S21_above; } else return tS20; } else return tS19; } else return tS18; } else return tS17; } else return tS16; S21_above: if (!S21()) { return tERR; } else return tS21; return tERR; }
/* * This function is called to start or restart the FEC during a link * change. This only happens when switching between half and full * duplex. */ static void restart(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); scc_t __iomem *sccp = fep->scc.sccp; scc_enet_t __iomem *ep = fep->scc.ep; const struct fs_platform_info *fpi = fep->fpi; u16 paddrh, paddrm, paddrl; const unsigned char *mac; int i; C32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT); /* clear everything (slow & steady does it) */ for (i = 0; i < sizeof(*ep); i++) __fs_out8((u8 __iomem *)ep + i, 0); /* point to bds */ W16(ep, sen_genscc.scc_rbase, fep->ring_mem_addr); W16(ep, sen_genscc.scc_tbase, fep->ring_mem_addr + sizeof(cbd_t) * fpi->rx_ring); /* Initialize function code registers for big-endian. */ #ifndef CONFIG_NOT_COHERENT_CACHE W8(ep, sen_genscc.scc_rfcr, SCC_EB | SCC_GBL); W8(ep, sen_genscc.scc_tfcr, SCC_EB | SCC_GBL); #else W8(ep, sen_genscc.scc_rfcr, SCC_EB); W8(ep, sen_genscc.scc_tfcr, SCC_EB); #endif /* Set maximum bytes per receive buffer. * This appears to be an Ethernet frame size, not the buffer * fragment size. It must be a multiple of four. */ W16(ep, sen_genscc.scc_mrblr, 0x5f0); /* Set CRC preset and mask. */ W32(ep, sen_cpres, 0xffffffff); W32(ep, sen_cmask, 0xdebb20e3); W32(ep, sen_crcec, 0); /* CRC Error counter */ W32(ep, sen_alec, 0); /* alignment error counter */ W32(ep, sen_disfc, 0); /* discard frame counter */ W16(ep, sen_pads, 0x8888); /* Tx short frame pad character */ W16(ep, sen_retlim, 15); /* Retry limit threshold */ W16(ep, sen_maxflr, 0x5ee); /* maximum frame length register */ W16(ep, sen_minflr, PKT_MINBUF_SIZE); /* minimum frame length register */ W16(ep, sen_maxd1, 0x000005f0); /* maximum DMA1 length */ W16(ep, sen_maxd2, 0x000005f0); /* maximum DMA2 length */ /* Clear hash tables. */ W16(ep, sen_gaddr1, 0); W16(ep, sen_gaddr2, 0); W16(ep, sen_gaddr3, 0); W16(ep, sen_gaddr4, 0); W16(ep, sen_iaddr1, 0); W16(ep, sen_iaddr2, 0); W16(ep, sen_iaddr3, 0); W16(ep, sen_iaddr4, 0); /* set address */ mac = dev->dev_addr; paddrh = ((u16) mac[5] << 8) | mac[4]; paddrm = ((u16) mac[3] << 8) | mac[2]; paddrl = ((u16) mac[1] << 8) | mac[0]; W16(ep, sen_paddrh, paddrh); W16(ep, sen_paddrm, paddrm); W16(ep, sen_paddrl, paddrl); W16(ep, sen_pper, 0); W16(ep, sen_taddrl, 0); W16(ep, sen_taddrm, 0); W16(ep, sen_taddrh, 0); fs_init_bds(dev); scc_cr_cmd(fep, CPM_CR_INIT_TRX); W16(sccp, scc_scce, 0xffff); /* Enable interrupts we wish to service. */ W16(sccp, scc_sccm, SCCE_ENET_TXE | SCCE_ENET_RXF | SCCE_ENET_TXB); /* Set GSMR_H to enable all normal operating modes. * Set GSMR_L to enable Ethernet to MC68160. */ W32(sccp, scc_gsmrh, 0); W32(sccp, scc_gsmrl, SCC_GSMRL_TCI | SCC_GSMRL_TPL_48 | SCC_GSMRL_TPP_10 | SCC_GSMRL_MODE_ENET); /* Set sync/delimiters. */ W16(sccp, scc_dsr, 0xd555); /* Set processing mode. Use Ethernet CRC, catch broadcast, and * start frame search 22 bit times after RENA. */ W16(sccp, scc_psmr, SCC_PSMR_ENCRC | SCC_PSMR_NIB22); /* Set full duplex mode if needed */ if (fep->phydev->duplex) S16(sccp, scc_psmr, SCC_PSMR_LPB | SCC_PSMR_FDE); S32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT); }