/*!
Detaches this backend from the current script engine.
The backend's state (including breakpoints and information on loaded
scripts) will be invalidated.
\sa attach()
*/
void QScriptDebuggerBackend::detach()
{
Q_D(QScriptDebuggerBackend);
if (!d->agent)
return;
QScriptEngine *eng = d->agent->engine();
if (eng && eng->agent() == d->agent) {
eng->setAgent(0);
QScriptValue global = eng->globalObject();
if (global.property(QString::fromLatin1("print")).strictlyEquals(traceFunction()))
global.setProperty(QString::fromLatin1("print"), QScriptValue());
// global.setProperty(QString::fromLatin1("qAssert"), QScriptValue());
if (global.property(QString::fromLatin1("__FILE__")).strictlyEquals(fileNameFunction()))
global.setProperty(QString::fromLatin1("__FILE__"), QScriptValue());
if (global.property(QString::fromLatin1("__LINE__")).strictlyEquals(lineNumberFunction()))
global.setProperty(QString::fromLatin1("__LINE__"), QScriptValue());
d->agent->nullifyBackendPointer();
d->agent = 0; // agent is owned by engine
}
d->pendingEvaluateLineNumber = -1;
d->ignoreExceptions = false;
d->nextScriptValueIteratorId = 0;
qDeleteAll(d->scriptValueIterators);
d->scriptValueIterators.clear();
qDeleteAll(d->scriptObjectSnapshots);
d->scriptObjectSnapshots.clear();
}
int Win32Network::inner_broadcast(SOCKET s,int port,char*buff,int buff_size){
traceFunction(eNetwork);
int r=-1;
sockaddr_in servaddr;
int len;
ulong netAddr=inet_addr("255.255.255.255");
memset(&servaddr,0,sizeof(sockaddr_in));
servaddr.sin_family=AF_INET;
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr=netAddr;
len=sizeof(servaddr);
r=::sendto(s,buff,buff_size,0,(sockaddr*)&servaddr,len);
if(r==SOCKET_ERROR){
if(WSAGetLastError()==WSAEWOULDBLOCK){
return 0;
}
messages::logMessage(messages::HMSG_BROADCAST,ELL_ERROR);
return -1;
}
return r;
}
bool FreeImageLoader::load(const core::string&filename,video::ImageInfo* tex,video::ETextureType target){
if(m_isDummy)
return false;
traceFunction(eEngine);
OS::IStreamPtr fp=gFileSystem.openFile(filename,OS::BIN_READ);
if(!fp){
gLogManager.log(mT("Couldn't open Bmp file"),filename,ELL_WARNING);
return 0;
}
return load(fp, tex,target);
}
Win32Network::Win32Network():SYNC_NUMBER(1234567)
{
traceFunction(eNetwork);
int error;
WSAData wd;
error=WSAStartup(MAKEWORD(2,2),&wd);
if(error==SOCKET_ERROR){
if(LOBYTE(wd.wVersion)!=2 || HIBYTE(wd.wVersion)!=0){
WSACleanup();
/////////error occourd
messages::logMessage(messages::HMSG_NET_START,ELL_ERROR);
return;
}
}
DWORD buffSize=0;
//Enumerate available protocols
int numProto=WSAEnumProtocols(0,0,&buffSize);
if(numProto!=SOCKET_ERROR && WSAGetLastError()!=WSAENOBUFS){
WSACleanup();
return;
}
LPWSAPROTOCOL_INFO selectedProto;
selectedProto=(LPWSAPROTOCOL_INFO)malloc(buffSize);
int *proto=new int[2];
proto[0]=IPPROTO_TCP;
proto[1]=IPPROTO_UDP;
numProto=WSAEnumProtocols(proto,selectedProto,&buffSize);
delete [] proto;
proto=0;
free(selectedProto);
selectedProto=0;
}
/*!
Attaches this backend to the given \a engine.
The backend automatically detaches from the old engine, if any.
This function installs its own agent on the \a engine using
QScriptEngine::setAgent(); any existing agent will be replaced.
\sa detach(). engine()
*/
void QScriptDebuggerBackend::attachTo(QScriptEngine *engine)
{
Q_D(QScriptDebuggerBackend);
detach();
d->agent = new QScriptDebuggerAgent(d, engine);
QScriptValue global = engine->globalObject();
global.setProperty(QString::fromLatin1("print"), traceFunction());
// global.setProperty(QString::fromLatin1("qAssert"), assertFunction());
global.setProperty(QString::fromLatin1("__FILE__"), fileNameFunction(),
QScriptValue::PropertyGetter | QScriptValue::PropertySetter
| QScriptValue::ReadOnly);
global.setProperty(QString::fromLatin1("__LINE__"), lineNumberFunction(),
QScriptValue::PropertyGetter | QScriptValue::PropertySetter
| QScriptValue::ReadOnly);
engine->setAgent(d->agent);
}
HANDLE WinThread::start(void*arg){
traceFunction(eOS);
this->arg(arg);
// CreateMutex(0,false,0);
IThreadManager::getInstance().preThreadStart();
threadHandle = CreateThread(0,0,(LPTHREAD_START_ROUTINE)WinThread::entryPoint,this,0,&threadID);
setThreadPriority(ETP_Normal);
//Sleep(10);
m_initSync.Block(2);
// m_initSync->wait(m_initMutex);
IThreadManager::getInstance().postThreadStart();
// HANDLE code = _beginthreadex(0,0,(LPTHREAD_START_ROUTINE)WinThread::entryPoint,this,0,&threadID);
return threadHandle;
}
SOCKET Win32Network::openUDPSocket(const char* netInterface,int port){
// Win32Socket*result=new Win32Socket();
traceFunction(eNetwork);
SOCKET result;
result=createSocket(EProtoType::EPT_UDP);
if(result==INVALID_SOCKET)
return result;
attachUDPSocket(result,netInterface,port);
messages::logMessage(messages::HMSG_UDP_SOCKET_CREATE,ELL_SUCCESS);
return result;
}
int PythonScript::SetScript(OS::IStream* file)
{
traceFunction(Script);
if (!file)
return -1;
file->seek(0, OS::ESeek_End);
int len = file->getPos() / sizeof(char);
file->seek(0, OS::ESeek_Set);
char *scriptTxt = new char[len + 1];
file->read(scriptTxt, len);
scriptTxt[len] = 0;
int res = SetScript(scriptTxt);
delete[] scriptTxt;
return res;
}
int Win32Network::inner_receivefrom(SOCKET s,void*data,int len,
NetAddress * fromAddress,int flags)
{
traceFunction(eNetwork);
DWORD recvLength = 0;
struct sockaddr_in sin;
if (!fromAddress)
recvLength = ::recv(s, (char*)data, len, flags);
else
{
int sinLength = sizeof (struct sockaddr_in);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
recvLength = ::recvfrom(s, (char*)data, len, flags,
(struct sockaddr *) & sin, &sinLength);
}
if (recvLength == SOCKET_ERROR)
{
int err=WSAGetLastError ();
if (err == WSAEWOULDBLOCK || err == WSAECONNRESET){
return 0;
}
return -1;
}
if (flags & MSG_PARTIAL){
return -1;
}
if (fromAddress != NULL)
{
fromAddress -> address = (u_int) sin.sin_addr.s_addr;
fromAddress -> port = ntohs (sin.sin_port);
}
return (int) recvLength;
}
void WinThread::terminate()
{
traceFunction(eOS);
active=false;
if (threadHandle)
{
resume();
// WaitForSingleObject(threadHandle, INFINITE);
DWORD res=WaitForSingleObject( threadHandle, INFINITE );
if(res==WAIT_TIMEOUT){
gLogManager.log(mT("WinThread::terminate()"),mT("Time Out"),ELL_ERROR);
}
TerminateThread(threadHandle,0);
CloseHandle( threadHandle );
threadHandle = NULL;
}
}
IFont* XML_Font::readFontElement(xml::XMLElement*attrs){
traceFunction(eGUI);
IFont* ret=0;
xml::XMLAttribute*type=attrs->getAttribute(mT("type"));
if(!type){
gGUILoggerSystem.log(mT("Error While Parsing Font XML File, No type for the Font"),ELL_ERROR);
}
IFontXMLParser*p= gFontResourceManager.getXMLParser(type->value);
if(p){
ret=p->parseAttributes(attrs);
}else
{
//.. no supported font!
gGUILoggerSystem.log(mT("Error While Parsing Font XML File, No support for font type: ")+type->value,ELL_ERROR);
}
return ret;
}
int Win32Network::inner_receivefrom(SOCKET s,CMsgBuffer*msg,
NetAddress * fromAddress,int flags)
{
traceFunction(eNetwork);
char data[8][MAX_DGRAM_SIZE];
static int currData=0;
int d=currData;
currData++;
if(currData>=8)
currData=0;
data[d][0]=0;
int recvLength=inner_receivefrom(s,data[d],MAX_DGRAM_SIZE,fromAddress,flags);
msg->reset();
msg->resize(recvLength);
memcpy(msg->pointer(),data[d],recvLength);
return (int) recvLength;
}
int Win32Network::inner_sendto(SOCKET s,const char*buff,int buff_size,
const NetAddress * toAddress,int flags)
{
traceFunction(eNetwork);
struct sockaddr_in sin;
DWORD sentLength;
if (toAddress != NULL)
{
sin.sin_family = AF_INET;
sin.sin_port = htons (toAddress -> port);
sin.sin_addr.s_addr = toAddress -> address;
}
sentLength=::sendto (s, (char*)buff,buff_size,
flags,
toAddress != NULL ? (struct sockaddr *) & sin : 0,
toAddress != NULL ? sizeof (struct sockaddr_in) : 0);
if (sentLength == SOCKET_ERROR)
{
int err=WSAGetLastError ();
if (err == WSAEWOULDBLOCK)
return 0;
if(err==WSAEHOSTUNREACH){
messages::logMessage(messages::HMSG_UNREACHABLEHOST,ELL_WARNING);
}
return -1;
}
return (int) sentLength;
}
void SceneManager::render(ViewPort*vp)
{
_AUTO_BENCHMARK(m_renderBI);
traceFunction(eScene);
if(!getDevice() || !vp || !vp->getCamera())
return;
getDevice()->set3DMode();
if(m_debugDrawManager)
{
//prepare debug draw manager primitives
m_debugDrawManager->StartDraw(vp->getCamera());
}
video::IRenderTarget* renderTarget;
if(vp ){
if(vp->getCamera())
m_activeCamera=vp->getCamera();
if(vp->getRenderTarget() )
renderTarget=vp->getRenderTarget();
}
if(vp){
//math::rectf rc=vp->getAbsViewPort();
//getDevice()->setViewportRect(rc);
}
RenderPassList passes;
/*
{
RenderPassList::iterator passIt=m_shadowPasses.begin();
for (;passIt!=m_shadowPasses.end();++passIt)
passes.push_back(*passIt);
}
{
RenderPassList::iterator passIt=m_passes.begin();
for (;passIt!=m_passes.end();++passIt)
passes.push_back(*passIt);
}
*/
_collectPasses(passes);
vp->getCamera()->GetRenderPasses(passes);
IViewNode*oldVN=0;
RenderPassList::iterator passIt=passes.begin();
for (;passIt!=passes.end();++passIt)
{
if(!(*passIt)->IsEnabled())
continue;
m_currentPass=*passIt;
m_currentPass->setActiveCamera(m_activeCamera);
m_currentPass->beginPass(this,vp);
RequestToRenderVisitor preRenderVisitor(m_currentPass);
RenderSceneVisitor renderVisitor(m_currentPass);
m_renderManager->clear();
m_jobsThreadsManager->Reset();
OnVisit(&preRenderVisitor);
// m_jobsThreadsManager->BeginProcessing();
// if(oldFrust!=m_activeFrustrum)
{
m_renderManager->startSorting();
oldVN=m_activeViewnode;
}
getDevice()->clearBuffer(video::EDB_DEPTH);
_setupLightsToRender(m_currentPass);
// m_jobsThreadsManager->EndProcessing();
m_renderManager->endSorting();
if(m_activeCamera)
m_activeCamera->render(m_currentPass);
m_renderManager->renderAll(m_currentPass);
//OnVisit(&renderVisitor);
m_currentPass->endPass();
}
m_currentPass=0;
m_renderManager->clear();
m_lightNodesToRender.clear();
if(m_debugDrawManager)
{
//draw primitives
m_debugDrawManager->EndDraw();
}
//update camera view
// if(ActiveCamera)
// ActiveCamera->updateView();
}
bool CSettingsFile::loadSettings(OS::IStream* stream){
if(!stream)return 0;
traceFunction(eScene);
GCPtr<script::ILexical>parser=new script::ILexical();
GCPtr<script::CTokenList> tokens=new script::CTokenList();
parser->loadFromStream(stream);
parser->setTokenDefinitionTable(settingTokenDefineTable,false,4);
parser->setDelimChars(mT("\t\n\r {}\""));
script::CTokenTranslator translater;
tokens->fromLexical(parser,&translater,true,true,mT("#"));
static mchar buffer[512];
static char msg[256];
core::string attrName;
core::string attrValue;
SConfigTag *tag;
enum EStatus{
ReadTag,
OpenBrace,
CloseBrace,
Attribute
};
EStatus state=ReadTag;
bool done=false;
ScriptToken* token;
if(!tokens->isDone()){
do{
if(tokens->isDone()){
// done=true;
break;
}
token=tokens->getNextToken();
if(token==0 || token->token==ERT_EOF)
break;
switch(state){
case ReadTag:
{
tag=addTag(token->lex);
state=OpenBrace;
}break;
case OpenBrace:
{
if(token->token!=Token_Open_Brace){
gLogManager.log(mT("CSettingsFile::loadSettings()")
,mT("Expected \"{\" after the tag[")+tag->tagName+mT("]!"),ELL_ERROR);
}else
state=Attribute;
}break;
case Attribute:
{
if(tag==0){
gLogManager.log(mT("CSettingsFile::loadSettings()")
,mT("No tag while reading attributes!"),ELL_ERROR);
}
if(token->token==Token_Closed_Brace){
tag=0;
state=ReadTag;
}
else
{
attrName = token->lex;
if(tokens->isDone())
{
done=1;
break;
}
attrValue=tokens->getNextToken()->lex;
tag->addAttr(attrName,attrValue);
}
}break;
}
}while(!done);
if(state!=ReadTag)
gLogManager.log(mT("CSettingsFile::loadSettings()")
,mT("Setting file has wrong syntax!"),ELL_ERROR);
}
parser=0;
return true;
}
