00001
00002
00003 #include "ace/OS_NS_stdlib.h"
00004
00005 ACE_RCSID (ace,
00006 OS_NS_stdlib,
00007 "$Id: OS_NS_stdlib.cpp 85363 2009-05-18 07:48:11Z johnnyw $")
00008
00009 #include "ace/Default_Constants.h"
00010
00011 #if !defined (ACE_HAS_INLINED_OSCALLS)
00012 # include "ace/OS_NS_stdlib.inl"
00013 #endif
00014
00015 #include "ace/OS_Memory.h"
00016
00017 #include "ace/OS_NS_unistd.h"
00018 #include "ace/OS_NS_ctype.h"
00019
00020 #if defined (ACE_LACKS_MKTEMP) \
00021 || defined (ACE_LACKS_MKSTEMP) \
00022 || defined (ACE_LACKS_REALPATH)
00023 # include "ace/OS_NS_stdio.h"
00024 # include "ace/OS_NS_sys_stat.h"
00025 #endif
00026
00027 #if defined (ACE_LACKS_MKSTEMP)
00028 # include "ace/OS_NS_fcntl.h"
00029 # include "ace/OS_NS_ctype.h"
00030 # include "ace/OS_NS_sys_time.h"
00031 # include "ace/OS_NS_Thread.h"
00032 # include "ace/Numeric_Limits.h"
00033 #endif
00034
00035 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00036
00037 ACE_EXIT_HOOK ACE_OS::exit_hook_ = 0;
00038
00039 void *
00040 ACE_OS::calloc (size_t elements, size_t sizeof_elements)
00041 {
00042 #if !defined (ACE_HAS_WINCE)
00043 return ACE_CALLOC_FUNC (elements, sizeof_elements);
00044 #else
00045
00046
00047 return ACE_MALLOC_FUNC (elements * sizeof_elements);
00048 #endif
00049 }
00050
00051 void
00052 ACE_OS::exit (int status)
00053 {
00054 ACE_OS_TRACE ("ACE_OS::exit");
00055
00056 #if defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER) && !defined (ACE_HAS_WINCE) && !defined (ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER)
00057
00058
00059
00060 if (exit_hook_)
00061 (*exit_hook_) ();
00062 #endif
00063
00064 #if defined (ACE_WIN32)
00065 ::ExitProcess ((UINT) status);
00066 #else
00067 ::exit (status);
00068 #endif
00069 }
00070
00071 void
00072 ACE_OS::free (void *ptr)
00073 {
00074 ACE_FREE_FUNC (ACE_MALLOC_T (ptr));
00075 }
00076
00077
00078
00079
00080
00081
00082 #if defined (ACE_WIN32) && defined (UNICODE) && !defined (ACE_USES_TCHAR)
00083 #undef GetEnvironmentStrings
00084 #endif
00085
00086 ACE_TCHAR *
00087 ACE_OS::getenvstrings (void)
00088 {
00089 #if defined (ACE_LACKS_GETENVSTRINGS)
00090 ACE_NOTSUP_RETURN (0);
00091 #elif defined (ACE_WIN32)
00092 # if defined (ACE_USES_WCHAR)
00093 return ::GetEnvironmentStringsW ();
00094 # else
00095 return ::GetEnvironmentStrings ();
00096 # endif
00097 #else
00098 ACE_NOTSUP_RETURN (0);
00099 #endif
00100 }
00101
00102
00103
00104
00105
00106
00107 ACE_TCHAR *
00108 ACE_OS::strenvdup (const ACE_TCHAR *str)
00109 {
00110 #if defined (ACE_HAS_WINCE)
00111
00112 return ACE_OS::strdup (str);
00113 #elif defined (ACE_LACKS_STRENVDUP)
00114 ACE_UNUSED_ARG (str);
00115 ACE_NOTSUP_RETURN (0);
00116 #else
00117 const ACE_TCHAR * start = 0;
00118 if ((start = ACE_OS::strchr (str, ACE_TEXT ('$'))) != 0)
00119 {
00120 ACE_TCHAR buf[ACE_DEFAULT_ARGV_BUFSIZ];
00121 size_t var_len = ACE_OS::strcspn (&start[1],
00122 ACE_TEXT ("$~!#%^&*()-+=\\|/?,.;:'\"`[]{} \t\n\r"));
00123 ACE_OS::strncpy (buf, &start[1], var_len);
00124 buf[var_len++] = ACE_TEXT ('\0');
00125 # if defined (ACE_WIN32)
00126
00127 ACE_TCHAR *temp = ACE_OS::getenv (buf);
00128 # else
00129
00130 char *temp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (buf));
00131 # endif
00132 size_t buf_len = ACE_OS::strlen (str) + 1;
00133 if (temp != 0)
00134 buf_len += ACE_OS::strlen (temp) - var_len;
00135 ACE_TCHAR * buf_p = buf;
00136 if (buf_len > ACE_DEFAULT_ARGV_BUFSIZ)
00137 {
00138 buf_p =
00139 (ACE_TCHAR *) ACE_OS::malloc (buf_len * sizeof (ACE_TCHAR));
00140 if (buf_p == 0)
00141 {
00142 errno = ENOMEM;
00143 return 0;
00144 }
00145 }
00146 ACE_TCHAR * p = buf_p;
00147 size_t len = start - str;
00148 ACE_OS::strncpy (p, str, len);
00149 p += len;
00150 if (temp != 0)
00151 {
00152 # if defined (ACE_WIN32)
00153 p = ACE_OS::strecpy (p, temp) - 1;
00154 # else
00155 p = ACE_OS::strecpy (p, ACE_TEXT_CHAR_TO_TCHAR (temp)) - 1;
00156 # endif
00157 }
00158 else
00159 {
00160 ACE_OS::strncpy (p, start, var_len);
00161 p += var_len;
00162 *p = ACE_TEXT ('\0');
00163 }
00164 ACE_OS::strcpy (p, &start[var_len]);
00165 return (buf_p == buf) ? ACE_OS::strdup (buf) : buf_p;
00166 }
00167 else
00168 return ACE_OS::strdup (str);
00169 #endif
00170 }
00171
00172 #if !defined (ACE_HAS_ITOA)
00173 char *
00174 ACE_OS::itoa_emulation (int value, char *string, int radix)
00175 {
00176 char *e = string;
00177 char *b = string;
00178
00179
00180
00181 if (value == 0)
00182 {
00183 string[0] = '0';
00184 string[1] = 0;
00185 return string;
00186 }
00187
00188
00189
00190
00191 if (value < 0 && radix == 10)
00192 {
00193 string[0] = '-';
00194 ++b;
00195 ++e;
00196 value = -value;
00197 }
00198
00199
00200
00201 while (value != 0)
00202 {
00203 int mod = value % radix;
00204 value = value / radix;
00205
00206 *e++ = (mod < 10) ? '0' + mod : 'a' + mod - 10;
00207 }
00208
00209 *e-- = 0;
00210
00211
00212
00213 while (e > b)
00214 {
00215 char temp = *e;
00216 *e = *b;
00217 *b = temp;
00218 ++b;
00219 --e;
00220 }
00221
00222 return string;
00223 }
00224 #endif
00225
00226 #if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_ITOW)
00227 wchar_t *
00228 ACE_OS::itow_emulation (int value, wchar_t *string, int radix)
00229 {
00230 wchar_t *e = string;
00231 wchar_t *b = string;
00232
00233
00234
00235 if (value == 0)
00236 {
00237 string[0] = '0';
00238 string[1] = 0;
00239 return string;
00240 }
00241
00242
00243
00244
00245 if (value < 0 && radix == 10)
00246 {
00247 string[0] = '-';
00248 b++;
00249 }
00250
00251
00252
00253 while (value != 0)
00254 {
00255 int mod = value % radix;
00256 value = value / radix;
00257
00258 *e++ = (mod < 10) ? '0' + mod : 'a' + mod - 10;
00259 }
00260
00261 *e-- = 0;
00262
00263
00264
00265 while (e > b)
00266 {
00267 wchar_t temp = *e;
00268 *e = *b;
00269 *b = temp;
00270 ++b;
00271 --e;
00272 }
00273
00274 return string;
00275 }
00276 #endif
00277
00278 void *
00279 ACE_OS::malloc (size_t nbytes)
00280 {
00281 return ACE_MALLOC_FUNC (nbytes);
00282 }
00283
00284 #if defined (ACE_LACKS_MKTEMP)
00285 ACE_TCHAR *
00286 ACE_OS::mktemp (ACE_TCHAR *s)
00287 {
00288 ACE_OS_TRACE ("ACE_OS::mktemp");
00289 if (s == 0)
00290
00291 return 0;
00292 else
00293 {
00294 ACE_TCHAR *xxxxxx = ACE_OS::strstr (s, ACE_TEXT ("XXXXXX"));
00295
00296 if (xxxxxx == 0)
00297
00298 return s;
00299 else
00300 {
00301 ACE_TCHAR unique_letter = ACE_TEXT ('a');
00302 ACE_stat sb;
00303
00304
00305
00306
00307
00308
00309
00310 ACE_OS::sprintf (xxxxxx,
00311 ACE_TEXT ("%05d%c"),
00312 ACE_OS::getpid (),
00313 unique_letter);
00314 while (ACE_OS::stat (s, &sb) >= 0)
00315 {
00316 if (++unique_letter <= ACE_TEXT ('z'))
00317 ACE_OS::sprintf (xxxxxx,
00318 ACE_TEXT ("%05d%c"),
00319 ACE_OS::getpid (),
00320 unique_letter);
00321 else
00322 {
00323
00324 ACE_OS::sprintf (xxxxxx, ACE_TEXT ("%s"), ACE_TEXT (""));
00325 return s;
00326 }
00327 }
00328 }
00329 return s;
00330 }
00331 }
00332 #endif
00333
00334 void *
00335 ACE_OS::realloc (void *ptr, size_t nbytes)
00336 {
00337 return ACE_REALLOC_FUNC (ACE_MALLOC_T (ptr), nbytes);
00338 }
00339
00340 #if defined (ACE_LACKS_REALPATH)
00341 char *
00342 ACE_OS::realpath (const char *file_name,
00343 char *resolved_name)
00344 {
00345 ACE_OS_TRACE ("ACE_OS::realpath");
00346
00347 if (file_name == 0)
00348 {
00349
00350
00351 errno = EINVAL;
00352 return 0;
00353 }
00354
00355 if (*file_name == '\0')
00356 {
00357
00358
00359
00360 errno = ENOENT;
00361 return 0;
00362 }
00363
00364 char* rpath;
00365
00366 if (resolved_name == 0)
00367 {
00368
00369
00370
00371
00372
00373
00374 rpath = static_cast<char*>(ACE_OS::malloc (PATH_MAX));
00375 if (rpath == 0)
00376 {
00377 errno = ENOMEM;
00378 return 0;
00379 }
00380 }
00381 else
00382 {
00383 rpath = resolved_name;
00384 }
00385
00386 char* dest;
00387
00388 if (*file_name != '/')
00389 {
00390
00391 if (ACE_OS::getcwd (rpath, PATH_MAX) == 0)
00392 {
00393 if (resolved_name == 0)
00394 ACE_OS::free (rpath);
00395 return 0;
00396 }
00397 dest = ACE_OS::strchr (rpath, '\0');
00398 }
00399 else
00400 {
00401 dest = rpath;
00402 }
00403
00404 #if !defined (ACE_LACKS_SYMLINKS)
00405 char expand_buf[PATH_MAX];
00406 int nlinks = 0;
00407 #endif
00408
00409 while (*file_name)
00410 {
00411 *dest++ = '/';
00412
00413
00414 while (*file_name == '/')
00415 ++file_name;
00416
00417 char* start = dest;
00418
00419
00420 while (*file_name && *file_name != '/')
00421 {
00422 *dest++ = *file_name++;
00423 if (dest - rpath > PATH_MAX)
00424 {
00425 errno = ENAMETOOLONG;
00426 if (resolved_name == 0)
00427 ACE_OS::free (rpath);
00428 return 0;
00429 }
00430 }
00431
00432 if (start == dest)
00433 {
00434 if (dest - rpath > 1)
00435 --dest;
00436 break;
00437 }
00438 else if (dest - start == 1 && *start == '.')
00439 {
00440 dest -= 2;
00441 }
00442 else if (dest - start == 2 && *start == '.' && *(start +1) == '.')
00443 {
00444 dest -= 3;
00445 if (dest > rpath)
00446 while (*--dest != '/')
00447 ;
00448 }
00449 # if !defined (ACE_LACKS_SYMLINKS)
00450 else
00451 {
00452 ACE_stat st;
00453
00454 *dest = '\0';
00455 if (ACE_OS::lstat(rpath, &st) < 0)
00456 {
00457 if (resolved_name == 0)
00458 ACE_OS::free (rpath);
00459 return 0;
00460 }
00461
00462
00463 if (S_ISLNK (st.st_mode))
00464 {
00465 if (++nlinks > MAXSYMLINKS)
00466 {
00467 errno = ELOOP;
00468 if (resolved_name == 0)
00469 ACE_OS::free (rpath);
00470 return 0;
00471 }
00472
00473 char link_buf[PATH_MAX];
00474
00475 ssize_t link_len = ACE_OS::readlink (rpath, link_buf, PATH_MAX);
00476 int tail_len = ACE_OS::strlen (file_name) + 1;
00477
00478
00479 if (link_len + tail_len > PATH_MAX)
00480 {
00481 errno = ENAMETOOLONG;
00482 if (resolved_name == 0)
00483 ACE_OS::free (rpath);
00484 return 0;
00485 }
00486
00487
00488 ACE_OS::memmove (expand_buf + link_len, file_name, tail_len);
00489 ACE_OS::memcpy (expand_buf, link_buf, link_len);
00490
00491 if (*link_buf == '/')
00492 {
00493 dest = rpath;
00494 }
00495 else
00496 {
00497 --dest;
00498 while (*--dest != '/')
00499 ;
00500 }
00501 file_name = expand_buf;
00502 }
00503 }
00504 # endif
00505 }
00506
00507 *dest = '\0';
00508
00509 return rpath;
00510 }
00511 #endif
00512
00513 #if defined (ACE_LACKS_STRTOL)
00514 long
00515 ACE_OS::strtol_emulation (const char *nptr, char **endptr, int base)
00516 {
00517 register const char *s = nptr;
00518 register unsigned long acc;
00519 register int c;
00520 register unsigned long cutoff;
00521 register int neg = 0, any, cutlim;
00522
00523
00524
00525
00526
00527
00528 do {
00529 c = *s++;
00530 } while (ACE_OS::ace_isspace(c));
00531 if (c == '-') {
00532 neg = 1;
00533 c = *s++;
00534 } else if (c == '+')
00535 c = *s++;
00536 if ((base == 0 || base == 16) &&
00537 c == '0' && (*s == 'x' || *s == 'X')) {
00538 c = s[1];
00539 s += 2;
00540 base = 16;
00541 }
00542 if (base == 0)
00543 base = c == '0' ? 8 : 10;
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562 cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
00563 cutlim = cutoff % (unsigned long)base;
00564 cutoff /= (unsigned long)base;
00565 for (acc = 0, any = 0;; c = *s++) {
00566 if (ACE_OS::ace_isdigit(c))
00567 c -= '0';
00568 else if (ACE_OS::ace_isalpha(c))
00569 c -= ACE_OS::ace_isupper(c) ? 'A' - 10 : 'a' - 10;
00570 else
00571 break;
00572 if (c >= base)
00573 break;
00574 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00575 any = -1;
00576 else {
00577 any = 1;
00578 acc *= base;
00579 acc += c;
00580 }
00581 }
00582 if (any < 0) {
00583 acc = neg ? LONG_MIN : LONG_MAX;
00584 errno = ERANGE;
00585 } else if (neg)
00586 acc = -acc;
00587 if (endptr != 0)
00588 *endptr = any ? (char *)s - 1 : (char *)nptr;
00589 return (acc);
00590 }
00591 #endif
00592
00593 #if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSTOL)
00594 long
00595 ACE_OS::wcstol_emulation (const wchar_t *nptr,
00596 wchar_t **endptr,
00597 int base)
00598 {
00599 register const wchar_t *s = nptr;
00600 register unsigned long acc;
00601 register int c;
00602 register unsigned long cutoff;
00603 register int neg = 0, any, cutlim;
00604
00605
00606
00607
00608
00609
00610 do {
00611 c = *s++;
00612 } while (ACE_OS::ace_isspace(c));
00613 if (c == L'-') {
00614 neg = 1;
00615 c = *s++;
00616 } else if (c == L'+')
00617 c = *s++;
00618 if ((base == 0 || base == 16) &&
00619 c == '0' && (*s == L'x' || *s == L'X')) {
00620 c = s[1];
00621 s += 2;
00622 base = 16;
00623 }
00624 if (base == 0)
00625 base = c == L'0' ? 8 : 10;
00626
00627
00628
00629
00630 cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
00631 cutlim = cutoff % (unsigned long)base;
00632 cutoff /= (unsigned long)base;
00633 for (acc = 0, any = 0;; c = *s++) {
00634 if (ACE_OS::ace_isdigit(c))
00635 c -= L'0';
00636 else if (ACE_OS::ace_isalpha(c))
00637 c -= ACE_OS::ace_isupper(c) ? L'A' - 10 : L'a' - 10;
00638 else
00639 break;
00640 if (c >= base)
00641 break;
00642 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00643 any = -1;
00644 else {
00645 any = 1;
00646 acc *= base;
00647 acc += c;
00648 }
00649 }
00650 if (any < 0) {
00651 acc = neg ? LONG_MIN : LONG_MAX;
00652 errno = ERANGE;
00653 } else if (neg)
00654 acc = -acc;
00655 if (endptr != 0)
00656 *endptr = any ? (wchar_t *)s - 1 : (wchar_t *)nptr;
00657 return (acc);
00658 }
00659 #endif
00660
00661 #if defined (ACE_LACKS_STRTOUL)
00662 unsigned long
00663 ACE_OS::strtoul_emulation (const char *nptr,
00664 char **endptr,
00665 register int base)
00666 {
00667 register const char *s = nptr;
00668 register unsigned long acc;
00669 register int c;
00670 register unsigned long cutoff;
00671 register int neg = 0, any, cutlim;
00672
00673
00674
00675
00676 do
00677 c = *s++;
00678 while (ACE_OS::ace_isspace(c));
00679 if (c == '-')
00680 {
00681 neg = 1;
00682 c = *s++;
00683 }
00684 else if (c == '+')
00685 c = *s++;
00686 if ((base == 0 || base == 16) &&
00687 c == '0' && (*s == 'x' || *s == 'X'))
00688 {
00689 c = s[1];
00690 s += 2;
00691 base = 16;
00692 }
00693 if (base == 0)
00694 base = c == '0' ? 8 : 10;
00695 cutoff = (unsigned long) ULONG_MAX / (unsigned long) base;
00696 cutlim = (unsigned long) ULONG_MAX % (unsigned long) base;
00697
00698 for (acc = 0, any = 0;; c = *s++)
00699 {
00700 if (ACE_OS::ace_isdigit(c))
00701 c -= '0';
00702 else if (ACE_OS::ace_isalpha(c))
00703 c -= ACE_OS::ace_isupper(c) ? 'A' - 10 : 'a' - 10;
00704 else
00705 break;
00706 if (c >= base)
00707 break;
00708 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00709 any = -1;
00710 else
00711 {
00712 any = 1;
00713 acc *= base;
00714 acc += c;
00715 }
00716 }
00717 if (any < 0)
00718 {
00719 acc = ULONG_MAX;
00720 errno = ERANGE;
00721 }
00722 else if (neg)
00723 acc = -acc;
00724 if (endptr != 0)
00725 *endptr = any ? (char *) s - 1 : (char *) nptr;
00726 return (acc);
00727 }
00728 #endif
00729
00730
00731 #if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSTOUL)
00732 unsigned long
00733 ACE_OS::wcstoul_emulation (const wchar_t *nptr,
00734 wchar_t **endptr,
00735 int base)
00736 {
00737 register const wchar_t *s = nptr;
00738 register unsigned long acc;
00739 register int c;
00740 register unsigned long cutoff;
00741 register int neg = 0, any, cutlim;
00742
00743
00744
00745
00746 do
00747 c = *s++;
00748 while (ACE_OS::ace_isspace(c));
00749 if (c == L'-')
00750 {
00751 neg = 1;
00752 c = *s++;
00753 }
00754 else if (c == L'+')
00755 c = *s++;
00756 if ((base == 0 || base == 16) &&
00757 c == L'0' && (*s == L'x' || *s == L'X'))
00758 {
00759 c = s[1];
00760 s += 2;
00761 base = 16;
00762 }
00763 if (base == 0)
00764 base = c == L'0' ? 8 : 10;
00765 cutoff = (unsigned long) ULONG_MAX / (unsigned long) base;
00766 cutlim = (unsigned long) ULONG_MAX % (unsigned long) base;
00767
00768 for (acc = 0, any = 0;; c = *s++)
00769 {
00770 if (ACE_OS::ace_isdigit(c))
00771 c -= L'0';
00772 else if (ACE_OS::ace_isalpha(c))
00773 c -= ACE_OS::ace_isupper(c) ? L'A' - 10 : L'a' - 10;
00774 else
00775 break;
00776 if (c >= base)
00777 break;
00778 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00779 any = -1;
00780 else
00781 {
00782 any = 1;
00783 acc *= base;
00784 acc += c;
00785 }
00786 }
00787 if (any < 0)
00788 {
00789 acc = ULONG_MAX;
00790 errno = ERANGE;
00791 }
00792 else if (neg)
00793 acc = -acc;
00794 if (endptr != 0)
00795 *endptr = any ? (wchar_t *) s - 1 : (wchar_t *) nptr;
00796 return (acc);
00797 }
00798 #endif
00799
00800 #if defined (ACE_LACKS_STRTOLL)
00801 ACE_INT64
00802 ACE_OS::strtoll_emulation (const char *nptr,
00803 char **endptr,
00804 register int base)
00805 {
00806 register const char *s = nptr;
00807 register ACE_UINT64 acc;
00808 register int c;
00809 register ACE_UINT64 cutoff;
00810 register int neg = 0, any, cutlim;
00811
00812
00813
00814
00815
00816
00817 do {
00818 c = *s++;
00819 } while (ACE_OS::ace_isspace(c));
00820 if (c == '-') {
00821 neg = 1;
00822 c = *s++;
00823 } else if (c == '+')
00824 c = *s++;
00825 if ((base == 0 || base == 16) &&
00826 c == '0' && (*s == 'x' || *s == 'X')) {
00827 c = s[1];
00828 s += 2;
00829 base = 16;
00830 }
00831 if (base == 0)
00832 base = c == '0' ? 8 : 10;
00833
00834
00835
00836
00837 cutoff = neg ? -(ACE_UINT64)ACE_INT64_MIN : ACE_INT64_MAX;
00838 cutlim = cutoff % (ACE_UINT64)base;
00839 cutoff /= (ACE_UINT64)base;
00840 for (acc = 0, any = 0;; c = *s++) {
00841 if (ACE_OS::ace_isdigit(c))
00842 c -= '0';
00843 else if (ACE_OS::ace_isalpha(c))
00844 c -= ACE_OS::ace_isupper(c) ? 'A' - 10 : 'a' - 10;
00845 else
00846 break;
00847 if (c >= base)
00848 break;
00849 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00850 any = -1;
00851 else {
00852 any = 1;
00853 acc *= base;
00854 acc += c;
00855 }
00856 }
00857 if (any < 0) {
00858 acc = neg ? ACE_INT64_MIN : ACE_INT64_MAX;
00859 errno = ERANGE;
00860 } else if (neg)
00861 acc = -acc;
00862 if (endptr != 0)
00863 *endptr = any ? (char *)s - 1 : (char *)nptr;
00864 return (acc);
00865 }
00866 #endif
00867
00868 #if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSTOLL)
00869 ACE_INT64
00870 ACE_OS::wcstoll_emulation (const wchar_t *nptr,
00871 wchar_t **endptr,
00872 int base)
00873 {
00874 register const wchar_t *s = nptr;
00875 register ACE_UINT64 acc;
00876 register int c;
00877 register ACE_UINT64 cutoff;
00878 register int neg = 0, any, cutlim;
00879
00880
00881
00882
00883
00884
00885 do {
00886 c = *s++;
00887 } while (ACE_OS::ace_isspace(c));
00888 if (c == L'-') {
00889 neg = 1;
00890 c = *s++;
00891 } else if (c == L'+')
00892 c = *s++;
00893 if ((base == 0 || base == 16) &&
00894 c == L'0' && (*s == L'x' || *s == L'X')) {
00895 c = s[1];
00896 s += 2;
00897 base = 16;
00898 }
00899 if (base == 0)
00900 base = c == L'0' ? 8 : 10;
00901
00902
00903
00904
00905 cutoff = neg ? -(ACE_UINT64)ACE_INT64_MIN : ACE_INT64_MAX;
00906 cutlim = cutoff % (ACE_UINT64)base;
00907 cutoff /= (ACE_UINT64)base;
00908 for (acc = 0, any = 0;; c = *s++) {
00909 if (ACE_OS::ace_isdigit(c))
00910 c -= L'0';
00911 else if (ACE_OS::ace_isalpha(c))
00912 c -= ACE_OS::ace_isupper(c) ? L'A' - 10 : L'a' - 10;
00913 else
00914 break;
00915 if (c >= base)
00916 break;
00917 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00918 any = -1;
00919 else {
00920 any = 1;
00921 acc *= base;
00922 acc += c;
00923 }
00924 }
00925 if (any < 0) {
00926 acc = neg ? ACE_INT64_MIN : ACE_INT64_MAX;
00927 errno = ERANGE;
00928 } else if (neg)
00929 acc = -acc;
00930 if (endptr != 0)
00931 *endptr = any ? (wchar_t *)s - 1 : (wchar_t *)nptr;
00932 return (acc);
00933 }
00934 #endif
00935
00936
00937 #if defined (ACE_LACKS_STRTOULL)
00938 ACE_UINT64
00939 ACE_OS::strtoull_emulation (const char *nptr,
00940 char **endptr,
00941 register int base)
00942 {
00943 register const char *s = nptr;
00944 register ACE_UINT64 acc;
00945 register int c;
00946 register ACE_UINT64 cutoff;
00947 register int neg = 0, any, cutlim;
00948
00949
00950
00951
00952 do
00953 c = *s++;
00954 while (ACE_OS::ace_isspace(c));
00955 if (c == '-')
00956 {
00957 neg = 1;
00958 c = *s++;
00959 }
00960 else if (c == '+')
00961 c = *s++;
00962 if ((base == 0 || base == 16) &&
00963 c == '0' && (*s == 'x' || *s == 'X'))
00964 {
00965 c = s[1];
00966 s += 2;
00967 base = 16;
00968 }
00969 if (base == 0)
00970 base = c == '0' ? 8 : 10;
00971
00972 cutoff = (ACE_UINT64) ACE_UINT64_MAX / (ACE_UINT64) base;
00973 cutlim = (ACE_UINT64) ACE_UINT64_MAX % (ACE_UINT64) base;
00974
00975 for (acc = 0, any = 0;; c = *s++)
00976 {
00977 if (ACE_OS::ace_isdigit(c))
00978 c -= '0';
00979 else if (ACE_OS::ace_isalpha(c))
00980 c -= ACE_OS::ace_isupper(c) ? 'A' - 10 : 'a' - 10;
00981 else
00982 break;
00983 if (c >= base)
00984 break;
00985 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
00986 any = -1;
00987 else
00988 {
00989 any = 1;
00990 acc *= base;
00991 acc += c;
00992 }
00993 }
00994 if (any < 0)
00995 {
00996 acc = ACE_UINT64_MAX;
00997 errno = ERANGE;
00998 }
00999 else if (neg)
01000 acc = -acc;
01001 if (endptr != 0)
01002 *endptr = any ? (char *) s - 1 : (char *) nptr;
01003 return (acc);
01004 }
01005 #endif
01006
01007 #if defined (ACE_HAS_WCHAR) && defined (ACE_LACKS_WCSTOULL)
01008 ACE_UINT64
01009 ACE_OS::wcstoull_emulation (const wchar_t *nptr,
01010 wchar_t **endptr,
01011 int base)
01012 {
01013 register const wchar_t *s = nptr;
01014 register ACE_UINT64 acc;
01015 register int c;
01016 register ACE_UINT64 cutoff;
01017 register int neg = 0, any, cutlim;
01018
01019
01020
01021
01022 do
01023 c = *s++;
01024 while (ACE_OS::ace_isspace(c));
01025 if (c == L'-')
01026 {
01027 neg = 1;
01028 c = *s++;
01029 }
01030 else if (c == L'+')
01031 c = *s++;
01032 if ((base == 0 || base == 16) &&
01033 c == L'0' && (*s == L'x' || *s == L'X'))
01034 {
01035 c = s[1];
01036 s += 2;
01037 base = 16;
01038 }
01039 if (base == 0)
01040 base = c == L'0' ? 8 : 10;
01041
01042 cutoff = (ACE_UINT64) ACE_UINT64_MAX / (ACE_UINT64) base;
01043 cutlim = (ACE_UINT64) ACE_UINT64_MAX % (ACE_UINT64) base;
01044
01045 for (acc = 0, any = 0;; c = *s++)
01046 {
01047 if (ACE_OS::ace_isdigit(c))
01048 c -= L'0';
01049 else if (ACE_OS::ace_isalpha(c))
01050 c -= ACE_OS::ace_isupper(c) ? L'A' - 10 : L'a' - 10;
01051 else
01052 break;
01053 if (c >= base)
01054 break;
01055 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
01056 any = -1;
01057 else
01058 {
01059 any = 1;
01060 acc *= base;
01061 acc += c;
01062 }
01063 }
01064 if (any < 0)
01065 {
01066 acc = ACE_UINT64_MAX;
01067 errno = ERANGE;
01068 }
01069 else if (neg)
01070 acc = -acc;
01071 if (endptr != 0)
01072 *endptr = any ? (wchar_t *) s - 1 : (wchar_t *) nptr;
01073 return (acc);
01074 }
01075 #endif
01076
01077 #if defined (ACE_LACKS_MKSTEMP)
01078 ACE_HANDLE
01079 ACE_OS::mkstemp_emulation (ACE_TCHAR * s)
01080 {
01081 if (s == 0)
01082 {
01083 errno = EINVAL;
01084 return ACE_INVALID_HANDLE;
01085 }
01086
01087
01088 ACE_TCHAR * const t = ACE_OS::strstr (s, ACE_TEXT ("XXXXXX"));
01089
01090 if (t == 0)
01091 {
01092 errno = EINVAL;
01093 return ACE_INVALID_HANDLE;
01094 }
01095
01096 static unsigned int const NUM_RETRIES = 50;
01097 static unsigned int const NUM_CHARS = 6;
01098
01099
01100
01101 ACE_UINT64 msec;
01102
01103
01104
01105 ACE_Time_Value const now = ACE_OS::gettimeofday();
01106 now.msec (msec);
01107
01108
01109 msec += ACE_OS::getpid();
01110 msec += (size_t) ACE_OS::thr_self();
01111
01112
01113
01114
01115 ACE_RANDR_TYPE seed = static_cast<ACE_RANDR_TYPE> (msec);
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128 float const MAX_VAL =
01129 static_cast<float> (ACE_Numeric_Limits<char>::max ());
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140 float const coefficient =
01141 static_cast<float> (MAX_VAL / (RAND_MAX + 1.0f));
01142
01143
01144
01145 for (unsigned int i = 0; i < NUM_RETRIES; ++i)
01146 {
01147 for (unsigned int n = 0; n < NUM_CHARS; ++n)
01148 {
01149 ACE_TCHAR r;
01150
01151
01152
01153 do
01154 {
01155 r = static_cast<ACE_TCHAR> (coefficient * ACE_OS::rand_r (seed));
01156 }
01157 while (!ACE_OS::ace_isalnum (r));
01158
01159 t[n] = r;
01160 }
01161
01162 static int const perms =
01163 #if defined (ACE_WIN32)
01164 0;
01165 #else
01166 0600;
01167 #endif
01168
01169
01170
01171
01172
01173
01174 ACE_HANDLE const handle = ACE_OS::open (s,
01175 O_RDWR | O_CREAT | O_EXCL,
01176 perms);
01177
01178 if (handle != ACE_INVALID_HANDLE)
01179 return handle;
01180 }
01181
01182 errno = EEXIST;
01183 return ACE_INVALID_HANDLE;
01184 }
01185 #endif
01186
01187 #if !defined (ACE_HAS_GETPROGNAME) && !defined (ACE_HAS_SETPROGNAME)
01188 static const char *__progname = "";
01189 #endif
01190
01191 #if !defined (ACE_HAS_GETPROGNAME)
01192 const char*
01193 ACE_OS::getprogname_emulation ()
01194 {
01195 return __progname;
01196 }
01197 #endif
01198
01199 #if !defined (ACE_HAS_SETPROGNAME)
01200 void
01201 ACE_OS::setprogname_emulation (const char* progname)
01202 {
01203 const char *p = ACE_OS::strrchr (progname, '/');
01204 if (p != 0)
01205 __progname = p + 1;
01206 else
01207 __progname = progname;
01208 }
01209 #endif
01210
01211 ACE_END_VERSIONED_NAMESPACE_DECL