dep/ACE_wrappers/ace/OS_main.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file   OS_main.h
   6  *
   7  *  $Id: OS_main.h 81843 2008-06-05 15:47:55Z schmidt $
   8  *
   9  *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
  10  *  @author Jesper S. M|ller<stophph@diku.dk>
  11  *  @author and a cast of thousands...
  12  *
  13  *  Originally in OS.h.
  14  */
  15 //=============================================================================
  16
  17 #include /**/ "ace/ACE_export.h"
  18
  19 #ifndef ACE_OS_MAIN_H
  20 # define ACE_OS_MAIN_H
  21
  22 # include /**/ "ace/pre.h"
  23
  24 # if !defined (ACE_LACKS_PRAGMA_ONCE)
  25 #  pragma once
  26 # endif /* ACE_LACKS_PRAGMA_ONCE */
  27
  28 # if defined (ACE_HAS_RTEMS)
  29 extern char* rtems_progname;
  30 # endif /* ACE_HAS_RTEMS */
  31
  32 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x640) && defined (__RTP__)
  33 #  include <resolvLib.h>
  34 #endif
  35
  36 # if !defined (ACE_MAIN)
  37 #   define ACE_MAIN main
  38 # endif /* ! ACE_MAIN */
  39
  40 # if !defined (ACE_WMAIN)
  41 #   define ACE_WMAIN wmain
  42 # endif /* ! ACE_WMAIN */
  43
  44 # if defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
  45 #   define ACE_TMAIN wmain
  46 # else
  47 #   if defined (ACE_USES_WCHAR)    /* Not Win32, but uses wchar */
  48       // Replace main() with a version that converts the char** argv to
  49       // ACE_TCHAR and calls the ACE_TMAIN entrypoint.
  50 #     include "ace/Argv_Type_Converter.h"
  51 #     define ACE_TMAIN \
  52         ace_main_i (int, ACE_TCHAR *[]); /* forward declaration */ \
  53         int main (int argc, char *argv[]) { \
  54           ACE_Argv_Type_Converter wide_argv (argc, argv); \
  55           return ace_main_i (argc, wide_argv.get_TCHAR_argv ()); \
  56         } \
  57         int ace_main_i
  58 #   else
  59 #     define ACE_TMAIN main
  60 #   endif /* ACE_USES_WCHAR */
  61 # endif
  62
  63 # if defined (ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER)
  64 #   if !defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER)
  65 #     define ACE_HAS_NONSTATIC_OBJECT_MANAGER
  66 #   endif /* ACE_HAS_NONSTATIC_OBJECT_MANAGER */
  67 # endif /* ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER */
  68
  69 # if defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER) \
  70        && !defined (ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER)
  71
  72 // Rename "main ()" on platforms that don't allow it to be called "main ()".
  73
  74 #   if defined (ACE_VXWORKS) && !defined (__RTP__)
  75
  76 typedef int (*ace_main_proc_ptr)(int, char *[]);
  77
  78 extern ace_main_proc_ptr vx_ace_main_i_ptr;
  79
  80 // Declare ACE_MAIN as extern C so that it can be retrieved
  81 // using symFindByName
  82 extern "C"
  83 {
  84   int ACE_MAIN (int, char* []);
  85 }
  86
  87 #     define main \
  88 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
  89 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
  90 int ace_os_main_i (int, char *[]); \
  91 ACE_END_VERSIONED_NAMESPACE_DECL \
  92 int ace_main_i(int, char *[]); \
  93 int \
  94 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
  95 { \
  96   vx_ace_main_i_ptr = ace_main_i; \
  97   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
  98 } \
  99 int \
 100 ace_main_i
 101
 102 #   elif defined (ACE_HAS_RTEMS)
 103
 104 #     define main \
 105 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
 106 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
 107 int ace_os_main_i (int, char *[]); \
 108 ACE_END_VERSIONED_NAMESPACE_DECL \
 109 int \
 110 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
 111 { \
 112   if ((argc > 0) && argv && argv[0]) \
 113     rtems_progname = argv[0]; \
 114   else \
 115     rtems_progname = "RTEMS"; \
 116   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
 117 } \
 118 int \
 119 ace_main_i
 120
 121 #   elif defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x640) && defined (__RTP__)
 122
 123 #     define main \
 124 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
 125 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
 126 int ace_os_main_i (int, char *[]); \
 127 ACE_END_VERSIONED_NAMESPACE_DECL \
 128 int \
 129 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
 130 { \
 131   resolvInit(); \
 132   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
 133 } \
 134 int \
 135 ace_main_i
 136
 137 #   elif !defined (ACE_WIN32)
 138
 139 #     define main \
 140 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
 141 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
 142 int ace_os_main_i (int, char *[]); \
 143 ACE_END_VERSIONED_NAMESPACE_DECL \
 144 int \
 145 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
 146 { \
 147   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
 148 } \
 149 int \
 150 ace_main_i
 151
 152 #   elif !defined (ACE_HAS_WINCE)
 153
 154 #     if defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
 155
 156 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 157
 158 class ACE_Export ACE_Main_Base
 159 {
 160 public:
 161   int run (int, ACE_TCHAR *[]);
 162   virtual int run_i (int, ACE_TCHAR *[]) = 0;
 163 };
 164
 165 ACE_END_VERSIONED_NAMESPACE_DECL
 166
 167 #       define wmain \
 168 ace_wmain_i (int, ACE_TCHAR *[]); \
 169 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
 170 ACE_Export int ace_os_wmain_i (ACE_Main_Base&, int, ACE_TCHAR *[]); \
 171 class ACE_Main : public ACE_Main_Base {int run_i (int, ACE_TCHAR *[]);}; \
 172 ACE_END_VERSIONED_NAMESPACE_DECL \
 173 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
 174 { \
 175   return ace_wmain_i (argc, argv); \
 176 } \
 177 int \
 178 ACE_WMAIN (int argc, ACE_TCHAR *argv[]) /* user's entry point, e.g., wmain */ \
 179 { \
 180   ACE_Main m; \
 181   return ace_os_wmain_i (m, argc, argv);   /* what the user calls "main" */ \
 182 } \
 183 int \
 184 ace_wmain_i
 185
 186 #     else /* ! (ACE_WIN32 && ACE_USES_WCHAR) */
 187
 188 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 189
 190 class ACE_Export ACE_Main_Base
 191 {
 192 public:
 193   ACE_Main_Base ();
 194   virtual ~ACE_Main_Base ();
 195   int run (int, char *[]);
 196   virtual int run_i (int, char *[]) = 0;
 197 };
 198
 199 ACE_END_VERSIONED_NAMESPACE_DECL
 200
 201 /*
 202 ** LabVIEW RT cannot directly use an executable. Need to build the program
 203 ** as a DLL and call it from something else. The ACE test framework knows this
 204 ** trick and uses a LabVIEW RT target-resident control program to load a
 205 ** DLL, look up it's main() entrypoint, and call it.
 206 */
 207 #       if defined (ACE_BUILD_LABVIEW_EXE_AS_DLL)
 208 extern "C" __declspec (dllexport) int main (int, char *[]);
 209 #       endif /* ACE_BUILD_LABVIEW_EXE_AS_DLL) */
 210
 211 #       define main \
 212 ace_main_i (int, char *[]); \
 213 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
 214 ACE_Export int ace_os_main_i (ACE_Main_Base&, int, char *[]); \
 215 class ACE_Main : public ACE_Main_Base {int run_i (int, char *[]);}; \
 216 inline int ACE_Main::run_i (int argc, char *argv[])  \
 217 { \
 218   return ace_main_i (argc, argv); \
 219 } \
 220 ACE_END_VERSIONED_NAMESPACE_DECL \
 221 int \
 222 ACE_MAIN (int argc, char *argv[]) /* user's entry point, e.g., wmain */ \
 223 { \
 224   ACE_Main m; \
 225   return m.run (argc, argv); /*ace_os_main_i (m, argc, argv);   what the user calls "main" */ \
 226 } \
 227 int \
 228 ace_main_i
 229
 230 #     endif /* ACE_WIN32 && ACE_USES_WCHAR */
 231
 232 #   else /* ACE_HAS_WINCE */
 233
 234 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 235
 236 class ACE_Export ACE_Main_Base
 237 {
 238 public:
 239   int run (HINSTANCE, HINSTANCE, LPWSTR, int);
 240   virtual int run_i (int, ACE_TCHAR *[]) = 0;
 241 };
 242
 243 ACE_END_VERSIONED_NAMESPACE_DECL
 244
 245 #     if defined (ACE_TMAIN)  // Use WinMain on CE; others give warning/error.
 246 #       undef ACE_TMAIN
 247 #     endif  // ACE_TMAIN
 248
 249 // Support for ACE_TMAIN, which is a recommended way. It would be nice if
 250 // CE had CommandLineToArgvW()... but it's only on NT3.5 and up.
 251
 252 #     define ACE_TMAIN \
 253 ace_tmain_i (int, ACE_TCHAR *[]); \
 254 class ACE_Main : public ACE_Main_Base {int run_i (int argc, ACE_TCHAR *argv[]);}; \
 255 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
 256 { \
 257   return ace_tmain_i (argc, argv); \
 258 } \
 259 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) \
 260 { \
 261   ACE_Main m; \
 262   return m.run (hInstance, hPrevInstance, lpCmdLine, nCmdShow); \
 263 } \
 264 int ace_tmain_i
 265
 266 // Support for wchar_t but still can't fit to CE because of the command
 267 // line parameters.
 268 #     define wmain \
 269 ace_wmain_i (int, ACE_TCHAR *[]); \
 270 ACE_Export int ace_os_winwmain_i (ACE_Main_Base&, hInstance, hPrevInstance, lpCmdLine, nCmdShow);  /* forward declaration */ \
 271 class ACE_Main : public ACE_Main_Base {int run_i (int argc, ACE_TCHAR *argv[]);}; \
 272 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
 273 { \
 274   return ace_wmain_i (argc, argv); \
 275 } \
 276 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) \
 277 { \
 278   return ace_os_winwmain_i (hInstance, hPrevInstance, lpCmdLine, nCmdShow); \
 279 } \
 280 int ace_wmain_i
 281
 282 // Supporting legacy 'main' is A LOT easier for users than changing existing
 283 // code on WinCE. Unfortunately, evc 3 can't grok a #include within the macro
 284 // expansion, so it needs to go out here.
 285 #     include "ace/Argv_Type_Converter.h"
 286 #     define main \
 287 ace_main_i (int, ACE_TCHAR *[]); \
 288 ACE_Export int ace_os_winmain_i (ACE_Main_Base&, hInstance, hPrevInstance, lpCmdLine, nCmdShow);  /* forward declaration */ \
 289 class ACE_Main : public ACE_Main_Base {int run_i (int argc, ACE_TCHAR *argv[]);}; \
 290 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
 291 { \
 292   return ace_main_i (argc, argv); \
 293 } \
 294 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) \
 295 { \
 296   return ace_os_winmain_i (hInstance, hPrevInstance, lpCmdLine, nCmdShow); \
 297 } \
 298 int ace_main_i
 299
 300 #   endif   /* ACE_PSOSIM */
 301 # endif /* ACE_HAS_NONSTATIC_OBJECT_MANAGER && !ACE_HAS_WINCE && !ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER */
 302
 303 # include /**/ "ace/post.h"
 304
 305 #endif /* ACE_OS_MAIN_H */