Stackless issue #242: more patchcheck fixes

Fix whitespace, mostly replace tab by spaces.

(cherry picked from commit 2e5f7b5)

Author: Anselm Kruis

Doc/library/stackless/debugging.rst

@@ -8,8 +8,8 @@ Debugging tools, like those used for tracing, are implemented through
 calls to the :func:`sys.settrace` function.  Now, in |CPY|, when
 this has been called any code that runs within the operating system thread
 is covered by it.  In Stackless however, this function only covers the
-current tasklet. Stackless provides the tasklet attributes 
-:attr:`~tasklet.trace_function` and :attr:`~tasklet.profile_function` to 
+current tasklet. Stackless provides the tasklet attributes
+:attr:`~tasklet.trace_function` and :attr:`~tasklet.profile_function` to
 get and set the trace/profile function of a particular tasklet.
 
 The debugging related modules, whether :doc:`in the standard library
@@ -19,8 +19,8 @@ In an ideal world, |SLP| might include modified versions of these
 modules, and patches adding them would be most welcome.
 
 If you want working debugging for |SLP|, at this time your best
-option is to use the `WingWare Python IDE <http://wingware.com>`_ 
-or the `Eclipse IDE with the PyDev-Plugin <http://pydev.org>`_.  
+option is to use the `WingWare Python IDE <http://wingware.com>`_
+or the `Eclipse IDE with the PyDev-Plugin <http://pydev.org>`_.
 Both have gone out of their way to add and support |SLP| development.
 
 .. note::
@@ -36,39 +36,39 @@ Tracing tasklets
 
 In order to get debugging support working on a per-tasklet basis, you need to
 ensure you enable tracing for all tasklets. This can be archived by the
-schedule callback. This callback sees every task switch. Here is 
+schedule callback. This callback sees every task switch. Here is
 a complete example::
 
     from __future__ import absolute_import, print_function
-    
+
     import sys
     import stackless
     import traceback
-    
-    
+
+
     class NamedTasklet(stackless.tasklet):
         __slots__ = ("name",)
-    
+
         def __init__(self, func, name=None):
             stackless.tasklet.__init__(self, func)
             if name is None:
                 name = "at %08x" % (id(self))
             self.name = name
-    
+
         def __repr__(self):
             return "<tasklet %s>" % (self.name)
-    
-    
+
+
     class Mutex(object):
-    
+
         def __init__(self, capacity=1):
             self.queue = stackless.channel()
             self.capacity = capacity
-    
+
         def isLocked(self):
             '''return non-zero if locked'''
             return self.capacity == 0
-    
+
         def lock(self):
             '''acquire the lock'''
             currentTasklet = stackless.getcurrent()
@@ -80,7 +80,7 @@ a complete example::
                     self.queue.receive()
             finally:
                 currentTasklet.set_atomic(atomic)
-    
+
         def unlock(self):
             '''release the lock'''
             currentTasklet = stackless.getcurrent()
@@ -92,10 +92,10 @@ a complete example::
                     self.capacity += 1
             finally:
                 currentTasklet.set_atomic(atomic)
-    
+
     m = Mutex()
-    
-    
+
+
     def task():
         name = stackless.getcurrent().name
         print(name, "acquiring")
@@ -104,8 +104,8 @@ a complete example::
         stackless.schedule()
         print(name, "releasing")
         m.unlock()
-    
-    
+
+
     def trace_function(frame, event, arg):
         if frame.f_code.co_name in ('schedule_cb', 'channel_cb'):
             return None
@@ -114,8 +114,8 @@ a complete example::
         if event in ('call', 'line', 'exception'):
             return trace_function
         return None
-    
-    
+
+
     def channel_cb(channel, tasklet, sending, willblock):
         tf = tasklet.trace_function
         try:
@@ -124,8 +124,8 @@ a complete example::
                   (tasklet, ("recv", "send")[sending], ("", " will block")[willblock]))
         finally:
             tasklet.trace_function = tf
-    
-    
+
+
     def schedule_cb(prev, next):
         # During a tasklet switch (during the execution of this function) the
         # the result of stackless.getcurrent() is implementation defined.
@@ -140,20 +140,20 @@ a complete example::
                 f_back = current_frame.f_back
                 if f_back is not None:
                     current_tf = f_back.f_trace
-    
+
             current_info = "Schedule CB "
             if not prev:
                 print("%sstarting %r" % (current_info, next))
             elif not next:
                 print("%sending %r" % (current_info, prev))
             else:
                 print("%sjumping from %s to %s" % (current_info, prev, next))
-    
+
             # Inform about the installed trace functions
             prev_tf = current_tf if prev.frame is current_frame else prev.trace_function
             next_tf = current_tf if next.frame is current_frame else next.trace_function
             print("    Current trace functions: prev: %r, next: %r" % (prev_tf, next_tf))
-    
+
             # Eventually set a trace function
             if next is not None:
                 if not next.is_main:
@@ -175,20 +175,20 @@ a complete example::
             traceback.print_exc()
         finally:
             sys.settrace(current_tf)
-    
+
     if __name__ == "__main__":
         if len(sys.argv) > 1 and sys.argv[1] == 'hard':
             stackless.enable_softswitch(False)
-    
+
         stackless.set_channel_callback(channel_cb)
         stackless.set_schedule_callback(schedule_cb)
-    
+
         NamedTasklet(task, "tick")()
         NamedTasklet(task, "trick")()
         NamedTasklet(task, "track")()
