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/os_include/os_errno.h"
00010 #include "ace/os_include/os_search.h"
00011
00012 #if defined (ACE_WCHAR_IN_STD_NAMESPACE)
00013 # define ACE_WCHAR_STD_NAMESPACE std
00014 #else
00015 # define ACE_WCHAR_STD_NAMESPACE ACE_STD_NAMESPACE
00016 #endif
00017
00018 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00019
00020
00021
00022 ACE_INLINE void
00023 ACE_OS::_exit (int status)
00024 {
00025 ACE_OS_TRACE ("ACE_OS::_exit");
00026 #if defined (ACE_VXWORKS)
00027 ::exit (status);
00028 #elif !defined (ACE_HAS_WINCE)
00029 ::_exit (status);
00030 #else
00031 ::TerminateProcess (::GetCurrentProcess (), status);
00032 #endif
00033 }
00034
00035 ACE_INLINE void
00036 ACE_OS::abort (void)
00037 {
00038 #if !defined (ACE_HAS_WINCE)
00039 ::abort ();
00040 #else
00041
00042 exit (1);
00043 #endif
00044 }
00045
00046 ACE_INLINE int
00047 ACE_OS::atexit (ACE_EXIT_HOOK func, const char* name)
00048 {
00049 return ACE_OS_Object_Manager::instance ()->at_exit (func, name);
00050 }
00051
00052 ACE_INLINE int
00053 ACE_OS::atoi (const char *s)
00054 {
00055 ACE_OSCALL_RETURN (::atoi (s), int, -1);
00056 }
00057
00058 #if defined (ACE_HAS_WCHAR)
00059 ACE_INLINE int
00060 ACE_OS::atoi (const wchar_t *s)
00061 {
00062 #if defined (ACE_WIN32) && defined (ACE_HAS_WTOI)
00063 ACE_OSCALL_RETURN (::_wtoi (s), int, -1);
00064 #else
00065 return ACE_OS::atoi (ACE_Wide_To_Ascii (s).char_rep ());
00066 #endif
00067 }
00068 #endif
00069
00070 ACE_INLINE long
00071 ACE_OS::atol (const char *s)
00072 {
00073 ACE_OSCALL_RETURN (::atol (s), long, -1);
00074 }
00075
00076 #if defined (ACE_HAS_WCHAR)
00077 ACE_INLINE long
00078 ACE_OS::atol (const wchar_t *s)
00079 {
00080 #if defined (ACE_WIN32) && defined (ACE_HAS_WTOL)
00081 ACE_OSCALL_RETURN (::_wtol (s), long, -1);
00082 #else
00083 return ACE_OS::atol (ACE_Wide_To_Ascii (s).char_rep ());
00084 #endif
00085 }
00086 #endif
00087
00088 ACE_INLINE double
00089 ACE_OS::atof (const char *s)
00090 {
00091 ACE_OSCALL_RETURN (::atof (s), double, -1);
00092 }
00093
00094 #if defined (ACE_HAS_WCHAR)
00095 ACE_INLINE double
00096 ACE_OS::atof (const wchar_t *s)
00097 {
00098 #if !defined (ACE_HAS_WTOF)
00099 return ACE_OS::atof (ACE_Wide_To_Ascii (s).char_rep ());
00100 #elif defined (ACE_WTOF_EQUIVALENT)
00101 ACE_OSCALL_RETURN (ACE_WTOF_EQUIVALENT (s), double, -1);
00102 #else
00103 ACE_OSCALL_RETURN (::wtof (s), double, -1);
00104 #endif
00105 }
00106 #endif
00107
00108 ACE_INLINE void *
00109 ACE_OS::atop (const char *s)
00110 {
00111 ACE_TRACE ("ACE_OS::atop");
00112 #if defined (ACE_WIN64)
00113 intptr_t ip = ::_atoi64 (s);
00114 #elif defined (ACE_OPENVMS)
00115 # if !defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64)
00116 int ip = ::atoi (s);
00117 # else
00118 intptr_t ip = ::atoi (s);
00119 # endif
00120 #else
00121 intptr_t ip = ::atoi (s);
00122 #endif
00123 void * p = reinterpret_cast<void *> (ip);
00124 return p;
00125 }
00126
00127 #if defined (ACE_HAS_WCHAR)
00128 ACE_INLINE void *
00129 ACE_OS::atop (const wchar_t *s)
00130 {
00131 # if defined (ACE_WIN64)
00132 intptr_t ip = ::_wtoi64 (s);
00133 # elif defined (ACE_OPENVMS)
00134 # if !defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64)
00135 int ip = ACE_OS::atoi (s);
00136 # else
00137 intptr_t ip = ACE_OS::atoi (s);
00138 # endif
00139 # else
00140 intptr_t ip = ACE_OS::atoi (s);
00141 # endif
00142 void * p = reinterpret_cast<void *> (ip);
00143 return p;
00144 }
00145 #endif
00146
00147 ACE_INLINE void *
00148 ACE_OS::bsearch (const void *key,
00149 const void *base,
00150 size_t nel,
00151 size_t size,
00152 ACE_COMPARE_FUNC compar)
00153 {
00154 #if !defined (ACE_LACKS_BSEARCH)
00155 return ::bsearch (key, base, nel, size, compar);
00156 #else
00157 ACE_UNUSED_ARG (key);
00158 ACE_UNUSED_ARG (base);
00159 ACE_UNUSED_ARG (nel);
00160 ACE_UNUSED_ARG (size);
00161 ACE_UNUSED_ARG (compar);
00162 ACE_NOTSUP_RETURN (0);
00163 #endif
00164 }
00165
00166 ACE_INLINE char *
00167 ACE_OS::getenv (const char *symbol)
00168 {
00169 ACE_OS_TRACE ("ACE_OS::getenv");
00170 #if defined (ACE_LACKS_GETENV)
00171 ACE_UNUSED_ARG (symbol);
00172 ACE_NOTSUP_RETURN (0);
00173 #else
00174 ACE_OSCALL_RETURN (::getenv (symbol), char *, 0);
00175 #endif
00176 }
00177
00178 #if defined (ACE_HAS_WCHAR) && defined (ACE_WIN32)
00179 ACE_INLINE wchar_t *
00180 ACE_OS::getenv (const wchar_t *symbol)
00181 {
00182 #if defined (ACE_LACKS_GETENV)
00183 ACE_UNUSED_ARG (symbol);
00184 ACE_NOTSUP_RETURN (0);
00185 #else
00186 ACE_OSCALL_RETURN (::_wgetenv (symbol), wchar_t *, 0);
00187 #endif
00188 }
00189 #endif
00190
00191 ACE_INLINE char *
00192 ACE_OS::itoa (int value, char *string, int radix)
00193 {
00194 #if !defined (ACE_HAS_ITOA)
00195 return ACE_OS::itoa_emulation (value, string, radix);
00196 #elif defined (ACE_ITOA_EQUIVALENT)
00197 return ACE_ITOA_EQUIVALENT (value, string, radix);
00198 #else
00199 return ::itoa (value, string, radix);
00200 #endif
00201 }
00202
00203 #if defined (ACE_HAS_WCHAR)
00204 ACE_INLINE wchar_t *
00205 ACE_OS::itoa (int value, wchar_t *string, int radix)
00206 {
00207 #if defined (ACE_LACKS_ITOW)
00208 return ACE_OS::itow_emulation (value, string, radix);
00209 #else
00210 return ::_itow (value, string, radix);
00211 #endif
00212 }
00213 #endif
00214
00215 ACE_INLINE ACE_HANDLE
00216 ACE_OS::mkstemp (char *s)
00217 {
00218 #if !defined (ACE_LACKS_MKSTEMP)
00219 return ::mkstemp (s);
00220 #elif defined (ACE_USES_WCHAR)
00221
00222
00223
00224 ACE_Ascii_To_Wide wide_s (s);
00225 const ACE_HANDLE fh = ACE_OS::mkstemp_emulation (wide_s.wchar_rep ());
00226 if (fh != ACE_INVALID_HANDLE)
00227 {
00228 ACE_Wide_To_Ascii narrow_s (wide_s.wchar_rep ());
00229 ACE_OS::strcpy (s, narrow_s.char_rep ());
00230 }
00231 return fh;
00232 #else
00233 return ACE_OS::mkstemp_emulation (s);
00234 #endif
00235 }
00236
00237 #if defined (ACE_HAS_WCHAR)
00238 ACE_INLINE ACE_HANDLE
00239 ACE_OS::mkstemp (wchar_t *s)
00240 {
00241 # if !defined (ACE_LACKS_MKSTEMP)
00242
00243
00244
00245 ACE_Wide_To_Ascii narrow_s (s);
00246 const ACE_HANDLE fh = ::mkstemp (narrow_s.char_rep ());
00247 if (fh != ACE_INVALID_HANDLE)
00248 {
00249 ACE_Ascii_To_Wide wide_s (narrow_s.char_rep ());
00250 ACE_OS::strcpy (s, wide_s.wchar_rep ());
00251 }
00252 return fh;
00253 # elif defined (ACE_USES_WCHAR)
00254 return ACE_OS::mkstemp_emulation (s);
00255 # else
00256
00257
00258
00259 ACE_Wide_To_Ascii narrow_s (s);
00260 const ACE_HANDLE fh = ACE_OS::mkstemp_emulation (narrow_s.char_rep ());
00261 if (fh != ACE_INVALID_HANDLE)
00262 {
00263 ACE_Ascii_To_Wide wide_s (narrow_s.char_rep ());
00264 ACE_OS::strcpy (s, wide_s.wchar_rep ());
00265 }
00266 return fh;
00267 # endif
00268 }
00269 #endif
00270
00271 #if !defined (ACE_LACKS_MKTEMP)
00272 ACE_INLINE char *
00273 ACE_OS::mktemp (char *s)
00274 {
00275 # if defined (ACE_WIN32)
00276 return ::_mktemp (s);
00277 # else
00278 return ::mktemp (s);
00279 # endif
00280 }
00281
00282 # if defined (ACE_HAS_WCHAR)
00283 ACE_INLINE wchar_t *
00284 ACE_OS::mktemp (wchar_t *s)
00285 {
00286 # if defined (ACE_WIN32)
00287 return ::_wmktemp (s);
00288 # else
00289
00290
00291
00292 ACE_Wide_To_Ascii narrow_s (s);
00293 if (::mktemp (narrow_s.char_rep ()) == 0)
00294 return 0;
00295 ACE_Ascii_To_Wide wide_s (narrow_s.char_rep ());
00296 ACE_OS::strcpy (s, wide_s.wchar_rep ());
00297 return s;
00298 # endif
00299 }
00300 # endif
00301
00302 #endif
00303
00304 ACE_INLINE int
00305 ACE_OS::putenv (const char *string)
00306 {
00307 ACE_OS_TRACE ("ACE_OS::putenv");
00308 #if defined (ACE_LACKS_PUTENV) && defined (ACE_HAS_SETENV)
00309 int result = 0;
00310 char *sp = ACE_OS::strchr (const_cast <char *> (string), '=');
00311 if (sp)
00312 {
00313 char *stmp = ACE_OS::strdup (string);
00314 if (stmp)
00315 {
00316 stmp[sp - string] = '\0';
00317 result = ACE_OS::setenv (stmp, sp+sizeof (char), 1);
00318 ACE_OS::free (stmp);
00319 }
00320 else
00321 {
00322 errno = ENOMEM;
00323 result = -1;
00324 }
00325 }
00326 else
00327 {
00328 result = ACE_OS::setenv (string, "", 1);
00329 }
00330
00331 return result;
00332 #elif defined (ACE_LACKS_PUTENV)
00333 ACE_UNUSED_ARG (string);
00334 ACE_NOTSUP_RETURN (0);
00335 #else
00336 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::putenv (const_cast <char *> (string)), int, -1);
00337 #endif
00338 }
00339
00340 ACE_INLINE int
00341 ACE_OS::setenv(const char *envname, const char *envval, int overwrite)
00342 {
00343 #if defined (ACE_LACKS_SETENV)
00344 ACE_UNUSED_ARG (envname);
00345 ACE_UNUSED_ARG (envval);
00346 ACE_UNUSED_ARG (overwrite);
00347 ACE_NOTSUP_RETURN (-1);
00348 #else
00349 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::setenv (envname, envval, overwrite), int, -1);
00350 #endif
00351 }
00352
00353 ACE_INLINE int
00354 ACE_OS::unsetenv(const char *name)
00355 {
00356 #if defined (ACE_LACKS_UNSETENV)
00357 ACE_UNUSED_ARG (name);
00358 ACE_NOTSUP_RETURN (-1);
00359 #else
00360 # if defined (ACE_HAS_VOID_UNSETENV)
00361 ::unsetenv (name);
00362 return 0;
00363 #else
00364 ACE_OSCALL_RETURN (ACE_STD_NAMESPACE::unsetenv (name), int, -1);
00365 # endif
00366 #endif
00367 }
00368
00369 #if defined (ACE_HAS_WCHAR) && defined (ACE_WIN32)
00370 ACE_INLINE int
00371 ACE_OS::putenv (const wchar_t *string)
00372 {
00373 ACE_OS_TRACE ("ACE_OS::putenv");
00374 #if defined (ACE_LACKS_PUTENV)
00375 ACE_UNUSED_ARG (string);
00376 ACE_NOTSUP_RETURN (-1);
00377 #else
00378 ACE_OSCALL_RETURN (::_wputenv (string), int, -1);
00379 #endif
00380 }
00381 #endif
00382
00383 ACE_INLINE void
00384 ACE_OS::qsort (void *base,
00385 size_t nel,
00386 size_t width,
00387 ACE_COMPARE_FUNC compar)
00388 {
00389 #if !defined (ACE_LACKS_QSORT)
00390 ::qsort (base, nel, width, compar);
00391 #else
00392 ACE_UNUSED_ARG (base);
00393 ACE_UNUSED_ARG (nel);
00394 ACE_UNUSED_ARG (width);
00395 ACE_UNUSED_ARG (compar);
00396 #endif
00397 }
00398
00399 ACE_INLINE int
00400 ACE_OS::rand (void)
00401 {
00402 ACE_OS_TRACE ("ACE_OS::rand");
00403 ACE_OSCALL_RETURN (::rand (), int, -1);
00404 }
00405
00406 #if !defined (ACE_WIN32)
00407
00408 ACE_INLINE int
00409 ACE_OS::rand_r (ACE_RANDR_TYPE &seed)
00410 {
00411 ACE_OS_TRACE ("ACE_OS::rand_r");
00412 # if defined (ACE_HAS_REENTRANT_FUNCTIONS) && \
00413 !defined (ACE_LACKS_RAND_REENTRANT_FUNCTIONS)
00414 # if defined (DIGITAL_UNIX)
00415 ACE_OSCALL_RETURN (::_Prand_r (&seed), int, -1);
00416 # elif defined (ACE_HAS_BROKEN_RANDR)
00417 ACE_OSCALL_RETURN (::rand_r (seed), int, -1);
00418 # else
00419 ACE_OSCALL_RETURN (::rand_r (&seed), int, -1);
00420 # endif
00421 # else
00422 ACE_UNUSED_ARG (seed);
00423 ACE_OSCALL_RETURN (::rand (), int, -1);
00424 # endif
00425 }
00426
00427 #else
00428
00429 ACE_INLINE int
00430 ACE_OS::rand_r (ACE_RANDR_TYPE& seed)
00431 {
00432 ACE_OS_TRACE ("ACE_OS::rand_r");
00433
00434 long new_seed = (long) (seed);
00435 if (new_seed == 0)
00436 new_seed = 0x12345987;
00437 long temp = new_seed / 127773;
00438 new_seed = 16807 * (new_seed - temp * 127773) - 2836 * temp;
00439 if (new_seed < 0)
00440 new_seed += 2147483647;
00441 (seed) = (unsigned int)new_seed;
00442 return (int) (new_seed & RAND_MAX);
00443 }
00444
00445 #endif
00446
00447 # if !defined (ACE_LACKS_REALPATH)
00448 ACE_INLINE char *
00449 ACE_OS::realpath (const char *file_name,
00450 char *resolved_name)
00451 {
00452 # if defined (ACE_WIN32)
00453 return ::_fullpath (resolved_name, file_name, PATH_MAX);
00454 # else
00455 return ::realpath (file_name, resolved_name);
00456 # endif
00457 }
00458
00459 # if defined (ACE_HAS_WCHAR)
00460 ACE_INLINE wchar_t *
00461 ACE_OS::realpath (const wchar_t *file_name,
00462 wchar_t *resolved_name)
00463 {
00464 # if defined (ACE_WIN32)
00465 return ::_wfullpath (resolved_name, file_name, PATH_MAX);
00466 # else
00467 ACE_Wide_To_Ascii n_file_name (file_name);
00468 char n_resolved[PATH_MAX];
00469 if (0 != ACE_OS::realpath (n_file_name.char_rep (), n_resolved))
00470 {
00471 ACE_Ascii_To_Wide w_resolved (n_resolved);
00472 ACE_OS::strcpy (resolved_name, w_resolved.wchar_rep ());
00473 return resolved_name;
00474 }
00475 return 0;
00476 # endif
00477 }
00478 # endif
00479 #endif
00480
00481 ACE_INLINE ACE_EXIT_HOOK
00482 ACE_OS::set_exit_hook (ACE_EXIT_HOOK exit_hook)
00483 {
00484 ACE_EXIT_HOOK old_hook = exit_hook_;
00485 exit_hook_ = exit_hook;
00486 return old_hook;
00487 }
00488
00489 ACE_INLINE void
00490 ACE_OS::srand (u_int seed)
00491 {
00492 ACE_OS_TRACE ("ACE_OS::srand");
00493 ::srand (seed);
00494 }
00495
00496 #if !defined (ACE_LACKS_STRTOD)
00497 ACE_INLINE double
00498 ACE_OS::strtod (const char *s, char **endptr)
00499 {
00500 return ::strtod (s, endptr);
00501 }
00502 #endif
00503
00504 #if defined (ACE_HAS_WCHAR) && !defined (ACE_LACKS_WCSTOD)
00505 ACE_INLINE double
00506 ACE_OS::strtod (const wchar_t *s, wchar_t **endptr)
00507 {
00508 return ACE_WCHAR_STD_NAMESPACE::wcstod (s, endptr);
00509 }
00510 #endif
00511
00512 ACE_INLINE long
00513 ACE_OS::strtol (const char *s, char **ptr, int base)
00514 {
00515 #if defined (ACE_LACKS_STRTOL)
00516 return ACE_OS::strtol_emulation (s, ptr, base);
00517 #else
00518 return ::strtol (s, ptr, base);
00519 #endif
00520 }
00521
00522 #if defined (ACE_HAS_WCHAR)
00523 ACE_INLINE long
00524 ACE_OS::strtol (const wchar_t *s, wchar_t **ptr, int base)
00525 {
00526 #if defined (ACE_LACKS_WCSTOL)
00527 return ACE_OS::wcstol_emulation (s, ptr, base);
00528 #else
00529 return ACE_WCHAR_STD_NAMESPACE::wcstol (s, ptr, base);
00530 #endif
00531 }
00532 #endif
00533
00534 ACE_INLINE unsigned long
00535 ACE_OS::strtoul (const char *s, char **ptr, int base)
00536 {
00537 #if defined (ACE_LACKS_STRTOUL)
00538 return ACE_OS::strtoul_emulation (s, ptr, base);
00539 #else
00540 return ::strtoul (s, ptr, base);
00541 #endif
00542 }
00543
00544 #if defined (ACE_HAS_WCHAR)
00545 ACE_INLINE unsigned long
00546 ACE_OS::strtoul (const wchar_t *s, wchar_t **ptr, int base)
00547 {
00548 #if defined (ACE_LACKS_WCSTOUL)
00549 return ACE_OS::wcstoul_emulation (s, ptr, base);
00550 #else
00551 return ACE_WCHAR_STD_NAMESPACE::wcstoul (s, ptr, base);
00552 #endif
00553 }
00554 #endif
00555
00556 ACE_INLINE ACE_INT64
00557 ACE_OS::strtoll (const char *s, char **ptr, int base)
00558 {
00559 #if defined (ACE_LACKS_STRTOLL)
00560 return ACE_OS::strtoll_emulation (s, ptr, base);
00561 #elif defined (ACE_STRTOLL_EQUIVALENT)
00562 return ACE_STRTOLL_EQUIVALENT (s, ptr, base);
00563 #else
00564 return ace_strtoll_helper (s, ptr, base);
00565 #endif
00566 }
00567
00568 #if defined (ACE_HAS_WCHAR)
00569 ACE_INLINE ACE_INT64
00570 ACE_OS::strtoll (const wchar_t *s, wchar_t **ptr, int base)
00571 {
00572 #if defined (ACE_LACKS_WCSTOLL)
00573 return ACE_OS::wcstoll_emulation (s, ptr, base);
00574 #elif defined (ACE_WCSTOLL_EQUIVALENT)
00575 return ACE_WCSTOLL_EQUIVALENT (s, ptr, base);
00576 #else
00577 return ACE_WCHAR_STD_NAMESPACE::wcstoll (s, ptr, base);
00578 #endif
00579 }
00580 #endif
00581
00582 ACE_INLINE ACE_UINT64
00583 ACE_OS::strtoull (const char *s, char **ptr, int base)
00584 {
00585 #if defined (ACE_LACKS_STRTOULL)
00586 return ACE_OS::strtoull_emulation (s, ptr, base);
00587 #elif defined (ACE_STRTOULL_EQUIVALENT)
00588 return ACE_STRTOULL_EQUIVALENT (s, ptr, base);
00589 #else
00590 return ace_strtoull_helper (s, ptr, base);
00591 #endif
00592 }
00593
00594 #if defined (ACE_HAS_WCHAR)
00595 ACE_INLINE ACE_UINT64
00596 ACE_OS::strtoull (const wchar_t *s, wchar_t **ptr, int base)
00597 {
00598 #if defined (ACE_LACKS_WCSTOULL)
00599 return ACE_OS::wcstoull_emulation (s, ptr, base);
00600 #elif defined (ACE_WCSTOULL_EQUIVALENT)
00601 return ACE_WCSTOULL_EQUIVALENT (s, ptr, base);
00602 #else
00603 return ACE_WCHAR_STD_NAMESPACE::wcstoull (s, ptr, base);
00604 #endif
00605 }
00606 #endif
00607
00608 ACE_INLINE int
00609 ACE_OS::system (const ACE_TCHAR *s)
00610 {
00611
00612 #if defined (ACE_LACKS_SYSTEM)
00613 ACE_UNUSED_ARG (s);
00614 ACE_NOTSUP_RETURN (-1);
00615 #elif defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
00616 ACE_OSCALL_RETURN (::_wsystem (s), int, -1);
00617 #elif defined (ACE_TANDEM_T1248_PTHREADS)
00618 ACE_OSCALL_RETURN (::spt_system (s), int, -1);
00619 #else
00620 ACE_OSCALL_RETURN (::system (ACE_TEXT_ALWAYS_CHAR (s)), int, -1);
00621 #endif
00622 }
00623
00624 ACE_INLINE const char*
00625 ACE_OS::getprogname ()
00626 {
00627 #if defined (ACE_HAS_GETPROGNAME)
00628 return ::getprogname ();
00629 #else
00630 return ACE_OS::getprogname_emulation ();
00631 #endif
00632 }
00633
00634 ACE_INLINE void
00635 ACE_OS::setprogname (const char* name)
00636 {
00637 #if defined (ACE_HAS_SETPROGNAME)
00638 ::setprogname (name);
00639 #else
00640 ACE_OS::setprogname_emulation (name);
00641 #endif
00642 }
00643
00644 ACE_END_VERSIONED_NAMESPACE_DECL