eval_cps.h

Go to the documentation of this file.

/*
    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_INIT    0
#define EVAL_CPS_STATE_PAUSED  1
#define EVAL_CPS_STATE_RUNNING 2
#define EVAL_CPS_STATE_STEP    3
#define EVAL_CPS_STATE_KILL    4
 
#define EVAL_CPS_DEFAULT_MAILBOX_SIZE 10
 
#define EVAL_CPS_CONTEXT_FLAG_NOTHING               (uint32_t)0x0
#define EVAL_CPS_CONTEXT_FLAG_TRAP                  (uint32_t)0x1
#define EVAL_CPS_CONTEXT_FLAG_CONST                 (uint32_t)0x2
#define EVAL_CPS_CONTEXT_FLAG_CONST_SYMBOL_STRINGS  (uint32_t)0x4
#define EVAL_CPS_CONTEXT_FLAG_INCREMENTAL_READ      (uint32_t)0x8
  
#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)3
#define LBM_THREAD_STATE_GC_BIT    (uint32_t)(1 << 31)
  
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_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(lbm_flat_value_t *fv);
bool lbm_event_unboxed(lbm_value unboxed);
 
int lbm_remove_done_ctx(lbm_cid cid, lbm_value *v);
bool lbm_wait_ctx(lbm_cid cid, lbm_uint timeout_ms);
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_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_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_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);
 
#ifdef __cplusplus
}
#endif
#endif