Mercurial > hg > CbC > CbC_gcc
comparison gcc/ada/libgnarl/s-osinte__darwin.ads @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 ------------------------------------------------------------------------------ | |
2 -- -- | |
3 -- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS -- | |
4 -- -- | |
5 -- S Y S T E M . O S _ I N T E R F A C E -- | |
6 -- -- | |
7 -- S p e c -- | |
8 -- -- | |
9 -- Copyright (C) 1991-2017, Florida State University -- | |
10 -- Copyright (C) 1995-2017, Free Software Foundation, Inc. -- | |
11 -- -- | |
12 -- GNAT is free software; you can redistribute it and/or modify it under -- | |
13 -- terms of the GNU General Public License as published by the Free Soft- -- | |
14 -- ware Foundation; either version 3, or (at your option) any later ver- -- | |
15 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |
16 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- | |
17 -- or FITNESS FOR A PARTICULAR PURPOSE. -- | |
18 -- -- | |
19 -- As a special exception under Section 7 of GPL version 3, you are granted -- | |
20 -- additional permissions described in the GCC Runtime Library Exception, -- | |
21 -- version 3.1, as published by the Free Software Foundation. -- | |
22 -- -- | |
23 -- You should have received a copy of the GNU General Public License and -- | |
24 -- a copy of the GCC Runtime Library Exception along with this program; -- | |
25 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- | |
26 -- <http://www.gnu.org/licenses/>. -- | |
27 -- -- | |
28 -- GNARL was developed by the GNARL team at Florida State University. -- | |
29 -- Extensive contributions were provided by Ada Core Technologies, Inc. -- | |
30 -- -- | |
31 ------------------------------------------------------------------------------ | |
32 | |
33 -- This is Darwin pthreads version of this package | |
34 | |
35 -- This package includes all direct interfaces to OS services that are needed | |
36 -- by the tasking run-time (libgnarl). | |
37 | |
38 -- PLEASE DO NOT add any with-clauses to this package or remove the pragma | |
39 -- Elaborate_Body. It is designed to be a bottom-level (leaf) package. | |
40 | |
41 with Interfaces.C; | |
42 with System.OS_Constants; | |
43 | |
44 package System.OS_Interface is | |
45 pragma Preelaborate; | |
46 | |
47 subtype int is Interfaces.C.int; | |
48 subtype short is Interfaces.C.short; | |
49 subtype long is Interfaces.C.long; | |
50 subtype unsigned is Interfaces.C.unsigned; | |
51 subtype unsigned_short is Interfaces.C.unsigned_short; | |
52 subtype unsigned_long is Interfaces.C.unsigned_long; | |
53 subtype unsigned_char is Interfaces.C.unsigned_char; | |
54 subtype plain_char is Interfaces.C.plain_char; | |
55 subtype size_t is Interfaces.C.size_t; | |
56 | |
57 ----------- | |
58 -- Errno -- | |
59 ----------- | |
60 | |
61 function errno return int; | |
62 pragma Import (C, errno, "__get_errno"); | |
63 | |
64 EINTR : constant := 4; | |
65 ENOMEM : constant := 12; | |
66 EINVAL : constant := 22; | |
67 EAGAIN : constant := 35; | |
68 ETIMEDOUT : constant := 60; | |
69 | |
70 ------------- | |
71 -- Signals -- | |
72 ------------- | |
73 | |
74 Max_Interrupt : constant := 31; | |
75 type Signal is new int range 0 .. Max_Interrupt; | |
76 for Signal'Size use int'Size; | |
77 | |
78 SIGHUP : constant := 1; -- hangup | |
79 SIGINT : constant := 2; -- interrupt (rubout) | |
80 SIGQUIT : constant := 3; -- quit (ASCD FS) | |
81 SIGILL : constant := 4; -- illegal instruction (not reset) | |
82 SIGTRAP : constant := 5; -- trace trap (not reset) | |
83 SIGIOT : constant := 6; -- IOT instruction | |
84 SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the future | |
85 SIGEMT : constant := 7; -- EMT instruction | |
86 SIGFPE : constant := 8; -- floating point exception | |
87 SIGKILL : constant := 9; -- kill (cannot be caught or ignored) | |
88 SIGBUS : constant := 10; -- bus error | |
89 SIGSEGV : constant := 11; -- segmentation violation | |
90 SIGSYS : constant := 12; -- bad argument to system call | |
91 SIGPIPE : constant := 13; -- write on a pipe with no one to read it | |
92 SIGALRM : constant := 14; -- alarm clock | |
93 SIGTERM : constant := 15; -- software termination signal from kill | |
94 SIGURG : constant := 16; -- urgent condition on IO channel | |
95 SIGSTOP : constant := 17; -- stop (cannot be caught or ignored) | |
96 SIGTSTP : constant := 18; -- user stop requested from tty | |
97 SIGCONT : constant := 19; -- stopped process has been continued | |
98 SIGCHLD : constant := 20; -- child status change | |
99 SIGTTIN : constant := 21; -- background tty read attempted | |
100 SIGTTOU : constant := 22; -- background tty write attempted | |
101 SIGIO : constant := 23; -- I/O possible (Solaris SIGPOLL alias) | |
102 SIGXCPU : constant := 24; -- CPU time limit exceeded | |
103 SIGXFSZ : constant := 25; -- filesize limit exceeded | |
104 SIGVTALRM : constant := 26; -- virtual timer expired | |
105 SIGPROF : constant := 27; -- profiling timer expired | |
106 SIGWINCH : constant := 28; -- window size change | |
107 SIGINFO : constant := 29; -- information request | |
108 SIGUSR1 : constant := 30; -- user defined signal 1 | |
109 SIGUSR2 : constant := 31; -- user defined signal 2 | |
110 | |
111 SIGADAABORT : constant := SIGABRT; | |
112 -- Change this if you want to use another signal for task abort. | |
113 -- SIGTERM might be a good one. | |
114 | |
115 type Signal_Set is array (Natural range <>) of Signal; | |
116 | |
117 Unmasked : constant Signal_Set := | |
118 (SIGTTIN, SIGTTOU, SIGSTOP, SIGTSTP); | |
119 | |
120 Reserved : constant Signal_Set := | |
121 (SIGKILL, SIGSTOP); | |
122 | |
123 Exception_Signals : constant Signal_Set := | |
124 (SIGFPE, SIGILL, SIGSEGV, SIGBUS); | |
125 -- These signals (when runtime or system) will be caught and converted | |
126 -- into an Ada exception. | |
127 | |
128 type sigset_t is private; | |
129 | |
130 function sigaddset (set : access sigset_t; sig : Signal) return int; | |
131 pragma Import (C, sigaddset, "sigaddset"); | |
132 | |
133 function sigdelset (set : access sigset_t; sig : Signal) return int; | |
134 pragma Import (C, sigdelset, "sigdelset"); | |
135 | |
136 function sigfillset (set : access sigset_t) return int; | |
137 pragma Import (C, sigfillset, "sigfillset"); | |
138 | |
139 function sigismember (set : access sigset_t; sig : Signal) return int; | |
140 pragma Import (C, sigismember, "sigismember"); | |
141 | |
142 function sigemptyset (set : access sigset_t) return int; | |
143 pragma Import (C, sigemptyset, "sigemptyset"); | |
144 | |
145 type siginfo_t is private; | |
146 type ucontext_t is private; | |
147 | |
148 type Signal_Handler is access procedure | |
149 (signo : Signal; | |
150 info : access siginfo_t; | |
151 context : access ucontext_t); | |
152 | |
153 type struct_sigaction is record | |
154 sa_handler : System.Address; | |
155 sa_mask : sigset_t; | |
156 sa_flags : int; | |
157 end record; | |
158 pragma Convention (C, struct_sigaction); | |
159 type struct_sigaction_ptr is access all struct_sigaction; | |
160 | |
161 SIG_BLOCK : constant := 1; | |
162 SIG_UNBLOCK : constant := 2; | |
163 SIG_SETMASK : constant := 3; | |
164 | |
165 SIG_DFL : constant := 0; | |
166 SIG_IGN : constant := 1; | |
167 | |
168 SA_SIGINFO : constant := 16#0040#; | |
169 SA_ONSTACK : constant := 16#0001#; | |
170 | |
171 function sigaction | |
172 (sig : Signal; | |
173 act : struct_sigaction_ptr; | |
174 oact : struct_sigaction_ptr) return int; | |
175 pragma Import (C, sigaction, "sigaction"); | |
176 | |
177 ---------- | |
178 -- Time -- | |
179 ---------- | |
180 | |
181 Time_Slice_Supported : constant Boolean := True; | |
182 -- Indicates whether time slicing is supported | |
183 | |
184 type timespec is private; | |
185 | |
186 type clockid_t is new int; | |
187 | |
188 function clock_gettime | |
189 (clock_id : clockid_t; | |
190 tp : access timespec) return int; | |
191 | |
192 function clock_getres | |
193 (clock_id : clockid_t; | |
194 res : access timespec) return int; | |
195 | |
196 function To_Duration (TS : timespec) return Duration; | |
197 pragma Inline (To_Duration); | |
198 | |
199 function To_Timespec (D : Duration) return timespec; | |
200 pragma Inline (To_Timespec); | |
201 | |
202 ------------------------- | |
203 -- Priority Scheduling -- | |
204 ------------------------- | |
205 | |
206 SCHED_OTHER : constant := 1; | |
207 SCHED_RR : constant := 2; | |
208 SCHED_FIFO : constant := 4; | |
209 | |
210 function To_Target_Priority | |
211 (Prio : System.Any_Priority) return Interfaces.C.int; | |
212 -- Maps System.Any_Priority to a POSIX priority | |
213 | |
214 ------------- | |
215 -- Process -- | |
216 ------------- | |
217 | |
218 type pid_t is private; | |
219 | |
220 function kill (pid : pid_t; sig : Signal) return int; | |
221 pragma Import (C, kill, "kill"); | |
222 | |
223 function getpid return pid_t; | |
224 pragma Import (C, getpid, "getpid"); | |
225 | |
226 --------- | |
227 -- LWP -- | |
228 --------- | |
229 | |
230 function lwp_self return System.Address; | |
231 pragma Import (C, lwp_self, "__gnat_lwp_self"); | |
232 -- Return the mach thread bound to the current thread. The value is not | |
233 -- used by the run-time library but made available to debuggers. | |
234 | |
235 ------------- | |
236 -- Threads -- | |
237 ------------- | |
238 | |
239 type Thread_Body is access | |
240 function (arg : System.Address) return System.Address; | |
241 pragma Convention (C, Thread_Body); | |
242 | |
243 type pthread_t is private; | |
244 subtype Thread_Id is pthread_t; | |
245 | |
246 type pthread_mutex_t is limited private; | |
247 type pthread_cond_t is limited private; | |
248 type pthread_attr_t is limited private; | |
249 type pthread_mutexattr_t is limited private; | |
250 type pthread_condattr_t is limited private; | |
251 type pthread_key_t is private; | |
252 | |
253 type pthread_mutex_ptr is access all pthread_mutex_t; | |
254 type pthread_cond_ptr is access all pthread_cond_t; | |
255 | |
256 PTHREAD_CREATE_DETACHED : constant := 2; | |
257 | |
258 PTHREAD_SCOPE_PROCESS : constant := 2; | |
259 PTHREAD_SCOPE_SYSTEM : constant := 1; | |
260 | |
261 -- Read/Write lock not supported on Darwin. To add support both types | |
262 -- pthread_rwlock_t and pthread_rwlockattr_t must properly be defined | |
263 -- with the associated routines pthread_rwlock_[init/destroy] and | |
264 -- pthread_rwlock_[rdlock/wrlock/unlock]. | |
265 | |
266 subtype pthread_rwlock_t is pthread_mutex_t; | |
267 subtype pthread_rwlockattr_t is pthread_mutexattr_t; | |
268 | |
269 ----------- | |
270 -- Stack -- | |
271 ----------- | |
272 | |
273 type stack_t is record | |
274 ss_sp : System.Address; | |
275 ss_size : size_t; | |
276 ss_flags : int; | |
277 end record; | |
278 pragma Convention (C, stack_t); | |
279 | |
280 function sigaltstack | |
281 (ss : not null access stack_t; | |
282 oss : access stack_t) return int; | |
283 pragma Import (C, sigaltstack, "sigaltstack"); | |
284 | |
285 Alternate_Stack : aliased System.Address; | |
286 pragma Import (C, Alternate_Stack, "__gnat_alternate_stack"); | |
287 -- The alternate signal stack for stack overflows | |
288 | |
289 Alternate_Stack_Size : constant := 32 * 1024; | |
290 -- This must be in keeping with init.c:__gnat_alternate_stack | |
291 | |
292 Stack_Base_Available : constant Boolean := False; | |
293 -- Indicates whether the stack base is available on this target. This | |
294 -- allows us to share s-osinte.adb between all the FSU run time. Note that | |
295 -- this value can only be true if pthread_t has a complete definition that | |
296 -- corresponds exactly to the C header files. | |
297 | |
298 function Get_Stack_Base (thread : pthread_t) return System.Address; | |
299 pragma Inline (Get_Stack_Base); | |
300 -- returns the stack base of the specified thread. Only call this function | |
301 -- when Stack_Base_Available is True. | |
302 | |
303 function Get_Page_Size return int; | |
304 pragma Import (C, Get_Page_Size, "getpagesize"); | |
305 -- Returns the size of a page | |
306 | |
307 PROT_NONE : constant := 0; | |
308 PROT_READ : constant := 1; | |
309 PROT_WRITE : constant := 2; | |
310 PROT_EXEC : constant := 4; | |
311 PROT_ALL : constant := PROT_READ + PROT_WRITE + PROT_EXEC; | |
312 | |
313 PROT_ON : constant := PROT_NONE; | |
314 PROT_OFF : constant := PROT_ALL; | |
315 | |
316 function mprotect | |
317 (addr : System.Address; | |
318 len : size_t; | |
319 prot : int) return int; | |
320 pragma Import (C, mprotect); | |
321 | |
322 --------------------------------------- | |
323 -- Nonstandard Thread Initialization -- | |
324 --------------------------------------- | |
325 | |
326 procedure pthread_init; | |
327 | |
328 ------------------------- | |
329 -- POSIX.1c Section 3 -- | |
330 ------------------------- | |
331 | |
332 function sigwait (set : access sigset_t; sig : access Signal) return int; | |
333 pragma Import (C, sigwait, "sigwait"); | |
334 | |
335 function pthread_kill (thread : pthread_t; sig : Signal) return int; | |
336 pragma Import (C, pthread_kill, "pthread_kill"); | |
337 | |
338 function pthread_sigmask | |
339 (how : int; | |
340 set : access sigset_t; | |
341 oset : access sigset_t) return int; | |
342 pragma Import (C, pthread_sigmask, "pthread_sigmask"); | |
343 | |
344 -------------------------- | |
345 -- POSIX.1c Section 11 -- | |
346 -------------------------- | |
347 | |
348 function pthread_mutexattr_init | |
349 (attr : access pthread_mutexattr_t) return int; | |
350 pragma Import (C, pthread_mutexattr_init, "pthread_mutexattr_init"); | |
351 | |
352 function pthread_mutexattr_destroy | |
353 (attr : access pthread_mutexattr_t) return int; | |
354 pragma Import (C, pthread_mutexattr_destroy, "pthread_mutexattr_destroy"); | |
355 | |
356 function pthread_mutex_init | |
357 (mutex : access pthread_mutex_t; | |
358 attr : access pthread_mutexattr_t) return int; | |
359 pragma Import (C, pthread_mutex_init, "pthread_mutex_init"); | |
360 | |
361 function pthread_mutex_destroy (mutex : access pthread_mutex_t) return int; | |
362 pragma Import (C, pthread_mutex_destroy, "pthread_mutex_destroy"); | |
363 | |
364 function pthread_mutex_lock (mutex : access pthread_mutex_t) return int; | |
365 pragma Import (C, pthread_mutex_lock, "pthread_mutex_lock"); | |
366 | |
367 function pthread_mutex_unlock (mutex : access pthread_mutex_t) return int; | |
368 pragma Import (C, pthread_mutex_unlock, "pthread_mutex_unlock"); | |
369 | |
370 function pthread_condattr_init | |
371 (attr : access pthread_condattr_t) return int; | |
372 pragma Import (C, pthread_condattr_init, "pthread_condattr_init"); | |
373 | |
374 function pthread_condattr_destroy | |
375 (attr : access pthread_condattr_t) return int; | |
376 pragma Import (C, pthread_condattr_destroy, "pthread_condattr_destroy"); | |
377 | |
378 function pthread_cond_init | |
379 (cond : access pthread_cond_t; | |
380 attr : access pthread_condattr_t) return int; | |
381 pragma Import (C, pthread_cond_init, "pthread_cond_init"); | |
382 | |
383 function pthread_cond_destroy (cond : access pthread_cond_t) return int; | |
384 pragma Import (C, pthread_cond_destroy, "pthread_cond_destroy"); | |
385 | |
386 function pthread_cond_signal (cond : access pthread_cond_t) return int; | |
387 pragma Import (C, pthread_cond_signal, "pthread_cond_signal"); | |
388 | |
389 function pthread_cond_wait | |
390 (cond : access pthread_cond_t; | |
391 mutex : access pthread_mutex_t) return int; | |
392 pragma Import (C, pthread_cond_wait, "pthread_cond_wait"); | |
393 | |
394 function pthread_cond_timedwait | |
395 (cond : access pthread_cond_t; | |
396 mutex : access pthread_mutex_t; | |
397 abstime : access timespec) return int; | |
398 pragma Import (C, pthread_cond_timedwait, "pthread_cond_timedwait"); | |
399 | |
400 Relative_Timed_Wait : constant Boolean := False; | |
401 -- pthread_cond_timedwait requires an absolute delay time | |
402 | |
403 -------------------------- | |
404 -- POSIX.1c Section 13 -- | |
405 -------------------------- | |
406 | |
407 PTHREAD_PRIO_NONE : constant := 0; | |
408 PTHREAD_PRIO_INHERIT : constant := 1; | |
409 PTHREAD_PRIO_PROTECT : constant := 2; | |
410 | |
411 function pthread_mutexattr_setprotocol | |
412 (attr : access pthread_mutexattr_t; | |
413 protocol : int) return int; | |
414 pragma Import | |
415 (C, pthread_mutexattr_setprotocol, "pthread_mutexattr_setprotocol"); | |
416 | |
417 function pthread_mutexattr_setprioceiling | |
418 (attr : access pthread_mutexattr_t; | |
419 prioceiling : int) return int; | |
420 pragma Import | |
421 (C, pthread_mutexattr_setprioceiling, | |
422 "pthread_mutexattr_setprioceiling"); | |
423 | |
424 type padding is array (int range <>) of Interfaces.C.char; | |
425 | |
426 type struct_sched_param is record | |
427 sched_priority : int; -- scheduling priority | |
428 opaque : padding (1 .. 4); | |
429 end record; | |
430 pragma Convention (C, struct_sched_param); | |
431 | |
432 function pthread_setschedparam | |
433 (thread : pthread_t; | |
434 policy : int; | |
435 param : access struct_sched_param) return int; | |
436 pragma Import (C, pthread_setschedparam, "pthread_setschedparam"); | |
437 | |
438 function pthread_attr_setscope | |
439 (attr : access pthread_attr_t; | |
440 contentionscope : int) return int; | |
441 pragma Import (C, pthread_attr_setscope, "pthread_attr_setscope"); | |
442 | |
443 function pthread_attr_setinheritsched | |
444 (attr : access pthread_attr_t; | |
445 inheritsched : int) return int; | |
446 pragma Import | |
447 (C, pthread_attr_setinheritsched, "pthread_attr_setinheritsched"); | |
448 | |
449 function pthread_attr_setschedpolicy | |
450 (attr : access pthread_attr_t; | |
451 policy : int) return int; | |
452 pragma Import (C, pthread_attr_setschedpolicy, "pthread_attr_setsched"); | |
453 | |
454 function sched_yield return int; | |
455 | |
456 --------------------------- | |
457 -- P1003.1c - Section 16 -- | |
458 --------------------------- | |
459 | |
460 function pthread_attr_init (attributes : access pthread_attr_t) return int; | |
461 pragma Import (C, pthread_attr_init, "pthread_attr_init"); | |
462 | |
463 function pthread_attr_destroy | |
464 (attributes : access pthread_attr_t) return int; | |
465 pragma Import (C, pthread_attr_destroy, "pthread_attr_destroy"); | |
466 | |
467 function pthread_attr_setdetachstate | |
468 (attr : access pthread_attr_t; | |
469 detachstate : int) return int; | |
470 pragma Import | |
471 (C, pthread_attr_setdetachstate, "pthread_attr_setdetachstate"); | |
472 | |
473 function pthread_attr_setstacksize | |
474 (attr : access pthread_attr_t; | |
475 stacksize : size_t) return int; | |
476 pragma Import | |
477 (C, pthread_attr_setstacksize, "pthread_attr_setstacksize"); | |
478 | |
479 function pthread_create | |
480 (thread : access pthread_t; | |
481 attributes : access pthread_attr_t; | |
482 start_routine : Thread_Body; | |
483 arg : System.Address) return int; | |
484 pragma Import (C, pthread_create, "pthread_create"); | |
485 | |
486 procedure pthread_exit (status : System.Address); | |
487 pragma Import (C, pthread_exit, "pthread_exit"); | |
488 | |
489 function pthread_self return pthread_t; | |
490 pragma Import (C, pthread_self, "pthread_self"); | |
491 | |
492 -------------------------- | |
493 -- POSIX.1c Section 17 -- | |
494 -------------------------- | |
495 | |
496 function pthread_setspecific | |
497 (key : pthread_key_t; | |
498 value : System.Address) return int; | |
499 pragma Import (C, pthread_setspecific, "pthread_setspecific"); | |
500 | |
501 function pthread_getspecific (key : pthread_key_t) return System.Address; | |
502 pragma Import (C, pthread_getspecific, "pthread_getspecific"); | |
503 | |
504 type destructor_pointer is access procedure (arg : System.Address); | |
505 pragma Convention (C, destructor_pointer); | |
506 | |
507 function pthread_key_create | |
508 (key : access pthread_key_t; | |
509 destructor : destructor_pointer) return int; | |
510 pragma Import (C, pthread_key_create, "pthread_key_create"); | |
511 | |
512 private | |
513 | |
514 type sigset_t is new unsigned; | |
515 | |
516 type int32_t is new int; | |
517 | |
518 type pid_t is new int32_t; | |
519 | |
520 type time_t is new long; | |
521 | |
522 type timespec is record | |
523 tv_sec : time_t; | |
524 tv_nsec : long; | |
525 end record; | |
526 pragma Convention (C, timespec); | |
527 | |
528 -- | |
529 -- Darwin specific signal implementation | |
530 -- | |
531 type Pad_Type is array (1 .. 7) of unsigned_long; | |
532 type siginfo_t is record | |
533 si_signo : int; -- signal number | |
534 si_errno : int; -- errno association | |
535 si_code : int; -- signal code | |
536 si_pid : int; -- sending process | |
537 si_uid : unsigned; -- sender's ruid | |
538 si_status : int; -- exit value | |
539 si_addr : System.Address; -- faulting instruction | |
540 si_value : System.Address; -- signal value | |
541 si_band : long; -- band event for SIGPOLL | |
542 pad : Pad_Type; -- RFU | |
543 end record; | |
544 pragma Convention (C, siginfo_t); | |
545 | |
546 type mcontext_t is new System.Address; | |
547 | |
548 type ucontext_t is record | |
549 uc_onstack : int; | |
550 uc_sigmask : sigset_t; -- Signal Mask Used By This Context | |
551 uc_stack : stack_t; -- Stack Used By This Context | |
552 uc_link : System.Address; -- Pointer To Resuming Context | |
553 uc_mcsize : size_t; -- Size of The Machine Context | |
554 uc_mcontext : mcontext_t; -- Machine Specific Context | |
555 end record; | |
556 pragma Convention (C, ucontext_t); | |
557 | |
558 -- | |
559 -- Darwin specific pthread implementation | |
560 -- | |
561 type pthread_t is new System.Address; | |
562 | |
563 type pthread_attr_t is record | |
564 sig : long; | |
565 opaque : padding (1 .. System.OS_Constants.PTHREAD_ATTR_SIZE); | |
566 end record; | |
567 pragma Convention (C, pthread_attr_t); | |
568 | |
569 type pthread_mutexattr_t is record | |
570 sig : long; | |
571 opaque : padding (1 .. System.OS_Constants.PTHREAD_MUTEXATTR_SIZE); | |
572 end record; | |
573 pragma Convention (C, pthread_mutexattr_t); | |
574 | |
575 type pthread_mutex_t is record | |
576 sig : long; | |
577 opaque : padding (1 .. System.OS_Constants.PTHREAD_MUTEX_SIZE); | |
578 end record; | |
579 pragma Convention (C, pthread_mutex_t); | |
580 | |
581 type pthread_condattr_t is record | |
582 sig : long; | |
583 opaque : padding (1 .. System.OS_Constants.PTHREAD_CONDATTR_SIZE); | |
584 end record; | |
585 pragma Convention (C, pthread_condattr_t); | |
586 | |
587 type pthread_cond_t is record | |
588 sig : long; | |
589 opaque : padding (1 .. System.OS_Constants.PTHREAD_COND_SIZE); | |
590 end record; | |
591 pragma Convention (C, pthread_cond_t); | |
592 | |
593 type pthread_once_t is record | |
594 sig : long; | |
595 opaque : padding (1 .. System.OS_Constants.PTHREAD_ONCE_SIZE); | |
596 end record; | |
597 pragma Convention (C, pthread_once_t); | |
598 | |
599 type pthread_key_t is new unsigned_long; | |
600 | |
601 end System.OS_Interface; |