C++ History类代码示例

void Window::notifyShowNext(NotifyWindow *remove) {
	if (App::quiting()) return;

	int32 count = NotifyWindowsCount;
	if (remove) {
		for (NotifyWindows::iterator i = notifyWindows.begin(), e = notifyWindows.end(); i != e; ++i) {
			if ((*i) == remove) {
				notifyWindows.erase(i);
				break;
			}
		}
	}

	uint64 ms = getms(true), nextAlert = 0;
	bool alert = false;
	for (NotifyWhenAlerts::iterator i = notifyWhenAlerts.begin(); i != notifyWhenAlerts.end();) {
		while (!i.value().isEmpty() && i.value().begin().key() <= ms) {
			i.value().erase(i.value().begin());
			NotifySettingsPtr n = i.key()->peer->notify;
			if (n == EmptyNotifySettings || (n != UnknownNotifySettings && n->mute <= unixtime())) {
				alert = true;
			}
		}
		if (i.value().isEmpty()) {
			i = notifyWhenAlerts.erase(i);
		} else {
			if (!nextAlert || nextAlert > i.value().begin().key()) {
				nextAlert = i.value().begin().key();
			}
			++i;
		}
	}
	if (alert) {
		psFlash();
		App::playSound();
	}

    if (cCustomNotifies()) {
        for (NotifyWindows::const_iterator i = notifyWindows.cbegin(), e = notifyWindows.cend(); i != e; ++i) {
            int32 ind = (*i)->index();
            if (ind < 0) continue;
            --count;
        }
    }
	if (count <= 0 || !cDesktopNotify()) {
		if (nextAlert) {
			notifyWaitTimer.start(nextAlert - ms);
		}
		return;
	}

	QRect r = psDesktopRect();
	int32 x = r.x() + r.width() - st::notifyWidth - st::notifyDeltaX, y = r.y() + r.height() - st::notifyHeight - st::notifyDeltaY;
	while (count > 0) {
		uint64 next = 0;
		HistoryItem *notifyItem = 0;
		NotifyWaiters::iterator notifyWaiter;
		for (NotifyWaiters::iterator i = notifyWaiters.begin(); i != notifyWaiters.end(); ++i) {
			History *history = i.key();
			if (history->currentNotification() && history->currentNotification()->id != i.value().msg) {
				NotifyWhenMaps::iterator j = notifyWhenMaps.find(history);
				if (j == notifyWhenMaps.end()) {
					history->clearNotifications();
					i = notifyWaiters.erase(i);
					continue;
				}
				do {
					NotifyWhenMap::const_iterator k = j.value().constFind(history->currentNotification()->id);
					if (k != j.value().cend()) {
						i.value().msg = k.key();
						i.value().when = k.value();
						break;
					}
					history->skipNotification();
				} while (history->currentNotification());
			}
			if (!history->currentNotification()) {
				notifyWhenMaps.remove(history);
				i = notifyWaiters.erase(i);
				continue;
			}
			uint64 when = i.value().when;
			if (!notifyItem || next > when) {
				next = when;
				notifyItem = history->currentNotification();
				notifyWaiter = i;
			}
		}
		if (notifyItem) {
			if (next > ms) {
				if (nextAlert && nextAlert < next) {
					next = nextAlert;
					nextAlert = 0;
				}
				notifyWaitTimer.start(next - ms);
				break;
			} else {
                if (cCustomNotifies()) {
                    NotifyWindow *notify = new NotifyWindow(notifyItem, x, y);
                    notifyWindows.push_back(notify);
//.........这里部分代码省略.........

vector<State*> Belief::Resample(int num, const Belief& belief, History history,
	int hstart) {
	double reward;
	OBS_TYPE obs;

	vector<State*> sample;
	int count = 0;
	int pos = 0;
	double max_wgt = Globals::NEG_INFTY;
	vector<State*> particles;
	int trial = 0;
	while (count < num || trial < 200 * num) {
		// Pick next particle
		if (pos == particles.size()) {
			particles = belief.Sample(num);
			pos = 0;
		}
		State* particle = particles[pos];

		trial++;

		// Step through history
		double log_wgt = 0;
		for (int i = hstart; i < history.Size(); i++) {
			belief.model_->Step(*particle, Random::RANDOM.NextDouble(),
				history.Action(i), reward, obs);

			double prob = belief.model_->ObsProb(history.Observation(i),
				*particle, history.Action(i));
			if (prob > 0) {
				log_wgt += log(prob);
			} else {
				belief.model_->Free(particle);
				break;
			}
		}

		// Add to sample if survived
		if (particle->IsAllocated()) {
			particle->weight = log_wgt;
			sample.push_back(particle);

			max_wgt = max(log_wgt, max_wgt);
			count++;
		}

		// Remove particles with very small weights
		if (count == num) {
			for (int i = sample.size() - 1; i >= 0; i--) {
				if (sample[i]->weight - max_wgt < log(1.0 / num)) {
					belief.model_->Free(sample[i]);
					sample.erase(sample.begin() + i);
					count--;
				}
			}
		}

		pos++;
	}

	// Free unused particles
	for (int i = pos; i < particles.size(); i++)
		belief.model_->Free(particles[i]);

	double total_weight = 0;
	for (int i = 0; i < sample.size(); i++) {
		sample[i]->weight = exp(sample[i]->weight - max_wgt);
		total_weight += sample[i]->weight;
	}
	for (int i = 0; i < sample.size(); i++) {
		sample[i]->weight = sample[i]->weight / total_weight;
	}

	logd << "[Belief::Resample] Resampled " << sample.size() << " particles"
		<< endl;
	for (int i = 0; i < sample.size(); i++) {
		logv << " " << i << " = " << *sample[i] << endl;
	}

	return sample;
}

bool V8History::namedSecurityCheck(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8::AccessType type, v8::Local<v8::Value>)
{
    History* history = V8History::toNative(host);
    return BindingSecurity::shouldAllowAccessToFrame(BindingState::instance(), history->frame(), DoNotReportSecurityError);
}

bool V8History::namedSecurityCheck(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8::AccessType type, v8::Local<v8::Value>)
{
    // Only allow same origin access.
    History* history = V8History::toNative(host);
    return V8BindingSecurity::canAccessFrame(V8BindingState::Only(), history->frame(), false);
}

TEST(GetLast, Empty) {
    History history;
    EXPECT_EQ(NULL, history.GetLast());
}

void InputConsumer::resampleTouchState(nsecs_t sampleTime, MotionEvent* event,
    const InputMessage* next) {
    if (!mResampleTouch
            || !(event->getSource() & AINPUT_SOURCE_CLASS_POINTER)
            || event->getAction() != AMOTION_EVENT_ACTION_MOVE) {
        return;
    }

    ssize_t index = findTouchState(event->getDeviceId(), event->getSource());
    if (index < 0) {
#if DEBUG_RESAMPLING
        ALOGD("Not resampled, no touch state for device.");
#endif
        return;
    }

    TouchState& touchState = mTouchStates.editItemAt(index);
    if (touchState.historySize < 1) {
#if DEBUG_RESAMPLING
        ALOGD("Not resampled, no history for device.");
#endif
        return;
    }

    // Ensure that the current sample has all of the pointers that need to be reported.
    const History* current = touchState.getHistory(0);
    size_t pointerCount = event->getPointerCount();
    for (size_t i = 0; i < pointerCount; i++) {
        uint32_t id = event->getPointerId(i);
        if (!current->idBits.hasBit(id)) {
#if DEBUG_RESAMPLING
            ALOGD("Not resampled, missing id %d", id);
#endif
            return;
        }
    }

    // Find the data to use for resampling.
    const History* other;
    History future;
    float alpha;
    if (next) {
        // Interpolate between current sample and future sample.
        // So current->eventTime <= sampleTime <= future.eventTime.
        future.initializeFrom(next);
        other = &future;
        nsecs_t delta = future.eventTime - current->eventTime;
        if (delta < RESAMPLE_MIN_DELTA) {
#if DEBUG_RESAMPLING
            ALOGD("Not resampled, delta time is %lld ns.", delta);
#endif
            return;
        }
        alpha = float(sampleTime - current->eventTime) / delta;
    } else if (touchState.historySize >= 2) {
        // Extrapolate future sample using current sample and past sample.
        // So other->eventTime <= current->eventTime <= sampleTime.
        other = touchState.getHistory(1);
        nsecs_t delta = current->eventTime - other->eventTime;
        if (delta < RESAMPLE_MIN_DELTA) {
#if DEBUG_RESAMPLING
            ALOGD("Not resampled, delta time is %lld ns.", delta);
#endif
            return;
        }
        nsecs_t maxPredict = current->eventTime + min(delta / 2, RESAMPLE_MAX_PREDICTION);
        if (sampleTime > maxPredict) {
#if DEBUG_RESAMPLING
            ALOGD("Sample time is too far in the future, adjusting prediction "
                    "from %lld to %lld ns.",
                    sampleTime - current->eventTime, maxPredict - current->eventTime);
#endif
            sampleTime = maxPredict;
        }
        alpha = float(current->eventTime - sampleTime) / delta;
    } else {
#if DEBUG_RESAMPLING
        ALOGD("Not resampled, insufficient data.");
#endif
        return;
    }

    // Resample touch coordinates.
    touchState.lastResample.eventTime = sampleTime;
    touchState.lastResample.idBits.clear();
    for (size_t i = 0; i < pointerCount; i++) {
        uint32_t id = event->getPointerId(i);
        touchState.lastResample.idToIndex[id] = i;
        touchState.lastResample.idBits.markBit(id);
        PointerCoords& resampledCoords = touchState.lastResample.pointers[i];
        const PointerCoords& currentCoords = current->getPointerById(id);
        if (other->idBits.hasBit(id)
                && shouldResampleTool(event->getToolType(i))) {
            const PointerCoords& otherCoords = other->getPointerById(id);
            resampledCoords.copyFrom(currentCoords);
            resampledCoords.setAxisValue(AMOTION_EVENT_AXIS_X,
                    lerp(currentCoords.getX(), otherCoords.getX(), alpha));
            resampledCoords.setAxisValue(AMOTION_EVENT_AXIS_Y,
                    lerp(currentCoords.getY(), otherCoords.getY(), alpha));
#if DEBUG_RESAMPLING
//.........这里部分代码省略.........

 Gshare() {
   globalHistory.setAllTaken();
   for (int i = 0; i < (1 << globalSize); i++) {
     table[i].setWeakTaken();
   }
 }

void  TestUseCaseUndo::run_006 ()
{
   Document document (Model::use (), 123456789UL, 'appl', 'gui ');

   Song & song = document.root <Song> ();
   Track & track = *song._tracks.emplace ();
   Clip & clip1 = *track._clips.emplace (1.0, 1.0);
   Clip & clip2 = *track._clips.emplace (5.0, 1.0);
   Clip & clip3 = *track._clips.emplace (2.5, 2.0);
   song._selection.emplace (clip1);
   song._selection.emplace (clip2);

   document.commit ();
   document.push ();

   History <HistoryStoreMemory> history (document);

   //

   clip1._position = 2.0;

   document.commit ();
   auto tx = document.squash ();
   history.add_undo_step (tx);

   //

   clip1._position = 3.5;

   document.commit ();
   tx = document.squash ();
   *history.last_undo () = tx;
   document.push ();

   //

   clip1._position = 4.7;
   clip1._duration = 2.5;
   clip2._position = 4.2;

   document.commit ();
   tx = document.squash ();
   history.add_undo_step (tx);

   //

   clip2._position = 4.2;
   document.commit ();

   clip1._position = 1.2;
   document.commit ();

   clip3._position = 3.4;
   document.commit ();

   tx = document.squash ();
   *history.last_undo () = tx;

   //

   bool ok_flag = history.execute_undo ();
   flip_TEST (ok_flag);

   flip_TEST (clip1._position == 3.5);
   flip_TEST (clip1._duration == 1.0);
   flip_TEST (clip2._position == 5.0);
   flip_TEST (clip2._duration == 1.0);
   flip_TEST (clip3._position == 2.5);
   flip_TEST (clip3._duration == 2.0);

   ok_flag = history.execute_redo ();
   flip_TEST (ok_flag);

   flip_TEST (clip1._position == 1.2);
   flip_TEST (clip1._duration == 2.5);
   flip_TEST (clip2._position == 4.2);
   flip_TEST (clip2._duration == 1.0);
   flip_TEST (clip3._position == 3.4);
   flip_TEST (clip3._duration == 2.0);

   ok_flag = history.execute_undo ();
   flip_TEST (ok_flag);

   ok_flag = history.execute_undo ();
   flip_TEST (ok_flag);

   flip_TEST (clip1._position == 1.0);
   flip_TEST (clip1._duration == 1.0);
   flip_TEST (clip2._position == 5.0);
   flip_TEST (clip2._duration == 1.0);
   flip_TEST (clip3._position == 2.5);
   flip_TEST (clip3._duration == 2.0);

   ok_flag = history.execute_redo ();
   flip_TEST (ok_flag);

   flip_TEST (clip1._position == 3.5);
   flip_TEST (clip1._duration == 1.0);
   flip_TEST (clip2._position == 5.0);
   flip_TEST (clip2._duration == 1.0);
//.........这里部分代码省略.........

void V8PopStateEvent::stateAttributeGetterCustom(
    const v8::FunctionCallbackInfo<v8::Value>& info) {
  ScriptState* scriptState = ScriptState::current(info.GetIsolate());
  v8::Local<v8::Value> result = V8HiddenValue::getHiddenValue(
      scriptState, info.Holder(), V8HiddenValue::state(info.GetIsolate()));

  if (!result.IsEmpty()) {
    v8SetReturnValue(info, result);
    return;
  }

  PopStateEvent* event = V8PopStateEvent::toImpl(info.Holder());
  History* history = event->history();
  if (!history || !event->serializedState()) {
    // If the event doesn't have serializedState(), it means that the
    // event was initialized with PopStateEventInit. In such case, we need
    // to get a v8 value for the current world from state().
    if (event->serializedState())
      result = event->serializedState()->deserialize();
    else
      result = event->state().v8ValueFor(scriptState);
    if (result.IsEmpty())
      result = v8::Null(info.GetIsolate());
    v8SetReturnValue(info, cacheState(scriptState, info.Holder(), result));
    return;
  }

  // There's no cached value from a previous invocation, nor a state value was
  // provided by the event, but there is a history object, so first we need to
  // see if the state object has been deserialized through the history object
  // already.
  // The current history state object might've changed in the meantime, so we
  // need to take care of using the correct one, and always share the same
  // deserialization with history.state.

  bool isSameState = history->isSameAsCurrentState(event->serializedState());

  if (isSameState) {
    v8::Local<v8::Value> v8HistoryValue =
        toV8(history, info.Holder(), info.GetIsolate());
    if (v8HistoryValue.IsEmpty())
      return;
    v8::Local<v8::Object> v8History = v8HistoryValue.As<v8::Object>();
    if (!history->stateChanged()) {
      result = V8HiddenValue::getHiddenValue(
          scriptState, v8History, V8HiddenValue::state(info.GetIsolate()));
      if (!result.IsEmpty()) {
        v8SetReturnValue(info, cacheState(scriptState, info.Holder(), result));
        return;
      }
    }
    result = event->serializedState()->deserialize(info.GetIsolate());
    V8HiddenValue::setHiddenValue(scriptState, v8History,
                                  V8HiddenValue::state(info.GetIsolate()),
                                  result);
  } else {
    result = event->serializedState()->deserialize(info.GetIsolate());
  }

  v8SetReturnValue(info, cacheState(scriptState, info.Holder(), result));
}

void guiChangeIP(Frame *frame, int eventId){
    Change c;
    HANDLE tibia = c.getTibiaProcess();
    if(!tibia){
        frame->sb->SetStatusText(wxT("Tibia process not found!"),0);
        if(eventId == MENU_CHANGE_IP)
            sendDialog(wxT("Tibia process not found!"), wxOK | wxICON_ERROR);
        CloseHandle(tibia);
        return;
    }
    std::string sip = std::string(frame->ip->GetValue().mb_str());
    int sport = frame->host->GetValue();
    std::string client = std::string(frame->clients->GetValue().mb_str());
    if(sip == ""){
        frame->sb->SetStatusText(wxT("IP adress not found!"),0);
        if(eventId == MENU_CHANGE_IP)
        	sendDialog(wxT("IP adress not found!"), wxOK | wxICON_ERROR);
        return;
    }
    size_t found = sip.find(":");
    if(found != string::npos){
        sport = atoi(sip.substr(found+1, sip.size()).c_str());
        sip = sip.substr(0, found);
        frame->ip->SetValue(sip);
        frame->host->SetValue(sport);
    }
        
    if(client != "Auto"){
        std::string s ="";
        s += client.at(1);
        if(s == ".")
        	client = client.erase(1,1);
    }
        	
    bool ret = c.changeIP(sip, sport, client);
        
    if(ret){
        frame->sb->SetStatusText(wxT("IP Changed!"),0);
        if(eventId == MENU_CHANGE_IP)
        	sendDialog(wxT("IP Changed!"), wxOK);
    }else{
        frame->sb->SetStatusText(wxT("IP not Changed!"),0);
        if(eventId == MENU_CHANGE_IP)
        	sendDialog(wxT("IP not Changed!"), wxOK | wxICON_ERROR);
        return;
    }
    
    char buf[4];
    itoa(sport, buf, 10);
    std::string save;
    save += sip + ":" + buf;
	h.saveHistory(save);
	frame->ip->Clear();
	vector<string>z;
	z = h.getHistory();
	for(int i = 0; i < int(z.size()); i++){
		wxString wxs(z[i].c_str(), wxConvUTF8);
		frame->ip->Append(wxs);
	}
	std::string tmp = z[0].substr(0, z[0].size()-5);
	wxString last(tmp.c_str(), wxConvUTF8);
	frame->ip->SetValue(last);
}

void NBShell::run() {
	Prompt * prompt = new Prompt();
	Path * path = new Path();
	History * history = new History();

	while (true){
		cout << (prompt -> get()) << "$ " << flush;
		CommandLine * cmd = new CommandLine(cin);

		if (cmd->getArgCount() == 0){ // If the input is empty, do nothing (Allow the user to press enter with no text)
			cmd->~CommandLine();
			continue;
		}

		else if ((string)cmd -> getCommand() == "history"){
			history -> add(cmd -> getRawInput());
			if ((cmd -> getArgCount() > 1)&&(string)(cmd -> getArgVector(1)) == 
"-c"){
				history -> clear();
			}
			else{
				history -> getAll();
			}
		}

		else if ((string)cmd -> getCommand() == "cd"){
			struct stat st;
			if (stat((cmd->getArgVector(1)), &st) == 0 && S_ISDIR(st.st_mode)) //Check to make sure the directory exists
			{
				chdir(cmd->getArgVector(1)); //Tell the system to change the current working directory
				prompt->update();
				history->add(cmd->getRawInput());
				cmd->~CommandLine(); // Destroy the CommandLine after it is done and restart the loop.
				continue;
			}
			else {
				cout << "No such directory!" << endl;
				history->add(cmd->getRawInput());
				cmd->~CommandLine();
				continue;
			}
		}

		else if ((string)cmd -> getCommand() == "exit"){
			exit(0); // Exit the program
		}

		else if ((string)cmd -> getCommand() == "pwd"){
			cout << prompt->get() << endl;
			history->add(cmd->getRawInput()); 
			cmd->~CommandLine();
			continue;
		}

		else{
			history -> add(cmd -> getRawInput());
			int status = path -> find((string)cmd -> getCommand());
			if (status != -1 ){ // After checking that the program exists...
				pid_t pid;
				int forkStatus;
				string completePath = (path->getDirectory(status)) + "/" + ((string)cmd -> getCommand()); // Add the file name to the end of the directory that contains it
				if ((pid = fork()) < 0) { // Attempt to create a child using fork
					perror("fork() error");
					exit(-1);
				}
				else if (pid == 0) { //Check to see if fork isn't a parent; If so execute the command.
					if (execve(completePath.c_str(),cmd->getArgVector(), NULL) < 0) { //Execute the file and pass in its arguments from the CommandLine
						perror("execve() error");
						cmd->~CommandLine();
						continue;
					}
					exit(0);
				}
				//Have the parent wait for child completion if & is included in the command
				if (cmd->Ampersand() == false) {
					waitpid(pid, &forkStatus, 0); // Wait for the child with the PID specified at its creation
					cmd->~CommandLine();
					continue;
				}
			}
			else{
				cout << "Command not found." << endl;
			} 
		}
	}
}

void render() {
	int i;

	if( changeMon.hasChanged() ) {
		cheReactionReset();
	}

	glScalef( 1.f/DIMX, 1.f/DIMX, 1.f );
	glTranslatef( -DIMX/2.f, -DIMY/2.f, 0.f );
	zviewpointSetupView();

	zprofBeg( band_update );
	for( i=0; i<Band_updates; i++ ) {
		partUpdate();
		cheReactionUpdate();
	}
	zprofEnd();

	Band_avgZHits = (float)zReactHits / (float)framesSinceLastReset;

	zprofBeg( band_render );
	glPointSize( Band_pointSize );
	glVertexPointer( 2, GL_INT, sizeof(Part), &part[0].pos );
	glEnableClientState( GL_VERTEX_ARRAY );
	glColorPointer( 3, GL_UNSIGNED_BYTE, sizeof(Part), &part[0].color );
	glEnableClientState( GL_COLOR_ARRAY );
 	glDrawArrays( GL_POINTS, 0, partCount );

	glColor3ub( 100, 100, 100 );
	glBegin( GL_LINES );
	float cntf = (float)spatialHistogramCount;
	for( int x=0; x<DIMX; x++ ) {
		glVertex2f( (float)x, 0.f );
		glVertex2f( (float)x, Band_histogramScale * (float)spatialHistogram[x] / cntf );
	}
	glEnd();

	glTranslatef( 0.f, -22, 0.f );
	glBegin( GL_LINES );
	glColor3ub( 255, 255, 255 );
	glVertex2f( 0.f, 0.f );
	glVertex2f( Band_plotScaleX * (float)inputHistory.size, 0.f );

	glColor3ub( 50, 255, 50 );
	glVertex2f( 0.f, Band_plotScaleY0 * Band_signalTop );
	glVertex2f( Band_plotScaleX * (float)inputHistory.size, Band_plotScaleY0 * Band_signalTop );
	glEnd();

	glColor3ub( 100, 255, 100 );
	glBegin( GL_LINE_STRIP );
	for( i=0; i<inputHistory.size-1; i++ ) {
		glVertex2f( Band_plotScaleX * (float)i, Band_plotScaleY0 * inputHistory.getVal(i) );
	}
	glEnd();

	glColor3ub( 100, 100, 255 );
	glBegin( GL_LINE_STRIP );
	for( i=0; i<inputHistory.size-1; i++ ) {
		glVertex2f( Band_plotScaleX * (float)i, Band_plotScaleY1 * outputHistory.getAvg(i) );
	}
	glEnd();

	// DRAW the power spectrum
	glTranslatef( 0.f, -22, 0.f );
	glBegin( GL_LINES );
	glColor3ub( 255, 255, 255 );
	glVertex2f( 0.f, 0.f );
	glVertex2f( Band_plotFFTScaleX * (float)fftBufSize/2.f, 0.f );
	glEnd();
	glColor3ub( 200, 200, 50 );
	glBegin( GL_LINE_STRIP );
	for( i=1; i<fftBufSize/2-1; i++ ) {
		glVertex2f( Band_plotFFTScaleX * (float)i, Band_plotFFTScaleY * cumPowerSpectrumLog[i] );
	}
	glEnd();
	zprofEnd();
}

void cheReactionUpdate() {
	framesSinceLastReset++;

	int i;

	if( Band_signalOmega != oldOmega ) {
		cheReactionReset();
	}

	avgBuf[avgBufCount++] = (float)outputHits;
	if( avgBufCount == avgBufSize ) {
		float sum = 0.f;
		for( i=0; i<avgBufCount; i++ ) {
			sum += avgBuf[i];
		}
		fftBuf[fftBufCount] = sum / (float)avgBufCount;
		fftBufCount++;
		avgBufCount = 0;
		if( fftBufCount == fftBufSize ) {
			FFT fft( fftBuf, fftBufSize );
			fft.fft();
			float *p = fft.computePowerSpectrum();
			for( i=0; i<fftBufCount/2-1; i++ ) {
				cumPowerSpectrum[i] += p[i];
				cumPowerSpectrumLog[i] = logf( 1.f + cumPowerSpectrum[i] );
			}
			fftBufCount = 0;
			cumPowerSpectrumCount++;
			FILE *file = fopen( ZTmpStr("/transfer/fft/fft-diff-%d.txt",cumPowerSpectrumCount), "wt" );
			for( i=1; i<100; i++ ) {
				fprintf( file, "%f\n", cumPowerSpectrum[i] / (float)cumPowerSpectrumCount );
			}
			fclose( file );
		}
	}

	if( !(simulationFrameNumber % 100 ) ) {
		spatialHistogramCount++;
		for( int x=0; x<DIMX; x++ ) {
			for( int y=0; y<DIMY; y++ ) {
				Part *p = partAt( IVec2(x,y) );
				if( p && p->type == TYPE_CHEYP ) {
					spatialHistogram[x]++;
				}
			}
		}
	}

	outputHistory.setAvgWindow( Band_plotWindowRadius );
	outputHistory.add( (float)outputHits );

	// COMPUTE input signal
	signal = Band_signal;
	if( Band_useSinSignal ) {
		signal = (float)( Band_signalTop * 0.5*( 1.0+sin( Band_signalOmega * (double)simulationFrameNumber ) ) );
	}
	inputHistory.add( signal );

	// SETUP for next computation
	outputHits = 0;
}

int TraceProcessorX86InterruptLinux::processInstruction(History<string>& strs)
{
  if (strs.size() < 2)
  {
    return (-1);
  }

  if (!isInterested(strs.at(0)))
  {
    return (-1);
  }

  const string& prevS = strs.at(1);

  size_t t = prevS.find("mov");
  if (t == string::npos)
  {
    return(-1);
  }

  //now that we found mov, lets find the $
  size_t t2 = prevS.find('$', t);

  //now that we found the $, we need to find the comma
  size_t t3 = prevS.find(',',t2);

  //now we should just make sure that the next thing is eax
  size_t t4 = prevS.find("%eax", t3);
  //make sure all characters from t3 to t4 are whitespaces
  for (size_t i = t3+1; i < t4; i++)
  {
    if (!isspace(prevS[i]))
    {
      return (-1);
    }
  }

  //if we are here that means everything checked out so lets get
  // the syscall number
  uint32_t syscallNum = 0;
  if(myHexStrToul(syscallNum, prevS.substr(t2+1,t3-t2-1)) != 0)
  {
    return (-1);
  }
  /*
  t4 = str.find("$0x80");

  outs = str.substr(0, t4);
  outs += "SYSCALL:";
  outs += sysCallTable[syscallNum];
  outs += "{";
  outs += str.substr(t4, 5);
  outs += "}";
  outs += str.substr(t4+5);
  */

  if (syscallNum >= SYSCALLTABLE_LINUX_2_6_LEN)
  {
    return (-1);
  }

  curSyscallName = sysCallTable[syscallNum];

  return (0);
}