//
// Bind_Values_Core: C
//
// Bind words in an array of values terminated with END
// to a specified context. See warnings on the functions like
// Bind_Values_Deep() about not passing just a singular REBVAL.
//
// NOTE: If types are added, then they will be added in "midstream". Only
// bindings that come after the added value is seen will be bound.
//
void Bind_Values_Core(
RELVAL *head,
REBCTX *context,
REBU64 bind_types,
REBU64 add_midstream_types,
REBFLGS flags // see %sys-core.h for BIND_DEEP, etc.
) {
struct Reb_Binder binder;
INIT_BINDER(&binder);
// Via the global hash table, each spelling of the word can find the
// canon form of the word. Associate that with an index number to signal
// a binding should be created to this context (at that index.)
REBCNT index = 1;
REBVAL *key = CTX_KEYS_HEAD(context);
for (; index <= CTX_LEN(context); key++, index++)
if (!GET_VAL_FLAG(key, TYPESET_FLAG_UNBINDABLE))
Add_Binder_Index(&binder, VAL_KEY_CANON(key), index);
Bind_Values_Inner_Loop(
&binder, head, context, bind_types, add_midstream_types, flags
);
// Reset all the binder indices to zero, balancing out what was added.
key = CTX_KEYS_HEAD(context);
for (; NOT_END(key); key++)
Remove_Binder_Index(&binder, VAL_KEY_CANON(key));
SHUTDOWN_BINDER(&binder);
}
//
// RL_Words_Of_Object: C
//
// Returns information about the object.
//
// Returns:
// Returns an array of words used as fields of the object.
// Arguments:
// obj - object pointer (e.g. from RXA_OBJECT)
// Notes:
// Returns a word array similar to MAP_WORDS().
// The array is allocated with OS_ALLOC. You can OS_FREE it any time.
//
RL_API u32 *RL_Words_Of_Object(REBSER *obj)
{
REBCNT index;
u32 *syms;
REBVAL *key;
REBCTX *context = AS_CONTEXT(obj);
key = CTX_KEYS_HEAD(context);
// We don't include hidden keys (e.g. SELF), but terminate by 0.
// Conservative estimate that there are no hidden keys, add one.
//
syms = OS_ALLOC_N(u32, CTX_LEN(context) + 1);
index = 0;
for (; NOT_END(key); key++) {
if (GET_VAL_FLAG(key, TYPESET_FLAG_HIDDEN))
continue;
syms[index] = VAL_TYPESET_CANON(key);
index++;
}
syms[index] = SYM_0; // Null terminate
return syms;
}
//
// Get_Object: C
//
// Get an instance variable from an ANY-CONTEXT! value.
//
REBVAL *Get_Object(const REBVAL *any_context, REBCNT index)
{
REBCTX *context = VAL_CONTEXT(any_context);
assert(GET_ARR_FLAG(CTX_VARLIST(context), ARRAY_FLAG_CONTEXT_VARLIST));
assert(index <= CTX_LEN(context));
return CTX_VAR(context, index);
}
//
// In_Object: C
//
// Get value from nested list of objects. List is null terminated.
// Returns object value, else returns 0 if not found.
//
REBVAL *In_Object(REBCTX *base, ...)
{
REBVAL *context = NULL;
REBCNT n;
va_list va;
va_start(va, base);
while ((n = va_arg(va, REBCNT))) {
if (n > CTX_LEN(base)) {
va_end(va);
return NULL;
}
context = CTX_VAR(base, n);
if (!ANY_CONTEXT(context)) {
va_end(va);
return NULL;
}
base = VAL_CONTEXT(context);
}
va_end(va);
return context;
}
//
// Get_Field: C
//
// Get an instance variable from an object series.
//
REBVAL *Get_Field(REBCTX *context, REBCNT index)
{
assert(index <= CTX_LEN(context));
return CTX_VAR(context, index);
}
//
// Get_Field_Name: C
//
// Get the name of a field of an object.
//
const REBYTE *Get_Field_Name(REBCTX *context, REBCNT index)
{
assert(index <= CTX_LEN(context));
return Get_Sym_Name(CTX_KEY_SYM(context, index));
}
//
// Bind_Values_Inner_Loop: C
//
// Bind_Values_Core() sets up the binding table and then calls
// this recursive routine to do the actual binding.
//
static void Bind_Values_Inner_Loop(
struct Reb_Binder *binder,
RELVAL *head,
REBCTX *context,
REBU64 bind_types, // !!! REVIEW: force word types low enough for 32-bit?
REBU64 add_midstream_types,
REBFLGS flags
) {
RELVAL *value = head;
for (; NOT_END(value); value++) {
REBU64 type_bit = FLAGIT_KIND(VAL_TYPE(value));
if (type_bit & bind_types) {
REBSTR *canon = VAL_WORD_CANON(value);
REBCNT n = Try_Get_Binder_Index(binder, canon);
if (n != 0) {
assert(n <= CTX_LEN(context));
// We're overwriting any previous binding, which may have
// been relative.
//
CLEAR_VAL_FLAG(value, VALUE_FLAG_RELATIVE);
SET_VAL_FLAG(value, WORD_FLAG_BOUND);
INIT_WORD_CONTEXT(value, context);
INIT_WORD_INDEX(value, n);
}
else if (type_bit & add_midstream_types) {
//
// Word is not in context, so add it if option is specified
//
Expand_Context(context, 1);
Append_Context(context, value, 0);
Add_Binder_Index(binder, canon, VAL_WORD_INDEX(value));
}
}
else if (ANY_ARRAY(value) && (flags & BIND_DEEP)) {
Bind_Values_Inner_Loop(
binder,
VAL_ARRAY_AT(value),
context,
bind_types,
add_midstream_types,
flags
);
}
else if (
IS_FUNCTION(value)
&& IS_FUNCTION_INTERPRETED(value)
&& (flags & BIND_FUNC)
) {
// !!! Likely-to-be deprecated functionality--rebinding inside the
// content of an already formed function. :-/
//
Bind_Values_Inner_Loop(
binder,
VAL_FUNC_BODY(value),
context,
bind_types,
add_midstream_types,
flags
);
}
}
}
//
// RL_Do_String: C
//
// Load a string and evaluate the resulting block.
//
// Returns:
// The datatype of the result if a positive number (or 0 if the
// type has no representation in the "RXT" API). An error code
// if it's a negative number. Two negative numbers are reserved
// for non-error conditions: -1 for halting (e.g. Escape), and
// -2 is reserved for exiting with exit_status set.
//
// Arguments:
// text - A null terminated UTF-8 (or ASCII) string to transcode
// into a block and evaluate.
// flags - set to zero for now
// result - value returned from evaluation, if NULL then result
// will be returned on the top of the stack
//
// Notes:
// This API was from before Rebol's open sourcing and had little
// vetting and few clients. The one client it did have was the
// "sample" console code (which wound up being the "only"
// console code for quite some time).
//
RL_API int RL_Do_String(
int *exit_status,
const REBYTE *text,
REBCNT flags,
RXIARG *out
) {
REBARR *code;
struct Reb_State state;
REBCTX *error;
REBVAL result;
VAL_INIT_WRITABLE_DEBUG(&result);
// assumes it can only be run at the topmost level where
// the data stack is completely empty.
//
assert(DSP == 0);
PUSH_UNHALTABLE_TRAP(&error, &state);
// The first time through the following code 'error' will be NULL, but...
// `fail` can longjmp here, so 'error' won't be NULL *if* that happens!
if (error) {
// Save error for WHY?
REBVAL *last = Get_System(SYS_STATE, STATE_LAST_ERROR);
Val_Init_Error(last, error);
if (ERR_NUM(error) == RE_HALT)
return -1; // !!! Revisit hardcoded #
if (out)
Value_To_RXI(out, last);
else
DS_PUSH(last);
return -ERR_NUM(error);
}
code = Scan_Source(text, LEN_BYTES(text));
PUSH_GUARD_ARRAY(code);
// Bind into lib or user spaces?
if (flags) {
// Top words will be added to lib:
Bind_Values_Set_Midstream_Shallow(ARR_HEAD(code), Lib_Context);
Bind_Values_Deep(ARR_HEAD(code), Lib_Context);
}
else {
REBCTX *user = VAL_CONTEXT(Get_System(SYS_CONTEXTS, CTX_USER));
REBVAL vali;
VAL_INIT_WRITABLE_DEBUG(&vali);
SET_INTEGER(&vali, CTX_LEN(user) + 1);
Bind_Values_All_Deep(ARR_HEAD(code), user);
Resolve_Context(user, Lib_Context, &vali, FALSE, FALSE);
}
if (Do_At_Throws(&result, code, 0)) {
DROP_GUARD_ARRAY(code);
if (
IS_FUNCTION_AND(&result, FUNC_CLASS_NATIVE) && (
VAL_FUNC_CODE(&result) == &N_quit
|| VAL_FUNC_CODE(&result) == &N_exit
)
) {
CATCH_THROWN(&result, &result);
DROP_TRAP_SAME_STACKLEVEL_AS_PUSH(&state);
*exit_status = Exit_Status_From_Value(&result);
return -2; // Revisit hardcoded #
}
fail (Error_No_Catch_For_Throw(&result));
}
DROP_GUARD_ARRAY(code);
DROP_TRAP_SAME_STACKLEVEL_AS_PUSH(&state);
if (out)
Value_To_RXI(out, &result);
else
DS_PUSH(&result);
return Reb_To_RXT[VAL_TYPE_0(&result)];
}
//
// Do_String()
//
// This is a version of a routine that was offered by the RL_Api, which has
// been expanded here in order to permit the necessary customizations for
// interesting REPL behavior w.r.t. binding, error handling, and response
// to throws.
//
// !!! Now that this code has been moved into the host, the convoluted
// integer-return-scheme can be eliminated and the code integrated more
// clearly into the surrounding calls.
//
int Do_String(
int *exit_status,
REBVAL *out,
const REBYTE *text,
REBOOL at_breakpoint
) {
struct Reb_State state;
REBCTX *error;
// Breakpoint REPLs are nested, and we may wish to jump out of them to
// the topmost level via a HALT. However, all other errors need to be
// confined, so that if one is doing evaluations during the pause of
// a breakpoint an error doesn't "accidentally resume" by virtue of
// jumping the stack out of the REPL.
//
// The topmost layer REPL, however, needs to catch halts in order to
// keep control and not crash out.
//
if (at_breakpoint)
PUSH_TRAP(&error, &state);
else
PUSH_UNHALTABLE_TRAP(&error, &state);
// The first time through the following code 'error' will be NULL, but...
// `fail` can longjmp here, so 'error' won't be NULL *if* that happens!
if (error) {
// Save error for WHY?
REBVAL *last = Get_System(SYS_STATE, STATE_LAST_ERROR);
if (ERR_NUM(error) == RE_HALT) {
assert(!at_breakpoint);
return -1; // !!! Revisit hardcoded #
}
Val_Init_Error(out, error);
*last = *out;
return -cast(REBINT, ERR_NUM(error));
}
REBARR *code = Scan_UTF8_Managed(text, LEN_BYTES(text));
// Where code ends up being bound when loaded at the REPL prompt should
// be more generally configurable. (It may be, for instance, that one
// wants to run something with it not bound at all.) Such choices
// must come from this REPL host...not from the interpreter itself.
{
// First the scanned code is bound into the user context with a
// fallback to the lib context.
//
// !!! This code is very old, and is how the REPL has bound since
// R3-Alpha. It comes from RL_Do_String, but should receive a modern
// review of why it's written exactly this way.
//
REBCTX *user_ctx = VAL_CONTEXT(Get_System(SYS_CONTEXTS, CTX_USER));
REBVAL vali;
SET_INTEGER(&vali, CTX_LEN(user_ctx) + 1);
Bind_Values_All_Deep(ARR_HEAD(code), user_ctx);
Resolve_Context(user_ctx, Lib_Context, &vali, FALSE, FALSE);
// If we're stopped at a breakpoint, the REPL should have a concept
// of what stack level it is inspecting (conveyed by the |#|>> in the
// prompt). This does a binding pass using the function for that
// stack level, just the way a body is bound during Make_Function()
//
if (at_breakpoint) {
REBVAL level;
SET_INTEGER(&level, HG_Stack_Level);
REBFRM *frame = Frame_For_Stack_Level(NULL, &level, FALSE);
assert(frame);
// Need to manage because it may be no words get bound into it,
// and we're not putting it into a FRAME! value, so it might leak
// otherwise if it's reified.
//
REBCTX *frame_ctx = Context_For_Frame_May_Reify_Managed(frame);
Bind_Values_Deep(ARR_HEAD(code), frame_ctx);
}
// !!! This was unused code that used to be in Do_String from
// RL_Api. It was an alternative path under `flags` which said
// "Bind into lib or user spaces?" and then "Top words will be
// added to lib". Is it relevant in any way?
//
/* Bind_Values_Set_Midstream_Shallow(ARR_HEAD(code), Lib_Context);
Bind_Values_Deep(ARR_HEAD(code), Lib_Context); */
}
if (Do_At_Throws(out, code, 0, SPECIFIED)) { // `code` will be GC protected
if (at_breakpoint) {
if (
IS_FUNCTION(out)
&& VAL_FUNC_DISPATCHER(out) == &N_resume
) {
//
// This means we're done with the embedded REPL. We want to
// resume and may be returning a piece of code that will be
// run by the finishing BREAKPOINT command in the target
// environment.
//
// We'll never return a halt, so we reuse -1 (in this very
// temporary scheme built on the very clunky historical REPL,
// which will not last much longer...fingers crossed.)
//
DROP_TRAP_SAME_STACKLEVEL_AS_PUSH(&state);
CATCH_THROWN(out, out);
*exit_status = -1;
return -1;
}
if (
IS_FUNCTION(out)
&& VAL_FUNC_DISPATCHER(out) == &N_quit
) {
//
// It would be frustrating if the system did not respond to
// a QUIT and forced you to do `resume/with [quit]`. So
// this is *not* caught, rather passed back up with the
// special -2 status code.
//
DROP_TRAP_SAME_STACKLEVEL_AS_PUSH(&state);
CATCH_THROWN(out, out);
*exit_status = -2;
return -2;
}
}
else {
// We are at the top level REPL, where we catch QUIT and for
// now, also EXIT as meaning you want to leave.
//
if (
IS_FUNCTION(out)
&& (
VAL_FUNC_DISPATCHER(out) == &N_quit
|| VAL_FUNC_DISPATCHER(out) == &N_exit
)
) {
DROP_TRAP_SAME_STACKLEVEL_AS_PUSH(&state);
CATCH_THROWN(out, out);
*exit_status = Exit_Status_From_Value(out);
return -2; // Revisit hardcoded #
}
}
fail (Error_No_Catch_For_Throw(out));
}
DROP_TRAP_SAME_STACKLEVEL_AS_PUSH(&state);
return 0;
}
