Private void Init_Boolean() { The_True_Object = Allocate(Boolean_Size); The_False_Object = Allocate(Boolean_Size); Get_Type(The_True_Object) = Boolean_Type; Get_Type_Name(The_True_Object) = "Boolean_Type/t"; Get_Type(The_False_Object) = Boolean_Type; Get_Type_Name(The_False_Object) = "Boolean_Type/f"; }
*/ void Dump_Stack(REBINT dsf, REBINT dsp) /* ***********************************************************************/ { REBINT n; REBINT m; REBVAL *args; if (dsf == 0) { dsf = DSF; dsp = DSP; } m = dsp - dsf - DSF_SIZE; Debug_Fmt(BOOT_STR(RS_STACK, 1), dsp, Get_Word_Name(DSF_WORD(dsf)), m, Get_Type_Name(DSF_FUNC(dsf))); if (dsf > 0) { if (ANY_FUNC(DSF_FUNC(dsf))) { args = BLK_HEAD(VAL_FUNC_ARGS(DSF_FUNC(dsf))); m = SERIES_TAIL(VAL_FUNC_ARGS(DSF_FUNC(dsf))); for (n = 1; n < m; n++) Debug_Fmt("\t%s: %72r", Get_Word_Name(args+n), DSF_ARGS(dsf, n)); } //Debug_Fmt(Str_Stack[2], PRIOR_DSF(dsf)); if (PRIOR_DSF(dsf) > 0) Dump_Stack(PRIOR_DSF(dsf), dsf-1); } //for (n = 1; n <= 2; n++) { // Debug_Fmt(" ARG%d: %s %r", n, Get_Type_Name(DSF_ARGS(dsf, n)), DSF_ARGS(dsf, n)); //} }
*/ void Dump_Values(REBVAL *vp, REBCNT count) /* ** Print out values in raw hex; If memory is corrupted ** this function still needs to work. ** ***********************************************************************/ { REBYTE buf[2048]; REBYTE *cp; REBCNT l, n; REBCNT *bp = (REBCNT*)vp; REBYTE *type; cp = buf; for (l = 0; l < count; l++) { cp = Form_Hex_Pad(cp, (REBCNT) l, 4); *cp++ = ':'; *cp++ = ' '; type = Get_Type_Name((REBVAL*)bp); for (n = 0; n < 11; n++) { if (*type) *cp++ = *type++; else *cp++ = ' '; } *cp++ = ' '; for (n = 0; n < 4; n++) { cp = Form_Hex_Pad(cp, *bp++, 8); *cp++ = ' '; } *cp = 0; Debug_Str(buf); cp = buf; } }
xx*/ void Dump_Block_Raw(REBSER *series, int depth, int max_depth) /* ***********************************************************************/ { REBVAL *val; REBCNT n; REBYTE *str; if (!IS_BLOCK_SERIES(series) || depth > max_depth) return; for (n = 0, val = BLK_HEAD(series); NOT_END(val); val++, n++) { Debug_Chars(' ', depth * 4); if (IS_BLOCK(val)) { Debug_Fmt("%3d: [%s] len: %d", n, Get_Type_Name(val), VAL_TAIL(val)); Dump_Block_Raw(VAL_SERIES(val), depth + 1, max_depth); } else { str = ""; if (ANY_WORD(val)) str = Get_Word_Name(val); Debug_Fmt("%3d: [%s] %s", n, Get_Type_Name(val), str); } } //if (depth == 2) Input_Str(); }
// // Dump_Values: C // // Print values in raw hex; If memory is corrupted this still needs to work. // void Dump_Values(RELVAL *vp, REBCNT count) { REBYTE buf[2048]; REBYTE *cp; REBCNT l, n; REBCNT *bp = (REBCNT*)vp; const REBYTE *type; cp = buf; for (l = 0; l < count; l++) { REBVAL *val = cast(REBVAL*, bp); cp = Form_Hex_Pad(cp, l, 8); *cp++ = ':'; *cp++ = ' '; type = Get_Type_Name((REBVAL*)bp); for (n = 0; n < 11; n++) { if (*type) *cp++ = *type++; else *cp++ = ' '; } *cp++ = ' '; for (n = 0; n < sizeof(REBVAL) / sizeof(REBCNT); n++) { cp = Form_Hex_Pad(cp, *bp++, 8); *cp++ = ' '; } n = 0; if (IS_WORD(val) || IS_GET_WORD(val) || IS_SET_WORD(val)) { const REBYTE *name = STR_HEAD(VAL_WORD_SPELLING(val)); n = snprintf( s_cast(cp), sizeof(buf) - (cp - buf), " (%s)", cs_cast(name) ); } *(cp + n) = 0; Debug_Str(s_cast(buf)); cp = buf; } }
xx*/ void Dump_Frame(REBSER *frame, REBINT limit) /* ***********************************************************************/ { REBINT n; REBVAL *values = FRM_VALUES(frame); REBVAL *words = FRM_WORDS(frame); if (limit == -1 || limit > (REBINT)SERIES_TAIL(frame)) limit = SERIES_TAIL(frame); Debug_Fmt("Frame: %x len = %d", frame, SERIES_TAIL(frame)); for (n = 0; n < limit; n++, values++, words++) { Debug_Fmt(" %02d: %s (%s) [%s]", n, Get_Sym_Name(VAL_BIND_SYM(words)), Get_Sym_Name(VAL_BIND_CANON(words)), Get_Type_Name(values) ); } if (limit >= (REBINT)SERIES_TAIL(frame) && NOT_END(words)) Debug_Fmt("** Word list not terminated! Type: %d, Tail: %d", VAL_TYPE(words), SERIES_TAIL(frame)); }
std::string cBackground::Get_Type_Name(void) const { return Get_Type_Name(m_type); }