7fd59977 |
1 | |
2 | #include <OSD.ixx> |
3 | |
4 | #include <stdio.h> |
5 | #include <math.h> |
6 | #if HAVE_IEEEFP_H |
7 | # include <ieeefp.h> |
8 | #endif |
9 | #if !defined(HAVE_FINITE) && defined(isfinite) |
10 | # define finite isfinite |
11 | #endif |
12 | |
13 | static Standard_Integer DecimalPoint = 0 ; |
14 | |
15 | static void GetDecimalPoint() { |
16 | float F1 = (float ) 1.1 ; |
17 | char str[5] ; |
18 | |
19 | sprintf(str,"%.1f",F1) ; |
20 | // printf("%s\n",str) ; |
21 | DecimalPoint = str[1] ; |
22 | } |
23 | |
24 | // Convert Real to CString in format e with 16 significant digits. |
25 | // The decimal point character is always a period. |
26 | // The conversion is independant from current locale database |
27 | |
28 | Standard_Boolean OSD::RealToCString(const Standard_Real aReal, |
29 | Standard_PCharacter& aString) |
30 | { |
31 | char *p, *q ; |
32 | |
33 | // Get the local decimal point character |
34 | |
35 | if (!DecimalPoint) |
36 | GetDecimalPoint() ; |
37 | |
38 | // Substitute it |
39 | |
40 | // if (sprintf(aString,"%.15le",aReal) <= 0) |
41 | if (sprintf(aString,"%.17e",aReal) <= 0) //BUC60808 |
42 | return Standard_False ; |
43 | |
44 | if ((p = strchr(aString,DecimalPoint))) |
45 | *p = '.' ; |
46 | |
47 | // Suppress "e+00" and unsignificant 0's |
48 | |
49 | if ((p = strchr(aString,'e'))) { |
50 | if (!strcmp(p,"e+00")) |
51 | *p = 0 ; |
52 | for (q = p-1 ; *q == '0' ; q--) ; |
53 | if (q != p-1) { |
54 | if (*q != '.') q++ ; |
55 | while (*p) |
56 | *q++ = *p++ ; |
57 | *q = 0 ; |
58 | } |
59 | } |
60 | return Standard_True ; |
61 | } |
62 | |
63 | // Make the RealToCString reciprocal conversion. |
64 | |
65 | Standard_Boolean OSD::CStringToReal(const Standard_CString aString, |
66 | Standard_Real& aReal) |
67 | { |
68 | const char *p; |
69 | char *endptr ; |
70 | |
71 | |
72 | // Get the local decimal point character |
73 | |
74 | if (!DecimalPoint) |
75 | GetDecimalPoint() ; |
76 | |
77 | const char *str = aString; |
78 | char buff[1024]; |
79 | //if((p = strchr(aString,'.'))) |
80 | if(DecimalPoint != '.' && (p = strchr(aString,'.'))&& ((p-aString) < 1000) ) |
81 | { |
82 | strncpy(buff, aString, 1000); |
83 | buff[p-aString] = DecimalPoint ; |
84 | str = buff; |
85 | } |
86 | aReal = strtod(str,&endptr) ; |
87 | if (*endptr) |
88 | return Standard_False ; |
89 | return Standard_True; |
90 | } |
91 | |
92 | //======================================================================= |
93 | //function : OSDSecSleep |
94 | //purpose : Cause the process to sleep during a amount of seconds |
95 | //======================================================================= |
96 | |
97 | #ifdef WNT |
98 | # include <Windows.h> |
99 | #if !defined(__CYGWIN32__) && !defined(__MINGW32__) |
100 | # include <Mapiwin.h> |
101 | #endif |
102 | # define _DEXPLEN 11 |
103 | # define _IEEE 1 |
104 | # define DMAXEXP ((1 << _DEXPLEN - 1) - 1 + _IEEE) |
105 | # define finite _finite |
106 | # define SLEEP(NSEC) Sleep(1000*(NSEC)) |
107 | #else |
108 | # define SLEEP(NSEC) sleep(NSEC) |
109 | #endif |
110 | |
111 | #ifdef HAVE_VALUES_H |
112 | //# include <values.h> |
113 | #endif |
114 | |
115 | #ifdef HAVE_UNISTD_H |
116 | # include <unistd.h> |
117 | #endif |
118 | |
119 | void OSD::SecSleep(const Standard_Integer aDelay) |
120 | { |
121 | SLEEP(aDelay); |
122 | } |
123 | |
124 | //======================================================================= |
125 | //function : MilliSecSleep |
126 | //purpose : Cause the process to sleep during a amount of milliseconds |
127 | //======================================================================= |
128 | |
129 | #ifdef WNT |
130 | |
131 | void OSD::MilliSecSleep(const Standard_Integer aDelay) |
132 | { |
133 | Sleep(aDelay) ; |
134 | } |
135 | |
136 | #else |
137 | |
138 | #ifdef HAVE_SYS_TIME_H |
139 | # include <sys/time.h> |
140 | #endif |
141 | |
142 | void OSD::MilliSecSleep(const Standard_Integer aDelay) |
143 | { |
144 | int fdn ; |
145 | struct timeval timeout ; |
146 | |
147 | timeout.tv_sec = aDelay / 1000 ; |
148 | timeout.tv_usec = (aDelay % 1000) * 1000 ; |
149 | |
150 | fdn = select(0,NULL,NULL,NULL,&timeout) ; |
151 | } |
152 | |
153 | #endif |
154 | |
155 | //======================================================================= |
156 | //function : IsDivisible |
157 | //purpose : |
158 | //======================================================================= |
159 | |
160 | Standard_Boolean OSD::IsDivisible(const Standard_Real theDividend,const Standard_Real theDivisor) |
161 | { |
162 | if ( theDivisor == 0. || ! finite(theDividend) ) return Standard_False; |
163 | // |
164 | // you may divide by infinity |
165 | // |
166 | if (! finite(theDivisor)) return Standard_True; |
167 | #ifdef DEB |
168 | // Standard_Integer aExp1, aExp2; |
169 | // Standard_Real aMant1 = frexp(theDividend, &aExp1); |
170 | // Standard_Real aMant2 = frexp(theDivisor, &aExp2); |
171 | #endif |
172 | // Code de :KL:dev:ref : |
173 | // return ((aExp1-aExp2 < DMAXEXP) || // exponent of the result |
174 | // (aExp1-aExp2 == DMAXEXP && aMant1 < aMant2)) ; |
175 | |
176 | // Code de :KAS:C30 : |
177 | return Standard_True; |
178 | |
179 | |
180 | // this is unacceptable return for Linux because of (temporary?) undefined aExp1 and aExp2. |
181 | // Testing both over and underflow should be (:KL:dev ) : |
182 | |
183 | // return ((aExp1-aExp2 < DMAXEXP) && (aExp1-aExp2 > DMINEXP) || |
184 | // (aExp1-aExp2 == DMAXEXP && aMant1 < aMant2) || |
185 | // (aExp1-aExp2 == DMINEXP && aMant1 > aMant2)) ; |
186 | } |
187 | |
188 | //======================================================================= |
189 | //function : GetExponent |
190 | //purpose : |
191 | //======================================================================= |
192 | |
193 | //Standard_Integer OSD::GetExponent(const Standard_Real aReal) |
194 | Standard_Integer OSD::GetExponent(const Standard_Real ) |
195 | { |
196 | // Code de :KAS:C30 : |
197 | |
198 | cout << "Function OSD::GetExponent() not yet implemented." << endl; |
199 | return 0 ; |
200 | |
201 | // Code de :KL:dev:ref : |
202 | |
203 | // Standard_Integer Exp ; |
204 | |
205 | //// Standard_Real Mant = frexp(aReal, &Exp) ; |
206 | // frexp(aReal, &Exp) ; |
207 | // return Exp ; |
208 | } |
209 | |
210 | //======================================================================= |
211 | //function : GetMantissa |
212 | //purpose : |
213 | //======================================================================= |
214 | |
215 | //Standard_Real OSD::GetMantissa(const Standard_Real aReal) |
216 | Standard_Real OSD::GetMantissa(const Standard_Real ) |
217 | { |
218 | // Code de :KAS:C30 : |
219 | cout << "Function OSD::GetMantissa() not yet implemented." << endl; |
220 | return 0 ; |
221 | |
222 | // Code de :KL:dev:ref : |
223 | |
224 | // Standard_Integer Exp ; |
225 | // return frexp(aReal, &Exp) ; |
226 | } |
227 | |
228 | //======================================================================= |
229 | // Code de :KAS:C30 : |
230 | //======================================================================= |
231 | Standard_Integer OSD::AvailableMemory() |
232 | { |
233 | cout << "Function OSD::AvailableMemory() not yet implemented." << endl; |
234 | return 0 ; |
235 | } |
236 | |
237 | // Code de :KL:dev:ref ??????????????? : |
238 | #if 0 |
239 | //======================================================================= |
240 | //function : AvailableMemory |
241 | //purpose : |
242 | //======================================================================= |
243 | #include <stdlib.h> |
244 | #include <stdio.h> |
245 | #include <malloc.h> |
246 | |
247 | # if defined(SUN) || defined(__sun) || defined(SOLARIS) |
248 | # define SIZE_MAX 0x7fffffff |
249 | # elif defined(__osf__) || defined(DECOSF1) |
250 | # define SIZE_MAX 0x10000000000 |
251 | # elif defined(WNT) |
252 | # define SIZE_MAX 0x7ffdefff |
253 | # else |
254 | # define SIZE_MAX 0xffffffff |
255 | # endif |
256 | |
257 | Standard_Integer OSD::AvailableMemory() |
258 | { |
259 | size_t min = 1024 ; |
260 | size_t max = SIZE_MAX ; |
261 | size_t middle = SIZE_MAX ; |
262 | void * addr ; |
263 | int nballoc = 0 ; |
264 | int nbfree = 0 ; |
265 | |
266 | while (min + 1024 < max) { |
267 | if ((addr = malloc (middle))== (void *)-1) { |
268 | perror("OSD::AvailableMemory()_malloc error :") ; |
269 | return 0 ; |
270 | } |
271 | nballoc++ ; |
272 | if (addr == 0) |
273 | max = middle ; |
274 | else { |
275 | free(addr) ; |
276 | nbfree++ ; |
277 | min = middle ; |
278 | } |
279 | middle = min + ((max - min ) >> 6) * 63 ; |
280 | } |
281 | return min >> 10 ; |
282 | } |
283 | |
284 | #endif |