flx_rtl.hpp

00001 #line 790 "./lpsrc/flx_rtl.pak"
00002 #ifndef FLX_RTL
00003 #define FLX_RTL
00004 #include "flx_rtl_config.hpp"
00005 #include "flx_meta.hpp"
00006 #ifndef FLX_GC
00007 #include "flx_gc.hpp"
00008 #endif
00009 #include <string>
00010 #include <functional>
00011 
00012 #if defined(FLX_PTF_STATIC_STRUCT)
00013 #define PTF ptf.
00014 #elif defined(FLX_PTF_STATIC_POINTER)
00015 #define PTF ptf->
00016 #else
00017 #define PTF ptf->
00018 #endif
00019 
00020 // for declarations in header file
00021 #if defined(FLX_PTF_STATIC_STRUCT)
00022 #define FLX_FMEM_DECL
00023 #define FLX_FPAR_DECL_ONLY
00024 #define FLX_FPAR_DECL
00025 #define FLX_APAR_DECL_ONLY
00026 #define FLX_APAR_DECL
00027 #define FLX_DCL_THREAD_FRAME extern thread_frame_t ptf;
00028 #elif defined(FLX_PTF_STATIC_POINTER)
00029 #define FLX_FMEM_DECL
00030 #define FLX_FPAR_DECL_ONLY
00031 #define FLX_FPAR_DECL
00032 #define FLX_APAR_DECL_ONLY
00033 #define FLX_APAR_DECL
00034 #define FLX_DCL_THREAD_FRAME extern thread_frame_t *ptf;
00035 #else
00036 #define FLX_FMEM_DECL thread_frame_t *ptf;
00037 #define FLX_FPAR_DECL_ONLY thread_frame_t *_ptf
00038 #define FLX_FPAR_DECL thread_frame_t *_ptf,
00039 #define FLX_APAR_DECL_ONLY thread_frame_t *ptf
00040 #define FLX_APAR_DECL thread_frame_t *ptf,
00041 #define FLX_DCL_THREAD_FRAME
00042 #endif
00043 
00044 namespace flx { namespace rtl {
00045 
00046 // ********************************************************
00047 // Felix system classes
00048 // ********************************************************
00049 
00050 struct RTL_EXTERN con_t;     // continuation
00051 struct RTL_EXTERN thread_t; // f-thread
00052 struct RTL_EXTERN _ref_;     // pointer/reference
00053 struct RTL_EXTERN _uctor_;   // union constructor
00054 struct RTL_EXTERN schannel_t;   // synchronous channel type
00055 struct RTL_EXTERN slist_t;   // singly linked list of void*
00056 struct RTL_EXTERN _root_ptr_t;   // singly linked list of void*
00057 
00058 struct RTL_EXTERN unit {};   // unit
00059   // INLINE DEFINITION, PROBLEMATIC!!
00060 
00061 // ********************************************************
00062 // Shape (RTTI) objects for system classes
00063 // con_t is only an abstract base, so has no fixed shape
00064 // shapes for instance types generated by Felix compiler
00065 // we provide a shape for C 'int' type as well
00066 // ********************************************************
00067 
00068 RTL_EXTERN extern flx::gc::generic::gc_shape_t _fthread_ptr_map;
00069 RTL_EXTERN extern flx::gc::generic::gc_shape_t schannel_ptr_map;
00070 RTL_EXTERN extern flx::gc::generic::gc_shape_t _ref_ptr_map;
00071 RTL_EXTERN extern flx::gc::generic::gc_shape_t _uctor_ptr_map;
00072 RTL_EXTERN extern flx::gc::generic::gc_shape_t _int_ptr_map;
00073 RTL_EXTERN extern flx::gc::generic::gc_shape_t unit_ptr_map;
00074 RTL_EXTERN extern flx::gc::generic::gc_shape_t slist_ptr_map;
00075 RTL_EXTERN extern flx::gc::generic::gc_shape_t _root_ptr_ptr_map;
00076 
00077 // ********************************************************
00078 // Standard C++ Exceptions
00079 // ********************************************************
00080 
00081 struct RTL_EXTERN flx_exception_t;
00082 struct RTL_EXTERN flx_exec_failure_t;
00083 struct RTL_EXTERN flx_range_srcref_t;
00084 struct RTL_EXTERN flx_match_failure_t;
00085 struct RTL_EXTERN flx_assert_failure_t;
00086 struct RTL_EXTERN flx_assert2_failure_t;
00087 struct RTL_EXTERN flx_switch_failure_t;
00088 // ********************************************************
00089 /// CONTINUATION.
00090 // ********************************************************
00091 
00092 struct RTL_EXTERN con_t ///< abstract base for mutable continuations
00093 {
00094 #ifdef FLX_CGOTO
00095   void *pc;                 ///< interior program counter
00096 #else
00097    int pc;
00098 #endif
00099 
00100   _uctor_ *p_svc;           ///< pointer to service request
00101 
00102   con_t();                  ///< initialise pc, p_svc to 0
00103   virtual con_t *resume()=0;///< method to perform a computational step
00104   virtual ~con_t();
00105   con_t * _caller;          ///< callers continuation (return address)
00106 };
00107 
00108 // ********************************************************
00109 /// SLIST. singly linked lists: SHARABLE and COPYABLE
00110 /// SLIST manages pointers to memory managed by the collector
00111 // ********************************************************
00112 
00113 struct RTL_EXTERN slist_t {
00114   gc::generic::collector_t *gc;
00115   struct slist_node_t *head;
00116 
00117   slist_t (gc::generic::collector_t *); ///< create empty list
00118   slist_t (slist_t const &);            ///< shallow copy
00119 
00120   void push(void *data);                ///< push a gc pointer
00121   void *pop();                          ///< pop a gc pointer
00122   bool isempty()const;
00123 };
00124 
00125 // ********************************************************
00126 /// FTHREAD. Felix threads
00127 // ********************************************************
00128 
00129 struct RTL_EXTERN fthread_t // fthread abstraction
00130 {
00131   con_t *cc;                    ///< current continuation
00132 
00133   fthread_t();                  ///< dead thread, suitable for assignment
00134   fthread_t(con_t*);            ///< make thread from a continuation
00135   _uctor_ *run();               ///< run until dead or driver service request
00136   void kill();                  ///< kill by detaching the continuation
00137   _uctor_ *get_svc()const;      ///< get current service request of waiting thread
00138 private: // uncopyable
00139   fthread_t(fthread_t const&);
00140   void operator=(fthread_t const&);
00141 };
00142 
00143 // ********************************************************
00144 /// SCHANNEL. Synchronous channels
00145 // ********************************************************
00146 
00147 struct RTL_EXTERN schannel_t
00148 {
00149   slist_t *waiting_to_read;             ///< fthreads waiting for a writer
00150   slist_t *waiting_to_write;            ///< fthreads waiting for a reader
00151   schannel_t(gc::generic::collector_t*);
00152   void push_reader(fthread_t *);        ///< add a reader
00153   fthread_t *pop_reader();              ///< pop a reader, NULL if none
00154   void push_writer(fthread_t *);        ///< add a writer
00155   fthread_t *pop_writer();              ///< pop a writer, NULL if none
00156 private: // uncopyable
00157   schannel_t(schannel_t const&);
00158   void operator= (schannel_t const&);
00159 };
00160 
00161 // ********************************************************
00162 /// REFERENCE. Felix pointer type
00163 /// note: non-polymorphic, so ctor can be inline
00164 /// This type is used to represent pointers to variables.
00165 /// It has two components: a frame pointer and offset.
00166 /// A whole frame is refered to by setting the offset to 0.
00167 /// A non-collectable pointer is refered to by setting the frame to 0
00168 /// References are first class values: they can copied, assigned,
00169 /// and default constructed. Holding a reference in a location
00170 /// known to the gc ensures the target variable is not collected:
00171 /// Such references cannot dangle.
00172 /// The frame/offset representation was chosen since it fits
00173 /// well with a copying collector: the price is that finding
00174 /// the interior pointer requires adding the offset to the frame
00175 /// pointer. Note that 'frame' points to the CLIENTDATA address
00176 /// of a frame where user data starts: this is not the lowest
00177 /// machine address of the frame's allocated memory or FRAME
00178 /// address, despite the name.
00179 // ********************************************************
00180 
00181 struct RTL_EXTERN _ref_
00182 {
00183   void *frame;      ///< Heap frame pointer
00184   std::ptrdiff_t offset;   ///< Client Data offset
00185 
00186   _ref_() : frame(0),offset(0) {} ///< NULL reference
00187   _ref_(void *f, void *d):
00188     frame(f), offset((unsigned char*)d-(unsigned char*)f) {}
00189       ///< init from interior pointer d of a collectable frame f
00190 
00191   _ref_(void *f, std::ptrdiff_t d):
00192     frame(f), offset(d) {} ///< init from collectable frame f and offset d
00193 
00194   _ref_(_ref_ const& r) : frame(r.frame), offset(r.offset) {}
00195     ///< copy constructor
00196 
00197   void operator = (_ref_ const& r); ///< assignment operator
00198 
00199   void *get_data()const { return (unsigned char*)frame + offset; }
00200     ///< get interior pointer
00201 
00202   void set_data(void *p)
00203     { offset = (unsigned char*)p - (unsigned char*)frame; }
00204     ///< set interior pointer into same frame
00205 
00206   void set(void *f, void *p)
00207   { frame = f; offset = (unsigned char*)p - (unsigned char*)f; } ///< set from frame f and interior pointer
00208 };
00209 
00210 
00211 // ********************************************************
00212 /// VARIANTS. Felix union type
00213 /// note: non-polymorphic, so ctor can be inline
00214 // ********************************************************
00215 
00216 struct RTL_EXTERN _uctor_
00217 {
00218   int variant;  ///< Variant code
00219   void *data;   ///< Heap variant constructor data
00220   _uctor_() : variant(-1), data(0) {}
00221   _uctor_(int i, void *d) : variant(i), data(d) {}
00222   _uctor_(int *a, _uctor_ x) : variant(a[x.variant]), data(x.data) {}
00223 };
00224 
00225 // ********************************************************
00226 /// ROOT POINTER.
00227 /// Use to chain pseudo roots together. Generally scannable
00228 /// but not collectable.
00229 // ********************************************************
00230 
00231 struct RTL_EXTERN _root_ptr_t
00232 {
00233   _root_ptr_t();
00234   _root_ptr_t(void *x);
00235   _root_ptr_t(_root_ptr_t const&);
00236   void operator=(_root_ptr_t const&);
00237   ~_root_ptr_t();
00238 
00239   _root_ptr_t *next;
00240   _root_ptr_t *prev;
00241   void *data;
00242 
00243 private:
00244   void insert_after (_root_ptr_t*);
00245   void erase();
00246 };
00247 
00248 // INLINE! All casts
00249 template<class T>
00250 struct root_ptr_t : _root_ptr_t {
00251   root_ptr_t(){}
00252   root_ptr_t(root_ptr_t<T> const&){}
00253   root_ptr_t<T>& operator=(root_ptr_t<T> const &a){
00254     return reinterpret_cast<root_ptr_t<T>&>(_root_ptr_t::operator=(a));
00255   }
00256  ~root_ptr_t(){}
00257 
00258   root_ptr_t(T const *a) : _root_ptr_t (const_cast<T*>(a)) {}
00259 
00260   T *operator->() { return (T*)data; }
00261   T const *operator->() const { return (T const*)data; }
00262   T &operator*() { return *(T*)data; }
00263   T const &operator*() const { return *(T const*)data; }
00264 };
00265 
00266 template<class T>
00267 bool operator == (root_ptr_t<T> a, root_ptr_t<T> b)
00268 {
00269   return a-> data == b->data;
00270 }
00271 
00272 template<class T>
00273 bool operator != (root_ptr_t<T> a, root_ptr_t<T> b)
00274 {
00275   return a-> data != b->data;
00276 }
00277 
00278 template<class T>
00279 bool operator < (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
00280 {
00281   // we use this because it enforces a total order
00282   return std::less<void const*>()(a-> data, b->data);
00283 }
00284 
00285 template<class T>
00286 bool operator <= (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
00287 {
00288   // we use this because it enforces a total order
00289   return std::less_equal<void const*>()(a-> data, b->data);
00290 }
00291 
00292 template<class T>
00293 bool operator > (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
00294 {
00295   // we use this because it enforces a total order
00296   return std::greater<void const*>()(a-> data, b->data);
00297 }
00298 
00299 template<class T>
00300 bool operator >= (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
00301 {
00302   // we use this because it enforces a total order
00303   return std::greater_equal<void const*>()(a-> data, b->data);
00304 }
00305 
00306 
00307 // ********************************************************
00308 /// EXCEPTION: Felix exception base abstraction.
00309 /// Mainly used to convert catches into subroutine
00310 /// calls which then dispatch on RTTI manually.
00311 // ********************************************************
00312 
00313 struct RTL_EXTERN flx_exception_t {
00314   virtual ~flx_exception_t()=0;
00315 };
00316 
00317 // ********************************************************
00318 /// EXCEPTION: EXEC protocol failure.
00319 /// Thrown when trying to run a dead procedure
00320 // ********************************************************
00321 
00322 struct RTL_EXTERN flx_exec_failure_t : flx_exception_t {
00323   std::string filename;  ///< dll filename
00324   std::string operation; ///< faulty operation
00325   std::string what;      ///< error description
00326   flx_exec_failure_t(std::string f, std::string o, std::string w);
00327   virtual ~flx_exec_failure_t();
00328 };
00329 
00330 // ********************************************************
00331 /// SOURCE REFERENCE: to track places in user source code.
00332 // ********************************************************
00333 
00334 struct RTL_EXTERN flx_range_srcref_t {
00335   char *filename;  ///< source file name
00336   int startline;   ///< first line (1 origin)
00337   int startcol;    ///< first column (1 origin)
00338   int endline;     ///< last line
00339   int endcol;      ///< last column
00340   flx_range_srcref_t(char *f,int sl, int sc, int el, int ec);
00341   flx_range_srcref_t();
00342 };
00343 
00344 // ********************************************************
00345 /// EXCEPTION: MATCH failure.
00346 /// Thrown when no match cases match the argument of a match,
00347 /// regmatch, or reglex
00348 // ********************************************************
00349 
00350 struct RTL_EXTERN flx_match_failure_t : flx_exception_t {
00351   flx_range_srcref_t flx_loc; ///< location in Felix file
00352   char *cxx_srcfile;          ///< C++ file name
00353   int cxx_srcline;            ///< C++ line number
00354   flx_match_failure_t(flx_range_srcref_t ff, char *cf, int cl);
00355   virtual ~flx_match_failure_t();
00356 };
00357 
00358 // ********************************************************
00359 /// EXCEPTION: ASSERT failure.
00360 /// Thrown when user assertion fails
00361 // ********************************************************
00362 
00363 struct RTL_EXTERN flx_assert_failure_t : flx_exception_t {
00364   flx_range_srcref_t flx_loc; ///< location in Felix file
00365   char *cxx_srcfile;          ///< C++ file
00366   int cxx_srcline;            ///< __LINE__ macro
00367   flx_assert_failure_t(flx_range_srcref_t ff, char *cf, int cl);
00368   virtual ~flx_assert_failure_t();
00369 };
00370 
00371 struct RTL_EXTERN flx_assert2_failure_t : flx_exception_t {
00372   flx_range_srcref_t flx_loc; ///< location in Felix file
00373   flx_range_srcref_t flx_loc2; ///< second location in Felix file
00374   char *cxx_srcfile;          ///< C++ file
00375   int cxx_srcline;            ///< __LINE__ macro
00376   flx_assert2_failure_t(flx_range_srcref_t ff, flx_range_srcref_t ff2, char *cf, int cl);
00377   virtual ~flx_assert2_failure_t();
00378 };
00379 
00380 // ********************************************************
00381 /// EXCEPTION: RANGE failure.
00382 /// Thrown when a range check fails
00383 // ********************************************************
00384 
00385 struct RTL_EXTERN flx_range_failure_t : flx_exception_t {
00386   flx_range_srcref_t flx_loc; ///< location in Felix file
00387   char *cxx_srcfile;          ///< C++ file
00388   int cxx_srcline;            ///< __LINE__ macro
00389   flx_range_failure_t(flx_range_srcref_t ff, char *cf, int cl);
00390   virtual ~flx_range_failure_t();
00391 };
00392 
00393 RTL_EXTERN long range_check (long l, long x, long h, flx_range_srcref_t sref, char *cf, int cl);
00394 
00395 
00396 // ********************************************************
00397 /// EXCEPTION: SWITCH failure. this is a system failure!
00398 // ********************************************************
00399 
00400 struct RTL_EXTERN flx_switch_failure_t : flx_exception_t {
00401   virtual ~flx_switch_failure_t();
00402 };
00403 
00404 
00405 // ********************************************************
00406 // SERVICE REQUEST CODE
00407 // THESE VALUES MUST SYNCH WITH THE STANDARD LIBRARY
00408 // ********************************************************
00409 
00410 enum svc_t               // what the dispatch should do
00411 {                        // when the resume callback returns
00412   svc_yield = 0,
00413   svc_get_fthread=1,
00414   svc_read=2,
00415   svc_general=3,         // temporary hack by RF
00416   svc_reserved=4,
00417   svc_spawn_pthread=5,
00418   svc_spawn_detached=6,
00419   svc_sread=7,           // synchronous read
00420   svc_swrite=8,          // synchronous write
00421   svc_kill=9,           // kill fthread
00422   svc_compact=10,        // run compactor
00423   svc_collect=11,        // run collector
00424   svc_collect_and_compact=12,        // run collector and compactor
00425   svc_end
00426 };
00427 
00428 struct readreq_t {
00429   schannel_t *chan;
00430   _ref_ variable;
00431 };
00432 
00433 }} // namespaces
00434 
00435 #define FLX_MATCH_FAILURE(f,sl,sc,el,ec) \
00436   throw flx::rtl::flx_match_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)
00437 
00438 #define FLX_ASSERT_FAILURE(f,sl,sc,el,ec) \
00439   throw flx::rtl::flx_assert_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)
00440 
00441 #define FLX_ASSERT2_FAILURE(f,sl,sc,el,ec,f2,sl2,sc2,el2,ec2) \
00442   throw flx::rtl::flx_assert2_failure_t (\
00443     flx_range_srcref_t(f,sl,sc,el,ec),\
00444     flx_range_srcref_t(f2,sl2,sc2,el2,sc2),\
00445     __FILE__,__LINE__)
00446 
00447 #define FLX_RANGE_FAILURE(f,sl,sc,el,ec) \
00448   throw flx::rtl::flx_range_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)
00449 
00450 // for generated code in body file
00451 #define INIT_PC pc=0;
00452 
00453 #ifdef FLX_CGOTO
00454   #define FLX_START_SWITCH if(pc)goto *pc;
00455   #define FLX_SET_PC(x) pc=&&case_##x;
00456   #define FLX_CASE_LABEL(x) case_##x:;
00457   #define FLX_DECLARE_LABEL(n,i,x) \
00458     extern void f##i##_##n##_##x(void) __asm__("l"#i"_"#n"_"#x);
00459   #define FLX_LABEL(n,i,x) x:\
00460     __asm__(".global l"#i"_"#n"_"#x);\
00461     __asm__("l"#i"_"#n"_"#x":");\
00462     __asm__(""::"g"(&&x));
00463   #define FLX_FARTARGET(n,i,x) (void*)&f##i##_##n##_##x
00464   #define FLX_END_SWITCH
00465 #else
00466   #define FLX_START_SWITCH switch(pc){case 0:;
00467   #define FLX_SET_PC(x) pc=x;
00468   #define FLX_CASE_LABEL(x) case x:;
00469   #define FLX_DECLARE_LABEL(n,i,x)
00470   #define FLX_LABEL(n,i,x) case n: x:;
00471   #define FLX_FARTARGET(n,i,x) n
00472   #define FLX_END_SWITCH default: throw flx_switch_failure_t(); }
00473 #endif
00474 
00475 #define FLX_RETURN \
00476 { \
00477   con_t *tmp = _caller; \
00478   _caller = 0; \
00479   return tmp; \
00480 }
00481 
00482 #define FLX_NEWP(x) new(*PTF gc,x##_ptr_map)x
00483 
00484 #define FLX_FINALISER(x) \
00485 static void x##_finaliser(collector_t *, void *p){\
00486   ((x*)p)->~x();\
00487 }
00488 
00489 #if defined(FLX_USE_REGPARM3) && defined(HAVE_GNU_X86)
00490 #define FLX_REGPARM __attribute__((regparm(3)))
00491 #else
00492 #define FLX_REGPARM
00493 #endif
00494 
00495 #if defined(FLX_PTF_STATIC_STRUCT)
00496 #define FLX_FMEM_INIT_ONLY
00497 #define FLX_FMEM_INIT :
00498 #define FLX_FPAR_PASS_ONLY
00499 #define FLX_FPAR_PASS
00500 #define FLX_APAR_PASS_ONLY
00501 #define FLX_APAR_PASS
00502 #define _PTF _ptf.
00503 #define _PTFV
00504 #define FLX_PASS_PTF 0
00505 #define FLX_EAT_PTF(x)
00506 #define FLX_DEF_THREAD_FRAME thread_frame_t ptf;
00507 #elif defined(FLX_PTF_STATIC_POINTER)
00508 #define FLX_FMEM_INIT_ONLY
00509 #define FLX_FMEM_INIT :
00510 #define FLX_FPAR_PASS_ONLY
00511 #define FLX_FPAR_PASS
00512 #define FLX_APAR_PASS_ONLY
00513 #define FLX_APAR_PASS
00514 #define _PTF _ptf->
00515 #define _PTFV
00516 #define FLX_PASS_PTF 0
00517 #define FLX_EAT
00518 #define FLX_DEF_THREAD_FRAME thread_frame_t *ptf=0;
00519 #else
00520 #define FLX_FMEM_INIT_ONLY : ptf(_ptf)
00521 #define FLX_FMEM_INIT : ptf(_ptf),
00522 #define FLX_FPAR_PASS_ONLY ptf
00523 #define FLX_FPAR_PASS ptf,
00524 #define FLX_APAR_PASS_ONLY _ptf
00525 #define FLX_APAR_PASS _ptf,
00526 #define _PTF _ptf->
00527 #define _PTFV _ptf
00528 #define FLX_PASS_PTF 1
00529 #define FLX_EAT_PTF(x) x
00530 #define FLX_DEF_THREAD_FRAME
00531 #endif
00532 
00533 #if defined(FLX_PTF_STATIC_STRUCT)
00534 #define FLX_FRAME_WRAPPERS(mname) \
00535 extern "C" thread_frame_t *create_thread_frame(\
00536   collector_t *gc\
00537 ) {\
00538   ptf.gc = gc;\
00539   return &ptf;\
00540 }
00541 #elif defined(FLX_PTF_STATIC_POINTER)
00542 #define FLX_FRAME_WRAPPERS(mname) \
00543 extern "C" thread_frame_t *create_thread_frame(\
00544   collector_t *gc\
00545 ) {\
00546   mname::thread_frame_t *p = new(*gc,mname::thread_frame_t_ptr_map) mname::thread_frame_t(gc);\
00547   ptf = p;\
00548   return p;\
00549 }
00550 #else
00551 #define FLX_FRAME_WRAPPERS(mname) \
00552 extern "C" FLX_EXPORT mname::thread_frame_t *create_thread_frame(\
00553   collector_t *gc\
00554 ) {\
00555   mname::thread_frame_t *p = new(*gc,mname::thread_frame_t_ptr_map) mname::thread_frame_t(gc);\
00556   return p;\
00557 }
00558 #endif
00559 
00560 #if defined(FLX_PTF_STATIC_STRUCT)
00561 #define FLX_START_WRAPPER(mname,x)\
00562 extern "C" con_t *flx_start(\
00563   mname::thread_frame_t *ptf,\
00564   int argc,\
00565   char **argv,\
00566   FILE *stdin_,\
00567   FILE *stdout_,\
00568   FILE *stderr_\
00569 ) {\
00570   ptf->argc = argc;\
00571   ptf->argv = argv;\
00572   ptf->flx_stdin = stdin_;\
00573   ptf->flx_stdout = stdout_;\
00574   ptf->flx_stderr = stderr_;\
00575   return (new(*ptf->gc,mname::x##_ptr_map) \
00576     mname::x()) ->call(0);\
00577 }
00578 #elif defined(FLX_PTF_STATIC_POINTER)
00579 #define FLX_START_WRAPPER(mname,x)\
00580 extern "C" con_t *flx_start(\
00581   mname::thread_frame_t *ptf,\
00582   int argc,\
00583   char **argv,\
00584   FILE *stdin_,\
00585   FILE *stdout_,\
00586   FILE *stderr_\
00587 ) {\
00588   ptf->argc = argc;\
00589   ptf->argv = argv;\
00590   ptf->flx_stdin = stdin_;\
00591   ptf->flx_stdout = stdout_;\
00592   ptf->flx_stderr = stderr_;\
00593   return (new(*ptf->gc,mname::x##_ptr_map) \
00594     mname::x()) ->call(0);\
00595 }
00596 #else
00597 #define FLX_START_WRAPPER(mname,x)\
00598 extern "C" FLX_EXPORT con_t *flx_start(\
00599   mname::thread_frame_t *ptf,\
00600   int argc,\
00601   char **argv,\
00602   FILE *stdin_,\
00603   FILE *stdout_,\
00604   FILE *stderr_\
00605 ) {\
00606   ptf->argc = argc;\
00607   ptf->argv = argv;\
00608   ptf->flx_stdin = stdin_;\
00609   ptf->flx_stdout = stdout_;\
00610   ptf->flx_stderr = stderr_;\
00611   return (new(*ptf->gc,mname::x##_ptr_map) \
00612     mname::x(ptf)) ->call(0);\
00613 }
00614 #endif
00615 
00616 #if defined(FLX_PTF_STATIC_STRUCT)
00617 #define FLX_STACK_START_WRAPPER(mname,x)\
00618 extern "C" con_t *flx_start(\
00619   mname::thread_frame_t *ptf,\
00620   int argc,\
00621   char **argv,\
00622   FILE *stdin_,\
00623   FILE *stdout_,\
00624   FILE *stderr_\
00625 ) {\
00626   ptf->argc = argc;\
00627   ptf->argv = argv;\
00628   ptf->flx_stdin = stdin_;\
00629   ptf->flx_stdout = stdout_;\
00630   ptf->flx_stderr = stderr_;\
00631   mname::x().stack_call();\
00632   return 0;\
00633 }
00634 #elif defined(FLX_PTF_STATIC_POINTER)
00635 #define FLX_STACK_START_WRAPPER(mname,x)\
00636 extern "C" con_t *flx_start(\
00637   mname::thread_frame_t *ptf,\
00638   int argc,\
00639   char **argv,\
00640   FILE *stdin_,\
00641   FILE *stdout_,\
00642   FILE *stderr_\
00643 ) {\
00644   ptf->argc = argc;\
00645   ptf->argv = argv;\
00646   ptf->flx_stdin = stdin_;\
00647   ptf->flx_stdout = stdout_;\
00648   ptf->flx_stderr = stderr_;\
00649   mname::x().stack_call();\
00650   return 0;\
00651 }
00652 #else
00653 #define FLX_STACK_START_WRAPPER(mname,x)\
00654 extern "C" FLX_EXPORT con_t *flx_start(\
00655   mname::thread_frame_t *ptf,\
00656   int argc,\
00657   char **argv,\
00658   FILE *stdin_,\
00659   FILE *stdout_,\
00660   FILE *stderr_\
00661 ) {\
00662   ptf->argc = argc;\
00663   ptf->argv = argv;\
00664   ptf->flx_stdin = stdin_;\
00665   ptf->flx_stdout = stdout_;\
00666   ptf->flx_stderr = stderr_;\
00667   mname::x(ptf).stack_call();\
00668   return 0;\
00669 }
00670 #endif
00671 
00672 #if defined(FLX_PTF_STATIC_STRUCT)
00673 #define FLX_C_START_WRAPPER(mname,x)\
00674 extern "C" con_t *flx_start(\
00675   mname::thread_frame_t *ptf,\
00676   int argc,\
00677   char **argv,\
00678   FILE *stdin_,\
00679   FILE *stdout_,\
00680   FILE *stderr_\
00681 ) {\
00682   ptf->argc = argc;\
00683   ptf->argv = argv;\
00684   ptf->flx_stdin = stdin_;\
00685   ptf->flx_stdout = stdout_;\
00686   ptf->flx_stderr = stderr_;\
00687   mname::x();\
00688   return 0;\
00689 }
00690 #elif defined(FLX_PTF_STATIC_POINTER)
00691 #define FLX_C_START_WRAPPER(mname,x)\
00692 extern "C" con_t *flx_start(\
00693   mname::thread_frame_t *ptf,\
00694   int argc,\
00695   char **argv,\
00696   FILE *stdin_,\
00697   FILE *stdout_,\
00698   FILE *stderr_\
00699 ) {\
00700   ptf->argc = argc;\
00701   ptf->argv = argv;\
00702   ptf->flx_stdin = stdin_;\
00703   ptf->flx_stdout = stdout_;\
00704   ptf->flx_stderr = stderr_;\
00705   mname::x();\
00706   return 0;\
00707 }
00708 #else
00709 #define FLX_C_START_WRAPPER(mname,x)\
00710 extern "C" FLX_EXPORT con_t *flx_start(\
00711   mname::thread_frame_t *ptf,\
00712   int argc,\
00713   char **argv,\
00714   FILE *stdin_,\
00715   FILE *stdout_,\
00716   FILE *stderr_\
00717 ) {\
00718   ptf->argc = argc;\
00719   ptf->argv = argv;\
00720   ptf->flx_stdin = stdin_;\
00721   ptf->flx_stdout = stdout_;\
00722   ptf->flx_stderr = stderr_;\
00723   mname::x(ptf);\
00724   return 0;\
00725 }
00726 #endif
00727 
00728 #endif
00729 

Generated on Mon Dec 11 18:08:29 2006 for Felix by  doxygen 1.5.1