flx_rtl.hpp

#line 475 "./lpsrc/flx_rtl.pak"
#ifndef __FLX_RTL_H__
#define __FLX_RTL_H__
#include "flx_rtl_config.hpp"
#include "flx_meta.hpp"
#include "flx_gc.hpp"
#include <string>
#include <functional>

#if FLX_PTF_STATIC_STRUCT
#define PTF ptf.
#elif FLX_PTF_STATIC_POINTER
#define PTF ptf->
#else
#define PTF ptf->
#endif

// for declarations in header file
#if FLX_PTF_STATIC_STRUCT
#define FLX_FMEM_DECL
#define FLX_FPAR_DECL_ONLY
#define FLX_FPAR_DECL
#define FLX_APAR_DECL_ONLY
#define FLX_APAR_DECL
#define FLX_DCL_THREAD_FRAME extern thread_frame_t ptf;
#elif FLX_PTF_STATIC_POINTER
#define FLX_FMEM_DECL
#define FLX_FPAR_DECL_ONLY
#define FLX_FPAR_DECL
#define FLX_APAR_DECL_ONLY
#define FLX_APAR_DECL
#define FLX_DCL_THREAD_FRAME extern thread_frame_t *ptf;
#else
#define FLX_FMEM_DECL thread_frame_t *ptf;
#define FLX_FPAR_DECL_ONLY thread_frame_t *_ptf
#define FLX_FPAR_DECL thread_frame_t *_ptf,
#define FLX_APAR_DECL_ONLY thread_frame_t *ptf
#define FLX_APAR_DECL thread_frame_t *ptf,
#define FLX_DCL_THREAD_FRAME
#endif

#if FLX_CGOTO
  #define FLX_PC_DECL void *pc;
#else
  #define FLX_PC_DECL int pc;
#endif


namespace flx { namespace rtl {

// ********************************************************
// Felix system classes
// ********************************************************

struct RTL_EXTERN con_t;     // continuation
struct RTL_EXTERN thread_t; // f-thread
//struct RTL_EXTERN _ref_;     // pointer/reference
struct RTL_EXTERN _uctor_;   // union constructor
struct RTL_EXTERN schannel_t;   // synchronous channel type
struct RTL_EXTERN slist_t;   // singly linked list of void*
struct RTL_EXTERN _root_ptr_t;   // singly linked list of void*

struct RTL_EXTERN unit {};   // unit
  // INLINE DEFINITION, PROBLEMATIC!!

// ********************************************************
// Shape (RTTI) objects for system classes
// con_t is only an abstract base, so has no fixed shape
// shapes for instance types generated by Felix compiler
// we provide a shape for C 'int' type as well
// ********************************************************

RTL_EXTERN extern flx::gc::generic::gc_shape_t _fthread_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t schannel_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t _ref_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t _uctor_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t _int_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t unit_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t slist_ptr_map;
RTL_EXTERN extern flx::gc::generic::gc_shape_t _root_ptr_ptr_map;

// ********************************************************
// Standard C++ Exceptions
// ********************************************************

struct RTL_EXTERN flx_exception_t;
struct RTL_EXTERN flx_exec_failure_t;
struct RTL_EXTERN flx_range_srcref_t;
struct RTL_EXTERN flx_match_failure_t;
struct RTL_EXTERN flx_assert_failure_t;
struct RTL_EXTERN flx_assert2_failure_t;
struct RTL_EXTERN flx_switch_failure_t;
// ********************************************************
/// CONTINUATION.
// ********************************************************

struct RTL_EXTERN con_t ///< abstract base for mutable continuations
{
  FLX_PC_DECL               ///< interior program counter
  _uctor_ *p_svc;           ///< pointer to service request

  con_t();                  ///< initialise pc, p_svc to 0
  virtual con_t *resume()=0;///< method to perform a computational step
  virtual ~con_t();
  con_t * _caller;          ///< callers continuation (return address)
};

// ********************************************************
/// SLIST. singly linked lists: SHARABLE and COPYABLE
/// SLIST manages pointers to memory managed by the collector
// ********************************************************

struct RTL_EXTERN slist_t {
  gc::generic::collector_t *gc;
  struct slist_node_t *head;

