nsresult
StorageCache::GetKey(const Storage* aStorage, uint32_t aIndex,
nsAString& aRetval)
{
// XXX: This does a linear search for the key at index, which would
// suck if there's a large numer of indexes. Do we care? If so,
// maybe we need to have a lazily populated key array here or
// something?
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETKEY_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
aRetval.SetIsVoid(true);
for (auto iter = DataSet(aStorage).mKeys.Iter(); !iter.Done(); iter.Next()) {
if (aIndex == 0) {
aRetval = iter.Key();
break;
}
aIndex--;
}
return NS_OK;
}
nsresult
StorageCache::RemoveItem(const Storage* aStorage, const nsAString& aKey,
nsString& aOld, const MutationSource aSource)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_REMOVEKEY_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
return NS_SUCCESS_DOM_NO_OPERATION;
}
// Recalculate the cached data size
const int64_t delta = -(static_cast<int64_t>(aOld.Length()) +
static_cast<int64_t>(aKey.Length()));
Unused << ProcessUsageDelta(aStorage, delta, aSource);
data.mKeys.Remove(aKey);
if (aSource == ContentMutation && Persist(aStorage)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
return sDatabase->AsyncRemoveItem(this, aKey);
}
return NS_OK;
}
/*--------------------------------------------------------------------------*/
PegMenuButton::PegMenuButton(PegMenuDescription *pDesc) :
PegThing(pDesc->wId, pDesc->wStyle),
PegTextThing(pDesc->wStyle, PEG_MENU_FONT)
{
mReal.Set(0, 0, 100, 18);
mClient.Set(0, 0, 100, 18);
Type(TYPE_MENU_BUTTON);
muColors[PCI_NORMAL] = PCLR_BUTTON_FACE;
DataSet(pDesc->pText);
mpOwner = NULL;
if (pDesc->pSubMenu)
{
mpSubMenu = new PegMenu(pDesc->pSubMenu);
}
else
{
mpSubMenu = NULL;
if (pDesc->wStyle & BF_DOTABLE)
{
SetSignals(SIGMASK(PSF_DOT_ON));
}
else
{
if (pDesc->wStyle & BF_CHECKABLE)
{
SetSignals(SIGMASK(PSF_CHECK_ON)|SIGMASK(PSF_CHECK_OFF));
}
else
{
if (pDesc->wStyle & AF_ENABLED)
{
SetSignals(SIGMASK(PSF_CLICKED));
}
else
{
RemoveStatus(PSF_SELECTABLE);
}
}
}
}
AddStatus(PSF_SIZEABLE | PSF_NONCLIENT);
RemoveStatus(PSF_ACCEPTS_FOCUS);
muColors[PCI_NORMAL] = PCLR_BUTTON_FACE;
muColors[PCI_SELECTED] = PCLR_ACTIVE_TITLE;
muColors[PCI_NTEXT] = PCLR_NORMAL_TEXT;
muColors[PCI_STEXT] = PCLR_HIGH_TEXT;
mbPointerOver = FALSE;
mbSubVisible = FALSE;
}
nsresult
LocalStorageCache::SetItem(const LocalStorage* aStorage, const nsAString& aKey,
const nsString& aValue, nsString& aOld,
const MutationSource aSource)
{
// Size of the cache that will change after this action.
int64_t delta = 0;
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_SETVALUE_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
// We only consider key size if the key doesn't exist before.
delta += static_cast<int64_t>(aKey.Length());
}
delta += static_cast<int64_t>(aValue.Length()) -
static_cast<int64_t>(aOld.Length());
if (!ProcessUsageDelta(aStorage, delta, aSource)) {
return NS_ERROR_DOM_QUOTA_REACHED;
}
if (aValue == aOld && DOMStringIsNull(aValue) == DOMStringIsNull(aOld)) {
return NS_SUCCESS_DOM_NO_OPERATION;
}
data.mKeys.Put(aKey, aValue);
if (aSource == ContentMutation && Persist(aStorage)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
if (DOMStringIsNull(aOld)) {
return sDatabase->AsyncAddItem(this, aKey, aValue);
}
return sDatabase->AsyncUpdateItem(this, aKey, aValue);
}
return NS_OK;
}
void
DOMStorageCache::GetKeys(const DOMStorage* aStorage, nsTArray<nsString>& aKeys)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETALLKEYS_BLOCKING_MS);
}
if (NS_FAILED(mLoadResult)) {
return;
}
DataSet(aStorage).mKeys.EnumerateRead(KeysArrayBuilder, &aKeys);
}
nsresult
DOMStorageCache::GetLength(const DOMStorage* aStorage, uint32_t* aRetval)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETLENGTH_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
*aRetval = DataSet(aStorage).mKeys.Count();
return NS_OK;
}
void
DOMStorageCache::GetKeys(const DOMStorage* aStorage, nsTArray<nsString>& aKeys)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETALLKEYS_BLOCKING_MS);
}
if (NS_FAILED(mLoadResult)) {
return;
}
for (auto iter = DataSet(aStorage).mKeys.Iter(); !iter.Done(); iter.Next()) {
aKeys.AppendElement(iter.Key());
}
}
nsTArray<nsString>*
DOMStorageCache::GetKeys(const DOMStorage* aStorage)
{
Telemetry::AutoTimer<Telemetry::LOCALDOMSTORAGE_GETALLKEYS_MS> autoTimer;
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETALLKEYS_BLOCKING_MS);
}
nsTArray<nsString>* result = new nsTArray<nsString>();
if (NS_SUCCEEDED(mLoadResult)) {
DataSet(aStorage).mKeys.EnumerateRead(KeysArrayBuilder, result);
}
return result;
}
DataSet DataSet::readTADMDataSet(istream &iss)
{
string line;
ContextVector contexts;
while (iss)
{
// Would really like to avoid reading the context here,
// so try to detect EOF.
if (iss.peek() == EOF)
break;
contexts.push_back(readContext(iss));
}
return DataSet(contexts);
}
nsresult
DOMStorageCache::SetItem(const DOMStorage* aStorage, const nsAString& aKey,
const nsString& aValue, nsString& aOld)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_SETVALUE_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
}
// Check the quota first
const int64_t delta = static_cast<int64_t>(aValue.Length()) -
static_cast<int64_t>(aOld.Length());
if (!ProcessUsageDelta(aStorage, delta)) {
return NS_ERROR_DOM_QUOTA_REACHED;
}
if (aValue == aOld && DOMStringIsNull(aValue) == DOMStringIsNull(aOld)) {
return NS_SUCCESS_DOM_NO_OPERATION;
}
data.mKeys.Put(aKey, aValue);
if (Persist(aStorage)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
if (DOMStringIsNull(aOld)) {
return sDatabase->AsyncAddItem(this, aKey, aValue);
}
return sDatabase->AsyncUpdateItem(this, aKey, aValue);
}
return NS_OK;
}
nsresult
DOMStorageCache::GetKey(const DOMStorage* aStorage, uint32_t aIndex, nsAString& aRetval)
{
// XXX: This does a linear search for the key at index, which would
// suck if there's a large numer of indexes. Do we care? If so,
// maybe we need to have a lazily populated key array here or
// something?
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETKEY_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
IndexFinderData data(aIndex, aRetval);
DataSet(aStorage).mKeys.EnumerateRead(FindKeyOrder, &data);
return NS_OK;
}
nsresult
DOMStorageCache::GetItem(const DOMStorage* aStorage, const nsAString& aKey,
nsAString& aRetval)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_GETVALUE_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
// not using AutoString since we don't want to copy buffer to result
nsString value;
if (!DataSet(aStorage).mKeys.Get(aKey, &value)) {
SetDOMStringToNull(value);
}
aRetval = value;
return NS_OK;
}
nsresult
LocalStorageCache::Clear(const LocalStorage* aStorage,
const MutationSource aSource)
{
bool refresh = false;
if (Persist(aStorage)) {
// We need to preload all data (know the size) before we can proceeed
// to correctly decrease cached usage number.
// XXX as in case of unload, this is not technically needed now, but
// after super-scope quota introduction we have to do this. Get telemetry
// right now.
WaitForPreload(Telemetry::LOCALDOMSTORAGE_CLEAR_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
// When we failed to load data from the database, force delete of the
// scope data and make use of the storage possible again.
refresh = true;
mLoadResult = NS_OK;
}
}
Data& data = DataSet(aStorage);
bool hadData = !!data.mKeys.Count();
if (hadData) {
Unused << ProcessUsageDelta(aStorage, -data.mOriginQuotaUsage, aSource);
data.mKeys.Clear();
}
if (aSource == ContentMutation && Persist(aStorage) && (refresh || hadData)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
return sDatabase->AsyncClear(this);
}
return hadData ? NS_OK : NS_SUCCESS_DOM_NO_OPERATION;
}
int main(int argc, char *argv[])
{
srand (time(NULL));
//kepek egyszeges meretenek beallitasa
int size = 25;
//a halo retegeinek es ezek mereteinek beallitasa
std::vector<int> array2(2);
array2[0] = size*size;
array2[1] = 43;
//az adatok betoltese
DataSet d = DataSet();
QString path = "../../TestLearning";
d.LoadData(size,path);
std::cout<< "Learning started" <<std::endl;
//a halo letrehozasa
Network net(array2);
//tanulas megkezdese
net.SGD(d,300,30,3,d);
std::cout<< "Learning finished" <<std::endl;
}
/*--------------------------------------------------------------------------*/
void PegTextBox::RewindDataSet(const PEGCHAR *Text)
{
miTopLine = 0;
DataSet(Text);
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isAlt,int isload) {
switch ( x.type ) {
case o_phrase:
//Добавляем в список ошибок(выводим сообщение)
//ошибку и адресс где это случилось
//QueueMark(Q_jumps, cmd.ea);
case o_void:
case o_reg:
break;
case o_sr:
case o_displ:
//Установить для данного байта признак immedia
doImmd(cmd.ea);
//Получить флаг для указанного линейного адресса
if ( !isAlt ) {
uint32 offb;
ushort addr = ushort(x.addr);
if ( x.type == o_displ ) {
addr += (ushort)cmd.ip;
addr += cmd.size;
//Получить линейный адресс
offb = (uint32)toEA(codeSeg(addr,x.n), 0);
DataSet(x, offb+addr, isload);
} else if ( isOff(uFlag, x.n) ) {
reref:
ua_add_off_drefs2(x, dr_O, x.type == o_displ ? OOF_ADDR : 0);
if ( x.type == o_displ )
//Преобразовать данные по указанному линейному адрессу в указанный тип
ua_dodata2(x.offb, calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr), x.dtyp);
} else if ( x.type == o_displ && !x.reg && !isDefArg(uFlag, x.n ) &&
set_offset(cmd.ea, x.n, toEA(cmd.cs,0))) goto reref;
}
break;
case o_stk:
case o_imm:
{
//Установить для данного байта признак immedia
doImmd(cmd.ea);
if ( isOff(get_flags_novalue(cmd.ea), x.n) )
ua_add_off_drefs2(x, dr_O, 0);
}
break;
case o_ab:
{
if ( x.TypeOper == TAB_INDIRECTED_ABS_X )
{
ea_t ea = toEA(cmd.cs, x.addr);
ua_dodata2(x.offb, ea, dt_word);
//добавить крос референсы для текущей инструкции
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
//получить данные
uint32 Addr;
Addr = get_word(ea);
Addr = uint32( Addr | (getPG<<16));
//добавить крос референсы для текущей инструкции
ua_add_cref(2, Addr, fl_JF);
}
else
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
}
break;
case o_mem:
{
// Конвертирование в данные(указан адресс) по указанному типу,
//добавить крос референсы для текущей инструкции
switch ( x.TypeOper )
{
case TDIR_DIR_Y:
case TDIR_DIR_X:
case TDIR_DIR:
case TDIR_INDIRECT_DIR:
case TDIR_INDIRECT_DIR_X:
case TDIR_INDIRECT_DIR_Y:
case TDIR_L_INDIRECT_DIR:
case TDIR_L_INDIRECT_DIR_Y:
{
if ( getDPReg == 1 )
{
uint32 d = x.addr & 0xC;
x.addr &= 0xFF3F;
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
x.addr |=d;
}
else
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
}
break;
default:
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
}//end switch
}
break;
case o_near:
{
//Получить линейный адресс
ea_t ea = toEA(cmd.cs, x.addr);
switch ( cmd.itype )
{
case m7900_jsr:
{
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, fl_CN );
if ( !func_does_return(ea) )
flow = false;
}
break;
case m7900_jsrl:
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, fl_CF);
if ( !func_does_return(ea) )
flow = false;
break;
case m7900_jmpl:
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, fl_JF);
break;
default:
ua_add_cref(x.offb, ea, fl_JN);
break;
}
}
break;
default:
// warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
void WaveformAnalysisExample(string cUserFileName, string cUserSignalType="-"){
gROOT->ProcessLine(".x BuildFastFrameLibrary.cpp");
// get data
TFastFrame DataSet(cUserFileName);
cout << DataSet.GetFrameCount() << " frames in data set" << endl;
// define analysis result storage
std::vector<Double_t> fSigWidths; // vector for signal widths
fSigWidths.reserve(DataSet.GetFrameCount());
std::vector<Double_t> fSigAmplitudes; // vector for signal amplitudes
fSigAmplitudes.reserve(DataSet.GetFrameCount());
std::vector<Double_t> fSigWidthsFiltered; // vector for filtered signal widths
fSigWidthsFiltered.reserve(DataSet.GetFrameCount());
std::vector<Double_t> fSigAmplitudesFiltered; // vector for filtered signal amplitudes
fSigAmplitudesFiltered.reserve(DataSet.GetFrameCount());
// define analysis parameters
const Double_t fWidthLevel = 0.5;
for(Int_t nIndex=0; nIndex<DataSet.GetFrameCount(); nIndex++){ // begin of loop over all recorded frames
TWaveform CurrentFrame = DataSet.GetWaveform(nIndex);
if(CurrentFrame.IsZombie())
continue;
//CurrentFrame.ScaleTimestamps(1.0e9); // change from s to ns
CurrentFrame.ShiftBaseline(CurrentFrame.GetMean(0,50)); // adjust baseline based on the first 50 samples
TWaveform FilteredFrame = CurrentFrame.MovingAverageFilter(10); // use moving average filter to remove noise, width of moving window is set to 10 samples
if(cUserSignalType=="-"){
fSigAmplitudes.push_back(CurrentFrame.GetMinAmplitude()); // get negative amplitude
fSigWidths.push_back(CurrentFrame.GetNegWidth(fWidthLevel)); // get negative width of signal
fSigAmplitudesFiltered.push_back(FilteredFrame.GetMinAmplitude()); // get negative amplitude of filtered signal
fSigWidthsFiltered.push_back(FilteredFrame.GetNegWidth(fWidthLevel)); // get negative width of filtered signal
}
else if(cUserSignalType=="+"){
fSigAmplitudes.push_back(CurrentFrame.GetMaxAmplitude()); // get negative amplitude
fSigWidths.push_back(CurrentFrame.GetPosWidth(fWidthLevel)); // get negative width of signal
fSigAmplitudesFiltered.push_back(FilteredFrame.GetMaxAmplitude()); // get positive amplitude of filtered signal
fSigWidthsFiltered.push_back(FilteredFrame.GetPosWidth(fWidthLevel)); // get positive width of filtered signal
}
else
exit;
} // end of loop over all recorded frames
// define output histograms and graphs
// first, raw signal
Double_t fRangeAmplitudes = fabs(*std::min_element(fSigAmplitudes.begin(),fSigAmplitudes.end()) - *std::max_element(fSigAmplitudes.begin(),fSigAmplitudes.end()));
TH1D hAmplitudes("hAmplitudes","Negative Amplitude Distribution; amplitude (V); frequency",30,*std::min_element(fSigAmplitudes.begin(),fSigAmplitudes.end())-0.1*fRangeAmplitudes,*std::max_element(fSigAmplitudes.begin(),fSigAmplitudes.end())+0.1*fRangeAmplitudes);
hAmplitudes.FillN(fSigAmplitudes.size(),&fSigAmplitudes[0],NULL);
Double_t fRangeWidths = *std::max_element(fSigWidths.begin(),fSigWidths.end()) - *std::min_element(fSigWidths.begin(),fSigWidths.end());
TH1D hWidths("hWidths","Negative Width Distribution; width (s); frequency",30,*std::min_element(fSigWidths.begin(),fSigWidths.end())-0.1*fRangeWidths,*std::max_element(fSigWidths.begin(),fSigWidths.end())+0.1*fRangeWidths);
hWidths.FillN(fSigWidths.size(),&fSigWidths[0],NULL);
TGraph grCorrelation(fSigAmplitudes.size(),&fSigAmplitudes[0],&fSigWidths[0]);
grCorrelation.SetTitle("Signal Amplitude and Width Correlation; amplitude (V); width (s)");
grCorrelation.SetMarkerStyle(24);
TProfile hCorrelation("hCorrelation","Correlation of signal amplitude and width; amplitude (V); width (s)",20,*std::min_element(fSigAmplitudes.begin(),fSigAmplitudes.end())-0.1*fRangeAmplitudes,*std::max_element(fSigAmplitudes.begin(),fSigAmplitudes.end())+0.1*fRangeAmplitudes,*std::min_element(fSigWidths.begin(),fSigWidths.end())-0.1*fRangeWidths,*std::max_element(fSigWidths.begin(),fSigWidths.end())+0.1*fRangeWidths);
hCorrelation.FillN(fSigAmplitudes.size(),&fSigAmplitudes[0],&fSigWidths[0],NULL,1);
TCanvas *canResults = new TCanvas("canResults","Results of Raw Waveform Analysis");
canResults->Divide(2,2);
canResults->cd(1);
hAmplitudes.DrawCopy();
canResults->cd(2);
hWidths.DrawCopy();
canResults->cd(3);
grCorrelation.DrawClone("AP");
canResults->cd(4);
hCorrelation.DrawCopy();
// now filtered signal
Double_t fRangeAmplitudesFiltered = fabs(*std::min_element(fSigAmplitudesFiltered.begin(),fSigAmplitudesFiltered.end()) - *std::max_element(fSigAmplitudesFiltered.begin(),fSigAmplitudesFiltered.end()));
TH1D hAmplitudesFiltered("hAmplitudesFiltered","Filtered Signal Amplitude Distribution; amplitude (V); frequency",30,*std::min_element(fSigAmplitudesFiltered.begin(),fSigAmplitudesFiltered.end())-0.1*fRangeAmplitudesFiltered,*std::max_element(fSigAmplitudesFiltered.begin(),fSigAmplitudesFiltered.end())+0.1*fRangeAmplitudesFiltered);
hAmplitudesFiltered.FillN(fSigAmplitudesFiltered.size(),&fSigAmplitudesFiltered[0],NULL);
Double_t fRangeWidthsFiltered = *std::max_element(fSigWidthsFiltered.begin(),fSigWidthsFiltered.end()) - *std::min_element(fSigWidthsFiltered.begin(),fSigWidthsFiltered.end());
TH1D hWidthsFiltered("hWidthsFiltered","Filtered Signal Width Distribution; width (s); frequency",30,*std::min_element(fSigWidthsFiltered.begin(),fSigWidthsFiltered.end())-0.1*fRangeWidthsFiltered,*std::max_element(fSigWidthsFiltered.begin(),fSigWidthsFiltered.end())+0.1*fRangeWidthsFiltered);
hWidthsFiltered.FillN(fSigWidthsFiltered.size(),&fSigWidthsFiltered[0],NULL);
TGraph grCorrelationFiltered(fSigAmplitudesFiltered.size(),&fSigAmplitudesFiltered[0],&fSigWidthsFiltered[0]);
grCorrelationFiltered.SetTitle("Filtered Signal Amplitude and Width Correlation; amplitude (V); width (s)");
grCorrelationFiltered.SetMarkerStyle(24);
TProfile hCorrelationFiltered("hCorrelationFiltered","Correlation of Filtered Signal Amplitude and Width; amplitude (V); width (s)",20,*std::min_element(fSigAmplitudesFiltered.begin(),fSigAmplitudesFiltered.end())-0.1*fRangeAmplitudesFiltered,*std::max_element(fSigAmplitudesFiltered.begin(),fSigAmplitudesFiltered.end())+0.1*fRangeAmplitudesFiltered,*std::min_element(fSigWidthsFiltered.begin(),fSigWidthsFiltered.end())-0.1*fRangeWidthsFiltered,*std::max_element(fSigWidthsFiltered.begin(),fSigWidthsFiltered.end())+0.1*fRangeWidthsFiltered);
hCorrelationFiltered.FillN(fSigAmplitudesFiltered.size(),&fSigAmplitudesFiltered[0],&fSigWidthsFiltered[0],NULL,1);
TCanvas *canResultsFiltered = new TCanvas("canResultsFiltered","Results of Filtered Waveform Analysis");
canResultsFiltered->Divide(2,2);
canResultsFiltered->cd(1);
hAmplitudesFiltered.DrawCopy();
canResultsFiltered->cd(2);
hWidthsFiltered.DrawCopy();
canResultsFiltered->cd(3);
grCorrelationFiltered.DrawClone("AP");
canResultsFiltered->cd(4);
hCorrelationFiltered.DrawCopy();
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isAlt,int isload)
{
switch (x.type)
{
case o_phrase:
//Добавляем в список ошибок(выводим сообщение)
//ошибку и адресс где это случилось
//QueueMark(Q_jumps, cmd.ea);
case o_void:
case o_reg:
break;
case o_imm:
{
//Установить для данного байта признак immedia
doImmd(cmd.ea);
//Получить флаг для указанного линейного адресса
if(!isAlt)
{
uint32 offb;
ushort addr = ushort(x.addr);
if(x.type == o_displ )
{
addr += (ushort)cmd.ip;
addr += cmd.size;
//Получить линейный адресс
offb = (uint32)toEA(codeSeg(addr,x.n), 0);
DataSet(x, offb+addr, isload);
}
else if ( isOff(uFlag, x.n) )
{
reref:
ua_add_off_drefs(x, dr_O);
if ( x.type == o_displ )
//Преобразовать данные по указанному линейному адрессу в указанный тип
ua_dodata2(x.offb, calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr), x.dtyp);
}
else if(x.type == o_displ && !x.reg && !isDefArg(uFlag, x.n) &&
set_offset(cmd.ea, x.n, toEA(cmd.cs,0))) goto reref;
}
} break;
case o_bit:
case o_mem:
// Конвертирование в данные(указан адресс) по указанному типу,
//добавить крос референсы для текущей инструкции
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
break;
case o_near:
{
//Получить линейный адресс
ea_t ea = toEA(cmd.cs, x.addr);
//Проверить является ли значение по указанному линейному адрессу - инструкцией
int iscall = InstrIsSet(cmd.itype, CF_CALL);
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, iscall ? fl_CN : fl_JN);
if ( iscall ) flow = func_does_return(ea);
} break;
default:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
namespace Exiv2 {
DataSet::DataSet(
uint16 number,
const char* name,
const char* desc,
bool mandatory,
bool repeatable,
uint32 minbytes,
uint32 maxbytes,
TypeId type,
uint16 recordId,
const char* photoshop
)
: number_(number), name_(name), desc_(desc), mandatory_(mandatory),
repeatable_(repeatable), minbytes_(minbytes), maxbytes_(maxbytes),
type_(type), recordId_(recordId), photoshop_(photoshop)
{
}
RecordInfo::RecordInfo(
uint16 recordId,
const char* name,
const char* desc
)
: recordId_(recordId), name_(name), desc_(desc)
{
}
const RecordInfo IptcDataSets::recordInfo_[] = {
RecordInfo(IptcDataSets::invalidRecord, "(invalid)", "(invalid)"),
RecordInfo(IptcDataSets::envelope, "Envelope", "IIM envelope record"),
RecordInfo(IptcDataSets::application2, "Application2", "IIM application record 2"),
};
static const DataSet envelopeRecord[] = {
DataSet(IptcDataSets::ModelVersion, "ModelVersion", "Version of IIM part 1", true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::Destination, "Destination", "Routing information", false, true, 0, 1024, Exiv2::string, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::FileFormat, "FileFormat", "IIM appendix A file format", true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::FileVersion, "FileVersion", "File format version", true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::ServiceId, "ServiceId", "Identifies the provider and product", true, false, 0, 10, Exiv2::string, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::EnvelopeNumber, "EnvelopeNumber", "Combined unique identification", true, false, 8, 8, Exiv2::string, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::ProductId, "ProductId", "Identifies service subset", false, true, 0, 32, Exiv2::string, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::EnvelopePriority, "EnvelopePriority", "Envelope handling priority", false, false, 1, 1, Exiv2::string, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::DateSent, "DateSent", "Date material was sent", true, false, 8, 8, Exiv2::date, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::TimeSent, "TimeSent", "Time material was sent", false, false, 11, 11, Exiv2::time, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::CharacterSet, "CharacterSet", "Specifies character sets", false, false, 0, 32, Exiv2::undefined, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::UNO, "UNO", "Unique Name of Object", false, false, 14, 80, Exiv2::string, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::ARMId, "ARMId", "Abstract Relationship Method identifier", false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
DataSet(IptcDataSets::ARMVersion, "ARMVersion", "Abstract Relationship Method version", false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
DataSet(0xffff, "(Invalid)", "(Invalid)", false, false, 0, 0, Exiv2::unsignedShort, IptcDataSets::envelope, "")
};
static const DataSet application2Record[] = {
DataSet(IptcDataSets::RecordVersion, "RecordVersion", "Version of IIM part 2", true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ObjectType, "ObjectType", "IIM appendix G object type", false, false, 3, 67, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ObjectAttribute, "ObjectAttribute", "IIM appendix G object attribute", false, true, 4, 68, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ObjectName, "ObjectName", "Shorthand reference of content", false, false, 0, 64, Exiv2::string, IptcDataSets::application2, "Document title"),
DataSet(IptcDataSets::EditStatus, "EditStatus", "Content status", false, false, 0, 64, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::EditorialUpdate, "EditorialUpdate", "Indicates the type of update", false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Urgency, "Urgency", "Editorial urgency of content", false, false, 1, 1, Exiv2::string, IptcDataSets::application2, "Urgency"),
DataSet(IptcDataSets::Subject, "Subject", "Structured definition of the subject", false, true, 13, 236, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Category, "Category", "Identifies the subject", false, false, 0, 3, Exiv2::string, IptcDataSets::application2, "Category"),
DataSet(IptcDataSets::SuppCategory, "SuppCategory", "Refines the subject", false, true, 0, 32, Exiv2::string, IptcDataSets::application2, "Supplemental Categories"),
DataSet(IptcDataSets::FixtureId, "FixtureId", "Identifies content that recurs", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Keywords, "Keywords", "Information retrieval words", false, true, 0, 64, Exiv2::string, IptcDataSets::application2, "Keywords"),
DataSet(IptcDataSets::LocationCode, "LocationCode", "ISO country code for content", false, true, 3, 3, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::LocationName, "LocationName", "Full country name for content", false, true, 0, 64, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ReleaseDate, "ReleaseDate", "Earliest intended usable date", false, false, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ReleaseTime, "ReleaseTime", "Earliest intended usable time", false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ExpirationDate, "ExpirationDate", "Latest intended usable date", false, false, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ExpirationTime, "ExpirationTime", "Latest intended usable time", false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
DataSet(IptcDataSets::SpecialInstructions, "SpecialInstructions", "Editorial usage instructions", false, false, 0, 256, Exiv2::string, IptcDataSets::application2, "Instructions"),
DataSet(IptcDataSets::ActionAdvised, "ActionAdvised", "Action provided to previous data", false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ReferenceService, "ReferenceService", "Service Identifier of a prior envelope", false, true, 0, 10, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ReferenceDate, "ReferenceDate", "Date of a prior envelope", false, true, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ReferenceNumber, "ReferenceNumber", "Envelope Number of a prior envelope", false, true, 8, 8, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::DateCreated, "DateCreated", "Creation date of intellectual content", false, false, 8, 8, Exiv2::date, IptcDataSets::application2, "Date created"),
DataSet(IptcDataSets::TimeCreated, "TimeCreated", "Creation time of intellectual content", false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
DataSet(IptcDataSets::DigitizationDate, "DigitizationDate", "Creation date of digital representation", false, false, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
DataSet(IptcDataSets::DigitizationTime, "DigitizationTime", "Creation time of digital representation", false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Program, "Program", "Content creation program", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ProgramVersion, "ProgramVersion", "Content creation program version", false, false, 0, 10, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ObjectCycle, "ObjectCycle", "Morning, evening, or both", false, false, 1, 1, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Byline, "Byline", "Name of content creator", false, true, 0, 32, Exiv2::string, IptcDataSets::application2, "Author"),
DataSet(IptcDataSets::BylineTitle, "BylineTitle", "Title of content creator", false, true, 0, 32, Exiv2::string, IptcDataSets::application2, "Authors Position"),
DataSet(IptcDataSets::City, "City", "City of content origin", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, "City"),
DataSet(IptcDataSets::SubLocation, "SubLocation", "Location within city", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ProvinceState, "ProvinceState", "Province/State of content origin", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, "State/Province"),
DataSet(IptcDataSets::CountryCode, "CountryCode", "ISO country code of content origin", false, false, 3, 3, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::CountryName, "CountryName", "Full country name of content origin", false, false, 0, 64, Exiv2::string, IptcDataSets::application2, "Country"),
DataSet(IptcDataSets::TransmissionReference, "TransmissionReference", "Location of original transmission", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, "Transmission Reference"),
DataSet(IptcDataSets::Headline, "Headline", "Content synopsis", false, false, 0, 256, Exiv2::string, IptcDataSets::application2, "Headline"),
DataSet(IptcDataSets::Credit, "Credit", "Content provider", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, "Credit"),
DataSet(IptcDataSets::Source, "Source", "Original owner of content", false, false, 0, 32, Exiv2::string, IptcDataSets::application2, "Source"),
DataSet(IptcDataSets::Copyright, "Copyright", "Necessary copyright notice", false, false, 0, 128, Exiv2::string, IptcDataSets::application2, "Copyright notice"),
DataSet(IptcDataSets::Contact, "Contact", "Person or organisation to contact", false, true, 0, 128, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Caption, "Caption", "Content description", false, false, 0, 2000, Exiv2::string, IptcDataSets::application2, "Description"),
DataSet(IptcDataSets::Writer, "Writer", "Person responsible for caption", false, true, 0, 32, Exiv2::string, IptcDataSets::application2, "Description writer"),
DataSet(IptcDataSets::RasterizedCaption, "RasterizedCaption", "Black and white caption image", false, false, 7360, 7360, Exiv2::undefined, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ImageType, "ImageType", "Color components in an image", false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::ImageOrientation, "ImageOrientation", "Indicates the layout of an image", false, false, 1, 1, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Language, "Language", "ISO 639:1988 language code", false, false, 2, 3, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::AudioType, "AudioType", "Information about audio content", false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::AudioRate, "AudioRate", "Sampling rate of audio content", false, false, 6, 6, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::AudioResolution, "AudioResolution", "Sampling resolution of audio content", false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::AudioDuration, "AudioDuration", "Duration of audio content", false, false, 6, 6, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::AudioOutcue, "AudioOutcue", "Final words or sounds of audio content", false, false, 0, 64, Exiv2::string, IptcDataSets::application2, ""),
DataSet(IptcDataSets::PreviewFormat, "PreviewFormat", "IIM appendix A file format of preview", false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::application2, ""),
DataSet(IptcDataSets::PreviewVersion, "PreviewVersion", "File format version of preview", false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::application2, ""),
DataSet(IptcDataSets::Preview, "Preview", "Binary preview data", false, false, 0, 256000, Exiv2::undefined, IptcDataSets::application2, ""),
DataSet(0xffff, "(Invalid)", "(Invalid)", false, false, 0, 0, Exiv2::unsignedShort, IptcDataSets::application2, "")
};
// Dataset lookup lists.This is an array with pointers to one list per IIM4 Record.
// The record id is used as the index into the array.
const DataSet* IptcDataSets::records_[] = {
0,
envelopeRecord, application2Record,
0
};
const char* IptcDataSets::familyName_ = "Iptc";
int IptcDataSets::dataSetIdx(uint16 number, uint16 recordId)
{
if( recordId != envelope && recordId != application2 ) return -1;
const DataSet* dataSet = records_[recordId];
if (dataSet == 0) return -1;
int idx;
for (idx = 0; dataSet[idx].number_ != number; ++idx) {
if (dataSet[idx].number_ == 0xffff) return -1;
}
return idx;
}
int IptcDataSets::dataSetIdx(const std::string& dataSetName, uint16 recordId)
{
if( recordId != envelope && recordId != application2 ) return -1;
const DataSet* dataSet = records_[recordId];
if (dataSet == 0) return -1;
int idx;
for (idx = 0; dataSet[idx].name_ != dataSetName; ++idx) {
if (dataSet[idx].number_ == 0xffff) return -1;
}
return idx;
}
TypeId IptcDataSets::dataSetType(uint16 number, uint16 recordId)
{
int idx = dataSetIdx(number, recordId);
if (idx == -1) throw Error("No dataSet for record Id");
return records_[recordId][idx].type_;
}
const char* IptcDataSets::dataSetName(uint16 number, uint16 recordId)
{
int idx = dataSetIdx(number, recordId);
if (idx == -1) throw Error("No dataSet for record Id");
return records_[recordId][idx].name_;
}
const char* IptcDataSets::dataSetDesc(uint16 number, uint16 recordId)
{
int idx = dataSetIdx(number, recordId);
if (idx == -1) throw Error("No dataSet for record Id");
return records_[recordId][idx].desc_;
}
const char* IptcDataSets::dataSetPsName(uint16 number, uint16 recordId)
{
int idx = dataSetIdx(number, recordId);
if (idx == -1) throw Error("No dataSet for record Id");
return records_[recordId][idx].photoshop_;
}
bool IptcDataSets::dataSetRepeatable(uint16 number, uint16 recordId)
{
int idx = dataSetIdx(number, recordId);
if (idx == -1) throw Error("No dataSet for record Id");
return records_[recordId][idx].repeatable_;
}
const char* IptcDataSets::recordName(uint16 recordId)
{
if( recordId != envelope && recordId != application2 ) {
throw Error("Unknown record");
}
return recordInfo_[recordId].name_;
}
const char* IptcDataSets::recordDesc(uint16 recordId)
{
if( recordId != envelope && recordId != application2 ) {
throw Error("Unknown record");
}
return recordInfo_[recordId].desc_;
}
uint16 IptcDataSets::recordId(const std::string& recordName)
{
uint16 i;
for (i = application2; i > 0; --i) {
if (recordInfo_[i].name_ == recordName) break;
}
return i;
}
std::string IptcDataSets::makeKey(const DataSet& dataSet)
{
return std::string(familyName())
+ "." + std::string(recordName(dataSet.recordId_))
+ "." + dataSet.name_;
}
std::string IptcDataSets::makeKey(uint16 number, uint16 recordId)
{
return std::string(familyName())
+ "." + std::string(recordName(recordId))
+ "." + std::string(dataSetName(number, recordId));
}
// This 'database lookup' function returns a match if it exists
std::pair<uint16, uint16> IptcDataSets::decomposeKey(const std::string& key)
{
// Get the type, record name and dataSet name parts of the key
std::string::size_type pos1 = key.find('.');
if (pos1 == std::string::npos) throw Error("Invalid key");
std::string type = key.substr(0, pos1);
if (type != "Iptc") throw Error("Invalid key");
std::string::size_type pos0 = pos1 + 1;
pos1 = key.find('.', pos0);
if (pos1 == std::string::npos) throw Error("Invalid key");
std::string recordName = key.substr(pos0, pos1 - pos0);
if (recordName == "") throw Error("Invalid key");
std::string dataSetName = key.substr(pos1 + 1);
if (dataSetName == "") throw Error("Invalid key");
// Use the parts of the key to find dataSet and recordInfo
uint16 recId = recordId(recordName);
if (recId == invalidRecord) return std::make_pair((uint16)0xffff, invalidRecord);
int idx = dataSetIdx(dataSetName, recId);
if (idx == -1 ) return std::make_pair((uint16)0xffff, invalidRecord);
return std::make_pair(records_[recId][idx].number_, recId);
} // IptcDataSets::decomposeKey
void IptcDataSets::dataSetList(std::ostream& os)
{
const int count = sizeof(records_)/sizeof(records_[0]);
for (int i=0; i < count; ++i) {
const DataSet *record = records_[i];
for (int j=0; record != 0 && record[j].number_ != 0xffff; ++j) {
os << record[j] << "\n";
}
}
} // IptcDataSets::dataSetList
// *************************************************************************
// free functions
std::ostream& operator<<(std::ostream& os, const DataSet& dataSet)
{
return os << dataSet.name_ << ", "
<< std::dec << dataSet.number_ << ", "
<< "0x" << std::setw(4) << std::setfill('0')
<< std::right << std::hex << dataSet.number_ << ", "
<< IptcDataSets::recordName(dataSet.recordId_) << ", "
<< std::boolalpha << dataSet.mandatory_ << ", "
<< dataSet.repeatable_ << ", "
<< std::dec << dataSet.minbytes_ << ", "
<< dataSet.maxbytes_ << ", "
<< IptcDataSets::makeKey(dataSet) << ", "
<< dataSet.desc_;
}
} // namespace Exiv2
DataSet DataSet::create (const File& file, const DataType& type, const DataSpace& space, const DataSetCreatePropList& dcpl, const DataSetAccessPropList& dapl) {
return DataSet (Exception::check ("H5Dcreate_anon", H5Dcreate_anon (file.handle (), type.handle (), space.handle (), dcpl.handleOrDefault (), dapl.handleOrDefault ())));
}
/*--------------------------------------------------------------------------*/
void PegTextBox::Append(const PEGCHAR *Text, BOOL bDraw)
{
if (!Text)
{
return;
}
if (!(*Text))
{
return;
}
PEGCHAR *pGet = DataGet();
if (!pGet)
{
WORD wTextLen = (WORD) strlen(Text);
if(wTextLen > mwMaxChars)
{
Text += (wTextLen - mwMaxChars);
}
DataSet(Text);
return;
}
WORD wStartLen = (WORD) strlen(pGet);
WORD wLen = strlen(Text) + wStartLen;
if (wLen >= mwMaxChars)
{
SIGNED iAdjust = wLen - mwMaxChars;
if (wStartLen >= iAdjust)
{
pGet += iAdjust;
wLen -= iAdjust;
}
else
{
pGet = NULL;
wLen -= wStartLen;
if (wLen > mwMaxChars)
{
iAdjust = wLen - mwMaxChars;
Text += iAdjust;
wLen -= iAdjust;
}
}
}
wLen += 2;
PEGCHAR *pTemp = new PEGCHAR[wLen];
if (pGet)
{
strcpy(pTemp, pGet);
}
else
{
*pTemp = '\0';
}
strcat(pTemp, Text);
PegTextThing::DataSet(pTemp);
delete (pTemp);
UpdateLineStarts();
if (muScrollMode & WSM_AUTOSCROLL)
{
if (CheckAutoScroll())
{
UpdateLineStarts();
}
}
SetTopLineToEnd();
if (bDraw)
{
Draw();
}
}
