예제 #1
0
파일: Cpu.cpp 프로젝트: tlevi/mipsim
const void Cpu::executeRegOp(const uInt op){
#if DEBUGLEVEL > 2
	printf("R-op, func:%x, r%d, r%d, r%d\n", ROP_FUNC(op), OP_DST_REG(op), OP_SRC_REG(op), OP_ADD_REG(op));
#endif

	uInt* const dst = &mips->r[OP_DST_REG(op)];
	const uInt* const add = &mips->r[OP_ADD_REG(op)];
	const uInt* const src = &mips->r[OP_SRC_REG(op)];

	switch (ROP_FUNC(op)){
		case OPFUNC_SLL:
			*dst = *add << ROP_SHAM(op);
			break;
		case OPFUNC_SRL:
			*dst = *add >> ROP_SHAM(op);
			break;
		case OPFUNC_SRA:
			*dst = uInt(sInt(*add) >> ROP_SHAM(op));
			break;
		case OPFUNC_JR:
			mips->pc = *src;
			break;
		case OPFUNC_MFHI:
		case OPFUNC_MFLO:
		case OPFUNC_MULT:
		case OPFUNC_DIV:
		case OPFUNC_DIVU:
			fatalError("Unimplemented R-op\n");
		case OPFUNC_ADD:
			//TODO throw overflow exception
		case OPFUNC_ADDU:
			*dst = *src + *add;
			break;
		case OPFUNC_SUB:
			//TODO throw some exception
		case OPFUNC_SUBU:
			*dst = *src - *add;
			break;
		case OPFUNC_AND:
			*dst = *src & *add;
			break;
		case OPFUNC_OR:
			*dst = *src | *add;
			break;
		case OPFUNC_NOR:
			*dst = ~(*src | *add);
			break;
		case OPFUNC_SLT:
			*dst = (sInt(*src) < sInt(*add)) ? 1 : 0;
			break;
		case OPFUNC_SLTU:
			*dst = (*src < *add) ? 1 : 0;
			break;
		default:
			fatalError("Unknown function for R-format instruction (opcode 0)\n");
	}
};
예제 #2
0
void sSoundHandlerTest(sS16 *data,sInt count)
{
  for(sInt i=0;i<count;i++)
  {
    data[0] = sInt(sFSin(((phase0)&0xffff)/65536.0f*sPI2F)*12000);
    data[1] = sInt(sFSin(((phase1)&0xffff)/65536.0f*sPI2F)*12000);

    phase0 += (mod+(mod/50))/16;
    phase1 += (mod+(mod/50))/16;
//    mod = mod+4;
    if(mod>0x40000) mod = 0x1000;

    data+=2;
  }
}
예제 #3
0
int ArgumentParser::parseFromArgs(int argc, char* argv[]){

	int cnt = 0;
	while(cnt < argc){
		if(strcmp(argv[cnt], "--serverPort") == 0){
			if(cnt + 1 < argc){
				std::string sInt(argv[cnt+1]);
				serverPort = atoi(sInt.c_str());
				Logging::getInstance()->Log(Logging::INFO, "Parsed serverPort = %d", serverPort);
			}else{
				Logging::getInstance()->Log(Logging::ERROR, "Error parsing serverPort!");
				return Error::ERROR_PARSING;
			}
		}
		if(strcmp(argv[cnt], "--spawnerPort") == 0){
			if(cnt + 1 < argc){
				this->spawnerServerPort = atoi(argv[cnt+1]);
				Logging::getInstance()->Log(Logging::INFO, "Parsed spawnerPort=%d", this->spawnerServerPort);
			}else{
				Logging::getInstance()->Log(Logging::ERROR, "Error parsing spawnerPort!");
				return Error::ERROR_PARSING;
			}
		}
		cnt++;
	}
	return Error::NO_ERROR;
}
예제 #4
0
void RangeCoder::Decode(sU32 cumfreq,sU32 freq)
{
  Low += cumfreq * Range;
  Range *= freq;
  while((Low ^ Low+Range)<sRANGETOP || Range<sRANGEBOT && ((Range = -sInt(Low) & sRANGEBOT-1),1))
  {
    Code = (Code<<8) + Buffer[Bytes++];
    Range <<= 8;
    Low <<= 8;
  }
}
예제 #5
0
파일: main.cpp 프로젝트: Ambrevar/fr_public
void TestFloat(sF32 null=0)
{
  sCheckModule(L"Float Stuff");
  CHECK(sInt(0.9f)==0);
  CHECK(sInt(1.0f)==1);
  CHECK(sInt(1.1f)==1);
  CHECK(sInt(1.5f)==1);
  CHECK(sInt(1.7f)==1);
  CHECK(sInt(-0.9f)==0);
  CHECK(sInt(-1.0f)==-1);
  CHECK(sInt(-1.1f)==-1);
  CHECK(sInt(-1.5f)==-1);
  CHECK(sInt(-1.7f)==-1);

  CHECK(!sIsInf(1.0f));
  CHECK(!sIsInf(0.0f));
  CHECK(!sIsNan(1.0f));
  CHECK(!sIsNan(0.0f));
  CHECK(sIsInf(1.0f/null));
  CHECK(sIsNan(sSqrt(-1+null)));
}
예제 #6
0
void RangeCoder::Encode(sU32 cumfreq,sU32 freq,sU32 totfreq)
{
  Range /= totfreq;
  Low += cumfreq * Range;
  Range *= freq;

  while ((Low ^ Low+Range)<sRANGETOP || Range<sRANGEBOT && ((Range = -sInt(Low) & sRANGEBOT-1),1))
  {
    Buffer[Bytes++] = Low>>24;
    Low <<= 8;
    Range <<= 8;
  }
}
예제 #7
0
static void evalRangeRecurse(const frAnimationClip *clip, sInt clipStart, sInt start, sInt end, std::vector<evalItem> &evalList)
{
  for (frAnimationClip::elementListCIt it = clip->m_elements.begin(); it != clip->m_elements.end(); ++it)
  {
    const sInt stime = fr::maximum(sInt(start) - it->relStart, 0);
    const sInt etime = fr::minimum(sInt(end) - it->relStart, it->len);
    const sInt cStart = clipStart + it->relStart;

    if (stime < etime)
    {
      switch (it->type)
      {
      case 0: // fcurve (evaluate last value in range)
        evalList.push_back(evalItem(cStart + etime, etime, it->id, it->curveID));
        break;

      case 1: // clip (evaluate clipped range)
        evalRangeRecurse(g_graph->m_clips->getClip(it->id), cStart, stime, etime, evalList);
        break;
      }
    }
  }
}
예제 #8
0
void sResourceManager_::SetLogFont(sInt family,const sChar *name,sInt basesize)
{
  FontFamilies[family].Name = name;
  FontFamilies[family].Sizes[0] = sInt(basesize*0.70f+0.5f); 
  FontFamilies[family].Sizes[1] = sInt(basesize*0.80f+0.5f); 
  FontFamilies[family].Sizes[2] = basesize; 
  FontFamilies[family].Sizes[3] = sInt(basesize*1.20f+0.5f); 
  FontFamilies[family].Sizes[4] = sInt(basesize*1.40f+0.5f); 
  FontFamilies[family].Sizes[5] = sInt(basesize*1.80f+0.5f); 
  FontFamilies[family].Sizes[6] = sInt(basesize*2.50f+0.5f); 
}
예제 #9
0
void Wz4ChannelPerFrame::Evaluate(sF32 time,Wz4AnimKey &result)
{
  result = Start;
  if(Keys>1)
  {
    time = (time / MaxTime) * (Keys-1);
    sInt key = sClamp<sInt>(sInt(sRoundDown(time*1024)),0,Keys*1024-1025);
    sF32 f = (key&1023)/1024.0f;
    key = key/1024;

    if(Scale)
      result.Scale.Fade(f,Scale[key+0],Scale[key+1]);
    if(Rot)
      result.Rot.Fade(f,Rot[key+0],Rot[key+1]);
    if(Trans)
      result.Trans.Fade(f,Trans[key+0],Trans[key+1]);
  }
}
예제 #10
0
void Settings::setAccount(
        QString _grid,
        QString _name,
        QString _icon,
        QString _jid,
        QString _pass,
        bool _connectOnStart,
        QString _resource,
        QString _host,
        QString _port,
        bool manuallyHostPort) //Q_INVOKABLE
{
    bool isNew = false;
    beginGroup( "accounts" );

    QVariant retList = value( "accounts", QStringList() );
    QStringList sl = retList.toStringList();
    if( sl.indexOf(_grid) < 0 )
        isNew = true;
    endGroup();

    sStr(_name,_grid,"name");
    sStr(_icon,_grid,"icon");
    sStr(_jid,_grid,"jid");
    sStr(_pass,_grid,"passwd");

    sStr(_resource,_grid,"resource");
    sStr(_host,_grid,"host");
    sBool(manuallyHostPort,_grid,"use_host_port");
    sBool(_connectOnStart,_grid,"connectOnStart");

    bool ok = false;
    int p = _port.toInt(&ok);
    if( ok ) { sInt( p, _jid, "port" ); }

    if (isNew) addAccount(_grid);
    else {
        initListOfAccounts();
        emit accountEdited(_grid);
    }
}
// 检测整数
BOOL CStringChecker::CheckIntNumber(CString cStr)
{
	char str[] = "^[\\-]?([1-9]\\d*)|0$";
	CString strTemp(cStr);
	strTemp.Trim(' ');
	BOOL b = RegexMatch(strTemp, str);
	//BOOL b = RegexMatch(cStr, str);
	if(!b)
	{
		SetLastErr(TYPE_INT);
		return FALSE;//"整数不合规则";
	}

	CString sInt(cStr);
	if (sInt == "-0")
	{
		SetLastErr(TYPE_INT);
		return FALSE;
	}

	return TRUE;//"";
}
예제 #12
0
파일: main.cpp 프로젝트: Ambrevar/fr_public
MyApp::MyApp()
{
  sImage *img;

  Painter = new sPainter;

  // perlin texture

  sInt xs = 256;
  sInt ys = 256;
  img = new sImage;
  img->Init(xs,ys);
  for(sInt y=0;y<ys;y++)
  {
    for(sInt x=0;x<xs;x++)
    {
      sF32 p = sPerlin2D(x*(0x100000/xs),y*(0x100000/ys),3,0)*2.0f
             + sPerlin2D(x*(0x200000/xs),y*(0x200000/ys),7,0)*1.5f
             + sPerlin2D(x*(0x400000/xs),y*(0x400000/ys),15,0)*1.0f
             ;
      sInt c = sInt(128+127*sClamp(p,-1.0f,1.0f));
      img->Data[y*xs+x] = c|(c<<8)|(c<<16)|0xff000000;
    }
  }
  Tex = sLoadTexture2D(img,sTEX_ARGB8888);
  delete img;

  CreateTorus();

  // materials

  TorusMtrl = new TorusShader;
  TorusMtrl->Texture[0] = Tex;
  TorusMtrl->Texture[1] = Tex;
  TorusMtrl->TBind[1] = sMTB_VS|0;
  TorusMtrl->Flags = sMTRL_ZON|sMTRL_CULLOFF;
  TorusMtrl->Prepare(TorusFormat);
}
예제 #13
0
void CAnimMixer::processMove(sInt cursorX, sInt cursorY)
{
	updateThisClip();

  if (m_thisClip && m_moveElement != -1)
  {
    sInt nsFrame = fr::maximum(0.0f, m_baseRelStart + (cursorX - m_dragPoint.x) / m_frameStep);
    sInt nTrack = fr::clamp(m_baseTrack + sInt(cursorY - m_dragPoint.y) / 22, 0, m_maxTrack);

    frAnimationClip::element& elem = m_thisClip->m_elements[m_moveElement];
		nsFrame = performSnap(m_moveElement, nsFrame);

		if (nsFrame != elem.relStart || nTrack != elem.trackID)
		{
			elem.updateLen();

			CRect rc1, rc2;
			getElemRect(m_moveElement, rc1);

			elem.relStart = nsFrame;
			elem.trackID = nTrack;

			getElemRect(m_moveElement, rc2);

			CRgn rgn1, rgn2;
			rgn1.CreateRectRgnIndirect(&rc1);
			rgn2.CreateRectRgnIndirect(&rc2);

			rgn1.CombineRgn(rgn1, rgn2, RGN_DIFF);
			InvalidateRgn(rgn1, TRUE); 
			UpdateWindow(); // erasebackground is a per-region flag, so we need to paint twice
			InvalidateRect(&rc2, FALSE);
			UpdateWindow();

			clipChanged();
		}
  }
}
예제 #14
0
void sFont2D::PrintMarked(sInt flags,const sRect *rc,sInt x,sInt y,const sChar *text,sInt len,sPrintInfo *pi)
{
  if(len==-1) len=sGetStringLen(text);
  sVERIFY(rc);
  sVERIFY(pi);
  sRect r(*rc);
  const sChar *ot = text;
  sInt ol = len;
  sInt ox = x;
  sBool nocull = 0;

  switch(pi->Mode)
  {
  case sPIM_PRINT:
    nocull = pi->CullRect.IsEmpty() || rc->IsInside(pi->CullRect);
    if(pi->SelectStart<len && pi->SelectEnd>0 && pi->SelectEnd>pi->SelectStart)
    {
      sInt i = pi->SelectStart;
      if(i>0)
      {
        r.x1 = x + GetWidth(text,i);
        PrintBasic(flags,&r,x,y,text,i);
        r.x0 = x = r.x1;

        len -= i;
        pi->SelectEnd -= i;
        pi->SelectStart -= i;
        text += i;
      }

      sU32 oldbackcolor=prv->BackColor;
      if (pi->SelectBackColor!=~0)
        prv->BackColor=BrushColor[pi->SelectBackColor];
      else
        sSwap(prv->TextColor,prv->BackColor);

      i = sMin(pi->SelectEnd,len);
      r.x1 = x + GetWidth(text,i);
      if(nocull)
        PrintBasic(flags,&r,x,y,text,i);
      r.x0 = x = r.x1;

      len -= i;
      pi->SelectEnd -= i;
      pi->SelectStart -= i;
      text += i;

      if (pi->SelectBackColor!=~0)
        prv->BackColor=oldbackcolor;
      else
        sSwap(prv->TextColor,prv->BackColor);
    }
    if(nocull)
    {
      r.x1 = x + GetWidth(text,len);
      PrintBasic(flags,&r,x,y,text,len);
      if(flags & sF2P_OPAQUE)
      {
        r.x0 = x = r.x1;
        r.x1 = rc->x1;
        if(pi->HintLine && pi->HintLine>=r.x0 && pi->HintLine+2<=r.x1)
        {
          r.x1 = pi->HintLine;
          sRect2D(r,prv->BackPen);
          r.x0 = r.x1;
          r.x1 = r.x0+2;
          sRect2D(r,pi->HintLineColor);
          r.x0 = r.x1;
          r.x1 = rc->x1;
        }
        sRect2D(r,prv->BackPen);
      }
    }

    if(pi->CursorPos>=0 && pi->CursorPos<=ol && pi->Mode==sPIM_PRINT)
    {
      sInt t = GetWidth(ot,pi->CursorPos);
      sInt w = 2;
      if(pi->Overwrite)
      {
        if(pi->CursorPos<ol)
          w = GetWidth(ot+pi->CursorPos,1);
        else
          w = GetWidth(L" ",1);
      }
      sRectInvert2D(ox+t,rc->y0,ox+t+w,rc->y1);
    }
    break;

  case sPIM_POINT2POS:
    if(pi->QueryY>=rc->y0 && pi->QueryY<rc->y1)
    {
      x = ox;
	    sInt i;
      for(i=0;i<len;i++)
      {
        x += GetWidth(ot+i,1);
        if(pi->QueryX < x)
          break;
      }
      pi->QueryPos = ot+i;
      pi->Mode = sPIM_QUERYDONE;
    }
    break;

  case sPIM_POS2POINT:
    if(pi->QueryPos>=ot && pi->QueryPos<=ot+len)
    {
      pi->QueryY = rc->y0;
      pi->QueryX = ox+GetWidth(ot,sInt(pi->QueryPos-ot));
    }
    break;
  }
}
예제 #15
0
void RNFR067_IsoSplash::Prepare(Wz4RenderContext *ctx)
{
  for(sInt i=0;i<4;i++)
  {
    if(Mtrl[i]) 
      Mtrl[i]->BeforeFrame(Para.LightEnv);
  }

  SphereEnable = (Para.SphereAmp!=0.0f);
  SphereAmp.x = 1.0f / Para.SphereDirections.x;
  SphereAmp.y = 1.0f / Para.SphereDirections.y;
  SphereAmp.z = 1.0f / Para.SphereDirections.z;
  SphereAmp = SphereAmp * SphereAmp;

  CubeEnable = (Para.CubeAmp!=0.0f);
  CubeAmp.x = 1.0f / Para.CubeDirections.x;
  CubeAmp.y = 1.0f / Para.CubeDirections.y;
  CubeAmp.z = 1.0f / Para.CubeDirections.z;

  NoiseEnable = (Para.NoiseAmp1!=0.0f) || (Para.NoiseAmp2!=0.0f);
  NoiseFreq1 = Para.NoiseFreq1*0x10000;
  NoisePhase1 = Para.NoisePhase1*0x10000;
  NoiseAmp1 = Para.NoiseAmp1;
  NoiseFreq2 = Para.NoiseFreq2*0x10000;
  NoisePhase2 = Para.NoisePhase2*0x10000;
  NoiseAmp2 = Para.NoiseAmp2;

  RotEnable = 0;
  RubberEnable = 0;
  if(Para.Rot.x!=0 || Para.Rot.y!=0 || Para.Rot.z!=0)
    RotEnable = 1;
  if(Para.Rubber.x!=0 || Para.Rubber.y!=0 || Para.Rubber.z!=0)
    RotEnable = RubberEnable = 1;

  PolarEnable = (Para.PolarAmp!=0.0f);


  for(sInt i=0;i<Size;i++)
  {
    sF32 py = sF32(i-1)/sF32((1<<Para.OctreeDivisions)*8);
    RubberMat[i].EulerXYZ((Para.Rot.x+Para.Rubber.x*py)*sPI2F,
                          (Para.Rot.y+Para.Rubber.y*py)*sPI2F,
                          (Para.Rot.z+Para.Rubber.z*py)*sPI2F);
  }

  sF32 f = 1.0f/((1<<Para.OctreeDivisions)*8);
  for(sInt y=0;y<Size;y++)
  {
    for(sInt x=0;x<Size;x++)
    {
      sF32 px = (x-1)*f*2-1;
      sF32 py = (y-1)*f*2-1;

      NoiseXY[Size*y+x] = NoiseAmp1*sPerlin2D(sInt(px*NoiseFreq1.x+NoisePhase1.x),
                                              sInt(py*NoiseFreq1.y+NoisePhase1.y),255,Para.NoiseSeed1)
                        + NoiseAmp2*sPerlin2D(sInt(px*NoiseFreq2.x+NoisePhase2.x),
                                              sInt(py*NoiseFreq2.y+NoisePhase2.y),255,Para.NoiseSeed2);

      NoiseYZ[Size*y+x] = NoiseAmp1*sPerlin2D(sInt(px*NoiseFreq1.y+NoisePhase1.y),
                                              sInt(py*NoiseFreq1.z+NoisePhase1.z),255,Para.NoiseSeed1)
                        + NoiseAmp2*sPerlin2D(sInt(px*NoiseFreq2.y+NoisePhase2.y),
                                              sInt(py*NoiseFreq2.z+NoisePhase2.z),255,Para.NoiseSeed2);

      NoiseZX[Size*y+x] = NoiseAmp1*sPerlin2D(sInt(px*NoiseFreq1.z+NoisePhase1.z),
                                              sInt(py*NoiseFreq1.x+NoisePhase1.x),255,Para.NoiseSeed1)
                        + NoiseAmp2*sPerlin2D(sInt(px*NoiseFreq2.z+NoisePhase2.z),
                                              sInt(py*NoiseFreq2.x+NoisePhase2.x),255,Para.NoiseSeed2);

      PolarPhi[Size*y+x] = sFSin(sATan2(px,py)*Para.PolarXZ*0.5f);
    }
  }



  // do it

  MakeNodes();

  March();

  sAABBoxC box;
  sF32 s = Para.GridSize/2.0f;
  box.Radius.Init(s,s,s);
  box.Center.Init(0,0,0);
  for(sInt i=0;i<4;i++)
    if(Mtrl[i])
      Mtrl[i]->BeforeFrame(Para.LightEnv,1,&box,Matrices.GetCount(),Matrices.GetData());
}
예제 #16
0
void MyApp::OnPaint3D()
{ 
  sRandom rnd;
  sVertexSingle *vp;

  // set rendertarget

  sSetRendertarget(0,sCLEAR_ALL,0xff405060);

  // get timing

  Timer.OnFrame(sGetTime());
  sInt time = Timer.GetTime();

  // set camera

  View.SetTargetCurrent();
  View.SetZoom(1.7f);
 // View.Model.EulerXYZ(time*0.0011f,time*0.0013f,time*0.0015f);
  View.Model.l.Init(0,0,0);
  View.Camera.l.Init(0,0,-4);
  View.Prepare();
  View.Set();
 
  // set material

  sCBuffer<sSimpleMaterialEnvPara> cb;
  cb.Data->Set(Env);

  // begin

  for(sInt i=0;i<4;i++)
    Geo[i]->BeginQuadrics();

  // grid

  Geo[0]->BeginGrid((void **) &vp,65,65);
  for(sInt y=-32;y<=32;y++)
  {
    for(sInt x=-32;x<=32;x++)
    {
      sF32 px,py,fx,fy;
      fx = x/32.0f;
      fy = y/32.0f;
      px = x/16.0f + sFSin(x*0.10f+y*0.12f+time*0.0011f)*0.1f;
      py = y/16.0f + sFSin(x*0.11f+y*0.13f+time*0.0011f)*0.1f;
      vp->Init(px,py,0,0xff808080,fx,fy);
      vp++;
    }
  }
  Geo[0]->EndGrid();

  // some random quads

  sInt max = sInt((sFSin(time*0.004f)+2)*64);
  for(sInt i=0;i<max;i++)
  {
    sF32 x,y,s;
    sInt r;

    x = sFSin(i*0.10f+time*0.0011f);
    y = sFCos(i*0.12f+time*0.0014f);
    s = 0.1f;
    r = rnd.Int(4);

    Geo[r]->BeginQuad((void **) &vp,1);
    vp[0].Init(x-s,y-s,0,  ~0, 0,0);
    vp[1].Init(x+s,y-s,0,  ~0, 1,0);
    vp[2].Init(x+s,y+s,0,  ~0, 1,1);
    vp[3].Init(x-s,y+s,0,  ~0, 0,1);
    Geo[r]->EndQuad();
  }

  // end and draw

  for(sInt i=0;i<4;i++)
    Geo[i]->EndQuadrics();

  for(sInt i=0;i<4;i++)
  {
    Mtrl[i]->Set(&cb);
    Geo[i]->Draw();
  }

  // debug output

  sF32 avg = Timer.GetAverageDelta();
  Painter->SetTarget();
  Painter->Begin();
  Painter->SetPrint(0,~0,2);
  Painter->PrintF(10,10,L"%5.2ffps %5.3fms",1000/avg,avg);
  Painter->End();

}
예제 #17
0
sChar *DebugInfo::WriteReport()
{
  sChar *Report;
  sInt i,j;
  sU32 size;
  sF32 pSize;
  
  Report = ReportBuffer;
  sSPrintF(Report,512,sAPPNAME " " sVERSION " >> pack ratio report\n\n");
  Report += sGetStringLen(Report);

  sSPrintF(Report,512,"Functions by packed size:\n");
  Report += sGetStringLen(Report);

  std::sort(&Symbols[0],&Symbols[Symbols.Count],symPackedSizeComp);

  for(i=0;i<Symbols.Count;i++)
  {
    if(Symbols[i].Class == DIC_CODE)
    {
      sSPrintF(Report,512,"%5d.%02d/%8d: %-50s %s\n",
        (sInt) Symbols[i].PackedSize,sInt(Symbols[i].PackedSize*100)%100,
        Symbols[i].Size,Symbols[i].Name,Files[Symbols[i].FileNum].Name);

      Report += sGetStringLen(Report);
    }
  }

  sSPrintF(Report,512,"\nData by packed size:\n");
  Report += sGetStringLen(Report);
  for(i=0;i<Symbols.Count;i++)
  {
    if(Symbols[i].Class == DIC_DATA)
    {
      sSPrintF(Report,512,"%5d.%02d/%8d: %-50s %s\n",
        (sInt) Symbols[i].PackedSize,sInt(Symbols[i].PackedSize*100)%100,
        Symbols[i].Size,Symbols[i].Name,Files[Symbols[i].FileNum].Name);

      Report += sGetStringLen(Report);
    }
  }

  sSPrintF(Report,512,"\nFunctions by object file and packed size:\n");
  Report += sGetStringLen(Report);

  for(i=1;i<Symbols.Count;i++)
    for(j=i;j>0;j--)
    {
      sInt f1 = Symbols[j].FileNum;
      sInt f2 = Symbols[j-1].FileNum;

      if(f1 == -1 || f2 != -1 && sCmpStringI(Files[f1].Name.String,Files[f2].Name.String) < 0)
        sSwap(Symbols[j],Symbols[j-1]);
    }

  for(i=0;i<Symbols.Count;i++)
  {
    if(Symbols[i].Class == DIC_CODE)
    {
      sSPrintF(Report,512,"%5d.%02d/%8d: %-50s %s\n",
        (sInt) Symbols[i].PackedSize,sInt(Symbols[i].PackedSize*100)%100,
        Symbols[i].Size,Symbols[i].Name,Files[Symbols[i].FileNum].Name);

      Report += sGetStringLen(Report);
    }
  }

  sSPrintF(Report,512,"\nClasses/Namespaces by packed size:\n");
  Report += sGetStringLen(Report);
  std::sort(&NameSps[0],&NameSps[NameSps.Count],namePackedSizeComp);

  for(i=0;i<NameSps.Count;i++)
  {
    sSPrintF(Report,512,"%5d.%02d/%8d: %s\n",sInt(NameSps[i].PackedSize),
      sInt(NameSps[i].PackedSize*100)%100,NameSps[i].Size,NameSps[i].Name);
    Report += sGetStringLen(Report);
  }

  sSPrintF(Report,512,"\nObject files by packed size:\n");
  Report += sGetStringLen(Report);
  std::sort(&Files[0],&Files[Files.Count],filePackedSizeComp);

  for(i=0;i<Files.Count;i++)
  {
    sSPrintF(Report,512,"%5d.%02d/%8d: %s\n",sInt(Files[i].PackedSize),
      sInt(Files[i].PackedSize*100)%100,Files[i].Size,Files[i].Name);
    Report += sGetStringLen(Report);
  }

  size = 0;
  pSize = 0.0f;
  for(i=0;i<Symbols.Count;i++)
  {
    if(Symbols[i].Class == DIC_CODE)
    {
      size += Symbols[i].Size;
      pSize += Symbols[i].PackedSize;
    }
  }

  sSPrintF(Report,512,"\nOverall code: %5d.%02d/%8d\n",sInt(pSize),
    sInt(pSize*100)%100,size);
  Report += sGetStringLen(Report);

  size = 0;
  pSize = 0.0f;
  for(i=0;i<Symbols.Count;i++)
  {
    if(Symbols[i].Class == DIC_DATA)
    {
      size += Symbols[i].Size;
      pSize += Symbols[i].PackedSize;
    }
  }

  sSPrintF(Report,512,"Overall data: %5d.%02d/%8d\n",sInt(pSize),
    sInt(pSize*100)%100,size);
  Report += sGetStringLen(Report);

  return sDupString(ReportBuffer,1);
}
예제 #18
0
sINLINE sInt sDivShift12(sInt var_a,sInt var_b)
{
  return sInt((sS64(var_a) << 12) / var_b);
}
예제 #19
0
 void Init(sF32 PX,sF32 PY,sF32 PZ,sF32 NX,sF32 NY,sF32 NZ)
 { px=PX; py=PY; pz=PZ; n[0]=sInt((NX+1)*127); n[1]=sInt((NY+1)*127); n[2]=sInt((NZ+1)*127); n[3]=0; }