  slist_t (gc::generic::collector_t *); ///< create empty list
  slist_t (slist_t const &);            ///< shallow copy

  void push(void *data);                ///< push a gc pointer
  void *pop();                          ///< pop a gc pointer
  bool isempty()const;
};

// ********************************************************
/// FTHREAD. Felix threads
// ********************************************************

struct RTL_EXTERN fthread_t // fthread abstraction
{
  con_t *cc;                    ///< current continuation

  fthread_t();                  ///< dead thread, suitable for assignment
  fthread_t(con_t*);            ///< make thread from a continuation
  _uctor_ *run();               ///< run until dead or driver service request
  void kill();                  ///< kill by detaching the continuation
  _uctor_ *get_svc()const;      ///< get current service request of waiting thread
private: // uncopyable
  fthread_t(fthread_t const&);
  void operator=(fthread_t const&);
};

// ********************************************************
/// SCHANNEL. Synchronous channels
// ********************************************************

struct RTL_EXTERN schannel_t
{
  slist_t *waiting_to_read;             ///< fthreads waiting for a writer
  slist_t *waiting_to_write;            ///< fthreads waiting for a reader
  schannel_t(gc::generic::collector_t*);
  void push_reader(fthread_t *);        ///< add a reader
  fthread_t *pop_reader();              ///< pop a reader, NULL if none
  void push_writer(fthread_t *);        ///< add a writer
  fthread_t *pop_writer();              ///< pop a writer, NULL if none
private: // uncopyable
  schannel_t(schannel_t const&);
  void operator= (schannel_t const&);
};

// ********************************************************
/// VARIANTS. Felix union type
/// note: non-polymorphic, so ctor can be inline
// ********************************************************

struct RTL_EXTERN _uctor_
{
  int variant;  ///< Variant code
  void *data;   ///< Heap variant constructor data
  _uctor_() : variant(-1), data(0) {}
  _uctor_(int i, void *d) : variant(i), data(d) {}
  _uctor_(int *a, _uctor_ x) : variant(a[x.variant]), data(x.data) {}
};

// ********************************************************
/// ROOT POINTER.
/// Use to chain pseudo roots together. Generally scannable
/// but not collectable.
// ********************************************************

struct RTL_EXTERN _root_ptr_t
{
  _root_ptr_t();
  _root_ptr_t(void *x);
  _root_ptr_t(_root_ptr_t const&);
  void operator=(_root_ptr_t const&);
  ~_root_ptr_t();

  _root_ptr_t *next;
  _root_ptr_t *prev;
  void *data;

private:
  void insert_after (_root_ptr_t*);
  void erase();
};

// INLINE! All casts
template<class T>
struct root_ptr_t : _root_ptr_t {
  root_ptr_t(){}
  root_ptr_t(root_ptr_t<T> const&){}
  root_ptr_t<T>& operator=(root_ptr_t<T> const &a){
    return reinterpret_cast<root_ptr_t<T>&>(_root_ptr_t::operator=(a));
  }
 ~root_ptr_t(){}

  root_ptr_t(T const *a) : _root_ptr_t (const_cast<T*>(a)) {}

