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
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
00048
00049
00050 struct RTL_EXTERN con_t;
00051 struct RTL_EXTERN thread_t;
00052 struct RTL_EXTERN _ref_;
00053 struct RTL_EXTERN _uctor_;
00054 struct RTL_EXTERN schannel_t;
00055 struct RTL_EXTERN slist_t;
00056 struct RTL_EXTERN _root_ptr_t;
00057
00058 struct RTL_EXTERN unit {};
00059
00060
00061
00062
00063
00064
00065
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
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
00090
00091
00092 struct RTL_EXTERN con_t
00093 {
00094 #ifdef FLX_CGOTO
00095 void *pc;
00096 #else
00097 int pc;
00098 #endif
00099
00100 _uctor_ *p_svc;
00101
00102 con_t();
00103 virtual con_t *resume()=0;
00104 virtual ~con_t();
00105 con_t * _caller;
00106 };
00107
00108
00109
00110
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 *);
00118 slist_t (slist_t const &);
00119
00120 void push(void *data);
00121 void *pop();
00122 bool isempty()const;
00123 };
00124
00125
00126
00127
00128
00129 struct RTL_EXTERN fthread_t
00130 {
00131 con_t *cc;
00132
00133 fthread_t();
00134 fthread_t(con_t*);
00135 _uctor_ *run();
00136 void kill();
00137 _uctor_ *get_svc()const;
00138 private:
00139 fthread_t(fthread_t const&);
00140 void operator=(fthread_t const&);
00141 };
00142
00143
00144
00145
00146
00147 struct RTL_EXTERN schannel_t
00148 {
00149 slist_t *waiting_to_read;
00150 slist_t *waiting_to_write;
00151 schannel_t(gc::generic::collector_t*);
00152 void push_reader(fthread_t *);
00153 fthread_t *pop_reader();
00154 void push_writer(fthread_t *);
00155 fthread_t *pop_writer();
00156 private:
00157 schannel_t(schannel_t const&);
00158 void operator= (schannel_t const&);
00159 };
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181 struct RTL_EXTERN _ref_
00182 {
00183 void *frame;
00184 std::ptrdiff_t offset;
00185
00186 _ref_() : frame(0),offset(0) {}
00187 _ref_(void *f, void *d):
00188 frame(f), offset((unsigned char*)d-(unsigned char*)f) {}
00189
00190
00191 _ref_(void *f, std::ptrdiff_t d):
00192 frame(f), offset(d) {}
00193
00194 _ref_(_ref_ const& r) : frame(r.frame), offset(r.offset) {}
00195
00196
00197 void operator = (_ref_ const& r);
00198
00199 void *get_data()const { return (unsigned char*)frame + offset; }
00200
00201
00202 void set_data(void *p)
00203 { offset = (unsigned char*)p - (unsigned char*)frame; }
00204
00205
00206 void set(void *f, void *p)
00207 { frame = f; offset = (unsigned char*)p - (unsigned char*)f; }
00208 };
00209
00210
00211
00212
00213
00214
00215
00216 struct RTL_EXTERN _uctor_
00217 {
00218 int variant;
00219 void *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
00227
00228
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
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
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
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
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
00303 return std::greater_equal<void const*>()(a-> data, b->data);
00304 }
00305
00306
00307
00308
00309
00310
00311
00312
00313 struct RTL_EXTERN flx_exception_t {
00314 virtual ~flx_exception_t()=0;
00315 };
00316
00317
00318
00319
00320
00321
00322 struct RTL_EXTERN flx_exec_failure_t : flx_exception_t {
00323 std::string filename;
00324 std::string operation;
00325 std::string what;
00326 flx_exec_failure_t(std::string f, std::string o, std::string w);
00327 virtual ~flx_exec_failure_t();
00328 };
00329
00330
00331
00332
00333
00334 struct RTL_EXTERN flx_range_srcref_t {
00335 char *filename;
00336 int startline;
00337 int startcol;
00338 int endline;
00339 int endcol;
00340 flx_range_srcref_t(char *f,int sl, int sc, int el, int ec);
00341 flx_range_srcref_t();
00342 };
00343
00344
00345
00346
00347
00348
00349
00350 struct RTL_EXTERN flx_match_failure_t : flx_exception_t {
00351 flx_range_srcref_t flx_loc;
00352 char *cxx_srcfile;
00353 int cxx_srcline;
00354 flx_match_failure_t(flx_range_srcref_t ff, char *cf, int cl);
00355 virtual ~flx_match_failure_t();
00356 };
00357
00358
00359
00360
00361
00362
00363 struct RTL_EXTERN flx_assert_failure_t : flx_exception_t {
00364 flx_range_srcref_t flx_loc;
00365 char *cxx_srcfile;
00366 int cxx_srcline;
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;
00373 flx_range_srcref_t flx_loc2;
00374 char *cxx_srcfile;
00375 int cxx_srcline;
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
00382
00383
00384
00385 struct RTL_EXTERN flx_range_failure_t : flx_exception_t {
00386 flx_range_srcref_t flx_loc;
00387 char *cxx_srcfile;
00388 int cxx_srcline;
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
00398
00399
00400 struct RTL_EXTERN flx_switch_failure_t : flx_exception_t {
00401 virtual ~flx_switch_failure_t();
00402 };
00403
00404
00405
00406
00407
00408
00409
00410 enum svc_t
00411 {
00412 svc_yield = 0,
00413 svc_get_fthread=1,
00414 svc_read=2,
00415 svc_general=3,
00416 svc_reserved=4,
00417 svc_spawn_pthread=5,
00418 svc_spawn_detached=6,
00419 svc_sread=7,
00420 svc_swrite=8,
00421 svc_kill=9,
00422 svc_compact=10,
00423 svc_collect=11,
00424 svc_collect_and_compact=12,
00425 svc_end
00426 };
00427
00428 struct readreq_t {
00429 schannel_t *chan;
00430 _ref_ variable;
00431 };
00432
00433 }}
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
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