eval_cps.h

Go to the documentation of this file.

/*
    Copyright 2018, 2020 - 2025 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)0u
#define LBM_THREAD_STATE_BLOCKED    (uint32_t)1u
#define LBM_THREAD_STATE_TIMEOUT    (uint32_t)2u
#define LBM_THREAD_STATE_SLEEPING   (uint32_t)4u
#define LBM_THREAD_STATE_RECV_BL    (uint32_t)8u
#define LBM_THREAD_STATE_RECV_TO    (uint32_t)16u
#define LBM_THREAD_STATE_GC_BIT     (uint32_t)(1u << 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);
void lbm_add_eval_symbols(void);
 
/* Concurrent interface */
int lbm_eval_init(void);
#ifdef LBM_USE_TIME_QUOTA
void lbm_set_eval_time_quota(uint32_t quota);
#else
void lbm_set_eval_step_quota(uint32_t quota);
#endif
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_all_ctxs_iterator(ctx_fun f, void *arg1, void *arg2);
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_hide_trapped_error(bool hide);
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);
void lbm_surrender_quota(void);
bool lbm_mailbox_change_size(eval_context_t *ctx, lbm_uint new_size);
 
bool create_string_channel(char *str, lbm_value *res, lbm_value dep);
 
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);
 
bool 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