1: #line 473 "./lpsrc/flx_rtl.pak"
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49: namespace flx { namespace rtl {
50:
51:
52:
53:
54:
55: struct RTL_EXTERN con_t;
56: struct RTL_EXTERN thread_t;
57: struct RTL_EXTERN _ref_;
58: struct RTL_EXTERN _uctor_;
59: struct RTL_EXTERN schannel_t;
60: struct RTL_EXTERN slist_t;
61: struct RTL_EXTERN _root_ptr_t;
62:
63: struct RTL_EXTERN unit {};
64:
65:
66:
67:
68:
69:
70:
71:
72:
73: RTL_EXTERN extern flx::gc::generic::gc_shape_t _fthread_ptr_map;
74: RTL_EXTERN extern flx::gc::generic::gc_shape_t schannel_ptr_map;
75: RTL_EXTERN extern flx::gc::generic::gc_shape_t _ref_ptr_map;
76: RTL_EXTERN extern flx::gc::generic::gc_shape_t _uctor_ptr_map;
77: RTL_EXTERN extern flx::gc::generic::gc_shape_t _int_ptr_map;
78: RTL_EXTERN extern flx::gc::generic::gc_shape_t unit_ptr_map;
79: RTL_EXTERN extern flx::gc::generic::gc_shape_t slist_ptr_map;
80: RTL_EXTERN extern flx::gc::generic::gc_shape_t _root_ptr_ptr_map;
81:
82:
83:
84:
85:
86: struct RTL_EXTERN flx_exception_t;
87: struct RTL_EXTERN flx_exec_failure_t;
88: struct RTL_EXTERN flx_range_srcref_t;
89: struct RTL_EXTERN flx_match_failure_t;
90: struct RTL_EXTERN flx_assert_failure_t;
91: struct RTL_EXTERN flx_assert2_failure_t;
92: struct RTL_EXTERN flx_switch_failure_t;
93:
94:
95:
96:
97: struct RTL_EXTERN con_t
98: {
99: FLX_PC_DECL
100: _uctor_ *p_svc;
101:
102: con_t();
103: virtual con_t *resume()=0;
104: virtual ~con_t();
105: con_t * _caller;
106: };
107:
108:
109:
110:
111:
112:
113: struct RTL_EXTERN slist_t {
114: gc::generic::collector_t *gc;
115: struct slist_node_t *head;
116:
117: slist_t (gc::generic::collector_t *);
118: slist_t (slist_t const &);
119:
120: void push(void *data);
121: void *pop();
122: bool isempty()const;
123: };
124:
125:
126:
127:
128:
129: struct RTL_EXTERN fthread_t
130: {
131: con_t *cc;
132:
133: fthread_t();
134: fthread_t(con_t*);
135: _uctor_ *run();
136: void kill();
137: _uctor_ *get_svc()const;
138: private:
139: fthread_t(fthread_t const&);
140: void operator=(fthread_t const&);
141: };
142:
143:
144:
145:
146:
147: struct RTL_EXTERN schannel_t
148: {
149: slist_t *waiting_to_read;
150: slist_t *waiting_to_write;
151: schannel_t(gc::generic::collector_t*);
152: void push_reader(fthread_t *);
153: fthread_t *pop_reader();
154: void push_writer(fthread_t *);
155: fthread_t *pop_writer();
156: private:
157: schannel_t(schannel_t const&);
158: void operator= (schannel_t const&);
159: };
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181: struct RTL_EXTERN _ref_
182: {
183: void *frame;
184: std::ptrdiff_t offset;
185:
186: _ref_() : frame(0),offset(0) {}
187: _ref_(void *f, void *d):
188: frame(f), offset((unsigned char*)d-(unsigned char*)f) {}
189:
190:
191: _ref_(void *f, std::ptrdiff_t d):
192: frame(f), offset(d) {}
193:
194: _ref_(_ref_ const& r) : frame(r.frame), offset(r.offset) {}
195:
196:
197: void operator = (_ref_ const& r);
198:
199: void *get_data()const { return (unsigned char*)frame + offset; }
200:
201:
202: void set_data(void *p)
203: { offset = (unsigned char*)p - (unsigned char*)frame; }
204:
205:
206: void set(void *f, void *p)
207: { frame = f; offset = (unsigned char*)p - (unsigned char*)f; }
208:
209: bool operator==(_ref_ x) const
210: { return frame==x.frame && offset==x.offset; }
211:
212: bool operator!=(_ref_ x) const
213: { return frame!=x.frame || offset!=x.offset; }
214: };
215:
216:
217:
218:
219:
220:
221:
222: struct RTL_EXTERN _uctor_
223: {
224: int variant;
225: void *data;
226: _uctor_() : variant(-1), data(0) {}
227: _uctor_(int i, void *d) : variant(i), data(d) {}
228: _uctor_(int *a, _uctor_ x) : variant(a[x.variant]), data(x.data) {}
229: };
230:
231:
232:
233:
234:
235:
236:
237: struct RTL_EXTERN _root_ptr_t
238: {
239: _root_ptr_t();
240: _root_ptr_t(void *x);
241: _root_ptr_t(_root_ptr_t const&);
242: void operator=(_root_ptr_t const&);
243: ~_root_ptr_t();
244:
245: _root_ptr_t *next;
246: _root_ptr_t *prev;
247: void *data;
248:
249: private:
250: void insert_after (_root_ptr_t*);
251: void erase();
252: };
253:
254:
255: template<class T>
256: struct root_ptr_t : _root_ptr_t {
257: root_ptr_t(){}
258: root_ptr_t(root_ptr_t<T> const&){}
259: root_ptr_t<T>& operator=(root_ptr_t<T> const &a){
260: return reinterpret_cast<root_ptr_t<T>&>(_root_ptr_t::operator=(a));
261: }
262: ~root_ptr_t(){}
263:
264: root_ptr_t(T const *a) : _root_ptr_t (const_cast<T*>(a)) {}
265:
266: T *operator->() { return (T*)data; }
267: T const *operator->() const { return (T const*)data; }
268: T &operator*() { return *(T*)data; }
269: T const &operator*() const { return *(T const*)data; }
270: };
271:
272: template<class T>
273: bool operator == (root_ptr_t<T> a, root_ptr_t<T> b)
274: {
275: return a-> data == b->data;
276: }
277:
278: template<class T>
279: bool operator != (root_ptr_t<T> a, root_ptr_t<T> b)
280: {
281: return a-> data != b->data;
282: }
283:
284: template<class T>
285: bool operator < (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
286: {
287:
288: return std::less<void const*>()(a-> data, b->data);
289: }
290:
291: template<class T>
292: bool operator <= (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
293: {
294:
295: return std::less_equal<void const*>()(a-> data, b->data);
296: }
297:
298: template<class T>
299: bool operator > (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
300: {
301:
302: return std::greater<void const*>()(a-> data, b->data);
303: }
304:
305: template<class T>
306: bool operator >= (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
307: {
308:
309: return std::greater_equal<void const*>()(a-> data, b->data);
310: }
311:
312:
313:
314:
315:
316:
317:
318:
319: struct RTL_EXTERN flx_exception_t {
320: virtual ~flx_exception_t()=0;
321: };
322:
323:
324:
325:
326:
327:
328: struct RTL_EXTERN flx_exec_failure_t : flx_exception_t {
329: std::string filename;
330: std::string operation;
331: std::string what;
332: flx_exec_failure_t(std::string f, std::string o, std::string w);
333: virtual ~flx_exec_failure_t();
334: };
335:
336:
337:
338:
339:
340: struct RTL_EXTERN flx_range_srcref_t {
341: char *filename;
342: int startline;
343: int startcol;
344: int endline;
345: int endcol;
346: flx_range_srcref_t(char *f,int sl, int sc, int el, int ec);
347: flx_range_srcref_t();
348: };
349:
350:
351:
352:
353:
354:
355: struct RTL_EXTERN flx_halt_t : flx_exception_t {
356: std::string reason;
357: flx_range_srcref_t flx_loc;
358: char *cxx_srcfile;
359: int cxx_srcline;
360: flx_halt_t(flx_range_srcref_t ff, char *cf, int cl, std::string reason);
361: virtual ~flx_halt_t();
362: };
363:
364:
365:
366:
367:
368:
369:
370: struct RTL_EXTERN flx_match_failure_t : flx_exception_t {
371: flx_range_srcref_t flx_loc;
372: char *cxx_srcfile;
373: int cxx_srcline;
374: flx_match_failure_t(flx_range_srcref_t ff, char *cf, int cl);
375: virtual ~flx_match_failure_t();
376: };
377:
378:
379:
380:
381:
382:
383: struct RTL_EXTERN flx_assert_failure_t : flx_exception_t {
384: flx_range_srcref_t flx_loc;
385: char *cxx_srcfile;
386: int cxx_srcline;
387: flx_assert_failure_t(flx_range_srcref_t ff, char *cf, int cl);
388: virtual ~flx_assert_failure_t();
389: };
390:
391: struct RTL_EXTERN flx_assert2_failure_t : flx_exception_t {
392: flx_range_srcref_t flx_loc;
393: flx_range_srcref_t flx_loc2;
394: char *cxx_srcfile;
395: int cxx_srcline;
396: flx_assert2_failure_t(flx_range_srcref_t ff, flx_range_srcref_t ff2, char *cf, int cl);
397: virtual ~flx_assert2_failure_t();
398: };
399:
400:
401:
402:
403:
404:
405: struct RTL_EXTERN flx_range_failure_t : flx_exception_t {
406: flx_range_srcref_t flx_loc;
407: char *cxx_srcfile;
408: int cxx_srcline;
409: flx_range_failure_t(flx_range_srcref_t ff, char *cf, int cl);
410: virtual ~flx_range_failure_t();
411: };
412:
413: RTL_EXTERN long range_check (long l, long x, long h, flx_range_srcref_t sref, char *cf, int cl);
414:
415:
416:
417:
418:
419:
420: struct RTL_EXTERN flx_switch_failure_t : flx_exception_t {
421: virtual ~flx_switch_failure_t();
422: };
423:
424:
425:
426:
427:
428:
429:
430: enum svc_t
431: {
432: svc_yield = 0,
433: svc_get_fthread=1,
434: svc_read=2,
435: svc_general=3,
436: svc_reserved=4,
437: svc_spawn_pthread=5,
438: svc_spawn_detached=6,
439: svc_sread=7,
440: svc_swrite=8,
441: svc_kill=9,
442: svc_compact=10,
443: svc_collect=11,
444: svc_collect_and_compact=12,
445: svc_end
446: };
447:
448: struct readreq_t {
449: schannel_t *chan;
450: _ref_ variable;
451: };
452:
453: }}
454:
455:
456: throw flx::rtl::flx_exec_failure_t (f,op,what)
457:
458:
459: throw flx::rtl::flx_halt_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__,s)
460:
461:
462: throw flx::rtl::flx_match_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)
463:
464:
465: throw flx::rtl::flx_assert_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)
466:
467:
468: throw flx::rtl::flx_assert2_failure_t (\
469: flx_range_srcref_t(f,sl,sc,el,ec),\
470: flx_range_srcref_t(f2,sl2,sc2,el2,sc2),\
471: __FILE__,__LINE__)
472:
473:
474: throw flx::rtl::flx_range_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485: extern void f##i##_##n##_##x(void) __asm__("l"#i"_"#n"_"#x);
486:
487: __asm__(".global l"#i"_"#n"_"#x);\
488: __asm__("l"#i"_"#n"_"#x":");\
489: __asm__(""::"g"(&&x));
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503: { \
504: con_t *tmp = _caller; \
505: _caller = 0; \
506: return tmp; \
507: }
508:
509:
510:
511:
512: static void x##_finaliser(collector_t *, void *p){\
513: ((x*)p)->~x();\
514: }
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562: extern "C" thread_frame_t *create_thread_frame(\
563: collector_t *gc\
564: ) {\
565: ptf.gc = gc;\
566: return &ptf;\
567: }
568:
569:
570: extern "C" thread_frame_t *create_thread_frame(\
571: collector_t *gc\
572: ) {\
573: mname::thread_frame_t *p = new(*gc,mname::thread_frame_t_ptr_map) mname::thread_frame_t(gc);\
574: ptf = p;\
575: return p;\
576: }
577:
578:
579: extern "C" FLX_EXPORT mname::thread_frame_t *create_thread_frame(\
580: collector_t *gc\
581: ) {\
582: mname::thread_frame_t *p = new(*gc,mname::thread_frame_t_ptr_map) mname::thread_frame_t(gc);\
583: return p;\
584: }
585:
586:
587:
588:
589: extern "C" con_t *flx_start(\
590: mname::thread_frame_t *ptf,\
591: int argc,\
592: char **argv,\
593: FILE *stdin_,\
594: FILE *stdout_,\
595: FILE *stderr_\
596: ) {\
597: ptf->argc = argc;\
598: ptf->argv = argv;\
599: ptf->flx_stdin = stdin_;\
600: ptf->flx_stdout = stdout_;\
601: ptf->flx_stderr = stderr_;\
602: return (new(*ptf->gc,mname::x##_ptr_map) \
603: mname::x()) ->call(0);\
604: }
605:
606:
607: extern "C" con_t *flx_start(\
608: mname::thread_frame_t *ptf,\
609: int argc,\
610: char **argv,\
611: FILE *stdin_,\
612: FILE *stdout_,\
613: FILE *stderr_\
614: ) {\
615: ptf->argc = argc;\
616: ptf->argv = argv;\
617: ptf->flx_stdin = stdin_;\
618: ptf->flx_stdout = stdout_;\
619: ptf->flx_stderr = stderr_;\
620: return (new(*ptf->gc,mname::x##_ptr_map) \
621: mname::x()) ->call(0);\
622: }
623:
624:
625: extern "C" FLX_EXPORT con_t *flx_start(\
626: mname::thread_frame_t *ptf,\
627: int argc,\
628: char **argv,\
629: FILE *stdin_,\
630: FILE *stdout_,\
631: FILE *stderr_\
632: ) {\
633: ptf->argc = argc;\
634: ptf->argv = argv;\
635: ptf->flx_stdin = stdin_;\
636: ptf->flx_stdout = stdout_;\
637: ptf->flx_stderr = stderr_;\
638: return (new(*ptf->gc,mname::x##_ptr_map) \
639: mname::x(ptf)) ->call(0);\
640: }
641:
642:
643:
644:
645: extern "C" con_t *flx_start(\
646: mname::thread_frame_t *ptf,\
647: int argc,\
648: char **argv,\
649: FILE *stdin_,\
650: FILE *stdout_,\
651: FILE *stderr_\
652: ) {\
653: ptf->argc = argc;\
654: ptf->argv = argv;\
655: ptf->flx_stdin = stdin_;\
656: ptf->flx_stdout = stdout_;\
657: ptf->flx_stderr = stderr_;\
658: mname::x().stack_call();\
659: return 0;\
660: }
661:
662:
663: extern "C" con_t *flx_start(\
664: mname::thread_frame_t *ptf,\
665: int argc,\
666: char **argv,\
667: FILE *stdin_,\
668: FILE *stdout_,\
669: FILE *stderr_\
670: ) {\
671: ptf->argc = argc;\
672: ptf->argv = argv;\
673: ptf->flx_stdin = stdin_;\
674: ptf->flx_stdout = stdout_;\
675: ptf->flx_stderr = stderr_;\
676: mname::x().stack_call();\
677: return 0;\
678: }
679:
680:
681: extern "C" FLX_EXPORT con_t *flx_start(\
682: mname::thread_frame_t *ptf,\
683: int argc,\
684: char **argv,\
685: FILE *stdin_,\
686: FILE *stdout_,\
687: FILE *stderr_\
688: ) {\
689: ptf->argc = argc;\
690: ptf->argv = argv;\
691: ptf->flx_stdin = stdin_;\
692: ptf->flx_stdout = stdout_;\
693: ptf->flx_stderr = stderr_;\
694: mname::x(ptf).stack_call();\
695: return 0;\
696: }
697:
698:
699:
700:
701: extern "C" con_t *flx_start(\
702: mname::thread_frame_t *ptf,\
703: int argc,\
704: char **argv,\
705: FILE *stdin_,\
706: FILE *stdout_,\
707: FILE *stderr_\
708: ) {\
709: ptf->argc = argc;\
710: ptf->argv = argv;\
711: ptf->flx_stdin = stdin_;\
712: ptf->flx_stdout = stdout_;\
713: ptf->flx_stderr = stderr_;\
714: mname::x();\
715: return 0;\
716: }
717:
718:
719: extern "C" con_t *flx_start(\
720: mname::thread_frame_t *ptf,\
721: int argc,\
722: char **argv,\
723: FILE *stdin_,\
724: FILE *stdout_,\
725: FILE *stderr_\
726: ) {\
727: ptf->argc = argc;\
728: ptf->argv = argv;\
729: ptf->flx_stdin = stdin_;\
730: ptf->flx_stdout = stdout_;\
731: ptf->flx_stderr = stderr_;\
732: mname::x();\
733: return 0;\
734: }
735:
736:
737: extern "C" FLX_EXPORT con_t *flx_start(\
738: mname::thread_frame_t *ptf,\
739: int argc,\
740: char **argv,\
741: FILE *stdin_,\
742: FILE *stdout_,\
743: FILE *stderr_\
744: ) {\
745: ptf->argc = argc;\
746: ptf->argv = argv;\
747: ptf->flx_stdin = stdin_;\
748: ptf->flx_stdout = stdout_;\
749: ptf->flx_stderr = stderr_;\
750: mname::x(ptf);\
751: return 0;\
752: }
753:
754:
755:
1: #line 1230 "./lpsrc/flx_rtl.pak"
2:
3:
4:
5:
6: namespace flx { namespace rtl {
7:
8:
9:
10:
11:
12: con_t::con_t() : pc(0), p_svc(0), _caller(0) {
13: #if FLX_DEBUG_CONT
14: fprintf(stderr,"Constructing %p\n",this);
15: #endif
16: }
17: con_t::~con_t(){
18: #if FLX_DEBUG_CONT
19: fprintf(stderr,"Destroying %p\n",this);
20: #endif
21: }
22:
23:
24:
25:
26:
27:
28: struct slist_node_t {
29: slist_node_t *next;
30: void *data;
31: slist_node_t(slist_node_t *n, void *d) : next(n), data(d) {}
32: };
33:
34:
35: static std::size_t slist_node_offsets[2]={
36: offsetof(slist_node_t,next),
37: offsetof(slist_node_t,data)
38: };
39:
40: flx::gc::generic::gc_shape_t slist_node_ptr_map(
41: NULL,
42: "slist_node_t",
43: 1,sizeof(slist_node_t),
44: 0,
45: 2,
46: slist_node_offsets
47: );
48:
49:
50: slist_t::slist_t(gc::generic::collector_t *_gc) : gc (_gc), head(0) {}
51: slist_t::slist_t(slist_t const &r) : gc (r.gc), head(r.head) {}
52:
53: bool slist_t::isempty()const { return head == 0; }
54:
55: void slist_t::push(void *data)
56: {
57: head = new(*gc,slist_node_ptr_map) slist_node_t(head,data);
58: }
59:
60:
61: void *slist_t::pop()
62: {
63: if(head) {
64: void *data = head->data;
65: head=head->next;
66: return data;
67: }
68: else return 0;
69: }
70:
71:
72: static std::size_t slist_offsets[1]={
73: offsetof(slist_t,head)
74: };
75:
76: flx::gc::generic::gc_shape_t slist_ptr_map(
77: &slist_node_ptr_map,
78: "slist_t",
79: 1,sizeof(slist_t),
80: 0,
81: 1,
82: slist_offsets
83: );
84:
85:
86:
87:
88:
89: _root_ptr_t::_root_ptr_t() : next(0), prev(0), data(0) {}
90: _root_ptr_t::_root_ptr_t(void *x) : next(0), prev(0), data(x) {}
91: _root_ptr_t::~_root_ptr_t() { erase(); }
92:
93: void _root_ptr_t::insert_after(_root_ptr_t *a) {
94: prev = a;
95: next = prev->next;
96: prev->next = this;
97: if(next)next->prev = this;
98: data = next->data;
99: }
100:
101: _root_ptr_t::_root_ptr_t(_root_ptr_t const &a) {
102: insert_after(const_cast<_root_ptr_t*>(&a));
103: }
104:
105: void _root_ptr_t::operator=(_root_ptr_t const &a) {
106: if (&a != this)
107: {
108: erase();
109: insert_after(const_cast<_root_ptr_t*>(&a));
110: }
111: }
112:
113:
114: static std::size_t _root_ptr_offsets[3]={
115: offsetof(_root_ptr_t,next),
116: offsetof(_root_ptr_t,prev),
117: offsetof(_root_ptr_t,data)
118: };
119:
120: flx::gc::generic::gc_shape_t _root_ptr_ptr_map(
121: &slist_ptr_map,
122: "_root_ptr_t",
123: 1,sizeof(_root_ptr_t),
124: 0,
125: 1,
126: _root_ptr_offsets
127: );
128:
129: void _root_ptr_t::erase() {
130: next->prev = prev;
131: prev->next = next;
132: next = 0; prev = 0;
133: data = 0;
134: }
135:
136:
137:
138:
139:
140: fthread_t::fthread_t() : cc(0) {}
141: fthread_t::fthread_t(con_t *a) : cc(a) {}
142:
143:
144: fthread_t::fthread_t(fthread_t const&){ assert(false); }
145: void fthread_t::operator=(fthread_t const&){ assert(false); }
146:
147: void fthread_t::kill() { cc = 0; }
148:
149: _uctor_ *fthread_t::get_svc()const { return cc?cc->p_svc:0; }
150:
151: _uctor_ *fthread_t::run() {
152: if(!cc) return 0;
153: restep:
154: cc->p_svc = 0;
155: step:
156:
157: try { cc = cc->resume(); }
158: catch (con_t *x) { cc = x; }
159:
160:
161: if(!cc) return 0;
162:
163: if(cc->p_svc)
164: {
165: switch(cc->p_svc->variant)
166: {
167: case svc_get_fthread:
168: **(fthread_t***)(cc->p_svc->data) = this;
169: goto restep;
170:
171:
172:
173:
174:
175:
176: default:
177: return cc->p_svc;
178: }
179: }
180: goto step;
181: }
182:
183:
184:
185: static std::size_t _fthread_offsets[1]={
186: offsetof(fthread_t,cc)
187: };
188:
189: flx::gc::generic::gc_shape_t _fthread_ptr_map(
190: &_root_ptr_ptr_map,
191: "fthread_t",
192: 1,sizeof(fthread_t),
193: 0,
194: 1,
195: _fthread_offsets,
196: gc::generic::gc_flags_immobile
197: );
198:
199:
200:
201:
202:
203: schannel_t::schannel_t (gc::generic::collector_t *gc) :
204: waiting_to_read(0), waiting_to_write(0)
205: {
206: waiting_to_read = new (*gc, slist_ptr_map) slist_t(gc);
207: waiting_to_write = new (*gc, slist_ptr_map) slist_t(gc);
208: }
209:
210:
211: schannel_t::schannel_t(schannel_t const&) { assert(false); }
212: void schannel_t::operator=(schannel_t const&) { assert(false); }
213:
214: void schannel_t::push_reader(fthread_t *r)
215: {
216: waiting_to_read->push(r);
217: }
218:
219: void schannel_t::push_writer(fthread_t *w)
220: {
221: waiting_to_write->push(w);
222: }
223:
224: fthread_t *schannel_t::pop_reader()
225: {
226: return (fthread_t*)waiting_to_read->pop();
227: }
228:
229: fthread_t *schannel_t::pop_writer()
230: {
231: return (fthread_t*)waiting_to_write->pop();
232: }
233:
234:
235: static std::size_t schannel_offsets[2]={
236: offsetof(schannel_t,waiting_to_read),
237: offsetof(schannel_t,waiting_to_write)
238: };
239:
240: flx::gc::generic::gc_shape_t schannel_ptr_map(
241: &_fthread_ptr_map,
242: "schannel_t",
243: 1,sizeof(schannel_t),
244: 0,
245: 2,
246: schannel_offsets
247: );
248:
249:
250:
251:
252:
253: void _ref_::operator = (_ref_ const& r)
254: {
255: if (frame != r.frame || offset != r.offset)
256: {
257: frame = r.frame;
258: offset = r.offset;
259: }
260: }
261:
262:
263: static std::size_t _ref_offsets[1]={
264: offsetof(_ref_,frame)
265: };
266:
267: flx::gc::generic::gc_shape_t _ref_ptr_map(
268: &schannel_ptr_map,
269: "_ref_",
270: 1,sizeof(_ref_),
271: 0,
272: 1,
273: _ref_offsets
274: );
275:
276:
277:
278:
279:
280:
281: static std::size_t _uctor_offsets[1]= {
282: offsetof(_uctor_,data)
283: };
284:
285: flx::gc::generic::gc_shape_t _uctor_ptr_map (
286: &_ref_ptr_map,
287: "_uctor_",
288: 1,
289: sizeof(_uctor_),
290: 0,
291: 1,
292: _uctor_offsets
293: );
294:
295:
296:
297:
298:
299: flx::gc::generic::gc_shape_t _int_ptr_map (
300: &_uctor_ptr_map,
301: "int",
302: 1,
303: sizeof(int),
304: 0,
305: 0,
306: 0
307: );
308:
309:
310:
311:
312:
313: flx::gc::generic::gc_shape_t unit_ptr_map (
314: &_int_ptr_map,
315: "unit",
316: 1,
317: sizeof(unit),
318: 0,
319: 0,
320: 0
321: );
322:
323:
324:
325:
326: flx_exception_t::~flx_exception_t(){}
327:
328: flx_exec_failure_t::flx_exec_failure_t(std::string f, std::string o, std::string w) :
329: filename(f),
330: operation(o),
331: what(w)
332: {}
333:
334: flx_exec_failure_t::~flx_exec_failure_t(){}
335:
336: flx_range_srcref_t::flx_range_srcref_t() :
337: filename(""),startline(0),startcol(0),endline(0),endcol(0){}
338: flx_range_srcref_t::flx_range_srcref_t(char *f,int sl, int sc, int el, int ec) :
339: filename(f),startline(sl),startcol(sc),endline(el),endcol(ec){}
340:
341: flx_halt_t::flx_halt_t(flx_range_srcref_t ff, char *cf, int cl, std::string r) :
342: reason(r), flx_loc(ff), cxx_srcfile(cf), cxx_srcline(cl) {}
343: flx_halt_t::~flx_halt_t(){}
344:
345: flx_match_failure_t::flx_match_failure_t(flx_range_srcref_t ff, char *cf, int cl) :
346: flx_loc(ff), cxx_srcfile(cf), cxx_srcline(cl) {}
347: flx_match_failure_t::~flx_match_failure_t(){}
348:
349: flx_assert_failure_t::flx_assert_failure_t(flx_range_srcref_t ff, char *cf, int cl) :
350: flx_loc(ff), cxx_srcfile(cf), cxx_srcline(cl) {}
351: flx_assert_failure_t::~flx_assert_failure_t(){}
352:
353: flx_assert2_failure_t::flx_assert2_failure_t(flx_range_srcref_t ff, flx_range_srcref_t ff2, char *cf, int cl) :
354: flx_loc(ff), flx_loc2(ff2), cxx_srcfile(cf), cxx_srcline(cl) {}
355: flx_assert2_failure_t::~flx_assert2_failure_t(){}
356:
357: flx_range_failure_t::flx_range_failure_t(flx_range_srcref_t ff, char *cf, int cl) :
358: flx_loc(ff), cxx_srcfile(cf), cxx_srcline(cl) {}
359: flx_range_failure_t::~flx_range_failure_t(){}
360:
361: flx_switch_failure_t::~flx_switch_failure_t(){}
362:
363: long range_check (long l, long x, long h, flx_range_srcref_t sref, char *cf, int cl)
364: {
365: if (x>=l && x<h) return x;
366: throw flx::rtl::flx_range_failure_t (sref,cf,cl);
367: }
368:
369:
370: }}