예제 #20
0
void s3DWindow::CmdGearShift(sDInt n)
{
  GearShift = sClamp(GearShift+sInt(n),-40,40);
  GearShiftDisplay = sGetTime()+500;
}
예제 #21
0
파일: Cpu.cpp 프로젝트: tlevi/mipsim
const void Cpu::executeImmOp(const uInt op){
#if DEBUGLEVEL > 2
	printf("I-op, op:%x, r%d, r%d, imm:%x\n", GET_OPCODE(op), OP_SRC_REG(op), OP_ADD_REG(op), GET_IMM(op));
#endif

	uInt* const add = &mips->r[OP_ADD_REG(op)];
	const uInt* const src = &mips->r[OP_SRC_REG(op)];
	const uInt pmem = *src + GET_IMMSGN(op);

	switch (GET_OPCODE(op)){
		case OPCODE_BEQ:
			mips->pc += (*src == *add) ? GET_IMMSGN(op)*4 : 0;
			break;
		case OPCODE_BNE:
			mips->pc += (*src != *add) ? GET_IMMSGN(op)*4 : 0;
			break;
		case OPCODE_ADDI:
			//TODO throw overflow exception
		case OPCODE_ADDIU:
			*add = *src + GET_IMMSGN(op);
			break;
		case OPCODE_MFC:
			fatalError("Unimplemented I-op\n");
		case OPCODE_FP:
			fatalError("In executeImmOp, but found FP-op!\n");
		case OPCODE_SLTI:
			*add = (sInt(*src) < GET_IMMSGN(op)) ? 1 : 0;
			break;
		case OPCODE_SLTIU:
			*add = (*src < GET_IMMSGN(op)) ? 1 : 0;
			break;
		case OPCODE_ANDI:
			*add = *src & GET_IMM(op);
			break;
		case OPCODE_ORI:
			*add = *src | GET_IMM(op);
			break;
		case OPCODE_LUI:
			*add = GET_IMM(op);
			break;
		case OPCODE_LW:
			*add = mem->get<uInt>(pmem);
			break;
		case OPCODE_LD:
			fatalError("Unimplemented I-op\n");
		case OPCODE_LBU:
			*add = mem->get<uChar>(pmem);
			break;
		case OPCODE_LHU:
			*add = mem->get<uShort>(pmem);
			break;
		case OPCODE_SB:
			mem->set(pmem, uChar(*add));
			break;
		case OPCODE_SH:
			mem->set(pmem, uShort(*add));
			break;
		case OPCODE_LL:
			fatalError("Unimplemented I-op\n");
		case OPCODE_SW:
			mem->set(pmem, *add);
			break;
		default:
			fatalError("Unknown I-op instruction\n");
	}
};
예제 #22
0
void RPCServer::ThreadFunc(sThread *t)
{

  while (t->CheckTerminate())
  {
    sTCPSocket *reads[100], *writes[100], *newconn;
    sInt nReads = 0, nWrites = 0;

    Connection *conn;
    sFORALL_LIST(Connections, conn)
    {
      reads[nReads++] = conn->Socket;
      if (!conn->OutBuffers.IsEmpty())
        writes[nWrites++] = conn->Socket;
    }

    if (Socket.WaitForEvents(nReads,reads,nWrites,writes,&newconn,100))
    {
      if (newconn)
      {
        conn = new Connection;
        conn->Socket = newconn;
        Connections.AddTail(conn);
      }

      // handle incoming data
      for (int i=0; i<nReads; i++)
      {
        sFORALL_LIST(Connections,conn) if (conn->Socket == reads[i])
        {
          sDInt read;
          Buffer *buf = conn->InBuffers.IsEmpty()?0:conn->InBuffers.GetTail();
          if (!buf || buf->Count == Buffer::SIZE)
          {
            buf = new Buffer;
            conn->InBuffers.AddTail(buf);
          }
          sBool ret = conn->Socket->Read(buf->Data+buf->Count,Buffer::SIZE-buf->Count,read);

          // close connection?
          if (!ret || read==0)
          {
            Connections.Rem(conn);
            sDelete(conn);
            break;
          }
          else
          {
            // add to in buffer
            buf->Count+=(sInt)read;

            // seach for end marker
            const sU8 *patptr = (const sU8*)"\n\r\n\r";
            const sU8 *bufptr = buf->Data+buf->Count;
            for (;;)
            {
              if (*--bufptr != *patptr) break;
              if (!*++patptr) break;
              if (bufptr == buf->Data)
              {
                if (buf == conn->InBuffers.GetHead())
                  break;
                buf = conn->InBuffers.GetPrev(buf);
                bufptr = buf->Data+buf->Count;
              }
            }

            if (!*patptr)
            {
              OnMessage(conn, buf, bufptr);
              sDeleteAll(conn->InBuffers);
            }
          }
          break;
        }

      }

      // handle outgoing data
      for (int i=0; i<nWrites; i++)
      {
        sFORALL_LIST(Connections,conn) if (conn->Socket == writes[i])
        {
          Buffer *buf = conn->OutBuffers.GetHead();
          sDInt written = 0;
          sBool ret = conn->Socket->Write(buf->Data, buf->Count, written);

          // close connection?
          if (!ret)
          {
            Connections.Rem(conn);
            sDelete(conn);
            break;
          }
          else
          {
            if (written<buf->Count)
              sMoveMem(buf->Data, buf->Data+written, sInt(buf->Count-written));
            buf->Count-=(sInt)written;

            if (!buf->Count)
            {
              conn->OutBuffers.RemHead();
              delete buf;
            }

            // close connection after sending it all out
            if (conn->OutBuffers.IsEmpty())
            {
              Connections.Rem(conn);
              sDelete(conn);
            }
          }
          
          break;
        }
      }

    }
  }
예제 #23
0
sInt sFont2D::Print(sInt flags,const sRect &r,const sChar *text,sInt len,sInt margin,sInt xo,sInt yo,sPrintInfo *pi)
{
  if(len==-1) len=sGetStringLen(text);
  sInt x,y;
  sPrintInfo pil;
  const sChar *textstart=text;
  sInt result;

  sRect r2(r);

  pil.Init();
  if(pi)
  {
    pil = *pi;
  }
  pil.CursorPos = -1;
  pil.Overwrite = 0;
  pil.SelectStart = -1;
  pil.SelectEnd = -1;

  r2.Extend(-margin);
  x = r2.x0 + xo;
  y = r2.y0 + yo;
  sInt xs = r2.SizeX();
  sInt h = GetHeight();
  sRect rs(r);
  result = rs.y0;

  if(pil.Mode==sPIM_POINT2POS && pil.QueryY<y)
  {
    pi->Mode = sPIM_QUERYDONE;
    pi->QueryPos = text;
    return result;
  }

  if(flags & sF2P_MULTILINE)
  {
    const sChar *textend = text+len;
    for(;;)
    {
      sInt i=0;
      sInt best = 0;
      if(pi)
      {
        pil.CursorPos   = pi->CursorPos   - sInt(text-textstart);
        pil.Overwrite   = pi->Overwrite;
        pil.SelectStart = pi->SelectStart - sInt(text-textstart);
        pil.SelectEnd   = pi->SelectEnd   - sInt(text-textstart);
      }
      for(;;)
      {
        while(text+i<textend && text[i]!=' ' && text[i]!='\n')
          i++;
        if(GetWidth(text,i)>xs)
          break;
        best = i;
        if(text[i]=='\n')
          break;
        if(text+i>=textend)
          break;
        i++;
      }
      if(best==0)
      {
        i = 0;
        while(text+i<textend && text[i]!=' ' && text[i]!='\n' && GetWidth(text,i)<=xs)
          i++;
        best = i-1;
        if(best<1 && text<textend && text[0]!=' ' && text[0]!='\n')
          best = 1;
        if(best<0)
          best = 0;
        else if(pil.CursorPos>=best)
          pil.CursorPos = -1;
      }

      rs.y1 = y + h;
      sRect rclip = rs;
      rclip.And(r);

      PrintMarked(flags,&rclip,x,y,text,best,&pil);

      rs.y0 = rs.y1;
      text+=best;
      if(text>=textend) break;
      y+=h;
      if(text[0]==' ' || text[0]=='\n')
        text++;
    }

    if(pil.Mode == sPIM_POS2POINT && pil.QueryPos == text) // query was to end of document?
    {
      pil.QueryX = x;
      pil.QueryY = y;
    }

    result = y+h+margin;
    rs.y1 = r.y1;
    if(rs.y1>rs.y0 && pil.Mode==sPIM_PRINT && (flags & sF2P_OPAQUE))
    {
      sRect r(rs);
      if(pil.HintLine && pil.HintLine>=r.x0 && pil.HintLine+2<=r.x1)
      {
        r.x1 = pil.HintLine;
        sRect2D(r,prv->BackPen);
        r.x0 = r.x1;
        r.x1 = r.x0+2;
        sRect2D(r,pil.HintLineColor);
        r.x0 = r.x1;
        r.x1 = rs.x1;
      }
      sRect2D(r,prv->BackPen);
    }

    if(pi)
    {
      pi->QueryPos = pil.QueryPos;
      pi->QueryX = pil.QueryX;
      pi->QueryY = pil.QueryY;
      pi->Mode = pil.Mode;
    }
  }
  else
  {
    sInt space=0;
    if(flags & sF2P_SPACE)
      space = GetWidth(L" ");
    if(flags & sF2P_LEFT)
    {
      x = r2.x0 + space;
    }
    else if(flags & sF2P_RIGHT)
    {
      x = r2.x1 - GetWidth(text,len) - space;
    }
    else
    {
      x = (r2.x0 + r2.x1 - GetWidth(text,len))/2;
    }
    if(flags & sF2P_TOP)
    {
      y = r2.y0;
    }
    else if(flags & sF2P_BOTTOM)
    {
      y = r2.y1 - h;
    }
    else
    {
      y = (r2.y0 + r2.y1 - h)/2;
    }

    if(pi)
    {
      sPrintInfo pi2 = *pi;
      PrintMarked(flags,&r,x+xo,y+yo,text,len,&pi2);
      if(pi->Mode)
      {
        pi->QueryPos = pi2.QueryPos;
        pi->QueryX = pi2.QueryX;
        pi->QueryY = pi2.QueryY;
      }
    }
    else
    {
      PrintBasic(flags,&r,x,y,text,len);
    }

    result = y+h;
  }

  return result;
}