X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/9f34bd86d0dc2c2ea51fe9aa54533aa68cfadc64..923c229f865f1d2052d99e10cdc8d4f3cce83f26:/lib/base/ebase.cpp

diff --git a/lib/base/ebase.cpp b/lib/base/ebase.cpp
index 7951f6e7..8563a593 100644
--- a/lib/base/ebase.cpp
+++ b/lib/base/ebase.cpp
@@ -45,8 +45,8 @@ void eTimer::start(long msek, bool singleShot)
 	bSingleShot = singleShot;
 	interval = msek;
 	gettimeofday(&nextActivation, 0);
-	nextActivation += (msek<0 ? 0 : msek);
 //	eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
+	nextActivation += (msek<0 ? 0 : msek);
 //	eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
 	context.addTimer(this);
 }
@@ -59,7 +59,7 @@ void eTimer::startLongTimer( int seconds )
 	bActive = bSingleShot = true;
 	interval = 0;
 	gettimeofday(&nextActivation, 0);
-//	eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
+//	eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_usec, seconds);
 	if ( seconds > 0 )
 		nextActivation.tv_sec += seconds;
 //	eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
@@ -121,45 +121,27 @@ void eMainloop::addSocketNotifier(eSocketNotifier *sn)
 
 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
 {
-	notifiers.erase(sn->getFD());
+	for (std::multimap<int,eSocketNotifier*>::iterator i = notifiers.find(sn->getFD());
+			i != notifiers.end();
+			++i)
+		if (i->second == sn)
+			return notifiers.erase(i);
+	eFatal("removed socket notifier which is not present");
 }
 
-void eMainloop::processOneEvent()
+int eMainloop::processOneEvent(unsigned int user_timeout, PyObject **res, PyObject *additional)
 {
-		/* notes:
-		  - we should use epoll(4)
-		  - timer are checked twice. there was a strong reason for it, but i can't remember. (FIXME)
-		  - for each time, we gettimeofday() and check wether the timer should fire.
-		    we should do this all better - we know how long the poll last, so we know which
-		    timers should fire. Problem is that a timer handler could have required so
-		    much time that another timer fired.
-
-		    A probably structure could look
-
-		    while (1)
-		    {
-			    time = gettimeofday()
-			    timeout = calculate_pending_timers(time);
-
-		      doPoll(timeout or infinite);
-
-		    	if (poll_had_results)
-		    		handle_poll_handler();
-		    	else
-				    fire_timers(time + timeout)
-			  }
-
-			  the gettimeofday() call is required because fire_timers could last more
-			  than nothing.
-
-			  when poll did no timeout, we don't handle timers, as this will be done
-			  in the next iteration (without adding overhead - we had to get the new
-			  time anyway
-		*/
-
+	int return_reason = 0;
 		/* get current time */
 	timeval now;
 	gettimeofday(&now, 0);
+	m_now_is_invalid = 0;
+	
+	if (additional && !PyDict_Check(additional))
+		eFatal("additional, but it's not dict");
+	
+	if (additional && !res)
+		eFatal("additional, but no res");
 	
 	int poll_timeout = -1; /* infinite in case of empty timer list */
 	
@@ -175,63 +157,145 @@ void eMainloop::processOneEvent()
 		poll_timeout /= 1000;
 	}
 	
+	if ((user_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > user_timeout))
+	{
+		poll_timeout = user_timeout;
+		return_reason = 1;
+	}
+	
 	int ret = 0;
-
+	
+	
 	if (poll_timeout)
 	{
+		std::multimap<int,eSocketNotifier*>::iterator it;
+		std::map<int,int> fd_merged;
+		std::map<int,int>::const_iterator fd_merged_it;
+		
+		for (it = notifiers.begin(); it != notifiers.end(); ++it)
+			fd_merged[it->first] |= it->second->getRequested();
+		
+		fd_merged_it = fd_merged.begin();
+		
+		int nativecount, fdcount;
+		
+		nativecount = fdcount = fd_merged.size();
+		
+		if (additional)	
+		{
+			additional = PyDict_Items(additional);
+			fdcount += PyList_Size(additional);
+		}
+
 			// build the poll aray
-		int fdcount = notifiers.size();
 		pollfd* pfd = new pollfd[fdcount];  // make new pollfd array
-
-		std::map<int,eSocketNotifier*>::iterator it(notifiers.begin());
-		for (int i=0; i < fdcount; i++, it++)
+		
+		for (int i=0; i < nativecount; i++, fd_merged_it++)
 		{
-			pfd[i].fd = it->first;
-			pfd[i].events = it->second->getRequested();
+			pfd[i].fd = fd_merged_it->first;
+			pfd[i].events = fd_merged_it->second;
+		}
+		
+		if (additional)
+		{
+			for (int i=0; i < PyList_Size(additional); ++i)
+			{
+				PyObject *it = PyList_GET_ITEM(additional, i);
+				if (!PyTuple_Check(it))
+					eFatal("poll item is not a tuple");
+				if (PyTuple_Size(it) != 2)
+					eFatal("poll tuple size is not 2");
+				int fd = PyObject_AsFileDescriptor(PyTuple_GET_ITEM(it, 0));
+				if (fd == -1)
+					eFatal("poll tuple not a filedescriptor");
+				pfd[nativecount + i].fd = fd;
+				pfd[nativecount + i].events = PyInt_AsLong(PyTuple_GET_ITEM(it, 1));
+			}
 		}
 
-		ret = poll(pfd, fdcount, poll_timeout);
-
+		ret = ::poll(pfd, fdcount, poll_timeout);
+		
 			/* ret > 0 means that there are some active poll entries. */
 		if (ret > 0)
 		{
-			for (int i=0; i < fdcount ; i++)
+			return_reason = 0;
+			for (int i=0; i < nativecount ; i++)
 			{
-				if (notifiers.find(pfd[i].fd) == notifiers.end())
-					continue;
+				it = notifiers.begin();
+				
+				int handled = 0;
 				
-				int req = notifiers[pfd[i].fd]->getRequested();
+				std::multimap<int,eSocketNotifier*>::iterator 
+					l = notifiers.lower_bound(pfd[i].fd),
+					u = notifiers.upper_bound(pfd[i].fd);
 				
-				if (pfd[i].revents & req)
+				ePtrList<eSocketNotifier> n;
+				
+				for (; l != u; ++l)
+					n.push_back(l->second);
+				
+				for (ePtrList<eSocketNotifier>::iterator li(n.begin()); li != n.end(); ++li)
 				{
-					notifiers[pfd[i].fd]->activate(pfd[i].revents);
+					int req = li->getRequested();
+					
+					handled |= req;
 				
-					if (!--ret)
-						break;
-				} else if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
-					eFatal("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d) -> FIX YOUR CODE", pfd[i].fd,pfd[i].revents);
+					if (pfd[i].revents & req)
+						(*li)->activate(pfd[i].revents);
+				}
+				if ((pfd[i].revents&~handled) & (POLLERR|POLLHUP|POLLNVAL))
+					eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents);
 			}
