OS_main.h

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file   OS_main.h
00006  *
00007  *  $Id: OS_main.h 79306 2007-08-10 08:58:08Z johnnyw $
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 #include /**/ "ace/ACE_export.h"
00018 
00019 #ifndef ACE_OS_MAIN_H
00020 # define ACE_OS_MAIN_H
00021 
00022 # include /**/ "ace/pre.h"
00023 
00024 # if !defined (ACE_LACKS_PRAGMA_ONCE)
00025 #  pragma once
00026 # endif /* ACE_LACKS_PRAGMA_ONCE */
00027 
00028 # if defined (ACE_HAS_RTEMS)
00029 extern char* rtems_progname;
00030 # endif /* ACE_HAS_RTEMS */
00031 
00032 # if !defined (ACE_MAIN)
00033 #   define ACE_MAIN main
00034 # endif /* ! ACE_MAIN */
00035 
00036 # if !defined (ACE_WMAIN)
00037 #   define ACE_WMAIN wmain
00038 # endif /* ! ACE_WMAIN */
00039 
00040 # if defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
00041 #   define ACE_TMAIN wmain
00042 # else
00043 #   if defined (ACE_USES_WCHAR)    /* Not Win32, but uses wchar */
00044       // Replace main() with a version that converts the char** argv to
00045       // ACE_TCHAR and calls the ACE_TMAIN entrypoint.
00046 #     include "ace/Argv_Type_Converter.h"
00047 #     define ACE_TMAIN \
00048         ace_main_i (int, ACE_TCHAR *[]); /* forward declaration */ \
00049         int main (int argc, char *argv[]) { \
00050           ACE_Argv_Type_Converter wide_argv (argc, argv); \
00051           return ace_main_i (argc, wide_argv.get_TCHAR_argv ()); \
00052         } \
00053         int ace_main_i
00054 #   else
00055 #     define ACE_TMAIN main
00056 #   endif /* ACE_USES_WCHAR */
00057 # endif
00058 
00059 # if defined (ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER)
00060 #   if !defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER)
00061 #     define ACE_HAS_NONSTATIC_OBJECT_MANAGER
00062 #   endif /* ACE_HAS_NONSTATIC_OBJECT_MANAGER */
00063 # endif /* ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER */
00064 
00065 # if defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER) \
00066        && !defined (ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER)
00067 
00068 // Rename "main ()" on platforms that don't allow it to be called "main ()".
00069 
00070 #   if defined (ACE_VXWORKS) && !defined (__RTP__)
00071 
00072 typedef int (*ace_main_proc_ptr)(int, char *[]);
00073 
00074 extern ace_main_proc_ptr vx_ace_main_i_ptr;
00075 
00076 #     define main \
00077 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
00078 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
00079 int ace_os_main_i (int, char *[]); \
00080 ACE_END_VERSIONED_NAMESPACE_DECL \
00081 int ace_main_i(int, char *[]); \
00082 int \
00083 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
00084 { \
00085   vx_ace_main_i_ptr = ace_main_i; \
00086   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
00087 } \
00088 int \
00089 ace_main_i
00090 
00091 #   elif defined (ACE_HAS_RTEMS)
00092 
00093 #     define main \
00094 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
00095 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
00096 int ace_os_main_i (int, char *[]); \
00097 ACE_END_VERSIONED_NAMESPACE_DECL \
00098 int \
00099 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
00100 { \
00101   if ((argc > 0) && argv && argv[0]) \
00102     rtems_progname = argv[0]; \
00103   else \
00104     rtems_progname = "RTEMS"; \
00105   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
00106 } \
00107 int \
00108 ace_main_i
00109 
00110 #   elif !defined (ACE_WIN32)
00111 
00112 #     define main \
00113 ACE_MAIN (int, char *[]); /* forward decl to gobble up the 'int' if there is one */ \
00114 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
00115 int ace_os_main_i (int, char *[]); \
00116 ACE_END_VERSIONED_NAMESPACE_DECL \
00117 int \
00118 ACE_MAIN (int argc, char *argv[])    /* user's entry point, e.g., main */ \
00119 { \
00120   return ace_os_main_i (argc, argv); /* what the user calls "main" */ \
00121 } \
00122 int \
00123 ace_main_i
00124 
00125 #   elif !defined (ACE_HAS_WINCE)
00126 
00127 #     if defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
00128 
00129 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00130 
00131 class ACE_Export ACE_Main_Base
00132 {
00133 public:
00134   int run (int, ACE_TCHAR *[]);
00135   virtual int run_i (int, ACE_TCHAR *[]) = 0;
00136 };
00137 
00138 ACE_END_VERSIONED_NAMESPACE_DECL
00139 
00140 #       define wmain \
00141 ace_wmain_i (int, ACE_TCHAR *[]); \
00142 ACE_Export int ace_os_wmain_i (ACE_Main_Base&, int, ACE_TCHAR *[]); \
00143 class ACE_Main : public ACE_Main_Base {int run_i (int, ACE_TCHAR *[]);}; \
00144 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
00145 { \
00146   return ace_wmain_i (argc, argv); \
00147 } \
00148 int \
00149 ACE_WMAIN (int argc, ACE_TCHAR *argv[]) /* user's entry point, e.g., wmain */ \
00150 { \
00151   ACE_Main m; \
00152   return ace_os_wmain_i (m, argc, argv);   /* what the user calls "main" */ \
00153 } \
00154 int \
00155 ace_wmain_i
00156 
00157 #     else /* ! (ACE_WIN32 && ACE_USES_WCHAR) */
00158 
00159 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00160 
00161 class ACE_Export ACE_Main_Base
00162 {
00163 public:
00164   ACE_Main_Base ();
00165   virtual ~ACE_Main_Base ();
00166   int run (int, char *[]);
00167   virtual int run_i (int, char *[]) = 0;
00168 };
00169 
00170 ACE_END_VERSIONED_NAMESPACE_DECL
00171 
00172 /*
00173 ** LabVIEW RT cannot directly use an executable. Need to build the program
00174 ** as a DLL and call it from something else. The ACE test framework knows this
00175 ** trick and uses a LabVIEW RT target-resident control program to load a
00176 ** DLL, look up it's main() entrypoint, and call it.
00177 */
00178 #       if defined (ACE_BUILD_LABVIEW_EXE_AS_DLL)
00179 extern "C" __declspec (dllexport) int main (int, char *[]);
00180 #       endif /* ACE_BUILD_LABVIEW_EXE_AS_DLL) */
00181 
00182 #       define main \
00183 ace_main_i (int, char *[]); \
00184 ACE_BEGIN_VERSIONED_NAMESPACE_DECL \
00185 ACE_Export int ace_os_main_i (ACE_Main_Base&, int, char *[]); \
00186 class ACE_Main : public ACE_Main_Base {int run_i (int, char *[]);}; \
00187 inline int ACE_Main::run_i (int argc, char *argv[])  \
00188 { \
00189   return ace_main_i (argc, argv); \
00190 } \
00191 ACE_END_VERSIONED_NAMESPACE_DECL \
00192 int \
00193 ACE_MAIN (int argc, char *argv[]) /* user's entry point, e.g., wmain */ \
00194 { \
00195   ACE_Main m; \
00196   return m.run (argc, argv); /*ace_os_main_i (m, argc, argv);   what the user calls "main" */ \
00197 } \
00198 int \
00199 ace_main_i
00200 
00201 #     endif /* ACE_WIN32 && ACE_USES_WCHAR */
00202 
00203 #   else /* ACE_HAS_WINCE */
00204 
00205 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00206 
00207 class ACE_Export ACE_Main_Base
00208 {
00209 public:
00210   int run (HINSTANCE, HINSTANCE, LPWSTR, int);
00211   virtual int run_i (int, ACE_TCHAR *[]) = 0;
00212 };
00213 
00214 ACE_END_VERSIONED_NAMESPACE_DECL
00215 
00216 #     if defined (ACE_TMAIN)  // Use WinMain on CE; others give warning/error.
00217 #       undef ACE_TMAIN
00218 #     endif  // ACE_TMAIN
00219 
00220 // Support for ACE_TMAIN, which is a recommended way. It would be nice if
00221 // CE had CommandLineToArgvW()... but it's only on NT3.5 and up.
00222 
00223 #     define ACE_TMAIN \
00224 ace_tmain_i (int, ACE_TCHAR *[]); \
00225 class ACE_Main : public ACE_Main_Base {int run_i (int argc, ACE_TCHAR *argv[]);}; \
00226 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
00227 { \
00228   return ace_tmain_i (argc, argv); \
00229 } \
00230 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) \
00231 { \
00232   ACE_Main m; \
00233   return m.run (hInstance, hPrevInstance, lpCmdLine, nCmdShow); \
00234 } \
00235 int ace_tmain_i
00236 
00237 // Support for wchar_t but still can't fit to CE because of the command
00238 // line parameters.
00239 #     define wmain \
00240 ace_wmain_i (int, ACE_TCHAR *[]); \
00241 ACE_Export int ace_os_winwmain_i (ACE_Main_Base&, hInstance, hPrevInstance, lpCmdLine, nCmdShow);  /* forward declaration */ \
00242 class ACE_Main : public ACE_Main_Base {int run_i (int argc, ACE_TCHAR *argv[]);}; \
00243 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
00244 { \
00245   return ace_wmain_i (argc, argv); \
00246 } \
00247 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) \
00248 { \
00249   return ace_os_winwmain_i (hInstance, hPrevInstance, lpCmdLine, nCmdShow); \
00250 } \
00251 int ace_wmain_i
00252 
00253 // Supporting legacy 'main' is A LOT easier for users than changing existing
00254 // code on WinCE. Unfortunately, evc 3 can't grok a #include within the macro
00255 // expansion, so it needs to go out here.
00256 #     include "ace/Argv_Type_Converter.h"
00257 #     define main \
00258 ace_main_i (int, ACE_TCHAR *[]); \
00259 ACE_Export int ace_os_winmain_i (ACE_Main_Base&, hInstance, hPrevInstance, lpCmdLine, nCmdShow);  /* forward declaration */ \
00260 class ACE_Main : public ACE_Main_Base {int run_i (int argc, ACE_TCHAR *argv[]);}; \
00261 inline int ACE_Main::run_i (int argc, ACE_TCHAR *argv[])  \
00262 { \
00263   return ace_main_i (argc, argv); \
00264 } \
00265 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) \
00266 { \
00267   return ace_os_winmain_i (hInstance, hPrevInstance, lpCmdLine, nCmdShow); \
00268 } \
00269 int ace_main_i
00270 
00271 #   endif   /* ACE_PSOSIM */
00272 # endif /* ACE_HAS_NONSTATIC_OBJECT_MANAGER && !ACE_HAS_WINCE && !ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER */
00273 
00274 # include /**/ "ace/post.h"
00275 
00276 #endif /* ACE_OS_MAIN_H */

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