← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Python/thread_wince.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
Python/thread_wince.h
 
1
 
 
2
/* This code implemented by Mark Hammond (MHammond@skippinet.com.au) */
 
3
 
 
4
#include <windows.h>
 
5
#include <limits.h>
 
6
#include <pydebug.h>
 
7
 
 
8
long PyThread_get_thread_ident(void);
 
9
 
 
10
/*
 
11
 * Change all headers to pure ANSI as no one will use K&R style on an
 
12
 * NT
 
13
 */
 
14
 
 
15
/*
 
16
 * Initialization of the C package, should not be needed.
 
17
 */
 
18
static void PyThread__init_thread(void)
 
19
{
 
20
}
 
21
 
 
22
/*
 
23
 * Thread support.
 
24
 */
 
25
long PyThread_start_new_thread(void (*func)(void *), void *arg)
 
26
{
 
27
        long rv;
 
28
        int success = -1;
 
29
 
 
30
        dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
 
31
        if (!initialized)
 
32
                PyThread_init_thread();
 
33
 
 
34
        rv = _beginthread(func, 0, arg); /* use default stack size */
 
35
 
 
36
        if (rv != -1) {
 
37
                success = 0;
 
38
                dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
 
39
        }
 
40
 
 
41
        return success;
 
42
}
 
43
 
 
44
/*
 
45
 * Return the thread Id instead of an handle. The Id is said to uniquely identify the
 
46
 * thread in the system
 
47
 */
 
48
long PyThread_get_thread_ident(void)
 
49
{
 
50
        if (!initialized)
 
51
                PyThread_init_thread();
 
52
        
 
53
        return GetCurrentThreadId();
 
54
}
 
55
 
 
56
static void do_PyThread_exit_thread(int no_cleanup)
 
57
{
 
58
        dprintf(("%ld: do_PyThread_exit_thread called\n", PyThread_get_thread_ident()));
 
59
        if (!initialized)
 
60
                if (no_cleanup)
 
61
                        exit(0); /* XXX - was _exit()!! */
 
62
                else
 
63
                        exit(0);
 
64
        _endthread();
 
65
}
 
66
 
 
67
void PyThread_exit_thread(void)
 
68
{
 
69
        do_PyThread_exit_thread(0);
 
70
}
 
71
 
 
72
void PyThread__exit_thread(void)
 
73
{
 
74
        do_PyThread_exit_thread(1);
 
75
}
 
76
 
 
77
#ifndef NO_EXIT_PROG
 
78
static void do_PyThread_exit_prog(int status, int no_cleanup)
 
79
{
 
80
        dprintf(("PyThread_exit_prog(%d) called\n", status));
 
81
        if (!initialized)
 
82
                if (no_cleanup)
 
83
                        _exit(status);
 
84
                else
 
85
                        exit(status);
 
86
}
 
87
 
 
88
void PyThread_exit_prog(int status)
 
89
{
 
90
        do_PyThread_exit_prog(status, 0);
 
91
}
 
92
 
 
93
void PyThread__exit_prog(int status)
 
94
{
 
95
        do_PyThread_exit_prog(status, 1);
 
96
}
 
97
#endif /* NO_EXIT_PROG */
 
98
 
 
99
/*
 
100
 * Lock support. It has to be implemented using Mutexes, as
 
101
 * CE doesnt support semaphores.  Therefore we use some hacks to
 
102
 * simulate the non reentrant requirements of Python locks
 
103
 */
 
104
PyThread_type_lock PyThread_allocate_lock(void)
 
105
{
 
106
    HANDLE aLock;
 
107
 
 
108
    dprintf(("PyThread_allocate_lock called\n"));
 
109
    if (!initialized)
 
110
        PyThread_init_thread();
 
111
 
 
112
    aLock = CreateEvent(NULL,           /* Security attributes      */
 
113
                        0,              /* Manual-Reset               */
 
114
                                                1,              /* Is initially signalled  */
 
115
                        NULL);          /* Name of event            */
 
116
 
 
117
    dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 
118
 
 
119
    return (PyThread_type_lock) aLock;
 
120
}
 
121
 
 
122
void PyThread_free_lock(PyThread_type_lock aLock)
 
123
{
 
124
    dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
125
 
 
126
    CloseHandle(aLock);
 
127
}
 
128
 
 
129
/*
 
130
 * Return 1 on success if the lock was acquired
 
131
 *
 
132
 * and 0 if the lock was not acquired. This means a 0 is returned
 
133
 * if the lock has already been acquired by this thread!
 
134
 */
 
135
int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 
136
{
 
137
    int success = 1;
 
138
    DWORD waitResult;
 
139
 
 
140
    dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
 
141
 
 
142
#ifndef DEBUG
 
143
    waitResult = WaitForSingleObject(aLock, (waitflag ? INFINITE : 0));
 
144
#else
 
145
        /* To aid in debugging, we regularly wake up.  This allows us to
 
146
        break into the debugger */
 
147
        while (TRUE) {
 
148
                waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
 
149
                if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))
 
150
                        break;
 
151
        }
 
152
#endif
 
153
 
 
154
    if (waitResult != WAIT_OBJECT_0) {
 
155
                success = 0;    /* We failed */
 
156
    }
 
157
 
 
158
        dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
 
159
 
 
160
        return success;
 
161
}
 
162
 
 
163
void PyThread_release_lock(PyThread_type_lock aLock)
 
164
{
 
165
    dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
166
 
 
167
    if (!SetEvent(aLock))
 
168
        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 
169
}
 
170
 
 
171