  T *operator->() { return (T*)data; }
  T const *operator->() const { return (T const*)data; }
  T &operator*() { return *(T*)data; }
  T const &operator*() const { return *(T const*)data; }
};

template<class T>
bool operator == (root_ptr_t<T> a, root_ptr_t<T> b)
{
  return a-> data == b->data;
}

template<class T>
bool operator != (root_ptr_t<T> a, root_ptr_t<T> b)
{
  return a-> data != b->data;
}

template<class T>
bool operator < (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
{
  // we use this because it enforces a total order
  return std::less<void const*>()(a-> data, b->data);
}

template<class T>
bool operator <= (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
{
  // we use this because it enforces a total order
  return std::less_equal<void const*>()(a-> data, b->data);
}

template<class T>
bool operator > (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
{
  // we use this because it enforces a total order
  return std::greater<void const*>()(a-> data, b->data);
}

template<class T>
bool operator >= (root_ptr_t<T> const &a, root_ptr_t<T> const &b)
{
  // we use this because it enforces a total order
  return std::greater_equal<void const*>()(a-> data, b->data);
}


// ********************************************************
/// EXCEPTION: Felix exception base abstraction.
/// Mainly used to convert catches into subroutine
/// calls which then dispatch on RTTI manually.
// ********************************************************

struct RTL_EXTERN flx_exception_t {
  virtual ~flx_exception_t()=0;
};

// ********************************************************
/// EXCEPTION: EXEC protocol failure.
/// Thrown when trying to run a dead procedure
// ********************************************************

struct RTL_EXTERN flx_exec_failure_t : flx_exception_t {
  std::string filename;  ///< dll filename
  std::string operation; ///< faulty operation
  std::string what;      ///< error description
  flx_exec_failure_t(std::string f, std::string o, std::string w);
  virtual ~flx_exec_failure_t();
};

// ********************************************************
/// SOURCE REFERENCE: to track places in user source code.
// ********************************************************

struct RTL_EXTERN flx_range_srcref_t {
  char *filename;  ///< source file name
  int startline;   ///< first line (1 origin)
  int startcol;    ///< first column (1 origin)
  int endline;     ///< last line
  int endcol;      ///< last column
  flx_range_srcref_t(char *f,int sl, int sc, int el, int ec);
  flx_range_srcref_t();
};

// ********************************************************
/// EXCEPTION: HALT.
/// Thrown by halt command
// ********************************************************

struct RTL_EXTERN flx_halt_t : flx_exception_t {
  std::string reason;         ///< halt argument
  flx_range_srcref_t flx_loc; ///< location in Felix file
  char *cxx_srcfile;          ///< C++ file name
  int cxx_srcline;            ///< C++ line number
  flx_halt_t(flx_range_srcref_t ff, char *cf, int cl, std::string reason);
  virtual ~flx_halt_t();
};

// ********************************************************
/// EXCEPTION: MATCH failure.
/// Thrown when no match cases match the argument of a match,
/// regmatch, or reglex
// ********************************************************

struct RTL_EXTERN flx_match_failure_t : flx_exception_t {
  flx_range_srcref_t flx_loc; ///< location in Felix file
  char *cxx_srcfile;          ///< C++ file name
  int cxx_srcline;            ///< C++ line number
  flx_match_failure_t(flx_range_srcref_t ff, char *cf, int cl);
  virtual ~flx_match_failure_t();
};

// ********************************************************
/// EXCEPTION: ASSERT failure.
/// Thrown when user assertion fails
// ********************************************************

struct RTL_EXTERN flx_assert_failure_t : flx_exception_t {
  flx_range_srcref_t flx_loc; ///< location in Felix file
  char *cxx_srcfile;          ///< C++ file
  int cxx_srcline;            ///< __LINE__ macro
  flx_assert_failure_t(flx_range_srcref_t ff, char *cf, int cl);
  virtual ~flx_assert_failure_t();
};

struct RTL_EXTERN flx_assert2_failure_t : flx_exception_t {
  flx_range_srcref_t flx_loc; ///< location in Felix file
  flx_range_srcref_t flx_loc2; ///< second location in Felix file
  char *cxx_srcfile;          ///< C++ file
  int cxx_srcline;            ///< __LINE__ macro
  flx_assert2_failure_t(flx_range_srcref_t ff, flx_range_srcref_t ff2, char *cf, int cl);
  virtual ~flx_assert2_failure_t();
};

// ********************************************************
/// EXCEPTION: RANGE failure.
/// Thrown when a range check fails
// ********************************************************

struct RTL_EXTERN flx_range_failure_t : flx_exception_t {
  flx_range_srcref_t flx_loc; ///< location in Felix file
  char *cxx_srcfile;          ///< C++ file
  int cxx_srcline;            ///< __LINE__ macro
  flx_range_failure_t(flx_range_srcref_t ff, char *cf, int cl);
  virtual ~flx_range_failure_t();
};

RTL_EXTERN long range_check (long l, long x, long h, flx_range_srcref_t sref, char *cf, int cl);


// ********************************************************
/// EXCEPTION: SWITCH failure. this is a system failure!
// ********************************************************

struct RTL_EXTERN flx_switch_failure_t : flx_exception_t {
  virtual ~flx_switch_failure_t();
};


// ********************************************************
// SERVICE REQUEST CODE
// THESE VALUES MUST SYNCH WITH THE STANDARD LIBRARY
// ********************************************************

enum svc_t               // what the dispatch should do
{                        // when the resume callback returns
  svc_yield = 0,
  svc_get_fthread=1,
  svc_read=2,
  svc_general=3,         // temporary hack by RF
  svc_reserved=4,
  svc_spawn_pthread=5,
  svc_spawn_detached=6,
  svc_sread=7,           // synchronous read
  svc_swrite=8,          // synchronous write
  svc_kill=9,           // kill fthread
  svc_collect=10,        // run collector
  svc_end
};

struct readreq_t {
  schannel_t *chan;
  void *variable;
};

}} // namespaces

#define FLX_EXEC_FAILURE(f,op,what) \
  throw flx::rtl::flx_exec_failure_t (f,op,what)

#define FLX_HALT(f,sl,sc,el,ec,s) \
  throw flx::rtl::flx_halt_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__,s)

#define FLX_MATCH_FAILURE(f,sl,sc,el,ec) \
  throw flx::rtl::flx_match_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)

#define FLX_ASSERT_FAILURE(f,sl,sc,el,ec) \
  throw flx::rtl::flx_assert_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)