-    
+
         stackless.run()
-    
+
         stackless.set_channel_callback(None)
         stackless.set_schedule_callback(None)
 
@@ -199,13 +199,13 @@ a complete example::
 
 .. note::
 
-   This section is out dated and only of historical interest. Since the 
-   implementation of :attr:`~tasklet.trace_function` and 
+   This section is out dated and only of historical interest. Since the
+   implementation of :attr:`~tasklet.trace_function` and
    :attr:`~tasklet.profile_function` a debugger can enable tracing or profiling
    within the schedule callback without monkey patching.
-   
+
 In order to get debugging support working on a per-tasklet basis, you need to
-ensure you call :func:`sys.settrace` for all tasklets.  Vilhelm Saevarsson 
+ensure you call :func:`sys.settrace` for all tasklets.  Vilhelm Saevarsson
 `has an email
 <http://www.stackless.com/pipermail/stackless/2007-October/003074.html>`_
 giving code and a description of the steps required including potentially
@@ -215,7 +215,7 @@ Vilhelm's code::
 
     import sys
     import stackless
-    
+
     def contextDispatch( prev, next ):
         if not prev: #Creating next
             # I never see this print out
@@ -232,7 +232,7 @@ Vilhelm's code::
             if not next.frame.f_trace:
                 # We might already be tracing so ...
                 sys.call_tracing(next.settrace, (traceDispatch, ))
-    
+
     stackless.set_schedule_callback(contextDispatch)
 
     def __call__(self, *args, **kwargs):
@@ -243,11 +243,11 @@ Vilhelm's code::
              sys.settrace(None)
          self.tempval = new_f
          stackless.tasklet.setup(self, f, args, kwargs)
-    
+
     def settrace( self, tb ):
         self.frame.f_trace = tb
         sys.settrace(tb)
-    
+
     stackless.tasklet.__call__ = __call__
     stackless.tasklet.settrace = settrace
 

Doc/library/stackless/threads.rst

@@ -22,19 +22,19 @@ want to make use of more than one thread.
 Tasklets and Threads
 --------------------
 
-A tasklet usually has an associated thread. This thread is identified by the 
-attribute :attr:`tasklet.thread_id`. A newly created tasklet is always  
-associated with its creator thread. 
+A tasklet usually has an associated thread. This thread is identified by the
+attribute :attr:`tasklet.thread_id`. A newly created tasklet is always
+associated with its creator thread.
 
-The associated thread of a tasklet changes only as the result of 
-a :meth:`tasklet.bind_thread` call or if the associated thread 
-terminates. In the later case the thread id becomes ``-1``. Application 
+The associated thread of a tasklet changes only as the result of
+a :meth:`tasklet.bind_thread` call or if the associated thread
+terminates. In the later case the thread id becomes ``-1``. Application
 code can bind the tasklet to another thread using :meth:`~tasklet.bind_thread`.
 
-When a thread dies, only tasklets with a C-state are actively killed. 
-Soft-switched tasklets simply stop. All tasklets bound to the thread will 
+When a thread dies, only tasklets with a C-state are actively killed.
+Soft-switched tasklets simply stop. All tasklets bound to the thread will
 lose their thread-state, which means that their :attr:`~tasklet.thread_id`
-will report as ``-1``. This also includes soft-switched tasklets, 
+will report as ``-1``. This also includes soft-switched tasklets,
 which share a C-state.
 
 The reason Stackless kills tasklets with C-state is that not doing so
@@ -45,8 +45,8 @@ with a C-state. Stackless cannot
 kill soft-switched tasklets, because there is no central list of them.
 Stackless only knows about the hard-switched ones.
 
-Threads that end really should make sure that they finish whatever worker 
-tasklets they have going by manually killing (``tasklet.kill()``) or 
+Threads that end really should make sure that they finish whatever worker
+tasklets they have going by manually killing (``tasklet.kill()``) or
 unbinding (``tasklet.bind(None)``) them, but that is up to application code.
 
 During interpreter shutdown Stackless kills other daemon threads (non-daemon
@@ -69,7 +69,7 @@ Example - scheduler per thread::
 
     import threading
     import stackless
-    
+
     def secondary_thread_func():
         print("THREAD(2): Has", stackless.runcount, "tasklets in its scheduler")
 
@@ -78,12 +78,12 @@ Example - scheduler per thread::
         while thread.is_alive():
             stackless.schedule()
         print("THREAD(1): Death of THREAD(2) detected")
-    
+
     mainThreadTasklet = stackless.tasklet(main_thread_func)()
-    
+
     thread = threading.Thread(target=secondary_thread_func)
     thread.start()
-    
+
     stackless.run()
 
 Output::

Doc/whatsnew/stackless.rst

@@ -10,4 +10,4 @@ For other changes see :ref:`whatsnew-index`.
 .. include:: ../../Stackless/changelog.txt
    :literal:
    :encoding: utf-8
-   
+

Include/descrobject.h

@@ -32,7 +32,7 @@ struct wrapperbase {
     int flags;
     PyObject *name_strobj;
 #ifdef STACKLESS
-	int slp_offset;
+        int slp_offset;
 #endif
 };
 
@@ -73,7 +73,7 @@ typedef struct {
     struct wrapperbase *d_base;
     void *d_wrapped; /* This can be any function pointer */
 #ifdef STACKLESS
-	int d_slpmask;
+        int d_slpmask;
 #endif
 } PyWrapperDescrObject;
 #endif /* Py_LIMITED_API */