+			
+			for (int i = nativecount; i < fdcount; ++i)
+			{
+				if (pfd[i].revents)
+				{
+					if (!*res)
+						*res = PyList_New(0);
+					PyObject *it = PyTuple_New(2);
+					PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd));
+					PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents));
+					PyList_Append(*res, it);
+					Py_DECREF(it);
+				}
+			}
+			
+			ret = 1; /* poll did not timeout. */
 		} else if (ret < 0)
 		{
-				/* when we got a signal, we get EINTR. we do not care, 
-				   because we check current time in timers anyway. */
+				/* when we got a signal, we get EINTR. */
 			if (errno != EINTR)
 				eDebug("poll made error (%m)");
 			else
-				ret = 0;
+			{
+				return_reason = 2;
+				ret = -1; /* don't assume the timeout has passed when we got a signal */
+			}
 		}
 		delete [] pfd;
+		Py_XDECREF(additional);
 	}
 	
 		/* when we not processed anything, check timers. */
 	if (!ret)
 	{
+			/* we know that this time has passed. */
+		now += poll_timeout;
+		
 		singleLock s(recalcLock);
 
+			/* this will never change while we have the recalcLock */
+			/* we can savely return here, the timer will be re-checked soon. */
+		if (m_now_is_invalid)
+			return 0;
+
 			/* process all timers which are ready. first remove them out of the list. */
-		while ((!m_timer_list.empty()) && (m_timer_list.begin()->getNextActivation() < now))
+		while ((!m_timer_list.empty()) && (m_timer_list.begin()->getNextActivation() <= now))
 			m_timer_list.begin()->activate();
 	}
+	
+	return return_reason;
 }
 
 void eMainloop::addTimer(eTimer* e)
@@ -244,47 +308,44 @@ void eMainloop::removeTimer(eTimer* e)
 	m_timer_list.remove(e);
 }
 
-int eMainloop::exec()
+int eMainloop::iterate(unsigned int user_timeout, PyObject **res, PyObject *dict)
 {
-	if (!loop_level)
-	{
-		app_quit_now = false;
-		app_exit_loop = false;
-		enter_loop();
-	}
-	return retval;
+	int ret = 0;
+	
+	do
+	{ 
+		if (app_quit_now) return -1;
+		ret = processOneEvent(user_timeout, res, dict);
+		if (res && *res)
+			return ret;
+	} while (ret == 0);
+	
+	return ret;
 }
 
-void eMainloop::enter_loop()
+int eMainloop::runLoop()
 {
-	loop_level++;
-	// Status der vorhandenen Loop merken
-	bool old_exit_loop = app_exit_loop;
-
-	app_exit_loop = false;
-
-	while (!app_exit_loop && !app_quit_now)
-		processOneEvent();
-
-	// wiederherstellen der vorherigen app_exit_loop
-	app_exit_loop = old_exit_loop;
-
-	--loop_level;
-
-	if (!loop_level)
-	{
-		// do something here on exit the last loop
-	}
+	while (!app_quit_now)
+		iterate();
+	return retval;
 }
 
-void eMainloop::exit_loop()  // call this to leave the current loop
+PyObject *eMainloop::poll(PyObject *timeout, PyObject *dict)
 {
-	app_exit_loop = true;
+	PyObject *res = 0;
+	int user_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout);
+	
+	iterate(user_timeout, &res, dict);
+	
+	if (!res) /* return empty list on timeout */
+		res = PyList_New(0);
+	
+	return res;
 }
 
-void eMainloop::quit( int ret )   // call this to leave all loops
+void eMainloop::quit(int ret)
 {
-	retval=ret;
+	retval = ret;
 	app_quit_now = true;
 }
 
@@ -294,6 +355,7 @@ void eMainloop::addTimeOffset(int offset)
 		;it != eMainloop::existing_loops.end(); ++it)
 	{
 		singleLock s(it->recalcLock);
+		it->m_now_is_invalid = 1;
 		for (ePtrList<eTimer>::iterator tit = it->m_timer_list.begin(); tit != it->m_timer_list.end(); ++tit )
 			tit->addTimeOffset(offset);
 	}