OS_NS_stdlib.inl

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

Generated on Sun Jan 27 12:05:33 2008 for ACE by doxygen 1.3.6