#define FLX_ASSERT2_FAILURE(f,sl,sc,el,ec,f2,sl2,sc2,el2,ec2) \
  throw flx::rtl::flx_assert2_failure_t (\
    flx_range_srcref_t(f,sl,sc,el,ec),\
    flx_range_srcref_t(f2,sl2,sc2,el2,sc2),\
    __FILE__,__LINE__)

#define FLX_RANGE_FAILURE(f,sl,sc,el,ec) \
  throw flx::rtl::flx_range_failure_t (flx_range_srcref_t(f,sl,sc,el,ec),__FILE__,__LINE__)

// for generated code in body file
#define INIT_PC pc=0;
    ///< interior program counter

#if FLX_CGOTO
  #define FLX_START_SWITCH if(pc)goto *pc;
  #define FLX_SET_PC(x) pc=&&case_##x;
  #define FLX_CASE_LABEL(x) case_##x:;
  #define FLX_DECLARE_LABEL(n,i,x) \
    extern void f##i##_##n##_##x(void) __asm__("l"#i"_"#n"_"#x);
  #define FLX_LABEL(n,i,x) x:\
    __asm__(".global l"#i"_"#n"_"#x);\
    __asm__("l"#i"_"#n"_"#x":");\
    __asm__(""::"g"(&&x));
  #define FLX_FARTARGET(n,i,x) (void*)&f##i##_##n##_##x
  #define FLX_END_SWITCH
#else
  #define FLX_START_SWITCH switch(pc){case 0:;
  #define FLX_SET_PC(x) pc=x;
  #define FLX_CASE_LABEL(x) case x:;
  #define FLX_DECLARE_LABEL(n,i,x)
  #define FLX_LABEL(n,i,x) case n: x:;
  #define FLX_FARTARGET(n,i,x) n
  #define FLX_END_SWITCH default: throw flx_switch_failure_t(); }
#endif

#define FLX_RETURN \
{ \
  con_t *tmp = _caller; \
  _caller = 0; \
  return tmp; \
}

#define FLX_NEWP(x) new(*PTF gc,x##_ptr_map)x

#define FLX_FINALISER(x) \
static void x##_finaliser(collector_t *, void *p){\
  ((x*)p)->~x();\
}

#if FLX_USE_REGPARM3 && FLX_HAVE_GNU_X86
#define FLX_REGPARM __attribute__((regparm(3)))
#else
#define FLX_REGPARM
#endif

#if FLX_PTF_STATIC_STRUCT
#define FLX_FMEM_INIT_ONLY
#define FLX_FMEM_INIT :
#define FLX_FPAR_PASS_ONLY
#define FLX_FPAR_PASS
#define FLX_APAR_PASS_ONLY
#define FLX_APAR_PASS
#define _PTF _ptf.
#define _PTFV
#define FLX_PASS_PTF 0
#define FLX_EAT_PTF(x)
#define FLX_DEF_THREAD_FRAME thread_frame_t ptf;
#elif FLX_PTF_STATIC_POINTER
#define FLX_FMEM_INIT_ONLY
#define FLX_FMEM_INIT :
#define FLX_FPAR_PASS_ONLY
#define FLX_FPAR_PASS
#define FLX_APAR_PASS_ONLY
#define FLX_APAR_PASS
#define _PTF _ptf->
#define _PTFV
#define FLX_PASS_PTF 0
#define FLX_EAT
#define FLX_DEF_THREAD_FRAME thread_frame_t *ptf=0;
#else
#define FLX_FMEM_INIT_ONLY : ptf(_ptf)
#define FLX_FMEM_INIT : ptf(_ptf),
#define FLX_FPAR_PASS_ONLY ptf
#define FLX_FPAR_PASS ptf,
#define FLX_APAR_PASS_ONLY _ptf
#define FLX_APAR_PASS _ptf,
#define _PTF _ptf->
#define _PTFV _ptf
#define FLX_PASS_PTF 1
#define FLX_EAT_PTF(x) x
#define FLX_DEF_THREAD_FRAME
#endif

#if FLX_PTF_STATIC_STRUCT
#define FLX_FRAME_WRAPPERS(mname) \
extern "C" thread_frame_t *create_thread_frame(\
  collector_t *gc\
) {\
  ptf.gc = gc;\
  return &ptf;\
}
#elif FLX_PTF_STATIC_POINTER
#define FLX_FRAME_WRAPPERS(mname) \
extern "C" thread_frame_t *create_thread_frame(\
  collector_t *gc\
) {\
  mname::thread_frame_t *p = new(*gc,mname::thread_frame_t_ptr_map) mname::thread_frame_t(gc);\
  ptf = p;\
  return p;\
}
#else
#define FLX_FRAME_WRAPPERS(mname) \
extern "C" FLX_EXPORT mname::thread_frame_t *create_thread_frame(\
  collector_t *gc\
) {\
  mname::thread_frame_t *p = new(*gc,mname::thread_frame_t_ptr_map) mname::thread_frame_t(gc);\
  return p;\
}
#endif

#if FLX_PTF_STATIC_STRUCT
#define FLX_START_WRAPPER(mname,x)\
extern "C" con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  return (new(*ptf->gc,mname::x##_ptr_map) \
    mname::x()) ->call(0);\
}
#elif FLX_PTF_STATIC_POINTER
#define FLX_START_WRAPPER(mname,x)\
extern "C" con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  return (new(*ptf->gc,mname::x##_ptr_map) \
    mname::x()) ->call(0);\
}
#else
#define FLX_START_WRAPPER(mname,x)\
extern "C" FLX_EXPORT con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  return (new(*ptf->gc,mname::x##_ptr_map) \
    mname::x(ptf)) ->call(0);\
}
#endif

#if FLX_PTF_STATIC_STRUCT
#define FLX_STACK_START_WRAPPER(mname,x)\
extern "C" con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  mname::x().stack_call();\
  return 0;\
}
#elif FLX_PTF_STATIC_POINTER
#define FLX_STACK_START_WRAPPER(mname,x)\
extern "C" con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  mname::x().stack_call();\
  return 0;\
}
#else
#define FLX_STACK_START_WRAPPER(mname,x)\
extern "C" FLX_EXPORT con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  mname::x(ptf).stack_call();\
  return 0;\
}
#endif

#if FLX_PTF_STATIC_STRUCT
#define FLX_C_START_WRAPPER(mname,x)\
extern "C" con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  mname::x();\
  return 0;\
}
#elif FLX_PTF_STATIC_POINTER
#define FLX_C_START_WRAPPER(mname,x)\
extern "C" con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  mname::x();\
  return 0;\
}
#else
#define FLX_C_START_WRAPPER(mname,x)\
extern "C" FLX_EXPORT con_t *flx_start(\
  mname::thread_frame_t *ptf,\
  int argc,\
  char **argv,\
  FILE *stdin_,\
  FILE *stdout_,\
  FILE *stderr_\
) {\
  ptf->argc = argc;\
  ptf->argv = argv;\
  ptf->flx_stdin = stdin_;\
  ptf->flx_stdout = stdout_;\
  ptf->flx_stderr = stderr_;\
  mname::x(ptf);\
  return 0;\
}
#endif

#endif

---