00001
00002
00003
00004
00005 #include "ace/config-all.h"
00006 #include "ace/Object_Manager_Base.h"
00007 #include "ace/OS_NS_string.h"
00008 #include "ace/Global_Macros.h"
00009 #include "ace/Basic_Types.h"
00010 #include "ace/os_include/os_errno.h"
00011 #include "ace/os_include/os_search.h"
00012
00013 #if defined (ACE_WCHAR_IN_STD_NAMESPACE)
00014 # define ACE_WCHAR_STD_NAMESPACE std
00015 #else
00016 # define ACE_WCHAR_STD_NAMESPACE ACE_STD_NAMESPACE
00017 #endif
00018
00019 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00020
00021
00022
00023 ACE_INLINE void
00024 ACE_OS::_exit (int status)
00025 {
00026 ACE_OS_TRACE ("ACE_OS::_exit");
00027 #if defined (ACE_VXWORKS)
00028 ::exit (status);
00029 #elif !defined (ACE_HAS_WINCE)
00030 ::_exit (status);
00031 #else
00032 ::TerminateProcess (::GetCurrentProcess (), status);
00033 #endif
00034 }
00035
00036 ACE_INLINE void
00037 ACE_OS::abort (void)
00038 {
00039 #if !defined (ACE_HAS_WINCE)
00040 ::abort ();
00041 #else
00042
00043 exit (1);
00044 #endif
00045 }
00046
00047 ACE_INLINE int
00048 ACE_OS::atexit (ACE_EXIT_HOOK func)
00049 {
00050 return ACE_OS_Object_Manager::instance ()->at_exit (func);
00051 }
00052
00053 ACE_INLINE int
00054 ACE_OS::atoi (const char *s)
00055 {
00056 ACE_OSCALL_RETURN (::atoi (s), int, -1);
00057 }
00058
00059 #if defined (ACE_HAS_WCHAR)
00060 ACE_INLINE int
00061 ACE_OS::atoi (const wchar_t *s)
00062 {
00063 #if defined (ACE_WIN32)
00064 ACE_OSCALL_RETURN (::_wtoi (s), int, -1);
00065 #else
00066 return ACE_OS::atoi (ACE_Wide_To_Ascii (s).char_rep ());
00067 #endif
00068 }
00069 #endif
00070
00071 #if defined (atop)
00072 # undef atop
00073 #endif
00074
00075 ACE_INLINE void *
00076 ACE_OS::atop (const char *s)
00077 {
00078 ACE_TRACE ("ACE_OS::atop");
00079 #if defined (ACE_WIN64)
00080 intptr_t ip = ::_atoi64 (s);
00081 #elif defined (ACE_OPENVMS)
00082 # if !defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64)
00083 int ip = ::atoi (s);
00084 # else
00085 intptr_t ip = ::atoi (s);
00086 # endif
00087 #else
00088 intptr_t ip = ::atoi (s);
00089 #endif
00090 void * p = reinterpret_cast<void *> (ip);
00091 return p;
00092 }
00093
00094 #if defined (ACE_HAS_WCHAR)
00095 ACE_INLINE void *
00096 ACE_OS::atop (const wchar_t *s)
00097 {
00098 # if defined (ACE_WIN64)
00099 intptr_t ip = ::_wtoi64 (s);
00100 # elif defined (ACE_OPENVMS)
00101 # if !defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64)
00102 int ip = ACE_OS::atoi (s);
00103 # else
00104 intptr_t ip = ACE_OS::atoi (s);
00105 # endif
00106 # else
00107 intptr_t ip = ACE_OS::atoi (s);
00108 # endif
00109 void * p = reinterpret_cast<void *> (ip);
00110 return p;
00111 }
00112 #endif
00113
00114 ACE_INLINE void *
00115 ACE_OS::bsearch (const void *key,
00116 const void *base,
00117 size_t nel,
00118 size_t size,
00119 ACE_COMPARE_FUNC compar)
00120 {
00121 #if !defined (ACE_LACKS_BSEARCH)
00122 return ::bsearch (key, base, nel, size, compar);
00123 #else
00124 ACE_UNUSED_ARG (key);
00125 ACE_UNUSED_ARG (base);
00126 ACE_UNUSED_ARG (nel);
00127 ACE_UNUSED_ARG (size);
00128 ACE_UNUSED_ARG (compar);
00129 ACE_NOTSUP_RETURN (0);
00130 #endif
00131 }
00132
00133 ACE_INLINE char *
00134 ACE_OS::getenv (const char *symbol)
00135 {
00136 ACE_OS_TRACE ("ACE_OS::getenv");
00137 #if defined (ACE_LACKS_ENV)
00138 ACE_UNUSED_ARG (symbol);
00139 ACE_NOTSUP_RETURN (0);
00140 #else
00141 ACE_OSCALL_RETURN (::getenv (symbol), char *, 0);
00142 #endif
00143 }
00144
00145 #if defined (ACE_HAS_WCHAR) && defined (ACE_WIN32)
00146 ACE_INLINE wchar_t *
00147 ACE_OS::getenv (const wchar_t *symbol)
00148 {
00149 #if defined (ACE_LACKS_ENV)
00150 ACE_UNUSED_ARG (symbol);
00151 ACE_NOTSUP_RETURN (0);
00152 #else
00153 ACE_OSCALL_RETURN (::_wgetenv (symbol), wchar_t *, 0);
00154 #endif
00155 }
00156 #endif
00157
00158 ACE_INLINE char *
00159 ACE_OS::itoa (int value, char *string, int radix)
00160 {
00161 #if !defined (ACE_HAS_ITOA)
00162 return ACE_OS::itoa_emulation (value, string, radix);
00163 #elif defined (ACE_ITOA_EQUIVALENT)
00164 return ACE_ITOA_EQUIVALENT (value, string, radix);
00165 #else
00166 return ::itoa (value, string, radix);
00167 #endif
00168 }
00169
00170 #if defined (ACE_HAS_WCHAR)
00171 ACE_INLINE wchar_t *
00172 ACE_OS::itoa (int value, wchar_t *string, int radix)
00173 {
00174 #if defined (ACE_LACKS_ITOW)
00175 return ACE_OS::itow_emulation (value, string, radix);
00176 #else
00177 return ::_itow (value, string, radix);
00178 #endif
00179 }
00180 #endif
00181
00182 ACE_INLINE ACE_HANDLE
00183 ACE_OS::mkstemp (char *s)
00184 {
00185 #if !defined (ACE_LACKS_MKSTEMP)
00186 return ::mkstemp (s);
00187 #else
00188 return ACE_OS::mkstemp_emulation (ACE_TEXT_CHAR_TO_TCHAR (s));
00189 #endif
00190 }
00191
00192 #if defined (ACE_HAS_WCHAR)
00193 ACE_INLINE ACE_HANDLE
00194 ACE_OS::mkstemp (wchar_t *s)
00195 {
00196 # if !defined (ACE_LACKS_MKSTEMP)
00197 return ::mkstemp (ACE_TEXT_WCHAR_TO_TCHAR (ACE_TEXT_ALWAYS_CHAR (s)));
00198 # else
00199 return ACE_OS::mkstemp_emulation (ACE_TEXT_WCHAR_TO_TCHAR (s));
00200 # endif
00201 }
00202 #endif
00203
00204 #if !defined (ACE_LACKS_MKTEMP)
00205 ACE_INLINE char *
00206 ACE_OS::mktemp (char *s)
00207 {
00208 # if defined (ACE_WIN32)
00209 return ::_mktemp (s);
00210 # else
00211 return ::mktemp (s);
00212 # endif
00213 }
00214
00215 # if defined (ACE_HAS_WCHAR)
00216 ACE_INLINE wchar_t *
00217 ACE_OS::mktemp (wchar_t *s)
00218 {
00219 # if defined (ACE_WIN32)
00220 return ::_wmktemp (s);
00221 # else
00222
00223
00224
00225 ACE_Wide_To_Ascii narrow_s (s);
00226 if (::mktemp (narrow_s.char_rep ()) == 0)
00227 return 0;
00228 ACE_Ascii_To_Wide wide_s (narrow_s.char_rep ());
00229 ACE_OS::strcpy (s, wide_s.wchar_rep ());
00230 return s;
00231 # endif
00232 }
00233 # endif
00234
00235 #endif
00236
00237 #if defined (INTEGRITY)
00238 extern "C" {
00239 int putenv (char *string);
00240 }
00241 #endif
00242
00243 ACE_INLINE int
00244 ACE_OS::putenv (const char *string)
00245 {
00246 ACE_OS_TRACE ("ACE_OS::putenv");
00247 #if defined (ACE_HAS_WINCE)
00248
00249 ACE_UNUSED_ARG (string);
00250 ACE_NOTSUP_RETURN (-1);
00251 #elif defined (ACE_LACKS_PUTENV) && defined (ACE_HAS_SETENV)
00252 int result = 0;
00253 char *sp = ACE_OS::strchr (const_cast <char *> (string), '=');
00254 if (sp)
00255 {
00256 char *stmp = ACE_OS::strdup (string);
00257 if (stmp)
00258 {
00259 stmp[sp - string] = '\0';
00260 ACE_OSCALL (::setenv (stmp, sp+sizeof (char), 1), int, -1, result);
00261 ACE_OS::free (stmp);
00262 }
00263 else
00264 {
00265 errno = ENOMEM;
00266 result = -1;
00267 }
00268 }
00269 else
00270 ACE_OSCALL (::setenv (string, "", 1), int, -1, result);
00271
00272 return result;
00273 #elif defined (ACE_LACKS_ENV) || defined (ACE_LACKS_PUTENV)
00274 ACE_UNUSED_ARG (string);
00275 ACE_NOTSUP_RETURN (0);
00276 #else
00277 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::putenv (const_cast <char *> (string)), int, -1);
00278 #endif
00279 }
00280
00281 #if defined (ACE_HAS_WCHAR) && defined (ACE_WIN32)
00282 ACE_INLINE int
00283 ACE_OS::putenv (const wchar_t *string)
00284 {
00285 ACE_OS_TRACE ("ACE_OS::putenv");
00286 #if defined (ACE_HAS_WINCE)
00287
00288 ACE_UNUSED_ARG (string);
00289 ACE_NOTSUP_RETURN (-1);
00290 #else
00291 ACE_OSCALL_RETURN (::_wputenv (string), int, -1);
00292 #endif
00293 }
00294 #endif
00295
00296 ACE_INLINE void
00297 ACE_OS::qsort (void *base,
00298 size_t nel,
00299 size_t width,
00300 ACE_COMPARE_FUNC compar)
00301 {
00302 #if !defined (ACE_LACKS_QSORT)
00303 ::qsort (base, nel, width, compar);
00304 #else
00305 ACE_UNUSED_ARG (base);
00306 ACE_UNUSED_ARG (nel);
00307 ACE_UNUSED_ARG (width);
00308 ACE_UNUSED_ARG (compar);
00309 #endif
00310 }
00311
00312 ACE_INLINE int
00313 ACE_OS::rand (void)
00314 {
00315 ACE_OS_TRACE ("ACE_OS::rand");
00316 ACE_OSCALL_RETURN (::rand (), int, -1);
00317 }
00318
00319 #if !defined (ACE_WIN32)
00320
00321 ACE_INLINE int
00322 ACE_OS::rand_r (ACE_RANDR_TYPE &seed)
00323 {
00324 ACE_OS_TRACE ("ACE_OS::rand_r");
00325 # if defined (ACE_HAS_REENTRANT_FUNCTIONS) && \
00326 !defined (ACE_LACKS_RAND_REENTRANT_FUNCTIONS)
00327 # if defined (DIGITAL_UNIX)
00328 ACE_OSCALL_RETURN (::_Prand_r (&seed), int, -1);
00329 # elif defined (ACE_HAS_BROKEN_RANDR)
00330 ACE_OSCALL_RETURN (::rand_r (seed), int, -1);
00331 # else
00332 ACE_OSCALL_RETURN (::rand_r (&seed), int, -1);
00333 # endif
00334 # else
00335 ACE_UNUSED_ARG (seed);
00336 ACE_OSCALL_RETURN (::rand (), int, -1);
00337 # endif
00338 }
00339
00340 #else
00341
00342 ACE_INLINE int
00343 ACE_OS::rand_r (ACE_RANDR_TYPE& seed)
00344 {
00345 ACE_OS_TRACE ("ACE_OS::rand_r");
00346
00347 long new_seed = (long) (seed);
00348 if (new_seed == 0)
00349 new_seed = 0x12345987;
00350 long temp = new_seed / 127773;
00351 new_seed = 16807 * (new_seed - temp * 127773) - 2836 * temp;
00352 if (new_seed < 0)
00353 new_seed += 2147483647;
00354 (seed) = (unsigned int)new_seed;
00355 return (int) (new_seed & RAND_MAX);
00356 }
00357
00358 #endif
00359
00360 #if !defined (ACE_HAS_WINCE)
00361 # if !defined (ACE_LACKS_REALPATH)
00362 ACE_INLINE char *
00363 ACE_OS::realpath (const char *file_name,
00364 char *resolved_name)
00365 {
00366 # if defined (ACE_WIN32)
00367 return ::_fullpath (resolved_name, file_name, PATH_MAX);
00368 # else
00369 return ::realpath (file_name, resolved_name);
00370 # endif
00371 }
00372 # endif
00373
00374 # if defined (ACE_HAS_WCHAR)
00375 ACE_INLINE wchar_t *
00376 ACE_OS::realpath (const wchar_t *file_name,
00377 wchar_t *resolved_name)
00378 {
00379 # if defined (ACE_WIN32)
00380 return ::_wfullpath (resolved_name, file_name, PATH_MAX);
00381 # else
00382 ACE_Wide_To_Ascii n_file_name (file_name);
00383 char n_resolved[PATH_MAX];
00384 if (0 != ACE_OS::realpath (n_file_name.char_rep (), n_resolved))
00385 {
00386 ACE_Ascii_To_Wide w_resolved (n_resolved);
00387 ACE_OS::strcpy (resolved_name, w_resolved.wchar_rep ());
00388 return resolved_name;
00389 }
00390 return 0;
00391 # endif
00392 }
00393 # endif
00394 #endif
00395
00396 ACE_INLINE ACE_EXIT_HOOK
00397 ACE_OS::set_exit_hook (ACE_EXIT_HOOK exit_hook)
00398 {
00399 ACE_EXIT_HOOK old_hook = exit_hook_;
00400 exit_hook_ = exit_hook;
00401 return old_hook;
00402 }
00403
00404 ACE_INLINE void
00405 ACE_OS::srand (u_int seed)
00406 {
00407 ACE_OS_TRACE ("ACE_OS::srand");
00408 ::srand (seed);
00409 }
00410
00411 #if !defined (ACE_LACKS_STRTOD)
00412 ACE_INLINE double
00413 ACE_OS::strtod (const char *s, char **endptr)
00414 {
00415 return ::strtod (s, endptr);
00416 }
00417 #endif
00418
00419 #if defined (ACE_HAS_WCHAR) && !defined (ACE_LACKS_WCSTOD)
00420 ACE_INLINE double
00421 ACE_OS::strtod (const wchar_t *s, wchar_t **endptr)
00422 {
00423 return ACE_WCHAR_STD_NAMESPACE::wcstod (s, endptr);
00424 }
00425 #endif
00426
00427 ACE_INLINE long
00428 ACE_OS::strtol (const char *s, char **ptr, int base)
00429 {
00430 #if defined (ACE_LACKS_STRTOL)
00431 return ACE_OS::strtol_emulation (s, ptr, base);
00432 #else
00433 return ::strtol (s, ptr, base);
00434 #endif
00435 }
00436
00437 #if defined (ACE_HAS_WCHAR) && !defined (ACE_LACKS_WCSTOL)
00438 ACE_INLINE long
00439 ACE_OS::strtol (const wchar_t *s, wchar_t **ptr, int base)
00440 {
00441 return ACE_WCHAR_STD_NAMESPACE::wcstol (s, ptr, base);
00442 }
00443 #endif
00444
00445 ACE_INLINE unsigned long
00446 ACE_OS::strtoul (const char *s, char **ptr, int base)
00447 {
00448 #if defined (ACE_LACKS_STRTOUL)
00449 return ACE_OS::strtoul_emulation (s, ptr, base);
00450 #else
00451 return ::strtoul (s, ptr, base);
00452 #endif
00453 }
00454
00455 #if defined (ACE_HAS_WCHAR) && !defined (ACE_LACKS_WCSTOUL)
00456 ACE_INLINE unsigned long
00457 ACE_OS::strtoul (const wchar_t *s, wchar_t **ptr, int base)
00458 {
00459 return ACE_WCHAR_STD_NAMESPACE::wcstoul (s, ptr, base);
00460 }
00461 #endif
00462
00463 ACE_INLINE int
00464 ACE_OS::system (const ACE_TCHAR *s)
00465 {
00466
00467 #if defined (ACE_LACKS_SYSTEM)
00468 ACE_UNUSED_ARG (s);
00469 ACE_NOTSUP_RETURN (-1);
00470 #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
00471 ACE_OSCALL_RETURN (::_wsystem (s), int, -1);
00472 #elif defined (ACE_TANDEM_T1248_PTHREADS)
00473 ACE_OSCALL_RETURN (::spt_system (s), int, -1);
00474 #else
00475 ACE_OSCALL_RETURN (::system (ACE_TEXT_ALWAYS_CHAR (s)), int, -1);
00476 #endif
00477 }
00478
00479 ACE_INLINE const char*
00480 ACE_OS::getprogname ()
00481 {
00482 #if defined (ACE_HAS_GETPROGNAME)
00483 return ::getprogname ();
00484 #else
00485 return ACE_OS::getprogname_emulation ();
00486 #endif
00487 }
00488
00489 ACE_INLINE void
00490 ACE_OS::setprogname (const char* name)
00491 {
00492 #if defined (ACE_HAS_SETPROGNAME)
00493 ::setprogname (name);
00494 #else
00495 ACE_OS::setprogname_emulation (name);
00496 #endif
00497 }
00498
00499 ACE_END_VERSIONED_NAMESPACE_DECL