cdocs/html/eval__cps_8h_source.html

/*

    Copyright 2018, 2020, 2021, 2022 Joel Svensson  svenssonjoel@yahoo.se


    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.


    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.


    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef EVAL_CPS_H_

#define EVAL_CPS_H_


#include "lbm_types.h"

#include "stack.h"

#include "lbm_channel.h"

#include "lbm_flat_value.h"


#ifdef __cplusplus

extern "C" {

#endif


#define EVAL_CPS_STATE_NONE    0

#define EVAL_CPS_STATE_PAUSED  1

#define EVAL_CPS_STATE_RUNNING 2

#define EVAL_CPS_STATE_KILL    4

#define EVAL_CPS_STATE_DEAD    8

#define EVAL_CPS_STATE_RESET   16


#define EVAL_CPS_DEFAULT_MAILBOX_SIZE 10


// Make sure the flags fit in an u28. (do not go beyond 27 flags)

#define EVAL_CPS_CONTEXT_FLAG_NOTHING               (uint32_t)0x00

#define EVAL_CPS_CONTEXT_FLAG_TRAP                  (uint32_t)0x01

#define EVAL_CPS_CONTEXT_FLAG_CONST                 (uint32_t)0x02

#define EVAL_CPS_CONTEXT_FLAG_CONST_SYMBOL_STRINGS  (uint32_t)0x04

#define EVAL_CPS_CONTEXT_FLAG_INCREMENTAL_READ      (uint32_t)0x08

#define EVAL_CPS_CONTEXT_FLAG_TRAP_UNROLL_RETURN    (uint32_t)0x10

#define EVAL_CPS_CONTEXT_READER_FLAGS_MASK          (EVAL_CPS_CONTEXT_FLAG_CONST | EVAL_CPS_CONTEXT_FLAG_CONST_SYMBOL_STRINGS | EVAL_CPS_CONTEXT_FLAG_INCREMENTAL_READ)


#define LBM_THREAD_STATE_READY      (uint32_t)0

#define LBM_THREAD_STATE_BLOCKED    (uint32_t)1

#define LBM_THREAD_STATE_TIMEOUT    (uint32_t)2

#define LBM_THREAD_STATE_SLEEPING   (uint32_t)4

#define LBM_THREAD_STATE_RECV_BL    (uint32_t)8

#define LBM_THREAD_STATE_RECV_TO    (uint32_t)16

#define LBM_THREAD_STATE_GC_BIT     (uint32_t)(1 << 31)


#define LBM_IS_STATE_TIMEOUT(X) (X & (LBM_THREAD_STATE_TIMEOUT | LBM_THREAD_STATE_RECV_TO))

#define LBM_IS_STATE_WAKE_UP_WAKABLE(X) (X & (LBM_THREAD_STATE_SLEEPING | LBM_IS_STATE_TIMEOUT(X)))

#define LBM_IS_STATE_UNBLOCKABLE(X) (X & (LBM_THREAD_STATE_BLOCKED | LBM_THREAD_STATE_TIMEOUT))

#define LBM_IS_STATE_RECV(X) (X & (LBM_THREAD_STATE_RECV_BL | LBM_THREAD_STATE_RECV_TO))

typedef struct eval_context_s{

  lbm_value program;

  lbm_value curr_exp;

  lbm_value curr_env;

  lbm_value *mailbox;    /* Message passing mailbox */

  uint32_t  mailbox_size;

  uint32_t  num_mail;    /* Number of messages in mailbox */

  uint32_t  flags;

  lbm_value r;

  char *error_reason;

  bool  app_cont;

  lbm_stack_t K;

  lbm_uint timestamp;

  lbm_uint sleep_us;

  uint32_t state;

  char *name;

  lbm_cid id;

  lbm_cid parent;

  /* while reading */

  lbm_int row0;

  lbm_int row1;

  /* List structure */

  struct eval_context_s *prev;

  struct eval_context_s *next;

} eval_context_t;


