bandaged fingers naming mistake for x264
[goodguy/cinelerra.git] / cinelerra-5.1 / libbthread-master / just-pt.cc
1 /* Cancel a thread.
2    Copyright (C) 2002 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19 #include <stdio.h>
20 #if defined(__TERMUX__)
21
22 #include <pthread.h>
23
24 #include <pt-internal.h>
25
26 #include <errno.h>
27
28 int
29 pthread_cancel (pthread_t t)
30 {
31   int err = 0;
32   struct pthread_internal_t *p = (struct pthread_internal_t*) t;
33         
34         pthread_init();
35         
36   pthread_mutex_lock (&p->cancel_lock);
37   if (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_PENDING)
38     {
39       pthread_mutex_unlock (&p->cancel_lock);
40       return 0;
41     }
42     
43   p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_PENDING;
44
45   if (!(p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE))
46     {
47       pthread_mutex_unlock (&p->cancel_lock);
48       return 0;
49     }
50
51   if (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS) {
52                 pthread_mutex_unlock (&p->cancel_lock);
53     err = __pthread_do_cancel (p);
54         } else {
55                 // DEFERRED CANCEL NOT IMPLEMENTED YET
56                 pthread_mutex_unlock (&p->cancel_lock);
57         }
58
59   return err;
60 }
61 /* Cancel a thread. */
62
63 #include <pthread.h>
64
65 #include <pt-internal.h>
66
67 static void
68 call_exit (void)
69 {
70   pthread_exit (0);
71 }
72
73 int
74 __pthread_do_cancel (struct pthread_internal_t *p)
75 {
76         
77         if(p == (struct pthread_internal_t *)pthread_self())
78     call_exit ();
79   else if(p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_HANDLER)
80     pthread_kill((pthread_t)p, SIGRTMIN);
81         else
82                 pthread_kill((pthread_t)p, SIGTERM);
83
84   return 0;
85 }
86 /* Init a thread. */
87
88 #include <pthread.h>
89 #include <bthread.h>
90 #include <pt-internal.h>
91 #include <signal.h>
92
93 void pthread_cancel_handler(int signum) {
94         pthread_exit(0);
95 }
96
97 void pthread_init(void) {
98         struct sigaction sa;
99         struct pthread_internal_t * p = (struct pthread_internal_t *)pthread_self();
100         
101         if(p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_HANDLER)
102                 return;
103         
104         // set thread status as pthread_create should do.
105         // ASYNCROUNOUS is not set, see pthread_setcancelstate(3)
106         p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_HANDLER|PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
107         
108         sa.sa_handler = pthread_cancel_handler;
109         sigemptyset(&(sa.sa_mask));
110         sa.sa_flags = 0;
111         
112         sigaction(SIGRTMIN, &sa, NULL);
113 }
114 /* Set the cancel state for the calling thread.  */
115
116 #include <pthread.h>
117 #include <bthread.h>
118 #include <pt-internal.h>
119 #include <errno.h>
120
121 int
122 pthread_setcancelstate (int state, int *oldstate)
123 {
124   struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
125         int newflags;
126
127         pthread_init();
128         
129   switch (state)
130     {
131     default:
132       return EINVAL;
133     case PTHREAD_CANCEL_ENABLE:
134     case PTHREAD_CANCEL_DISABLE:
135       break;
136     }
137
138   pthread_mutex_lock (&p->cancel_lock);
139   if (oldstate)
140     *oldstate = p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
141   
142         if(state == PTHREAD_ATTR_FLAG_CANCEL_ENABLE)
143                 p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
144         else
145                 p->attr.flags &= ~PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
146         newflags=p->attr.flags;
147   pthread_mutex_unlock (&p->cancel_lock);
148
149         if((newflags & PTHREAD_ATTR_FLAG_CANCEL_PENDING) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS))
150                 __pthread_do_cancel(p);
151         
152   return 0;
153 }
154 /*   */
155
156 #include <pthread.h>
157 #include <bthread.h>
158 #include <pt-internal.h>
159 #include <errno.h>
160
161 int
162 pthread_setcanceltype (int type, int *oldtype)
163 {
164   struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
165         int newflags;
166         
167         pthread_init();
168         
169   switch (type)
170     {
171     default:
172       return EINVAL;
173     case PTHREAD_CANCEL_DEFERRED:
174     case PTHREAD_CANCEL_ASYNCHRONOUS:
175       break;
176     }
177
178   pthread_mutex_lock (&p->cancel_lock);
179   if (oldtype)
180     *oldtype = p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS;
181         
182         if(type == PTHREAD_CANCEL_ASYNCHRONOUS)
183                 p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS;
184         else
185                 p->attr.flags &= ~PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS;
186         newflags=p->attr.flags;
187   pthread_mutex_unlock (&p->cancel_lock);
188
189         if((newflags & PTHREAD_ATTR_FLAG_CANCEL_PENDING) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS))
190                 __pthread_do_cancel(p);
191         
192   return 0;
193 }
194 /* Add an explicit cancelation point.  */
195
196 #include <pthread.h>
197 #include <bthread.h>
198 #include <pt-internal.h>
199
200 void
201 pthread_testcancel (void)
202 {
203   struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
204   int cancelled;
205         
206         pthread_init();
207
208   pthread_mutex_lock (&p->cancel_lock);
209   cancelled = (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_PENDING);
210   pthread_mutex_unlock (&p->cancel_lock);
211
212   if (cancelled)
213     pthread_exit (PTHREAD_CANCELED);
214                 
215 }
216 #endif