void deduplicate(std::vector<Replacement> &Replaces,
std::vector<Range> &Conflicts) {
if (Replaces.empty())
return;
// Deduplicate
std::sort(Replaces.begin(), Replaces.end());
std::vector<Replacement>::iterator End =
std::unique(Replaces.begin(), Replaces.end());
Replaces.erase(End, Replaces.end());
// Detect conflicts
Range ConflictRange(Replaces.front().getOffset(),
Replaces.front().getLength());
unsigned ConflictStart = 0;
unsigned ConflictLength = 1;
for (unsigned i = 1; i < Replaces.size(); ++i) {
Range Current(Replaces[i].getOffset(), Replaces[i].getLength());
if (ConflictRange.overlapsWith(Current)) {
// Extend conflicted range
ConflictRange = Range(ConflictRange.getOffset(),
std::max(ConflictRange.getLength(),
Current.getOffset() + Current.getLength() -
ConflictRange.getOffset()));
++ConflictLength;
} else {
if (ConflictLength > 1)
Conflicts.push_back(Range(ConflictStart, ConflictLength));
ConflictRange = Current;
ConflictStart = i;
ConflictLength = 1;
}
}
if (ConflictLength > 1)
Conflicts.push_back(Range(ConflictStart, ConflictLength));
}
inline void StopWatch::Clear()
{
#if (MFEM_TIMER_TYPE == 0)
user_time = 0;
if (Running)
start_utime = std::clock();
#elif (MFEM_TIMER_TYPE == 1)
real_time = user_time = syst_time = 0;
if (Running)
Current(&start_rtime, &start_utime, &start_stime);
#elif (MFEM_TIMER_TYPE == 2)
real_time.tv_sec = user_time.tv_sec = 0;
real_time.tv_nsec = user_time.tv_nsec = 0;
if (Running)
{
GetRealTime(start_rtime);
GetUserTime(start_utime);
}
#elif (MFEM_TIMER_TYPE == 3)
real_time.QuadPart = 0;
if (Running)
QueryPerformanceCounter(&start_rtime);
#endif
}
/**
* name: OnMenuPopup
* class: CAnnivEditCtrl
* desc: is called to show a popup menu for all anniversaries of a contact
* param: none
* return: nothing
**/
void CAnnivEditCtrl::OnDateChanged(LPNMDATETIMECHANGE lpChange)
{
MAnnivDate *pCurrent = Current();
if (pCurrent && !pCurrent->IsEqual(lpChange->st))
{
HWND hPs = GetParent(_hwndDlg);
// save the new date to the structure
DateTime_SetFormat(_hwndDate, NULL);
pCurrent->Set(lpChange->st, TRUE);
pCurrent->SetFlags(MAnnivDate::MADF_CHANGED|MAnnivDate::MADF_HASCUSTOM);
// notify parent of the change
SendMessage(hPs, PSM_CHANGED, NULL, NULL);
EnableWindow(_hBtnDel, TRUE);
// update the age and zodiac controls on the general propertysheetpage
if (pCurrent->Id() == ANID_BIRTHDAY)
{
SetZodiacAndAge(pCurrent);
}
}
}
eOSState MhpApplicationMenu::ProcessKey(eKeys Key) {
eOSState state = cOsdMenu::ProcessKey(Key);
if(state == osUnknown) {
switch(Key) {
case kOk:
{
cOsdItem *item=Get(Current());
if (typeid(*item) == typeid(MhpApplicationMenuItem)) {
MhpApplicationMenuItem *appitem=static_cast<MhpApplicationMenuItem *>(item);
if (appitem->GetApplication()->GetTransportProtocol()->GetProtocol() == ApplicationInfo::cTransportProtocol::Local) {
Mhp::RunningManager::getManager()->Start(appitem->GetApplication());
} else {
if (GetReceptionState(appitem->GetApplication()->GetService())<=StateNeedsTuning) {
Service::Tunable *tunable=appitem->GetApplication()->GetService()->getTunable();
Service::Tuner *tuner=Service::ServiceManager::getManager()->getTuner(tunable);
if (!tuner || !tuner->Tune(tunable)) {
Skins.Message(mtError, tr("Cannot receive application!"));
return osContinue;
}
Mhp::RunningManager::getManager()->Start(appitem->GetApplication());
return osEnd;
}
}
}
}
case kMenu: return osEnd;
case kRed:
case kGreen:
case kYellow:
case kBlue: return osContinue;
default: break;
}
}
return state;
}
eOSState cMenuSqueezeSetup::ProcessKey(eKeys Key)
{
eOSState state = cMenuSetupPage::ProcessKey(Key);
switch (state)
{
case osContinue:
{
if (NORMALKEY(Key) == kUp || NORMALKEY(Key) == kDown)
{
cOsdItem* item = Get(Current());
if (item)
item->ProcessKey(kNone);
}
break;
}
default: break;
}
return state;
}
inline double StopWatch::RealTime()
{
#if (MFEM_TIMER_TYPE == 0)
return UserTime();
#elif (MFEM_TIMER_TYPE == 1)
clock_t curr_rtime, curr_utime, curr_stime;
clock_t rtime = real_time;
if (Running)
{
Current(&curr_rtime, &curr_utime, &curr_stime);
rtime += (curr_rtime - start_rtime);
}
return (double)(rtime) / my_CLK_TCK;
#elif (MFEM_TIMER_TYPE == 2)
if (Running)
{
struct timespec curr_rtime;
GetRealTime(curr_rtime);
return ((real_time.tv_sec + (curr_rtime.tv_sec - start_rtime.tv_sec)) +
1e-9*(real_time.tv_nsec +
(curr_rtime.tv_nsec - start_rtime.tv_nsec)));
}
else
{
return real_time.tv_sec + 1e-9*real_time.tv_nsec;
}
#elif (MFEM_TIMER_TYPE == 3)
LARGE_INTEGER curr_rtime, rtime = real_time;
if (Running)
{
QueryPerformanceCounter(&curr_rtime);
rtime.QuadPart += (curr_rtime.QuadPart - start_rtime.QuadPart);
}
return (double)(rtime.QuadPart) / frequency.QuadPart;
#endif
}
cCMDDir::cCMDDir(cMainMenu *osdobject, bool select, char *buffer)
:cOsdMenu(tr("Directory Management"), 2, 2)
{
MYDEBUG("Verzeichnis Management Args: cMainMenu %s, select %s, buffer %s ", osdobject?"valid":"null", select?"yes":"no", buffer );
ImageDir(DVDSwitchSetup.ImageDir);
CurrentDir(DVDSwitchSetup.ImageDir); // XXXX
ParentDir(DVDSwitchSetup.ImageDir);
State = csNone;
OsdObject = osdobject;
Select = select;
Buffer = buffer;
SetDir();
if(Select)
SetTitle(tr("Select Directory"));
Build(DVDSwitchSetup.ImageDir);
cMainMenuItem *mItem = (cMainMenuItem*)Get(Current());
if(mItem)
LastSelDir(mItem->FileName());
}
int
set_menu_opts(MENU *m, int opt)
{
ITEM **ip;
if (m) {
if (Posted(m)) {
return (E_POSTED);
}
/* Check to see if the ROWMAJOR option is changing. If so, */
/* set top and current to 0. */
if ((opt & O_ROWMAJOR) != RowMajor(m)) {
Top(m) = 0;
Current(m) = IthItem(m, 0);
(void) set_menu_format(m, FRows(m), FCols(m));
}
/* if O_NONCYCLIC option changed, set bit to re-link items */
if ((opt & O_NONCYCLIC) != (Mopt(m) & O_NONCYCLIC)) {
SetLink(m);
}
Mopt(m) = opt;
if (OneValue(m) && Items(m)) {
for (ip = Items(m); *ip; ip++) {
/* Unset values if selection not allowed. */
Value(*ip) = FALSE;
}
}
_scale(m); /* Redo sizing information */
} else {
Mopt(Dfl_Menu) = opt;
}
return (E_OK);
}
//обработка состояния
bool StateManager::Process(){
Current()->Run();
return true;
}
eOSState cReplayList::ProcessColourKeys(eKeys Key) {
eOSState state = osUnknown;
if (Key==kRed) {
Mode=(eMode) ( ( Mode + 1 ) % eMLast );
return osContinue;
};
switch (lastMode) {
case eMNormal:
switch(Key) {
case kGreen:
// Skip backward, pass to cControl
state= osUnknown;
break;
case kYellow:
// Skip forward, pass to cControl
state= osUnknown;
break;
case kBlue:
// end replay
state= osEnd;
break;
default:
break;
};
break;
case eMEdit:
switch(Key) {
case kGreen:
// add files TODO
state= osContinue;
break;
case kYellow:
// delete Item
MENUDEB("Del current %d: %s\n",
Current(),
playList->GetItemByIndex(Current())->GetName() );
playList->RemoveItem(
playList->GetItemByIndex(Current()));
MENUDEB("Remove finished\n");
Del(Current());
Display();
state=osContinue;
break;
case kBlue:
// move files TODO
hold=true;
origPos=Current();
SetItemStr(Get(Current()),
playList->GetItemByIndex(Current()),
hold);
DisplayCurrent(true);
state= osContinue;
break;
default:
break;
};
break;
case eMOptions:
switch(Key) {
case kGreen:
// call options menu
state = AddSubMenu(
new cPlOptionsMenu(playList));
break;
case kYellow:
// nothing
state= osContinue;
break;
case kBlue:
// save list TODO
state= osContinue;
Softplay->SaveList(playList);
break;
default:
break;
};
break;
default:
break;
};
return state;
};
eOSState cReplayList::ProcessKey(eKeys Key) {
int lastCurrent=Current();
eOSState state = cOsdMenu::ProcessKey(Key);
// fallback to default mode after some time of inactivity
if ( Key!=kNone)
lastModeActivity=time(NULL);
if ( lastMode !=eMNormal &&
time(NULL) - lastModeActivity > 40 ) {
if (hold) {
// break move
hold=false;
SetItemStr(Get(Current()),
playList->GetItemByIndex(Current()),
hold);
Move(Current(),origPos);
playList->GetShuffleIdx()->Move(Current(),
origPos);
SetCurrent(Get(origPos));
Display();
};
Mode=eMNormal;
};
// don't move cursor when it has been moved by the user
// a short while ago or in move item mode
if ( Key==kUp || Key==kDown || Key==kRight || Key==kLeft )
lastActivity=time(NULL);
if (Current() != playList->GetCurrIdx() &&
time(NULL) - lastActivity > 40
&& !hold ) {
MENUDEB("SetCurrent current title %d time %d lastActivity %d\n",
playList->GetCurrIdx(),int(time(NULL)),int(lastActivity));
SetCurrent(Get(playList->GetCurrIdx()));
Display();
};
// handle move item mode
if ( lastMode == eMEdit && hold ) {
// moves
if ( (Key==kUp || Key==kDown|| Key==kRight || Key==kLeft) ) {
Move(lastCurrent,Current());
playList->GetShuffleIdx()->Move(lastCurrent,Current());
Display();
};
// end move
switch(Key) {
case kBack:
case kRed:
case kGreen:
case kYellow:
// break Move
hold=false;
SetItemStr(Get(Current()),
playList->GetItemByIndex(Current()),
hold);
Move(Current(),origPos);
playList->GetShuffleIdx()->Move(Current(),
origPos);
SetCurrent(Get(origPos));
Display();
Key=kNone;
state= osContinue;
break;
case kOk:
case kBlue:
// finish move
hold=false;
SetItemStr(Get(Current()),
playList->GetItemByIndex(Current()),
hold);
DisplayCurrent(true);
state= osContinue;
break;
default:
break;
}
};
// handle new items or removed items
if ( lastListItemCount != playList->GetNIdx()
|| playList->IsDirty() ) {
Clear();
RebuildList();
Display();
};
if (state != osUnknown )
return state;
switch (Key) {
case kOk:
// skip to current track
playList->SetCurrIdx( Current() );
state = PLAY_CURR_FILE;
// want to have automatic track change
lastActivity=time(NULL)-300;
break;
case kBack:
state= osBack;
break;
default:
break;
};
if ( Key >= kRed && Key <= kBlue)
state=ProcessColourKeys(Key);
if (!HasSubMenu())
UpdateStatus();
if ( Mode != lastMode )
UpdateHelp();
return state;
}
void CShaderTools::RealUpdateProperties()
{
Current()->RealUpdateProperties();
m_Flags.set(flRefreshProps,FALSE);
}
void SnapShot::InitializeForSnapshotCompare(const SnapShot* snap1, const SnapShot* snap2, TTDCompareMap& compareMap)
{
////
//Initialize all of the maps
//top-level functions
for(auto iter = snap1->m_ctxList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapValues::SnapContext* ctx = iter.Current();
for(uint32 i = 0; i < ctx->m_loadedTopLevelScriptCount; ++i)
{
compareMap.H1FunctionTopLevelLoadMap.AddNew(ctx->m_loadedTopLevelScriptArray[i].ContextSpecificBodyPtrId, ctx->m_loadedTopLevelScriptArray[i].TopLevelBodyCtr);
}
for(uint32 i = 0; i < ctx->m_newFunctionTopLevelScriptCount; ++i)
{
compareMap.H1FunctionTopLevelNewMap.AddNew(ctx->m_newFunctionTopLevelScriptArray[i].ContextSpecificBodyPtrId, ctx->m_newFunctionTopLevelScriptArray[i].TopLevelBodyCtr);
}
for(uint32 i = 0; i < ctx->m_evalTopLevelScriptCount; ++i)
{
compareMap.H1FunctionTopLevelEvalMap.AddNew(ctx->m_evalTopLevelScriptArray[i].ContextSpecificBodyPtrId, ctx->m_evalTopLevelScriptArray[i].TopLevelBodyCtr);
}
}
for(auto iter = snap2->m_ctxList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapValues::SnapContext* ctx = iter.Current();
for(uint32 i = 0; i < ctx->m_loadedTopLevelScriptCount; ++i)
{
compareMap.H2FunctionTopLevelLoadMap.AddNew(ctx->m_loadedTopLevelScriptArray[i].ContextSpecificBodyPtrId, ctx->m_loadedTopLevelScriptArray[i].TopLevelBodyCtr);
}
for(uint32 i = 0; i < ctx->m_newFunctionTopLevelScriptCount; ++i)
{
compareMap.H2FunctionTopLevelNewMap.AddNew(ctx->m_newFunctionTopLevelScriptArray[i].ContextSpecificBodyPtrId, ctx->m_newFunctionTopLevelScriptArray[i].TopLevelBodyCtr);
}
for(uint32 i = 0; i < ctx->m_evalTopLevelScriptCount; ++i)
{
compareMap.H2FunctionTopLevelEvalMap.AddNew(ctx->m_evalTopLevelScriptArray[i].ContextSpecificBodyPtrId, ctx->m_evalTopLevelScriptArray[i].TopLevelBodyCtr);
}
}
//Values and things
for(auto iter = snap1->m_primitiveObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H1ValueMap.AddNew(iter.Current()->PrimitiveValueId, iter.Current());
}
for(auto iter = snap2->m_primitiveObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H2ValueMap.AddNew(iter.Current()->PrimitiveValueId, iter.Current());
}
for(auto iter = snap1->m_slotArrayEntries.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H1SlotArrayMap.AddNew(iter.Current()->SlotId, iter.Current());
}
for(auto iter = snap2->m_slotArrayEntries.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H2SlotArrayMap.AddNew(iter.Current()->SlotId, iter.Current());
}
for(auto iter = snap1->m_scopeEntries.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H1FunctionScopeInfoMap.AddNew(iter.Current()->ScopeId, iter.Current());
}
for(auto iter = snap2->m_scopeEntries.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H2FunctionScopeInfoMap.AddNew(iter.Current()->ScopeId, iter.Current());
}
//Bodies and objects
for(auto iter = snap1->m_functionBodyList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H1FunctionBodyMap.AddNew(iter.Current()->FunctionBodyId, iter.Current());
}
for(auto iter = snap2->m_functionBodyList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H2FunctionBodyMap.AddNew(iter.Current()->FunctionBodyId, iter.Current());
}
for(auto iter = snap1->m_compoundObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H1ObjectMap.AddNew(iter.Current()->ObjectPtrId, iter.Current());
}
for(auto iter = snap2->m_compoundObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
compareMap.H2ObjectMap.AddNew(iter.Current()->ObjectPtrId, iter.Current());
}
}
virtual uint32_t Playlist(int count) const { return Current(); };
const std::string* operator->() const
{
return &Current();
}
base::Observable<void> &AuthSession::CurrentDownloaderTaskFinished() {
return Current().downloader().taskFinished();
}
void CoroutineService::_update(Object* arg){
CoroutineService* self =static_cast< CoroutineService* >(Current());
self->update(DateTime::Now());
}
void CShaderTools::RealUpdateList()
{
Current()->RealUpdateList();
m_Flags.set(flRefreshList,FALSE);
}
eOSState cCMDDir::ProcessKey(eKeys Key)
{
cMainMenuItem *mItem = NULL;
cDirHandling *DirHand = NULL;
cFileInfo *info = NULL;
if(!HasSubMenu())
{
switch(State)
{
case csNone:
mItem = (cMainMenuItem*)Get(Current());
switch(Key)
{
case kUp:
case kUp|k_Repeat:
case kDown:
case kDown|k_Repeat:
cOsdMenu::ProcessKey(Key);
SetHelp();
mItem = (cMainMenuItem*)Get(Current());
if(mItem)
LastSelDir(mItem->FileName());
return osContinue;
break;
case kOk:
{
if (!mItem)
return osBack;
info = new cFileInfo(mItem->FileName());
if(!info->isExecutable() || !info->isReadable())
{
MYDEBUG("Verzeichniswechsel: Keine Rechte");
DELETENULL(info);
OSD_ERRMSG(tr("no Rights!"));
return osContinue;
break;
}
DELETENULL(info);
DirHand = new cDirHandling(this, this);
DirHand->ProcessKey(mItem);
delete(DirHand);
Build();
}
break;
case kRed:
if(mItem->Type() == iDir)
return Edit(mItem);
break;
case kGreen:
return New();
break;
case kYellow:
if(mItem->Type() == iDir && Interface->Confirm(tr("really delete?")))
{
MYDEBUG("Verzeichnis l�schen");
if(cFileCMD::DirIsEmpty(mItem->FileName()) ||
(!cFileCMD::DirIsEmpty(mItem->FileName()) && Interface->Confirm(tr("Directory not empty. however delete?"))))
{
cFileDelThread *del = new cFileDelThread(mItem->FileName());
if(del && del->OK())
{
MYDEBUG("Verzeichnis l�schen gestartet");
del->Start();
Build();
OsdObject->SetState(mmsReInit);
}
else
DELETENULL(del);
}
return osContinue;
}
break;
case kBlue:
if(mItem->Type() == iDir)
{
if(Select)
{
MYDEBUG("Verzeichnis gew�hlt: %s", mItem->FileName());
info = new cFileInfo(mItem->FileName());
if(!info->isExecutable() || !info->isReadable())
{
MYDEBUG("Verzeichnis: Keine Rechte");
OSD_ERRMSG(tr("no rights!"));
}
else
{
char *seldir = mItem->FileName();
for (unsigned int i = 0; i < strlen(DVDSwitchSetup.ImageDir); i++)
seldir++;
if(seldir[0] == '/')
seldir++;
strn0cpy((char*)Buffer, seldir, MaxFileName);
cRemote::Put(kBack);
}
DELETENULL(info);
return osContinue;
}
else
return AddSubMenu(new cCMDMove(mItem->FileName(), OsdObject));
}
break;
default:
break;
}
break;
case csDirNew:
return New(Key);
break;
case csDirEdit:
return Edit(Key);
break;
default:
break;
}
}
eOSState ret = cOsdMenu::ProcessKey(Key);
if(!HasSubMenu() && Key == kBlue && ret == osContinue)
{
if((cMainMenuItem*)Get(Current() + 1))
mItem = (cMainMenuItem*)Get(Current() + 1);
else
mItem = (cMainMenuItem*)Get(Current() - 1);
if(mItem)
LastSelDir(mItem->FileName());
Build();
}
return ret;
}
eOSState cCMDMenu::ProcessKey(eKeys Key)
{
eOSState ret = osUnknown;
if(!HasSubMenu())
{
cCMDImage *CMDImage = NULL;
cOsdItem *item = NULL;
eCMDs cmd = cmdNone;
std::string scmd;
//int current = Current(); // remove
switch(Key)
{
case kOk:
item = Get(Current());
if(strstr(item->Text(),tr("Directory management")))
cmd = cmdDirManage;
if(strstr(item->Text(),tr("Burn image")))
cmd = cmdImgBurn;
if(strstr(item->Text(),tr("Open DVD-tray")))
cmd = cmdDVDopen;
if(strstr(item->Text(),tr("Close DVD-tray")))
cmd = cmdDVDclose;
/*
if(strstr(item->Text(),tr("Play")))
cmd = cmdImgPlay;
*/
if(strstr(item->Text(),tr("Rename image")))
cmd = cmdImgRename;
if(strstr(item->Text(),tr("Delete cache")))
cmd = cmdDeleteCache;
if(strstr(item->Text(),tr("Format DVD-RW")))
cmd = cmdDVDRWFormat;
/*
if(strstr(item->Text(),tr("Image move")))
cmd = cmdImgMove;
if(strstr(item->Text(),tr("Image delete")))
cmd = cmdImgDelete;
if(strstr(item->Text(),tr("Image burn")))
cmd = cmdImgBurn;
if(strstr(item->Text(),tr("DVD reading")))
cmd = cmdImgRead;
*/
switch(cmd)
{
case cmdDirManage:
return AddSubMenu(new cCMDDir(OsdObject));
break;
case cmdImgBurn:
CMDImage = new cCMDImage(OsdObject);
ret = CMDImage->Burn(iItem->FileName());
DELETENULL(CMDImage);
return ret;
break;
case cmdDVDopen:
return cCMD::Eject(false);
break;
case cmdDVDclose:
return cCMD::Eject(true);
break;
case cmdImgPlay:
return cCMD::Play(iItem);
break;
case cmdImgRename:
OsdObject->SetState(mmsImgRename);
item = OsdObject->Get(OsdObject->Current());
item->ProcessKey(kRight);
return osBack;
break;
case cmdImgMove:
return AddSubMenu(new cCMDMove(iItem->FileName(), OsdObject, false));
break;
case cmdImgDelete:
CMDImage = new cCMDImage(OsdObject);
ret = CMDImage->Delete(iItem->FileName());
DELETENULL(CMDImage);
return ret;
break;
case cmdDeleteCache:
scmd = "/usr/bin/sudo rm -f /etc/vdr/DVD.db";
system(scmd.c_str());
Skins.Message(mtInfo,tr("Success..."));
break;
case cmdImgRead:
/* MARKUS */
//DvdRead();
//return osBack;
return AddSubMenu(new cCMDImageRead);
break;
case cmdDVDRWFormat:
SystemExec("/usr/sbin/dvd-rw-format.sh");
////Skins.Message(mtInfo, tr("Formating started"));
break;
default:
break;
}
break;
default:
break;
}
}
return cOsdMenu::ProcessKey(Key);
}
const std::string& operator*() const
{
return Current();
}
void SnapShot::EmitSnapshotToFile(FileWriter* writer, ThreadContext* threadContext) const
{
TTDTimer timer;
double startWrite = timer.Now();
writer->WriteRecordStart();
writer->AdjustIndent(1);
uint64 usedSpace = 0;
uint64 reservedSpace = 0;
this->ComputeSnapshotMemory(&usedSpace, &reservedSpace);
writer->WriteDouble(NSTokens::Key::timeTotal, this->MarkTime + this->ExtractTime);
writer->WriteUInt64(NSTokens::Key::usedMemory, usedSpace, NSTokens::Separator::CommaSeparator);
writer->WriteUInt64(NSTokens::Key::reservedMemory, reservedSpace, NSTokens::Separator::CommaSeparator);
writer->WriteDouble(NSTokens::Key::timeMark, this->MarkTime, NSTokens::Separator::CommaSeparator);
writer->WriteDouble(NSTokens::Key::timeExtract, this->ExtractTime, NSTokens::Separator::CommaSeparator);
writer->WriteLengthValue(this->m_ctxList.Count(), NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->WriteSequenceStart_DefaultKey(NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->AdjustIndent(1);
bool firstCtx = true;
for(auto iter = this->m_ctxList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
NSSnapValues::EmitSnapContext(iter.Current(), writer, firstCtx ? NSTokens::Separator::BigSpaceSeparator : NSTokens::Separator::CommaAndBigSpaceSeparator);
firstCtx = false;
}
writer->AdjustIndent(-1);
writer->WriteSequenceEnd(NSTokens::Separator::BigSpaceSeparator);
////
SnapShot::EmitListHelper(&NSSnapType::EmitSnapHandler, this->m_handlerList, writer);
SnapShot::EmitListHelper(&NSSnapType::EmitSnapType, this->m_typeList, writer);
////
writer->WriteLengthValue(this->m_functionBodyList.Count(), NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->WriteSequenceStart_DefaultKey(NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->AdjustIndent(1);
bool firstBody = true;
for(auto iter = this->m_functionBodyList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
NSSnapValues::EmitFunctionBodyInfo(iter.Current(), writer, firstBody ? NSTokens::Separator::BigSpaceSeparator : NSTokens::Separator::CommaAndBigSpaceSeparator);
firstBody = false;
}
writer->AdjustIndent(-1);
writer->WriteSequenceEnd(NSTokens::Separator::BigSpaceSeparator);
SnapShot::EmitListHelper(&NSSnapValues::EmitSnapPrimitiveValue, this->m_primitiveObjectList, writer);
writer->WriteLengthValue(this->m_compoundObjectList.Count(), NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->WriteSequenceStart_DefaultKey(NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->AdjustIndent(1);
bool firstObj = true;
for(auto iter = this->m_compoundObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
NSSnapObjects::EmitObject(iter.Current(), writer, firstObj ? NSTokens::Separator::BigSpaceSeparator : NSTokens::Separator::CommaAndBigSpaceSeparator, this->m_snapObjectVTableArray, threadContext);
firstObj = false;
}
writer->AdjustIndent(-1);
writer->WriteSequenceEnd(NSTokens::Separator::BigSpaceSeparator);
////
SnapShot::EmitListHelper(&NSSnapValues::EmitScriptFunctionScopeInfo, this->m_scopeEntries, writer);
SnapShot::EmitListHelper(&NSSnapValues::EmitSlotArrayInfo, this->m_slotArrayEntries, writer);
////
double almostEndWrite = timer.Now();
writer->WriteDouble(NSTokens::Key::timeWrite, (almostEndWrite - startWrite) / 1000.0, NSTokens::Separator::CommaAndBigSpaceSeparator);
writer->AdjustIndent(-1);
writer->WriteRecordEnd(NSTokens::Separator::BigSpaceSeparator);
}
void Shader::Change(const String& name)
{
Current() = &Instance().m_effects.at(name);
}
void CShaderTools::Modified()
{
Current()->Modified();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
const HssScanFrame* HssScanListIterator::Next()
{
current_m += HssScanList::AddPadding( Size() );
return Current();
}
bool Shader::IsCached(const String& name)
{
return Current()->variable.find(name) != Current()->variable.end();
}
void SnapShot::Inflate(InflateMap* inflator, const NSSnapValues::SnapContext* sCtx) const
{
//We assume the caller has inflated all of the ScriptContexts for us and we are just filling in the objects
////
//set the map from all function body ids to their snap representations
TTDIdentifierDictionary<TTD_PTR_ID, NSSnapValues::FunctionBodyResolveInfo*> idToSnpBodyMap;
idToSnpBodyMap.Initialize(this->m_functionBodyList.Count());
for(auto iter = this->m_functionBodyList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
idToSnpBodyMap.AddItem(iter.Current()->FunctionBodyId, iter.Current());
}
//set the map from all compound object ids to their snap representations
TTDIdentifierDictionary<TTD_PTR_ID, NSSnapObjects::SnapObject*> idToSnpObjectMap;
idToSnpObjectMap.Initialize(this->m_compoundObjectList.Count());
for(auto iter = this->m_compoundObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
idToSnpObjectMap.AddItem(iter.Current()->ObjectPtrId, iter.Current());
}
////
//inflate all the function bodies
for(auto iter = this->m_functionBodyList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapValues::FunctionBodyResolveInfo* fbInfo = iter.Current();
NSSnapValues::InflateFunctionBody(fbInfo, inflator, idToSnpBodyMap);
}
//inflate all the primitive objects
for(auto iter = this->m_primitiveObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapValues::SnapPrimitiveValue* pSnap = iter.Current();
NSSnapValues::InflateSnapPrimitiveValue(pSnap, inflator);
}
//inflate all the regular objects
for(auto iter = this->m_compoundObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapObjects::SnapObject* sObj = iter.Current();
this->InflateSingleObject(sObj, inflator, idToSnpObjectMap);
}
//take care of all the slot arrays
for(auto iter = this->m_slotArrayEntries.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapValues::SlotArrayInfo* sai = iter.Current();
Js::Var* slots = NSSnapValues::InflateSlotArrayInfo(sai, inflator);
inflator->AddSlotArray(sai->SlotId, slots);
}
//and the scope entries
for(auto iter = this->m_scopeEntries.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapValues::ScriptFunctionScopeInfo* sfsi = iter.Current();
Js::FrameDisplay* frame = NSSnapValues::InflateScriptFunctionScopeInfo(sfsi, inflator);
inflator->AddEnvironment(sfsi->ScopeId, frame);
}
//Link up the object pointers
for(auto iter = this->m_compoundObjectList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
const NSSnapObjects::SnapObject* sobj = iter.Current();
Js::RecyclableObject* iobj = inflator->LookupObject(sobj->ObjectPtrId);
NSSnapObjects::fPtr_DoAddtlValueInstantiation addtlInstFPtr = this->m_snapObjectVTableArray[(uint32)sobj->SnapObjectTag].AddtlInstationationFunc;
if(addtlInstFPtr != nullptr)
{
addtlInstFPtr(sobj, iobj, inflator);
}
if(Js::DynamicType::Is(sobj->SnapType->JsTypeId))
{
NSSnapObjects::StdPropertyRestore(sobj, Js::DynamicObject::FromVar(iobj), inflator);
}
}
Js::ScriptContext* tCtx = inflator->LookupScriptContext(sCtx->m_scriptContextLogId);
NSSnapValues::ReLinkRoots(sCtx, tCtx, inflator);
}
ID3DX11EffectVariable* Shader::Cache(const String& name)
{
return Current()->variable.at(name);
}
SnapShot* SnapShot::ParseSnapshotFromFile(FileReader* reader)
{
reader->ReadRecordStart();
reader->ReadDouble(NSTokens::Key::timeTotal);
reader->ReadUInt64(NSTokens::Key::usedMemory, true);
reader->ReadUInt64(NSTokens::Key::reservedMemory, true);
reader->ReadDouble(NSTokens::Key::timeMark, true);
reader->ReadDouble(NSTokens::Key::timeExtract, true);
SnapShot* snap = HeapNew(SnapShot);
uint32 ctxCount = reader->ReadLengthValue(true);
reader->ReadSequenceStart_WDefaultKey(true);
for(uint32 i = 0; i < ctxCount; ++i)
{
NSSnapValues::SnapContext* snpCtx = snap->m_ctxList.NextOpenEntry();
NSSnapValues::ParseSnapContext(snpCtx, i != 0, reader, snap->GetSnapshotSlabAllocator());
}
reader->ReadSequenceEnd();
////
SnapShot::ParseListHelper(&NSSnapType::ParseSnapHandler, snap->m_handlerList, reader, snap->GetSnapshotSlabAllocator());
TTDIdentifierDictionary<TTD_PTR_ID, NSSnapType::SnapHandler*> handlerMap;
handlerMap.Initialize(snap->m_handlerList.Count());
for(auto iter = snap->m_handlerList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
handlerMap.AddItem(iter.Current()->HandlerId, iter.Current());
}
SnapShot::ParseListHelper_WMap(&NSSnapType::ParseSnapType, snap->m_typeList, reader, snap->GetSnapshotSlabAllocator(), handlerMap);
TTDIdentifierDictionary<TTD_PTR_ID, NSSnapType::SnapType*> typeMap;
typeMap.Initialize(snap->m_typeList.Count());
for(auto iter = snap->m_typeList.GetIterator(); iter.IsValid(); iter.MoveNext())
{
typeMap.AddItem(iter.Current()->TypePtrId, iter.Current());
}
////
uint32 bodyCount = reader->ReadLengthValue(true);
reader->ReadSequenceStart_WDefaultKey(true);
for(uint32 i = 0; i < bodyCount; ++i)
{
NSSnapValues::FunctionBodyResolveInfo* into = snap->m_functionBodyList.NextOpenEntry();
NSSnapValues::ParseFunctionBodyInfo(into, i != 0, reader, snap->GetSnapshotSlabAllocator());
}
reader->ReadSequenceEnd();
SnapShot::ParseListHelper_WMap(&NSSnapValues::ParseSnapPrimitiveValue, snap->m_primitiveObjectList, reader, snap->GetSnapshotSlabAllocator(), typeMap);
uint32 objCount = reader->ReadLengthValue(true);
reader->ReadSequenceStart_WDefaultKey(true);
for(uint32 i = 0; i < objCount; ++i)
{
NSSnapObjects::SnapObject* into = snap->m_compoundObjectList.NextOpenEntry();
NSSnapObjects::ParseObject(into, i != 0, reader, snap->GetSnapshotSlabAllocator(), snap->m_snapObjectVTableArray, typeMap);
}
reader->ReadSequenceEnd();
////
SnapShot::ParseListHelper(&NSSnapValues::ParseScriptFunctionScopeInfo, snap->m_scopeEntries, reader, snap->GetSnapshotSlabAllocator());
SnapShot::ParseListHelper(&NSSnapValues::ParseSlotArrayInfo, snap->m_slotArrayEntries, reader, snap->GetSnapshotSlabAllocator());
reader->ReadDouble(NSTokens::Key::timeWrite, true);
reader->ReadRecordEnd();
return snap;
}
void EatSpace()
{
while (index < length && IsSpace(Current())) Advance();
}