typedef enum {

  LBM_EVENT_FOR_HANDLER = 0,

  LBM_EVENT_UNBLOCK_CTX,

  LBM_EVENT_DEFINE,

  LBM_EVENT_RUN_USER_CALLBACK,

} lbm_event_type_t;


typedef struct {

  lbm_event_type_t type;

  lbm_uint parameter;

  lbm_uint buf_ptr;

  lbm_uint buf_len;

} lbm_event_t;


typedef lbm_value (*fundamental_fun)(lbm_value *, lbm_uint, eval_context_t*);


extern const fundamental_fun fundamental_table[];


typedef void (*ctx_fun)(eval_context_t *, void*, void*);


/* Common interface */

lbm_value eval_cps_get_env(void);


/* Concurrent interface */

int lbm_eval_init(void);

void lbm_set_eval_step_quota(uint32_t quota);

bool lbm_eval_init_events(unsigned int num_events);

lbm_cid lbm_get_event_handler_pid(void);

void lbm_set_event_handler_pid(lbm_cid pid);

bool lbm_event_handler_exists(void);

bool lbm_event_define(lbm_value key, lbm_flat_value_t *fv);

bool lbm_event_run_user_callback(void *arg);

bool lbm_event(lbm_flat_value_t *fv);

bool lbm_event_unboxed(lbm_value unboxed);

bool lbm_event_queue_is_empty(void);

int lbm_remove_done_ctx(lbm_cid cid, lbm_value *v);


lbm_cid lbm_eval_program(lbm_value lisp);

lbm_cid lbm_eval_program_ext(lbm_value lisp, unsigned int stack_size);


void lbm_run_eval(void);

void lbm_reset_eval(void);

void lbm_pause_eval(void);

void lbm_pause_eval_with_gc(uint32_t num_free);

void lbm_continue_eval(void);

void lbm_kill_eval(void);

uint32_t lbm_get_eval_state(void);

void lbm_set_error_reason(char *error_str);

void lbm_set_error_suspect(lbm_value suspect);

void lbm_critical_error(void);

void lbm_set_user_callback(void (*fptr)(void *));

void lbm_set_critical_error_callback(void (*fptr)(void));

lbm_cid lbm_create_ctx(lbm_value program, lbm_value env, lbm_uint stack_size, char *name);

void lbm_block_ctx_from_extension(void);

void lbm_block_ctx_from_extension_timeout(float s);

void lbm_undo_block_ctx_from_extension(void);

bool lbm_unblock_ctx(lbm_cid cid, lbm_flat_value_t *fv);

bool lbm_unblock_ctx_r(lbm_cid cid);

bool lbm_unblock_ctx_unboxed(lbm_cid cid, lbm_value unboxed);

void lbm_running_iterator(ctx_fun f, void*, void*);

void lbm_blocked_iterator(ctx_fun f, void*, void*);

void lbm_toggle_verbose(void);

void lbm_set_verbose(bool verbose);

void lbm_set_usleep_callback(void (*fptr)(uint32_t));

void lbm_set_timestamp_us_callback(uint32_t (*fptr)(void));

void lbm_set_ctx_done_callback(void (*fptr)(eval_context_t *));

void lbm_set_printf_callback(int (*prnt)(const char*, ...));

void lbm_set_dynamic_load_callback(bool (*fptr)(const char *, const char **));

lbm_cid lbm_get_current_cid(void);


eval_context_t *lbm_get_current_context(void);


bool lbm_mailbox_change_size(eval_context_t *ctx, lbm_uint new_size);


bool create_string_channel(char *str, lbm_value *res);


bool lift_char_channel(lbm_char_channel_t *ch, lbm_value *res);


lbm_flash_status request_flash_storage_cell(lbm_value val, lbm_value *res);

  //bool lift_array_flash(lbm_value flash_cell, char *data, lbm_uint num_elt);


lbm_value lbm_find_receiver_and_send(lbm_cid cid, lbm_value msg);

int lbm_perform_gc(void);

void lbm_request_gc(void);

#ifdef __cplusplus

}

#endif

#endif