blob: a598df3e87a88b5fd655cda861a4f0da5d854cf4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// -*- c++ -*-
// no-threads.h - Defines for using no threads.
/* Copyright (C) 1998, 1999, 2004, 2006 Free Software Foundation
This file is part of libgcj.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
#ifndef __JV_NO_THREADS__
#define __JV_NO_THREADS__
#include "config.h"
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
//
// Typedefs.
//
typedef int _Jv_ConditionVariable_t;
typedef int _Jv_Mutex_t;
typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
//
// Declarations
//
class _Jv_Thread_t { };
//
// Condition variables.
//
inline void
_Jv_CondInit (_Jv_ConditionVariable_t *)
{
}
// Waiting is ok provided there is a timeout. Otherwise we will just
// wait forever.
inline int
_Jv_CondWait (_Jv_ConditionVariable_t *, _Jv_Mutex_t *,
jlong millis, jint nanos)
{
if (millis == 0 && nanos == 0)
JvFail ("_Jv_CondWait without timeout");
#ifdef HAVE_SLEEP
int seconds = millis / 1000;
if (seconds > 0)
sleep (seconds);
#endif
return 0;
}
inline int
_Jv_CondNotify (_Jv_ConditionVariable_t *, _Jv_Mutex_t *)
{
// It is ok to notify -- it just has no effect.
return 0;
}
inline int
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *, _Jv_Mutex_t *)
{
// It is ok to notify -- it just has no effect.
return 0;
}
//
// Mutexes.
//
inline int _Jv_MutexCheckMonitor (_Jv_Mutex_t *)
{
return 0;
}
inline void
_Jv_MutexInit (_Jv_Mutex_t *)
{
}
inline int
_Jv_MutexLock (_Jv_Mutex_t *)
{
return 0;
}
inline int
_Jv_MutexUnlock (_Jv_Mutex_t *)
{
return 0;
}
//
// Thread creation and manipulation.
//
inline void
_Jv_InitThreads (void)
{
}
_Jv_Thread_t *
_Jv_ThreadInitData (java::lang::Thread *);
inline void
_Jv_ThreadDestroyData (_Jv_Thread_t *)
{
}
inline java::lang::Thread *
_Jv_ThreadCurrent (void)
{
extern java::lang::Thread *_Jv_OnlyThread;
return _Jv_OnlyThread;
}
inline void
_Jv_ThreadYield (void)
{
}
inline void
_Jv_ThreadSetPriority (_Jv_Thread_t *, jint)
{
}
inline void
_Jv_ThreadRegister (_Jv_Thread_t *)
{
}
inline void
_Jv_ThreadUnRegister (void)
{
}
void _Jv_ThreadStart (java::lang::Thread *, _Jv_Thread_t *,
_Jv_ThreadStartFunc *meth);
inline void
_Jv_ThreadWait (void)
{
}
inline void
_Jv_ThreadInterrupt (_Jv_Thread_t *)
{
}
#endif /* __JV_NO_THREADS__ */
|
