ACE: OS_NS_stdio.h Source File

00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file   OS_NS_stdio.h
00006  *
00007  *  $Id: OS_NS_stdio.h 80826 2008-03-04 14:51:23Z wotte $
00008  *
00009  *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
00010  *  @author Jesper S. M|ller<stophph@diku.dk>
00011  *  @author and a cast of thousands...
00012  *
00013  *  Originally in OS.h.
00014  */
00015 //=============================================================================
00016 
00017 #ifndef ACE_OS_NS_STDIO_H
00018 # define ACE_OS_NS_STDIO_H
00019 
00020 # include /**/ "ace/pre.h"
00021 
00022 # include "ace/config-all.h"
00023 
00024 # if !defined (ACE_LACKS_PRAGMA_ONCE)
00025 #  pragma once
00026 # endif /* ACE_LACKS_PRAGMA_ONCE */
00027 
00028 #include "ace/os_include/os_stdio.h"
00029 #include "ace/os_include/os_fcntl.h"
00030 #include /**/ "ace/ACE_export.h"
00031 
00032 /* OPENVMS needs unistd for cuserid() */
00033 #if defined (CYGWIN32) || defined (ACE_OPENVMS)
00034 #  include "ace/os_include/os_unistd.h"
00035 #endif /* CYGWIN32 || ACE_OPENVMS */
00036 
00037 #if defined (ACE_EXPORT_MACRO)
00038 #  undef ACE_EXPORT_MACRO
00039 #endif
00040 #define ACE_EXPORT_MACRO ACE_Export
00041 
00042 /*
00043  * We inline and undef some functions that may be implemented
00044  * as macros on some platforms. This way macro definitions will
00045  * be usable later as there is no way to save the macro definition
00046  * using the pre-processor.
00047  *
00048  */
00049 #if !defined (ACE_LACKS_CLEARERR)
00050 inline void ace_clearerr_helper (FILE *stream)
00051 {
00052 #  if defined (clearerr)
00053   clearerr (stream);
00054 #  undef clearerr
00055 #  else
00056   ACE_STD_NAMESPACE::clearerr (stream);
00057 #  endif /* defined (clearerr) */
00058 }
00059 #endif /* !ACE_LACKS_CLEARERR */
00060 
00061 inline int ace_fgetc_helper (FILE *fp)
00062 {
00063 #if defined (fgetc)
00064   return fgetc (fp);
00065 #undef fgetc
00066 #else
00067   return ACE_STD_NAMESPACE::fgetc (fp);
00068 #endif /* defined (fgetc) */
00069 }
00070 
00071 inline int ace_fputc_helper (int ch, FILE *fp)
00072 {
00073 #if defined (fputc)
00074   return fputc (ch, fp);
00075 #undef fputc
00076 #else
00077   return ACE_STD_NAMESPACE::fputc (ch, fp);
00078 #endif /* defined (fputc) */
00079 }
00080 
00081 inline int ace_getc_helper (FILE *fp)
00082 {
00083 #if defined (getc)
00084   return getc (fp);
00085 #undef getc
00086 #else
00087   return ACE_STD_NAMESPACE::getc (fp);
00088 #endif /* defined (getc) */
00089 }
00090 
00091 inline int ace_putc_helper (int ch, FILE *fp)
00092 {
00093 #if defined (putc)
00094   return putc (ch, fp);
00095 #undef putc
00096 #else
00097   return ACE_STD_NAMESPACE::putc (ch, fp);
00098 #endif /* defined (putc) */
00099 }
00100 
00101 inline int ace_ungetc_helper (int ch, FILE *fp)
00102 {
00103 #if defined (ungetc)
00104   return ungetc (ch, fp);
00105 #undef ungetc
00106 #else
00107   return ACE_STD_NAMESPACE::ungetc (ch, fp);
00108 #endif /* defined (ungetc) */
00109 }
00110 
00111 
00112 #if !defined (ACE_LACKS_CUSERID) && !defined(ACE_HAS_ALT_CUSERID) \
00113     && !defined(ACE_WIN32) && !defined (ACE_VXWORKS)
00114 /// Helper for the ACE_OS::cuserid() function
00115 /**
00116  * On some platforms cuserid is a macro.  Defining ACE_OS::cuserid()
00117  * becomes really hard, as there is no way to save the macro
00118  * definition using the pre-processor.
00119  * This inline function achieves the same effect, without namespace
00120  * pollution or performance penalties.
00121  *
00122  * @todo We maybe should move a lot of the code in ACE_OS::cuserid here so
00123  *       it is treated the same as the above ace_difftime and ace_timezone.
00124  *       But since there is a good deal more code in ACE_OS::cuserid, we
00125  *       probably need to move some of it off into some sort of emulation
00126  *       function.
00127  */
00128 inline char *ace_cuserid(char *user)
00129 {
00130   return cuserid(user);
00131 }
00132 #endif /* !ACE_LACKS_CUSERID && !ACE_HAS_ALT_CUSERID && ... */
00133 
00134 # if defined (ACE_LACKS_FILELOCKS)
00135 #   if ! defined (ACE_VXWORKS) && ! defined (ACE_HAS_RTEMS) && !defined (INTEGRITY)
00136 // VxWorks defines struct flock in sys/fcntlcom.h.  But it doesn't
00137 // appear to support flock ().  RTEMS defines struct flock but
00138 // currently does not support locking.
00139 struct flock
00140 {
00141   short l_type;
00142   short l_whence;
00143   ACE_OFF_T l_start;
00144   ACE_OFF_T l_len;          /* len == 0 means until end of file */
00145   long  l_sysid;
00146   pid_t l_pid;
00147   long  l_pad[4];               /* reserve area */
00148 };
00149 #   endif /* ! VXWORKS */
00150 # endif /* ACE_LACKS_FILELOCKS */
00151 
00152 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00153 
00154 namespace ACE_OS {
00155 
00156   /**
00157    * @class ace_flock_t
00158    *
00159    * @brief OS file locking structure.
00160    */
00161   class ACE_Export ace_flock_t
00162   {
00163   public:
00164   /// Dump state of the object.
00165     void dump (void) const;
00166 
00167 # if defined (ACE_WIN32)
00168     ACE_OVERLAPPED overlapped_;
00169 # else
00170     struct flock lock_;
00171 # endif /* ACE_WIN32 */
00172 
00173     /// Name of this filelock.
00174     const ACE_TCHAR *lockname_;
00175 
00176     /// Handle to the underlying file.
00177     ACE_HANDLE handle_;
00178   };
00179 
00180 # if defined (ACE_USES_WCHAR)
00181   // If fp points to the Unicode format file, the file pointer will be moved right next
00182   // to the Unicode header (2 types).  Otherwise, file pointer will be at the beginning.
00183   extern ACE_Export
00184   void checkUnicodeFormat (FILE* fp);
00185 # endif  // ACE_USES_WCHAR
00186 
00187 # if !defined (ACE_LACKS_CLEARERR)
00188   ACE_NAMESPACE_INLINE_FUNCTION
00189   void clearerr (FILE* fp);
00190 # endif /* !ACE_LACKS_CLEARERR */
00191 
00192   //@{ @name Wrappers to obtain the current user id
00193   // Legacy as per SUSV3
00194 # if !defined (ACE_LACKS_CUSERID)
00195 #   if defined(cuserid)
00196 #     undef cuserid
00197 #   endif /* cuserid */
00198 
00199   ACE_NAMESPACE_INLINE_FUNCTION
00200   char *cuserid (char *user,
00201                  size_t maxlen = ACE_MAX_USERID);
00202 
00203 #   if defined (ACE_HAS_WCHAR)
00204   ACE_NAMESPACE_INLINE_FUNCTION
00205   wchar_t *cuserid (wchar_t *user,
00206                     size_t maxlen = ACE_MAX_USERID);
00207 #   endif /* ACE_HAS_WCHAR */
00208 # endif /* ACE_LACKS_CUSERID */
00209   //@}
00210 
00211   extern ACE_Export
00212   int asprintf (char **bufp, const char* format, ...);
00213 
00214 # if defined (ACE_HAS_WCHAR)
00215   extern ACE_Export
00216   int asprintf (wchar_t **bufp, const wchar_t* format, ...);
00217 #endif /* ACE_HAS_WCHAR */
00218 
00219   ACE_NAMESPACE_INLINE_FUNCTION
00220   int fclose (FILE *fp);
00221 
00222 # if defined (fdopen)
00223 #   undef fdopen
00224 # endif /* fdopen */
00225 
00226   ACE_NAMESPACE_INLINE_FUNCTION
00227   FILE *fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode);
00228 
00229   ACE_NAMESPACE_INLINE_FUNCTION
00230   int fflush (FILE *fp);
00231 
00232   ACE_NAMESPACE_INLINE_FUNCTION
00233   int fgetc (FILE* fp);
00234 
00235   ACE_NAMESPACE_INLINE_FUNCTION
00236   int getc (FILE* fp);
00237 
00238   ACE_NAMESPACE_INLINE_FUNCTION
00239   int fgetpos (FILE* fp, fpos_t* pos);
00240 
00241   ACE_NAMESPACE_INLINE_FUNCTION
00242   char *fgets (char *buf, int size, FILE *fp);
00243 
00244 # if defined (ACE_HAS_WCHAR) && !defined(ACE_LACKS_FGETWS)
00245   ACE_NAMESPACE_INLINE_FUNCTION
00246   wchar_t *fgets (wchar_t *buf, int size, FILE *fp);
00247 # endif /* ACE_HAS_WCHAR && !ACE_LACKS_FGETWS */
00248 
00249   //@{ @name A set of wrappers for file locks.
00250 
00251 # if defined (ACE_WIN32)
00252   ACE_NAMESPACE_INLINE_FUNCTION
00253   void flock_adjust_params (ace_flock_t *lock,
00254                             short whence,
00255                             ACE_OFF_T &start,
00256                             ACE_OFF_T &len);
00257 # endif /* ACE_WIN32 */
00258 
00259   ACE_NAMESPACE_INLINE_FUNCTION
00260   int flock_init (ace_flock_t *lock,
00261                   int flags = 0,
00262                   const ACE_TCHAR *name = 0,
00263                   mode_t perms = 0);
00264 
00265   ACE_NAMESPACE_INLINE_FUNCTION
00266   int flock_destroy (ace_flock_t *lock,
00267                      int unlink_file = 1);
00268 
00269   ACE_NAMESPACE_INLINE_FUNCTION
00270   int flock_rdlock (ace_flock_t *lock,
00271                     short whence = 0,
00272                     ACE_OFF_T start = 0,
00273                     ACE_OFF_T len = 0);
00274 
00275   ACE_NAMESPACE_INLINE_FUNCTION
00276   int flock_tryrdlock (ace_flock_t *lock,
00277                        short whence = 0,
00278                        ACE_OFF_T start = 0,
00279                        ACE_OFF_T len = 0);
00280 
00281   ACE_NAMESPACE_INLINE_FUNCTION
00282   int flock_trywrlock (ace_flock_t *lock,
00283                        short whence = 0,
00284                        ACE_OFF_T start = 0,
00285                        ACE_OFF_T len = 0);
00286 
00287   ACE_NAMESPACE_INLINE_FUNCTION
00288   int flock_unlock (ace_flock_t *lock,
00289                     short whence = 0,
00290                     ACE_OFF_T start = 0,
00291                     ACE_OFF_T len = 0);
00292 
00293   ACE_NAMESPACE_INLINE_FUNCTION
00294   int flock_wrlock (ace_flock_t *lock,
00295                     short whence = 0,
00296                     ACE_OFF_T start = 0,
00297                     ACE_OFF_T len = 0);
00298 
00299   //@}
00300 
00301 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
00302   extern ACE_Export
00303 #else
00304   ACE_NAMESPACE_INLINE_FUNCTION
00305 #endif /* ACE_WIN32 */
00306   FILE *fopen (const char *filename, const ACE_TCHAR *mode);
00307 
00308 #if defined (ACE_HAS_WCHAR)
00309 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
00310   extern ACE_Export
00311 #else
00312   ACE_NAMESPACE_INLINE_FUNCTION
00313 #endif /* ACE_WIN32 */
00314   FILE *fopen (const wchar_t *filename, const ACE_TCHAR *mode);
00315 #endif /* ACE_HAS_WCHAR */
00316 
00317 #if defined (ACE_WIN32)
00318   /// Default Win32 Security Attributes definition.
00319   ACE_NAMESPACE_INLINE_FUNCTION
00320   LPSECURITY_ATTRIBUTES default_win32_security_attributes (LPSECURITY_ATTRIBUTES);
00321   ACE_NAMESPACE_INLINE_FUNCTION
00322   LPSECURITY_ATTRIBUTES default_win32_security_attributes_r (LPSECURITY_ATTRIBUTES,
00323                                              LPSECURITY_ATTRIBUTES,
00324                                              SECURITY_DESCRIPTOR*);
00325 
00326   // = Win32 OS version determination function.
00327   /// Return the win32 OSVERSIONINFO structure.
00328   ACE_NAMESPACE_INLINE_FUNCTION
00329   const ACE_TEXT_OSVERSIONINFO &get_win32_versioninfo (void);
00330 
00331   // = A pair of functions for modifying ACE's Win32 resource usage.
00332   /// Return the handle of the module containing ACE's resources. By
00333   /// default, for a DLL build of ACE this is a handle to the ACE DLL
00334   /// itself, and for a static build it is a handle to the executable.
00335   ACE_NAMESPACE_INLINE_FUNCTION
00336   HINSTANCE get_win32_resource_module (void);
00337 
00338   /// Allow an application to modify which module contains ACE's
00339   /// resources. This is mainly useful for a static build of ACE where
00340   /// the required resources reside somewhere other than the executable.
00341   ACE_NAMESPACE_INLINE_FUNCTION
00342   void set_win32_resource_module (HINSTANCE);
00343 
00344   extern ACE_Export ACE_TEXT_OSVERSIONINFO win32_versioninfo_;
00345 
00346   extern ACE_Export HINSTANCE win32_resource_module_;
00347 
00348 #endif /* ACE_WIN32 */
00349 
00350   extern ACE_Export
00351   int fprintf (FILE *fp, const char *format, ...);
00352 
00353 # if defined (ACE_HAS_WCHAR)
00354   extern ACE_Export
00355   int fprintf (FILE *fp, const wchar_t *format, ...);
00356 # endif /* ACE_HAS_WCHAR */
00357 
00358   ACE_NAMESPACE_INLINE_FUNCTION
00359   int ungetc (int c,
00360               FILE *fp);
00361 
00362   ACE_NAMESPACE_INLINE_FUNCTION
00363   int fputc (int c,
00364              FILE *fp);
00365 
00366   ACE_NAMESPACE_INLINE_FUNCTION
00367   int putc (int c,
00368             FILE *fp);
00369 
00370   ACE_NAMESPACE_INLINE_FUNCTION
00371   int fputs (const char *s,
00372              FILE *stream);
00373 
00374 # if defined (ACE_HAS_WCHAR) && !defined(ACE_LACKS_FPUTWS)
00375   ACE_NAMESPACE_INLINE_FUNCTION
00376   int fputs (const wchar_t *s,
00377              FILE *stream);
00378 # endif /* ACE_HAS_WCHAR && !ACE_LACKS_FPUTWS */
00379 
00380   ACE_NAMESPACE_INLINE_FUNCTION
00381   size_t fread (void *ptr,
00382                 size_t size,
00383                 size_t nelems,
00384                 FILE *fp);
00385 
00386   ACE_NAMESPACE_INLINE_FUNCTION
00387   FILE *freopen (const ACE_TCHAR *filename,
00388                  const ACE_TCHAR *mode,
00389                  FILE* stream);
00390 
00391   ACE_NAMESPACE_INLINE_FUNCTION
00392   int fseek (FILE *fp,
00393              long offset,
00394              int ptrname);
00395 
00396   ACE_NAMESPACE_INLINE_FUNCTION
00397   int  fsetpos (FILE* fp, fpos_t* pos);
00398 
00399   ACE_NAMESPACE_INLINE_FUNCTION
00400   long ftell (FILE* fp);
00401 
00402   ACE_NAMESPACE_INLINE_FUNCTION
00403   size_t fwrite (const void *ptr,
00404                  size_t size,
00405                  size_t nitems,
00406                  FILE *fp);
00407 
00408   ACE_NAMESPACE_INLINE_FUNCTION
00409   void perror (const char *s);
00410 
00411 #if defined (ACE_HAS_WCHAR)
00412   ACE_NAMESPACE_INLINE_FUNCTION
00413   void perror (const wchar_t *s);
00414 #endif /* ACE_HAS_WCHAR */
00415 
00416   extern ACE_Export
00417   int printf (const char *format, ...);
00418 
00419 #if defined (ACE_HAS_WCHAR)
00420   extern ACE_Export
00421   int printf (const wchar_t *format, ...);
00422 #endif
00423 
00424   ACE_NAMESPACE_INLINE_FUNCTION
00425   int puts (const char *s);
00426 
00427 #if defined (ACE_HAS_WCHAR)
00428   ACE_NAMESPACE_INLINE_FUNCTION
00429   int puts (const wchar_t *s);
00430 #endif /* ACE_HAS_WCHAR */
00431 
00432   ACE_NAMESPACE_INLINE_FUNCTION
00433   int rename (const char *old_name,
00434               const char *new_name,
00435               int flags = -1);
00436 
00437 #if defined (ACE_HAS_WCHAR)
00438   ACE_NAMESPACE_INLINE_FUNCTION
00439   int rename (const wchar_t *old_name,
00440               const wchar_t *new_name,
00441               int flags = -1);
00442 #endif /* ACE_HAS_WCHAR */
00443 
00444   ACE_NAMESPACE_INLINE_FUNCTION
00445   void rewind (FILE *fp);
00446 
00447   extern ACE_Export
00448   int snprintf (char *buf, size_t maxlen, const char *format, ...);
00449 
00450 # if defined (ACE_HAS_WCHAR)
00451   extern ACE_Export
00452   int snprintf (wchar_t *buf, size_t maxlen, const wchar_t *format, ...);
00453 # endif /* ACE_HAS_WCHAR */
00454 
00455   extern ACE_Export
00456   int sprintf (char *buf, const char *format, ...);
00457 
00458 # if defined (ACE_HAS_WCHAR)
00459   extern ACE_Export
00460   int sprintf (wchar_t *buf, const wchar_t *format, ...);
00461 # endif /* ACE_HAS_WCHAR */
00462 
00463   ACE_NAMESPACE_INLINE_FUNCTION
00464   char *tempnam (const char *dir = 0,
00465                  const char *pfx = 0);
00466 
00467 #if defined (ACE_HAS_WCHAR)
00468   ACE_NAMESPACE_INLINE_FUNCTION
00469   wchar_t *tempnam (const wchar_t *dir,
00470                     const wchar_t *pfx = 0);
00471 #endif /* ACE_HAS_WCHAR */
00472 
00473   ACE_NAMESPACE_INLINE_FUNCTION
00474   int vasprintf (char **bufp, const char *format, va_list argptr);
00475 
00476   ACE_NAMESPACE_INLINE_FUNCTION
00477   int vprintf (const char *format, va_list argptr);
00478 
00479   ACE_NAMESPACE_INLINE_FUNCTION
00480   int vfprintf (FILE *fp, const char *format, va_list argptr);
00481 
00482   ACE_NAMESPACE_INLINE_FUNCTION
00483   int vsprintf (char *buffer, const char *format, va_list argptr);
00484 
00485   ACE_NAMESPACE_INLINE_FUNCTION
00486   int vsnprintf (char *buffer, size_t maxlen, const char *format, va_list argptr);
00487 
00488 # if defined (ACE_HAS_WCHAR)
00489   ACE_NAMESPACE_INLINE_FUNCTION
00490   int vasprintf (wchar_t **bufp, const wchar_t *format, va_list argptr);
00491 
00492   ACE_NAMESPACE_INLINE_FUNCTION
00493   int vprintf (const wchar_t *format, va_list argptr);
00494 
00495   ACE_NAMESPACE_INLINE_FUNCTION
00496   int vfprintf (FILE *fp, const wchar_t *format, va_list argptr);
00497 
00498   ACE_NAMESPACE_INLINE_FUNCTION
00499   int vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr);
00500 
00501   ACE_NAMESPACE_INLINE_FUNCTION
00502   int vsnprintf (wchar_t *buffer, size_t maxlen, const wchar_t *format, va_list argptr);
00503 # endif /* ACE_HAS_WCHAR */
00504 
00505 #if !defined (ACE_HAS_VASPRINTF)
00506   extern ACE_Export
00507   int vasprintf_emulation (char **bufp, const char *format, va_list argptr); 
00508 #endif /* !ACE_HAS_VASPRINTF */
00509 
00510 #if defined (ACE_HAS_WCHAR)
00511 #if !defined (ACE_HAS_VASWPRINTF)
00512   extern ACE_Export
00513   int vaswprintf_emulation (wchar_t **bufp, const wchar_t *format, va_list argptr);
00514 #endif /* !ACE_HAS_VASWPRINTF */
00515 #endif /* ACE_HAS_WCHAR */
00516 
00517 } /* namespace ACE_OS */
00518 
00519 ACE_END_VERSIONED_NAMESPACE_DECL
00520 
00521 # if defined (ACE_HAS_INLINED_OSCALLS)
00522 #   if defined (ACE_INLINE)
00523 #     undef ACE_INLINE
00524 #   endif /* ACE_INLINE */
00525 #   define ACE_INLINE inline
00526 #   include "ace/OS_NS_stdio.inl"
00527 # endif /* ACE_HAS_INLINED_OSCALLS */
00528 
00529 # include /**/ "ace/post.h"
00530 #endif /* ACE_OS_NS_STDIO_H */