00001
00002
00003 #include "ace/OS_NS_stdio.h"
00004 #include "ace/OS_NS_Thread.h"
00005
00006 ACE_RCSID (ace,
00007 OS_NS_stdio,
00008 "$Id: OS_NS_stdio.cpp 86912 2009-10-04 14:26:19Z schmidt $")
00009
00010
00011 #if !defined (ACE_HAS_INLINED_OSCALLS)
00012 # include "ace/OS_NS_stdio.inl"
00013 #endif
00014
00015 # if defined (ACE_WIN32)
00016
00017 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00018 ACE_TEXT_OSVERSIONINFO ACE_OS::win32_versioninfo_;
00019 HINSTANCE ACE_OS::win32_resource_module_;
00020 ACE_END_VERSIONED_NAMESPACE_DECL
00021
00022 # if defined (ACE_HAS_DLL) && (ACE_HAS_DLL == 1) && !defined (ACE_HAS_WINCE)
00023
00024
00025 extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID)
00026 {
00027 if (reason == DLL_PROCESS_ATTACH)
00028 {
00029 # if defined (ACE_DISABLES_THREAD_LIBRARY_CALLS) && (ACE_DISABLES_THREAD_LIBRARY_CALLS == 1)
00030 ::DisableThreadLibraryCalls (instance);
00031 # endif
00032 ACE_OS::set_win32_resource_module(instance);
00033 }
00034 else if (reason == DLL_THREAD_DETACH)
00035 {
00036 ACE_OS::cleanup_tss (0);
00037 }
00038 return TRUE;
00039 }
00040 # endif
00041 # endif
00042
00043 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00044
00045 void
00046 ACE_OS::ace_flock_t::dump (void) const
00047 {
00048 #if defined (ACE_HAS_DUMP)
00049 ACE_OS_TRACE ("ACE_OS::ace_flock_t::dump");
00050
00051 # if 0
00052 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00053 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("handle_ = %u"), this->handle_));
00054 # if defined (ACE_WIN32)
00055 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nInternal = %d"),
00056 this->overlapped_.Internal));
00057 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nInternalHigh = %d"),
00058 this->overlapped_.InternalHigh));
00059 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nOffsetHigh = %d"),
00060 this->overlapped_.OffsetHigh));
00061 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nhEvent = %d"),
00062 this->overlapped_.hEvent));
00063 # else
00064 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nl_whence = %d"),
00065 this->lock_.l_whence));
00066 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nl_start = %d"), this->lock_.l_start));
00067 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nl_len = %d"), this->lock_.l_len));
00068 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nl_type = %d"), this->lock_.l_type));
00069 # endif
00070 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00071 # endif
00072 #endif
00073 }
00074
00075
00076
00077
00078 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
00079 namespace
00080 {
00081
00082
00083 void
00084 fopen_mode_to_open_mode_converter (ACE_TCHAR x, int & hmode)
00085 {
00086 switch (x)
00087 {
00088 case ACE_TEXT ('r'):
00089 if (ACE_BIT_DISABLED (hmode, _O_RDWR))
00090 {
00091 ACE_CLR_BITS (hmode, _O_WRONLY);
00092 ACE_SET_BITS (hmode, _O_RDONLY);
00093 }
00094 break;
00095 case ACE_TEXT ('w'):
00096 if (ACE_BIT_DISABLED (hmode, _O_RDWR))
00097 {
00098 ACE_CLR_BITS (hmode, _O_RDONLY);
00099 ACE_SET_BITS (hmode, _O_WRONLY);
00100 }
00101 ACE_SET_BITS (hmode, _O_CREAT | _O_TRUNC);
00102 break;
00103 case ACE_TEXT ('a'):
00104 if (ACE_BIT_DISABLED (hmode, _O_RDWR))
00105 {
00106 ACE_CLR_BITS (hmode, _O_RDONLY);
00107 ACE_SET_BITS (hmode, _O_WRONLY);
00108 }
00109 ACE_SET_BITS (hmode, _O_CREAT | _O_APPEND);
00110 break;
00111 case ACE_TEXT ('+'):
00112 ACE_CLR_BITS (hmode, _O_RDONLY | _O_WRONLY);
00113 ACE_SET_BITS (hmode, _O_RDWR);
00114 break;
00115 case ACE_TEXT ('t'):
00116 ACE_CLR_BITS (hmode, _O_BINARY);
00117 ACE_SET_BITS (hmode, _O_TEXT);
00118 break;
00119 case ACE_TEXT ('b'):
00120 ACE_CLR_BITS (hmode, _O_TEXT);
00121 ACE_SET_BITS (hmode, _O_BINARY);
00122 break;
00123 }
00124 }
00125 }
00126
00127 FILE *
00128 ACE_OS::fopen (const char *filename,
00129 const ACE_TCHAR *mode)
00130 {
00131 ACE_OS_TRACE ("ACE_OS::fopen");
00132 #if defined (ACE_LACKS_FOPEN)
00133 ACE_UNUSED_ARG (filename);
00134 ACE_UNUSED_ARG (mode);
00135 ACE_NOTSUP_RETURN (0);
00136 #else
00137 int hmode = _O_TEXT;
00138
00139
00140
00141
00142 ACE_TCHAR const empty_mode[] = ACE_TEXT ("");
00143 if (!mode)
00144 mode = empty_mode;
00145
00146 for (ACE_TCHAR const* mode_ptr = mode; *mode_ptr != 0; ++mode_ptr)
00147 fopen_mode_to_open_mode_converter (*mode_ptr, hmode);
00148
00149 ACE_HANDLE const handle = ACE_OS::open (filename, hmode);
00150 if (handle != ACE_INVALID_HANDLE)
00151 {
00152 hmode &= _O_TEXT | _O_RDONLY | _O_APPEND;
00153
00154 int const fd = ::_open_osfhandle (intptr_t (handle), hmode);
00155
00156 if (fd != -1)
00157 {
00158 # if defined (ACE_HAS_NONCONST_FDOPEN) && !defined (ACE_USES_WCHAR)
00159 FILE * const fp = ::_fdopen (fd, const_cast<ACE_TCHAR *> (mode));
00160 # elif defined (ACE_HAS_NONCONST_FDOPEN) && defined (ACE_USES_WCHAR)
00161 FILE * const fp = ::_wfdopen (fd, const_cast<ACE_TCHAR *> (mode));
00162 # elif defined (ACE_USES_WCHAR)
00163 FILE * const fp = ::_wfdopen (fd, mode);
00164 # else
00165 FILE * const fp = ::fdopen (fd, mode);
00166 # endif
00167 if (fp != 0)
00168 {
00169 return fp;
00170 }
00171 ::_close (fd);
00172 }
00173
00174 ACE_OS::close (handle);
00175 }
00176 return 0;
00177 #endif
00178 }
00179
00180 #if defined (ACE_HAS_WCHAR)
00181 FILE *
00182 ACE_OS::fopen (const char *filename,
00183 const ACE_ANTI_TCHAR *mode)
00184 {
00185 return ACE_OS::fopen (filename, ACE_TEXT_ANTI_TO_TCHAR (mode));
00186 }
00187
00188 FILE *
00189 ACE_OS::fopen (const wchar_t *filename,
00190 const ACE_ANTI_TCHAR *mode)
00191 {
00192 return ACE_OS::fopen (filename, ACE_TEXT_ANTI_TO_TCHAR (mode));
00193 }
00194
00195 FILE *
00196 ACE_OS::fopen (const wchar_t *filename,
00197 const ACE_TCHAR *mode)
00198 {
00199 ACE_OS_TRACE ("ACE_OS::fopen");
00200 #if defined (ACE_LACKS_FOPEN)
00201 ACE_UNUSED_ARG (filename);
00202 ACE_UNUSED_ARG (mode);
00203 ACE_NOTSUP_RETURN (0);
00204 #else
00205 int hmode = _O_TEXT;
00206
00207 for (const ACE_TCHAR *mode_ptr = mode; *mode_ptr != 0; mode_ptr++)
00208 fopen_mode_to_open_mode_converter (*mode_ptr, hmode);
00209
00210 ACE_HANDLE handle = ACE_OS::open (filename, hmode);
00211 if (handle != ACE_INVALID_HANDLE)
00212 {
00213 hmode &= _O_TEXT | _O_RDONLY | _O_APPEND;
00214
00215 int const fd = ::_open_osfhandle (intptr_t (handle), hmode);
00216
00217 if (fd != -1)
00218 {
00219 # if defined (ACE_HAS_NONCONST_FDOPEN) && !defined (ACE_USES_WCHAR)
00220 FILE *fp = ::_fdopen (fd, const_cast<char *> (mode));
00221 # elif defined (ACE_HAS_NONCONST_FDOPEN) && defined (ACE_USES_WCHAR)
00222 FILE *fp = ::_wfdopen (fd, const_cast<wchar_t *> (mode));
00223 # elif defined (ACE_USES_WCHAR)
00224 FILE *fp = ::_wfdopen (fd, mode);
00225 # else
00226 FILE *fp = ::fdopen (fd, mode);
00227 # endif
00228 if (fp != 0)
00229 {
00230 return fp;
00231 }
00232 ::_close (fd);
00233 }
00234
00235 ACE_OS::close (handle);
00236 }
00237 return 0;
00238 #endif
00239 }
00240 #endif
00241
00242 #endif
00243
00244
00245
00246
00247 int
00248 ACE_OS::fprintf (FILE *fp, const char *format, ...)
00249 {
00250
00251 va_list ap;
00252 va_start (ap, format);
00253 int const result = ACE_OS::vfprintf (fp, format, ap);
00254 va_end (ap);
00255 return result;
00256 }
00257
00258 #if defined (ACE_HAS_WCHAR)
00259 int
00260 ACE_OS::fprintf (FILE *fp, const wchar_t *format, ...)
00261 {
00262
00263 va_list ap;
00264 va_start (ap, format);
00265 int const result = ACE_OS::vfprintf (fp, format, ap);
00266 va_end (ap);
00267 return result;
00268 }
00269 #endif
00270
00271 int
00272 ACE_OS::asprintf (char **bufp, const char *format, ...)
00273 {
00274
00275 va_list ap;
00276 va_start (ap, format);
00277 int const result = ACE_OS::vasprintf (bufp, format, ap);
00278 va_end (ap);
00279 return result;
00280 }
00281
00282 #if defined (ACE_HAS_WCHAR)
00283 int
00284 ACE_OS::asprintf (wchar_t **bufp, const wchar_t *format, ...)
00285 {
00286
00287 va_list ap;
00288 va_start (ap, format);
00289 int const result = ACE_OS::vasprintf (bufp, format, ap);
00290 va_end (ap);
00291 return result;
00292 }
00293 #endif
00294
00295 int
00296 ACE_OS::printf (const char *format, ...)
00297 {
00298
00299 va_list ap;
00300 va_start (ap, format);
00301 int const result = ACE_OS::vprintf (format, ap);
00302 va_end (ap);
00303 return result;
00304 }
00305
00306 #if defined (ACE_HAS_WCHAR)
00307 int
00308 ACE_OS::printf (const wchar_t *format, ...)
00309 {
00310
00311 va_list ap;
00312 va_start (ap, format);
00313 int const result = ACE_OS::vprintf (format, ap);
00314 va_end (ap);
00315 return result;
00316 }
00317 #endif
00318
00319 int
00320 ACE_OS::snprintf (char *buf, size_t maxlen, const char *format, ...)
00321 {
00322
00323 va_list ap;
00324 va_start (ap, format);
00325 int const result = ACE_OS::vsnprintf (buf, maxlen, format, ap);
00326 va_end (ap);
00327 return result;
00328 }
00329
00330 #if defined (ACE_HAS_WCHAR)
00331 int
00332 ACE_OS::snprintf (wchar_t *buf, size_t maxlen, const wchar_t *format, ...)
00333 {
00334
00335 va_list ap;
00336 va_start (ap, format);
00337 int const result = ACE_OS::vsnprintf (buf, maxlen, format, ap);
00338 va_end (ap);
00339 return result;
00340 }
00341 #endif
00342
00343 int
00344 ACE_OS::sprintf (char *buf, const char *format, ...)
00345 {
00346
00347 va_list ap;
00348 va_start (ap, format);
00349 int const result = ACE_OS::vsprintf (buf, format, ap);
00350 va_end (ap);
00351 return result;
00352 }
00353
00354 #if defined (ACE_HAS_WCHAR)
00355 int
00356 ACE_OS::sprintf (wchar_t *buf, const wchar_t *format, ...)
00357 {
00358
00359 va_list ap;
00360 va_start (ap, format);
00361 int const result = ACE_OS::vsprintf (buf, format, ap);
00362 va_end (ap);
00363 return result;
00364 }
00365 #endif
00366
00367 #if !defined (ACE_HAS_VASPRINTF)
00368 int
00369 ACE_OS::vasprintf_emulation(char **bufp, const char *format, va_list argptr)
00370 {
00371 va_list ap;
00372 va_copy (ap, argptr);
00373 int size = ACE_OS::vsnprintf (0, 0, format, ap);
00374 va_end (ap);
00375
00376 if (size != -1)
00377 {
00378 char *buf = reinterpret_cast<char*>(ACE_OS::malloc(size + 1));
00379 if (!buf)
00380 return -1;
00381
00382 va_list aq;
00383 va_copy (aq, argptr);
00384 size = ACE_OS::vsnprintf(buf, size + 1, format, aq);
00385 va_end (aq);
00386
00387 if (size != -1)
00388 *bufp = buf;
00389 }
00390
00391 return size;
00392 }
00393 #endif
00394
00395 #if defined (ACE_HAS_WCHAR)
00396 #if !defined (ACE_HAS_VASWPRINTF)
00397 int
00398 ACE_OS::vaswprintf_emulation(wchar_t **bufp, const wchar_t *format, va_list argptr)
00399 {
00400 va_list ap;
00401 va_copy (ap, argptr);
00402 int size = ACE_OS::vsnprintf(0, 0, format, ap);
00403 va_end (ap);
00404
00405 if (size != -1)
00406 {
00407 wchar_t *buf = reinterpret_cast<wchar_t*>
00408 (ACE_OS::malloc((size + 1) * sizeof(wchar_t)));
00409 if (!buf)
00410 return -1;
00411
00412 va_list aq;
00413 va_copy (aq, argptr);
00414 size = ACE_OS::vsnprintf(buf, size + 1, format, aq);
00415 va_end (aq);
00416
00417 if (size != -1)
00418 *bufp = buf;
00419 }
00420
00421 return size;
00422 }
00423 #endif
00424 #endif
00425
00426 ACE_END_VERSIONED_NAMESPACE_DECL