/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 1998-2009. All Rights Reserved.
*
* The contents of this file are subject to the Erlang Public License,
* Version 1.1, (the "License"); you may not use this file except in
* compliance with the License. You should have received a copy of the
* Erlang Public License along with this software. If not, it can be
* retrieved online at http://www.erlang.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* %CopyrightEnd%
*/
/*
* Common utilities for the different types of db tables.
* Mostly matching etc.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "sys.h"
#include "erl_vm.h"
#include "global.h"
#include "erl_process.h"
#include "error.h"
#define ERTS_WANT_DB_INTERNAL__
#include "erl_db.h"
#include "bif.h"
#include "big.h"
#include "erl_binary.h"
#include "erl_db_util.h"
/*
** Flags for the guard bif's
*/
/* These are offsets from the DCOMP_* value */
#define DBIF_GUARD 1
#define DBIF_BODY 0
/* These are the DBIF flag bits corresponding to the DCOMP_* value.
* If a bit is set, the BIF is allowed in that context. */
#define DBIF_TABLE_GUARD (1 << (DCOMP_TABLE + DBIF_GUARD))
#define DBIF_TABLE_BODY (1 << (DCOMP_TABLE + DBIF_BODY))
#define DBIF_TRACE_GUARD (1 << (DCOMP_TRACE + DBIF_GUARD))
#define DBIF_TRACE_BODY (1 << (DCOMP_TRACE + DBIF_BODY))
#define DBIF_ALL \
DBIF_TABLE_GUARD | DBIF_TABLE_BODY | DBIF_TRACE_GUARD | DBIF_TRACE_BODY
/*
** Some convenience macros for stacks (DMC == db_match_compile)
*/
#define DMC_DEFAULT_SIZE 25
#define DMC_STACK_TYPE(Type) DMC_##Type##_stack
#define DMC_DECLARE_STACK_TYPE(Type) \
typedef struct DMC_STACK_TYPE(Type) { \
int pos; \
int siz; \
Type def[DMC_DEFAULT_SIZE]; \
Type *data; \
} DMC_STACK_TYPE(Type)
#define DMC_INIT_STACK(Name) \
(Name).pos = 0; (Name).siz = DMC_DEFAULT_SIZE; (Name).data = (Name).def
#define DMC_STACK_DATA(Name) (Name).data
#define DMC_STACK_NUM(Name) (Name).pos
#define DMC_PUSH(On, What) \
do { \
if ((On).pos >= (On).siz) { \
(On).siz *= 2; \
(On).data \
= (((On).def == (On).data) \
? memcpy(erts_alloc(ERTS_ALC_T_DB_MC_STK, \
(On).siz*sizeof(*((On).data))), \
(On).def, \
DMC_DEFAULT_SIZE*sizeof(*((On).data))) \
: erts_realloc(ERTS_ALC_T_DB_MC_STK, \
(void *) (On).data, \
(On).siz*sizeof(*((On).data)))); \
} \
(On).data[(On).pos++] = What; \
} while (0)
#define DMC_POP(From) (From).data[--(From).pos]
#define DMC_TOP(From) (From).data[(From).pos - 1]
#define DMC_EMPTY(Name) ((Name).pos == 0)
#define DMC_PEEK(On, At) (On).data[At]
#define DMC_POKE(On, At, Value) ((On).data[At] = (Value))
#define DMC_CLEAR(Name) (Name).pos = 0
#define DMC_FREE(Name) \
do { \
if ((Name).def != (Name).data) \
erts_free(ERTS_ALC_T_DB_MC_STK, (Name).data); \
} while (0)
static ERTS_INLINE Process *
get_proc(Process *cp, Uint32 cp_locks, Eterm id, Uint32 id_locks)
{
Process *proc = erts_pid2proc(cp, cp_locks, id, id_locks);
if (!proc && is_atom(id))
proc = erts_whereis_process(cp, cp_locks, id, id_locks, 0);
return proc;
}
static Eterm
set_tracee_flags(Process *tracee_p, Eterm tracer, Uint d_flags, Uint e_flags) {
Eterm ret;
Uint flags;
if (tracer == NIL) {
flags = tracee_p->trace_flags & ~TRACEE_FLAGS;
} else {
flags = ((tracee_p->trace_flags & ~d_flags) | e_flags);
if (! flags) tracer = NIL;
}
ret = tracee_p->tracer_proc != tracer || tracee_p->trace_flags != flags
? am_true : am_false;
tracee_p->tracer_proc = tracer;
tracee_p->trace_flags = flags;
return ret;
}
/*
** Assuming all locks on tracee_p on entry
**
** Changes tracee_p->trace_flags and tracee_p->tracer_proc
** according to input disable/enable flags and tracer.
**
** Returns am_true|am_false on success, am_true if value changed,
** returns fail_term on failure. Fails if tracer pid or port is invalid.
*/
static Eterm
set_match_trace(Process *tracee_p, Eterm fail_term, Eterm tracer,
Uint d_flags, Uint e_flags) {
Eterm ret = fail_term;
Process *tracer_p;
ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCKS_ALL ==
erts_proc_lc_my_proc_locks(tracee_p));
if (is_internal_pid(tracer)
&& (tracer_p =
erts_pid2proc(tracee_p, ERTS_PROC_LOCKS_ALL,
tracer, ERTS_PROC_LOCKS_ALL))) {
if (tracee_p != tracer_p) {
ret = set_tracee_flags(tracee_p, tracer, d_flags, e_flags);
tracer_p->trace_flags |= tracee_p->trace_flags ? F_TRACER : 0;
erts_smp_proc_unlock(tracer_p, ERTS_PROC_LOCKS_ALL);
}
} else if (is_internal_port(tracer)) {
Port *tracer_port =
erts_id2port(tracer, tracee_p, ERTS_PROC_LOCKS_ALL);
if (tracer_port) {
if (! INVALID_TRACER_PORT(tracer_port, tracer)) {
ret = set_tracee_flags(tracee_p, tracer, d_flags, e_flags);
}
erts_smp_port_unlock(tracer_port);
}
} else {
ASSERT(is_nil(tracer));
ret = set_tracee_flags(tracee_p, tracer, d_flags, e_flags);
}
return ret;
}
/* Type checking... */
#define BOXED_IS_TUPLE(Boxed) is_arity_value(*boxed_val((Boxed)))
/*
**
** Types and enum's (compiled matches)
**
*/
/*
** match VM instructions
*/
typedef enum {
matchArray, /* Only when parameter is an array (DCOMP_TRACE) */
matchArrayBind, /* ------------- " ------------ */
matchTuple,
matchPushT,
matchPushL,
matchPop,
matchBind,
matchCmp,
matchEqBin,
matchEqFloat,
matchEqBig,
matchEqRef,
matchEq,
matchList,
matchSkip,
matchPushC,
matchConsA, /* Car is below Cdr */
matchConsB, /* Cdr is below Car (unusual) */
matchMkTuple,
matchCall0,
matchCall1,
matchCall2,
matchCall3,
matchPushV,
matchPushExpr, /* Push the whole expression we're matching ('$_') */
matchPushArrayAsList, /* Only when parameter is an Array and
not an erlang term (DCOMP_TRACE) */
matchPushArrayAsListU, /* As above but unknown size */
matchTrue,
matchOr,
matchAnd,
matchOrElse,
matchAndAlso,
matchJump,
matchSelf,
matchWaste,
matchReturn,
matchProcessDump,
matchDisplay,
matchIsSeqTrace,
matchSetSeqToken,
matchGetSeqToken,
matchSetReturnTrace,
matchSetExceptionTrace,
matchCatch,
matchEnableTrace,
matchDisableTrace,
matchEnableTrace2,
matchDisableTrace2,
matchTryMeElse,
matchCaller,
matchHalt,
matchSilent,
matchSetSeqTokenFake,
matchTrace2,
matchTrace3
} MatchOps;
/*
** Guard bif's
*/
typedef struct dmc_guard_bif {
Eterm name; /* atom */
void *biff;
/* BIF_RETTYPE (*biff)(); */
int arity;
Uint32 flags;
} DMCGuardBif;
/*
** Error information (for lint)
*/
/*
** Type declarations for stacks
*/
DMC_DECLARE_STACK_TYPE(Eterm);
DMC_DECLARE_STACK_TYPE(Uint);
DMC_DECLARE_STACK_TYPE(unsigned);
/*
** Data about the heap during compilation
*/
typedef struct DMCHeap {
int size;
unsigned def[DMC_DEFAULT_SIZE];
unsigned *data;
int used;
} DMCHeap;
/*
** Return values from sub compilation steps (guard compilation)
*/
typedef enum dmc_ret {
retOk,
retFail,
retRestart
} DMCRet;
/*
** Diverse context information
*/
typedef struct dmc_context {
int stack_need;
int stack_used;
ErlHeapFragment *save;
ErlHeapFragment *copy;
Eterm *matchexpr;
Eterm *guardexpr;
Eterm *bodyexpr;
int num_match;
int current_match;
int eheap_need;
Uint cflags;
int is_guard; /* 1 if in guard, 0 if in body */
int special; /* 1 if the head in the match was a single expression */
DMCErrInfo *err_info;
} DMCContext;
/*
**
** Global variables
**
*/
/*
** Internal
*/
/*
** The pseudo process used by the VM (pam).
*/
#define ERTS_DEFAULT_MS_HEAP_SIZE 128
typedef struct {
Process process;
Eterm *heap;
Eterm default_heap[ERTS_DEFAULT_MS_HEAP_SIZE];
} ErtsMatchPseudoProcess;
#ifdef ERTS_SMP
static erts_smp_tsd_key_t match_pseudo_process_key;
#else
static ErtsMatchPseudoProcess *match_pseudo_process;
#endif
static ERTS_INLINE void
cleanup_match_pseudo_process(ErtsMatchPseudoProcess *mpsp, int keep_heap)
{
if (mpsp->process.mbuf
|| mpsp->process.off_heap.mso
#ifndef HYBRID /* FIND ME! */
|| mpsp->process.off_heap.funs
#endif
|| mpsp->process.off_heap.externals) {
erts_cleanup_empty_process(&mpsp->process);
}
#ifdef DEBUG
else {
erts_debug_verify_clean_empty_process(&mpsp->process);
}
#endif
if (!keep_heap) {
if (mpsp->heap != &mpsp->default_heap[0]) {
/* Have to be done *after* call to erts_cleanup_empty_process() */
erts_free(ERTS_ALC_T_DB_MS_RUN_HEAP, (void *) mpsp->heap);
mpsp->heap = &mpsp->default_heap[0];
}
#ifdef DEBUG
else {
int i;
for (i = 0; i < ERTS_DEFAULT_MS_HEAP_SIZE; i++) {
#ifdef ARCH_64
mpsp->default_heap[i] = (Eterm) 0xdeadbeefdeadbeef;
#else
mpsp->default_heap[i] = (Eterm) 0xdeadbeef;
#endif
}
}
#endif
}
}
static ErtsMatchPseudoProcess *
create_match_pseudo_process(void)
{
ErtsMatchPseudoProcess *mpsp;
mpsp = (ErtsMatchPseudoProcess *)erts_alloc(ERTS_ALC_T_DB_MS_PSDO_PROC,
sizeof(ErtsMatchPseudoProcess));
erts_init_empty_process(&mpsp->process);
mpsp->heap = &mpsp->default_heap[0];
return mpsp;
}
static ERTS_INLINE ErtsMatchPseudoProcess *
get_match_pseudo_process(Process *c_p, Uint heap_size)
{
ErtsMatchPseudoProcess *mpsp;
#ifdef ERTS_SMP
mpsp = (ErtsMatchPseudoProcess *) c_p->scheduler_data->match_pseudo_process;
if (mpsp)
cleanup_match_pseudo_process(mpsp, 0);
else {
ASSERT(erts_smp_tsd_get(match_pseudo_process_key) == NULL);
mpsp = create_match_pseudo_process();
c_p->scheduler_data->match_pseudo_process = (void *) mpsp;
erts_smp_tsd_set(match_pseudo_process_key, (void *) mpsp);
}
ASSERT(mpsp == erts_smp_tsd_get(match_pseudo_process_key));
mpsp->process.scheduler_data = c_p->scheduler_data;
#else
mpsp = match_pseudo_process;
cleanup_match_pseudo_process(mpsp, 0);
#endif
if (heap_size > ERTS_DEFAULT_MS_HEAP_SIZE)
mpsp->heap = (Eterm *) erts_alloc(ERTS_ALC_T_DB_MS_RUN_HEAP,
heap_size*sizeof(Uint));
else {
ASSERT(mpsp->heap == &mpsp->default_heap[0]);
}
return mpsp;
}
#ifdef ERTS_SMP
static void
destroy_match_pseudo_process(void)
{
ErtsMatchPseudoProcess *mpsp;
mpsp = (ErtsMatchPseudoProcess *)erts_smp_tsd_get(match_pseudo_process_key);
if (mpsp) {
cleanup_match_pseudo_process(mpsp, 0);
erts_free(ERTS_ALC_T_DB_MS_PSDO_PROC, (void *) mpsp);
erts_smp_tsd_set(match_pseudo_process_key, (void *) NULL);
}
}
#endif
static
void
match_pseudo_process_init(void)
{
#ifdef ERTS_SMP
erts_smp_tsd_key_create(&match_pseudo_process_key);
erts_smp_install_exit_handler(destroy_match_pseudo_process);
#else
match_pseudo_process = create_match_pseudo_process();
#endif
}
void
erts_match_set_release_result(Process* c_p)
{
(void) get_match_pseudo_process(c_p, 0); /* Clean it up */
}
/* The trace control word. */
static erts_smp_atomic_t trace_control_word;
Eterm
erts_ets_copy_object(Eterm obj, Process* to)
{
Uint size = size_object(obj);
Eterm* hp = HAlloc(to, size);
Eterm res;
res = copy_struct(obj, size, &hp, &MSO(to));
#ifdef DEBUG
if (eq(obj, res) == 0) {
erl_exit(1, "copy not equal to source\n");
}
#endif
return res;
}
/* This needs to be here, before the bif table... */
static Eterm db_set_trace_control_word_fake_1(Process *p, Eterm val);
/*
** The table of callable bif's, i e guard bif's and
** some special animals that can provide us with trace
** information. This array is sorted on init.
*/
static DMCGuardBif guard_tab[] =
{
{
am_is_atom,
&is_atom_1,
1,
DBIF_ALL
},
{
am_is_float,
&is_float_1,
1,
DBIF_ALL
},
{
am_is_integer,
&is_integer_1,
1,
DBIF_ALL
},
{
am_is_list,
&is_list_1,
1,
DBIF_ALL
},
{
am_is_number,
&is_number_1,
1,
DBIF_ALL
},
{
am_is_pid,
&is_pid_1,
1,
DBIF_ALL
},
{
am_is_port,
&is_port_1,
1,
DBIF_ALL
},
{
am_is_reference,
&is_reference_1,
1,
DBIF_ALL
},
{
am_is_tuple,
&is_tuple_1,
1,
DBIF_ALL
},
{
am_is_binary,
&is_binary_1,
1,
DBIF_ALL
},
{
am_is_function,
&is_function_1,
1,
DBIF_ALL
},
{
am_is_record,
&is_record_3,
3,
DBIF_ALL
},
{
am_abs,
&abs_1,
1,
DBIF_ALL
},
{
am_element,
&element_2,
2,
DBIF_ALL
},
{
am_hd,
&hd_1,
1,
DBIF_ALL
},
{
am_length,
&length_1,
1,
DBIF_ALL
},
{
am_node,
&node_1,
1,
DBIF_ALL
},
{
am_node,
&node_0,
0,
DBIF_ALL
},
{
am_round,
&round_1,
1,
DBIF_ALL
},
{
am_size,
&size_1,
1,
DBIF_ALL
},
{
am_bit_size,
&bit_size_1,
1,
DBIF_ALL
},
{
am_tl,
&tl_1,
1,
DBIF_ALL
},
{
am_trunc,
&trunc_1,
1,
DBIF_ALL
},
{
am_float,
&float_1,
1,
DBIF_ALL
},
{
am_Plus,
&splus_1,
1,
DBIF_ALL
},
{
am_Minus,
&sminus_1,
1,
DBIF_ALL
},
{
am_Plus,
&splus_2,
2,
DBIF_ALL
},
{
am_Minus,
&sminus_2,
2,
DBIF_ALL
},
{
am_Times,
&stimes_2,
2,
DBIF_ALL
},
{
am_Div,
&div_2,
2,
DBIF_ALL
},
{
am_div,
&intdiv_2,
2,
DBIF_ALL
},
{
am_rem,
&rem_2,
2,
DBIF_ALL
},
{
am_band,
&band_2,
2,
DBIF_ALL
},
{
am_bor,
&bor_2,
2,
DBIF_ALL
},
{
am_bxor,
&bxor_2,
2,
DBIF_ALL
},
{
am_bnot,
&bnot_1,
1,
DBIF_ALL
},
{
am_bsl,
&bsl_2,
2,
DBIF_ALL
},
{
am_bsr,
&bsr_2,
2,
DBIF_ALL
},
{
am_Gt,
&sgt_2,
2,
DBIF_ALL
},
{
am_Ge,
&sge_2,
2,
DBIF_ALL
},
{
am_Lt,
&slt_2,
2,
DBIF_ALL
},
{
am_Le,
&sle_2,
2,
DBIF_ALL
},
{
am_Eq,
&seq_2,
2,
DBIF_ALL
},
{
am_Eqeq,
&seqeq_2,
2,
DBIF_ALL
},
{
am_Neq,
&sneq_2,
2,
DBIF_ALL
},
{
am_Neqeq,
&sneqeq_2,
2,
DBIF_ALL
},
{
am_not,
¬_1,
1,
DBIF_ALL
},
{
am_xor,
&xor_2,
2,
DBIF_ALL
},
{
am_get_tcw,
&db_get_trace_control_word_0,
0,
DBIF_TRACE_GUARD | DBIF_TRACE_BODY
},
{
am_set_tcw,
&db_set_trace_control_word_1,
1,
DBIF_TRACE_BODY
},
{
am_set_tcw_fake,
&db_set_trace_control_word_fake_1,
1,
DBIF_TRACE_BODY
}
};
/*
** Exported
*/
Eterm db_am_eot; /* Atom '$end_of_table' */
/*
** Forward decl's
*/
/*
** ... forwards for compiled matches
*/
/* Utility code */
static DMCGuardBif *dmc_lookup_bif(Eterm t, int arity);
#ifdef DMC_DEBUG
static Eterm dmc_lookup_bif_reversed(void *f);
#endif
static int cmp_uint(void *a, void *b);
static int cmp_guard_bif(void *a, void *b);
static int match_compact(ErlHeapFragment *expr, DMCErrInfo *err_info);
static Uint my_size_object(Eterm t);
static Eterm my_copy_struct(Eterm t, Eterm **hp, ErlOffHeap* off_heap);
/* Guard compilation */
static void do_emit_constant(DMCContext *context, DMC_STACK_TYPE(Uint) *text,
Eterm t);
static DMCRet dmc_list(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant);
static DMCRet dmc_tuple(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant);
static DMCRet dmc_variable(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant);
static DMCRet dmc_fun(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant);
static DMCRet dmc_expr(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant);
static DMCRet compile_guard_expr(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t);
/* match expression subroutine */
static DMCRet dmc_one_term(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Eterm) *stack,
DMC_STACK_TYPE(Uint) *text,
Eterm c);
#ifdef DMC_DEBUG
static int test_disassemble_next = 0;
static void db_match_dis(Binary *prog);
#define TRACE erts_fprintf(stderr,"Trace: %s:%d\n",__FILE__,__LINE__)
#define FENCE_PATTERN_SIZE 1
#define FENCE_PATTERN 0xDEADBEEFUL
#else
#define TRACE /* Nothing */
#define FENCE_PATTERN_SIZE 0
#endif
static void add_dmc_err(DMCErrInfo *err_info,
char *str,
int variable,
Eterm term,
DMCErrorSeverity severity);
static Eterm dpm_array_to_list(Process *psp, Eterm *arr, int arity);
static Eterm match_spec_test(Process *p, Eterm against, Eterm spec, int trace);
static Eterm seq_trace_fake(Process *p, Eterm arg1);
/*
** Interface routines.
*/
/*
** Pseudo BIF:s to be callable from the PAM VM.
*/
BIF_RETTYPE db_get_trace_control_word_0(Process *p)
{
Uint32 tcw = (Uint32) erts_smp_atomic_read(&trace_control_word);
BIF_RET(erts_make_integer((Uint) tcw, p));
}
BIF_RETTYPE db_set_trace_control_word_1(Process *p, Eterm new)
{
Uint val;
Uint32 old_tcw;
if (!term_to_Uint(new, &val))
BIF_ERROR(p, BADARG);
if (val != ((Uint32)val))
BIF_ERROR(p, BADARG);
old_tcw = (Uint32) erts_smp_atomic_xchg(&trace_control_word, (long) val);
BIF_RET(erts_make_integer((Uint) old_tcw, p));
}
static Eterm db_set_trace_control_word_fake_1(Process *p, Eterm new)
{
Uint val;
if (!term_to_Uint(new, &val))
BIF_ERROR(p, BADARG);
if (val != ((Uint32)val))
BIF_ERROR(p, BADARG);
BIF_RET(db_get_trace_control_word_0(p));
}
/*
** The API used by the tracer (declared in global.h):
*/
/*
** Matchexpr is a list of tuples containing match-code, i e:
**
** Matchexpr = [{Pattern, Guards, Body}, ...]
** Pattern = [ PatternExpr , ...]
** PatternExpr = Constant | PatternTuple | PatternList | Variable
** Constant = Any erlang term
** PatternTuple = { PatternExpr ... }
** PatternList = [ PatternExpr ]
** Variable = '$' ++ <number>
** Guards = [Guard ...]
** Guard = {GuardFunc, GuardExpr, ...}
** GuardExpr = BoundVariable | Guard | GuardList | GuardTuple | ConstExpr
** BoundVariable = Variable (existing in Pattern)
** GuardList = [ GuardExpr , ... ]
** GuardTuple = {{ GuardExpr, ... }}
** ConstExpr = {const, Constant}
** GuardFunc = is_list | .... | element | ...
** Body = [ BodyExpr, ... ]
** BodyExpr = GuardExpr | { BodyFunc, GuardExpr, ... }
** BodyFunc = return_trace | seq_trace | trace | ...
** - or something like that...
*/
Eterm erts_match_set_get_source(Binary *mpsp)
{
MatchProg *prog = Binary2MatchProg(mpsp);
return prog->saved_program;
}
/* This one is for the tracing */
Binary *erts_match_set_compile(Process *p, Eterm matchexpr) {
Binary *bin;
Uint sz;
Eterm *hp;
bin = db_match_set_compile(p, matchexpr, DCOMP_TRACE);
if (bin != NULL) {
MatchProg *prog = Binary2MatchProg(bin);
sz = size_object(matchexpr);
prog->saved_program_buf = new_message_buffer(sz);
hp = prog->saved_program_buf->mem;
prog->saved_program =
copy_struct(matchexpr, sz, &hp,
&(prog->saved_program_buf->off_heap));
}
return bin;
}
Binary *db_match_set_compile(Process *p, Eterm matchexpr,
Uint flags)
{
Eterm l;
Eterm t;
Eterm l2;
Eterm *tp;
Eterm *hp;
int n = 0;
int num_heads;
int i;
Binary *mps = NULL;
int compiled = 0;
Eterm *matches,*guards, *bodies;
Eterm *buff;
Eterm sbuff[15];
if (!is_list(matchexpr))
return NULL;
num_heads = 0;
for (l = matchexpr; is_list(l); l = CDR(list_val(l)))
++num_heads;
if (l != NIL) /* proper list... */
return NULL;
if (num_heads > 5) {
buff = erts_alloc(ERTS_ALC_T_DB_TMP,
sizeof(Eterm) * num_heads * 3);
} else {
buff = sbuff;
}
matches = buff;
guards = buff + num_heads;
bodies = buff + (num_heads * 2);
i = 0;
for (l = matchexpr; is_list(l); l = CDR(list_val(l))) {
t = CAR(list_val(l));
if (!is_tuple(t) || arityval((tp = tuple_val(t))[0]) != 3) {
goto error;
}
if (!(flags & DCOMP_TRACE) || (!is_list(tp[1]) &&
!is_nil(tp[1]))) {
t = tp[1];
} else {
/* This is when tracing, the parameter is a list,
that I convert to a tuple and that is matched
against an array (strange, but gives the semantics
of matching against a parameter list) */
n = 0;
for (l2 = tp[1]; is_list(l2); l2 = CDR(list_val(l2))) {
++n;
}
if (l2 != NIL) {
goto error;
}
hp = HAlloc(p, n + 1);
t = make_tuple(hp);
*hp++ = make_arityval((Uint) n);
l2 = tp[1];
while (n--) {
*hp++ = CAR(list_val(l2));
l2 = CDR(list_val(l2));
}
}
matches[i] = t;
guards[i] = tp[2];
bodies[i] = tp[3];
++i;
}
if ((mps = db_match_compile(matches, guards, bodies,
num_heads,
flags,
NULL)) == NULL) {
goto error;
}
compiled = 1;
if (buff != sbuff) {
erts_free(ERTS_ALC_T_DB_TMP, buff);
}
return mps;
error:
if (compiled) {
erts_bin_free(mps);
}
if (buff != sbuff) {
erts_free(ERTS_ALC_T_DB_TMP, buff);
}
return NULL;
}
/* This is used when tracing */
Eterm erts_match_set_lint(Process *p, Eterm matchexpr) {
return db_match_set_lint(p, matchexpr, DCOMP_TRACE);
}
Eterm db_match_set_lint(Process *p, Eterm matchexpr, Uint flags)
{
Eterm l;
Eterm t;
Eterm l2;
Eterm *tp;
Eterm *hp;
DMCErrInfo *err_info = db_new_dmc_err_info();
Eterm ret;
int n = 0;
int num_heads;
Binary *mp;
Eterm *matches,*guards, *bodies;
Eterm sbuff[15];
Eterm *buff = sbuff;
int i;
if (!is_list(matchexpr)) {
add_dmc_err(err_info, "Match programs are not in a list.",
-1, 0UL, dmcError);
goto done;
}
num_heads = 0;
for (l = matchexpr; is_list(l); l = CDR(list_val(l)))
++num_heads;
if (l != NIL) { /* proper list... */
add_dmc_err(err_info, "Match programs are not in a proper "
"list.",
-1, 0UL, dmcError);
goto done;
}
if (num_heads > 5) {
buff = erts_alloc(ERTS_ALC_T_DB_TMP,
sizeof(Eterm) * num_heads * 3);
}
matches = buff;
guards = buff + num_heads;
bodies = buff + (num_heads * 2);
i = 0;
for (l = matchexpr; is_list(l); l = CDR(list_val(l))) {
t = CAR(list_val(l));
if (!is_tuple(t) || arityval((tp = tuple_val(t))[0]) != 3) {
add_dmc_err(err_info,
"Match program part is not a tuple of "
"arity 3.",
-1, 0UL, dmcError);
goto done;
}
if (!(flags & DCOMP_TRACE) || (!is_list(tp[1]) &&
!is_nil(tp[1]))) {
t = tp[1];
} else {
n = 0;
for (l2 = tp[1]; is_list(l2); l2 = CDR(list_val(l2))) {
++n;
}
if (l2 != NIL) {
add_dmc_err(err_info,
"Match expression part %T is not a "
"proper list.",
-1, tp[1], dmcError);
goto done;
}
hp = HAlloc(p, n + 1);
t = make_tuple(hp);
*hp++ = make_arityval((Uint) n);
l2 = tp[1];
while (n--) {
*hp++ = CAR(list_val(l2));
l2 = CDR(list_val(l2));
}
}
matches[i] = t;
guards[i] = tp[2];
bodies[i] = tp[3];
++i;
}
mp = db_match_compile(matches, guards, bodies, num_heads,
flags, err_info);
if (mp != NULL) {
erts_bin_free(mp);
}
done:
ret = db_format_dmc_err_info(p, err_info);
db_free_dmc_err_info(err_info);
if (buff != sbuff) {
erts_free(ERTS_ALC_T_DB_TMP, buff);
}
return ret;
}
Eterm erts_match_set_run(Process *p, Binary *mpsp,
Eterm *args, int num_args,
Uint32 *return_flags)
{
Eterm ret;
ret = db_prog_match(p, mpsp,
(Eterm) args,
num_args, return_flags);
#if defined(HARDDEBUG)
if (is_non_value(ret)) {
erts_fprintf(stderr, "Failed\n");
} else {
erts_fprintf(stderr, "Returning : %T\n", ret);
}
#endif
return ret;
/* Returns
* THE_NON_VALUE if no match
* am_false if {message,false} has been called,
* am_true if {message,_} has not been called or
* if {message,true} has been called,
* Msg if {message,Msg} has been called.
*/
}
/*
** API Used by other erl_db modules.
*/
void db_initialize_util(void){
qsort(guard_tab,
sizeof(guard_tab) / sizeof(DMCGuardBif),
sizeof(DMCGuardBif),
(int (*)(const void *, const void *)) &cmp_guard_bif);
match_pseudo_process_init();
erts_smp_atomic_init(&trace_control_word, 0);
}
Eterm db_getkey(int keypos, Eterm obj)
{
if (is_tuple(obj)) {
Eterm *tptr = tuple_val(obj);
if (arityval(*tptr) >= keypos)
return *(tptr + keypos);
}
return THE_NON_VALUE;
}
/*
** Matching compiled (executed by "Pam" :-)
*/
/*
** The actual compiling of the match expression and the guards
*/
Binary *db_match_compile(Eterm *matchexpr,
Eterm *guards,
Eterm *body,
int num_progs,
Uint flags,
DMCErrInfo *err_info)
{
DMCHeap heap;
DMC_STACK_TYPE(Eterm) stack;
DMC_STACK_TYPE(Uint) text;
DMCContext context;
MatchProg *ret = NULL;
Eterm t;
Uint i;
Uint num_iters;
int structure_checked;
DMCRet res;
int current_try_label;
Uint max_eheap_need;
Binary *bp = NULL;
unsigned clause_start;
DMC_INIT_STACK(stack);
DMC_INIT_STACK(text);
context.stack_need = context.stack_used = 0;
context.save = context.copy = NULL;
context.num_match = num_progs;
context.matchexpr = matchexpr;
context.guardexpr = guards;
context.bodyexpr = body;
context.eheap_need = 0;
context.err_info = err_info;
context.cflags = flags;
heap.size = DMC_DEFAULT_SIZE;
heap.data = heap.def;
/*
** Compile the match expression
*/
restart:
heap.used = 0;
max_eheap_need = 0;
for (context.current_match = 0;
context.current_match < num_progs;
++context.current_match) { /* This loop is long,
too long */
memset(heap.data, 0, heap.size * sizeof(*heap.data));
t = context.matchexpr[context.current_match];
context.stack_used = 0;
context.eheap_need = 0;
structure_checked = 0;
if (context.current_match < num_progs - 1) {
DMC_PUSH(text,matchTryMeElse);
current_try_label = DMC_STACK_NUM(text);
DMC_PUSH(text,0);
} else {
current_try_label = -1;
}
clause_start = DMC_STACK_NUM(text); /* the "special" test needs it */
DMC_PUSH(stack,NIL);
for (;;) {
switch (t & _TAG_PRIMARY_MASK) {
case TAG_PRIMARY_BOXED:
if (!BOXED_IS_TUPLE(t)) {
goto simple_term;
}
num_iters = arityval(*tuple_val(t));
if (!structure_checked) { /* i.e. we did not
pop it */
DMC_PUSH(text,matchTuple);
DMC_PUSH(text,num_iters);
}
structure_checked = 0;
for (i = 1; i <= num_iters; ++i) {
if ((res = dmc_one_term(&context,
&heap,
&stack,
&text,
tuple_val(t)[i]))
!= retOk) {
if (res == retRestart) {
goto restart; /* restart the
surrounding
loop */
} else goto error;
}
}
break;
case TAG_PRIMARY_LIST:
if (!structure_checked) {
DMC_PUSH(text, matchList);
}
structure_checked = 0; /* Whatever it is, we did
not pop it */
if ((res = dmc_one_term(&context, &heap, &stack,
&text, CAR(list_val(t))))
!= retOk) {
if (res == retRestart) {
goto restart;
} else goto error;
}
t = CDR(list_val(t));
continue;
default: /* Nil and non proper tail end's or
single terms as match
expressions */
simple_term:
structure_checked = 0;
if ((res = dmc_one_term(&context, &heap, &stack,
&text, t))
!= retOk) {
if (res == retRestart) {
goto restart;
} else goto error;
}
break;
}
/* The *program's* stack just *grows* while we are
traversing one composite data structure, we can
check the stack usage here */
if (context.stack_used > context.stack_need)
context.stack_need = context.stack_used;
/* We are at the end of one composite data structure,
pop sub structures and emit a matchPop instruction
(or break) */
if ((t = DMC_POP(stack)) == NIL) {
break;
} else {
DMC_PUSH(text, matchPop);
structure_checked = 1; /*
* Checked with matchPushT
* or matchPushL
*/
--(context.stack_used);
}
}
/*
** There is one single top variable in the match expression
** iff the text is tho Uint's and the single instruction
** is 'matchBind' or it is only a skip.
*/
context.special =
(DMC_STACK_NUM(text) == 2 + clause_start &&
DMC_PEEK(text,clause_start) == matchBind) ||
(DMC_STACK_NUM(text) == 1 + clause_start &&
DMC_PEEK(text, clause_start) == matchSkip);
if (flags & DCOMP_TRACE) {
if (context.special) {
if (DMC_PEEK(text, clause_start) == matchBind) {
DMC_POKE(text, clause_start, matchArrayBind);
}
} else {
ASSERT(DMC_STACK_NUM(text) >= 1);
if (DMC_PEEK(text, clause_start) != matchTuple) {
/* If it isn't "special" and the argument is
not a tuple, the expression is not valid
when matching an array*/
if (context.err_info) {
add_dmc_err(context.err_info,
"Match head is invalid in "
"this context.",
-1, 0UL,
dmcError);
}
goto error;
}
DMC_POKE(text, clause_start, matchArray);
}
}
/*
** ... and the guards
*/
context.is_guard = 1;
if (compile_guard_expr
(&context,
&heap,
&text,
context.guardexpr[context.current_match]) != retOk)
goto error;
context.is_guard = 0;
if ((context.cflags & DCOMP_TABLE) &&
!is_list(context.bodyexpr[context.current_match])) {
if (context.err_info) {
add_dmc_err(context.err_info,
"Body clause does not return "
"anything.", -1, 0UL,
dmcError);
}
goto error;
}
if (compile_guard_expr
(&context,
&heap,
&text,
context.bodyexpr[context.current_match]) != retOk)
goto error;
/*
* The compilation does not bail out when error information
* is requested, so we need to detect that here...
*/
if (context.err_info != NULL &&
(context.err_info)->error_added) {
goto error;
}
/* If the matchprogram comes here, the match is
successful */
DMC_PUSH(text,matchHalt);
/* Fill in try-me-else label if there is one. */
if (current_try_label >= 0) {
DMC_POKE(text, current_try_label, DMC_STACK_NUM(text));
}
/* So, how much eheap did this part of the match program need? */
if (context.eheap_need > max_eheap_need) {
max_eheap_need = context.eheap_need;
}
} /* for (context.current_match = 0 ...) */
/*
** Done compiling
** Allocate enough space for the program,
** heap size is in 'heap_used', stack size is in 'stack_need'
** and text size is simply DMC_STACK_NUM(text).
** The "program memory" is allocated like this:
** text ----> +-------------+
** | |
** ..........
** +-------------+
**
** The heap-eheap-stack block of a MatchProg is nowadays allocated
** when the match program is run (see db_prog_match()).
**
** heap ----> +-------------+
** ..........
** eheap ---> + +
** ..........
** stack ---> + +
** ..........
** +-------------+
** The stack is expected to grow towards *higher* adresses.
** A special case is when the match expression is a single binding
** (i.e '$1'), then the field single_variable is set to 1.
*/
bp = erts_create_magic_binary(((sizeof(MatchProg) - sizeof(Uint)) +
(DMC_STACK_NUM(text) * sizeof(Uint))),
erts_db_match_prog_destructor);
ret = Binary2MatchProg(bp);
ret->saved_program_buf = NULL;
ret->saved_program = NIL;
ret->term_save = context.save;
ret->num_bindings = heap.used;
ret->single_variable = context.special;
sys_memcpy(ret->text, DMC_STACK_DATA(text),
DMC_STACK_NUM(text) * sizeof(Uint));
ret->heap_size = ((heap.used * sizeof(Eterm)) +
(max_eheap_need * sizeof(Eterm)) +
(context.stack_need * sizeof(Eterm *)) +
(3 * (FENCE_PATTERN_SIZE * sizeof(Eterm *))));
ret->eheap_offset = heap.used + FENCE_PATTERN_SIZE;
ret->stack_offset = ret->eheap_offset + max_eheap_need + FENCE_PATTERN_SIZE;
#ifdef DMC_DEBUG
ret->prog_end = ret->text + DMC_STACK_NUM(text);
#endif
/*
* Fall through to cleanup code, but context.save should not be free'd
*/
context.save = NULL;
error: /* Here is were we land when compilation failed. */
while (context.save != NULL) {
ErlHeapFragment *ll = context.save->next;
free_message_buffer(context.save);
context.save = ll;
}
DMC_FREE(stack);
DMC_FREE(text);
if (context.copy != NULL)
free_message_buffer(context.copy);
if (heap.data != heap.def)
erts_free(ERTS_ALC_T_DB_MS_CMPL_HEAP, (void *) heap.data);
return bp;
}
/*
** Free a match program (in a binary)
*/
void erts_db_match_prog_destructor(Binary *bprog)
{
MatchProg *prog;
ErlHeapFragment *tmp, *ll;
if (bprog == NULL)
return;
prog = Binary2MatchProg(bprog);
tmp = prog->term_save;
while (tmp != NULL) {
ll = tmp->next;
free_message_buffer(tmp);
tmp = ll;
}
if (prog->saved_program_buf != NULL)
free_message_buffer(prog->saved_program_buf);
}
void
erts_match_prog_foreach_offheap(Binary *bprog,
void (*func)(ErlOffHeap *, void *),
void *arg)
{
MatchProg *prog;
ErlHeapFragment *tmp;
if (bprog == NULL)
return;
prog = Binary2MatchProg(bprog);
tmp = prog->term_save;
while (tmp) {
(*func)(&(tmp->off_heap), arg);
tmp = tmp->next;
}
if (prog->saved_program_buf)
(*func)(&(prog->saved_program_buf->off_heap), arg);
}
/*
** This is not the most efficient way to do it, but it's a rare
** and not especially nice case when this is used.
*/
static Eterm dpm_array_to_list(Process *psp, Eterm *arr, int arity)
{
Eterm *hp = HAlloc(psp, arity * 2);
Eterm ret = NIL;
while (--arity >= 0) {
ret = CONS(hp, arr[arity], ret);
hp += 2;
}
return ret;
}
/*
** Execution of the match program, this is Pam.
** May return THE_NON_VALUE, which is a bailout.
** the para meter 'arity' is only used if 'term' is actually an array,
** i.e. 'DCOMP_TRACE' was specified
*/
Eterm db_prog_match(Process *c_p, Binary *bprog, Eterm term,
int arity,
Uint32 *return_flags)
{
MatchProg *prog = Binary2MatchProg(bprog);
Eterm *ep;
Eterm *tp;
Eterm t;
Eterm **sp;
Eterm *esp;
Eterm *hp;
Uint *pc = prog->text;
Eterm *ehp;
Eterm ret;
Uint n = 0; /* To avoid warning. */
int i;
unsigned do_catch;
ErtsMatchPseudoProcess *mpsp;
Process *psp;
Process *tmpp;
Process *current_scheduled;
ErtsSchedulerData *esdp;
Eterm (*bif)(Process*, ...);
int fail_label;
int atomic_trace;
#ifdef DMC_DEBUG
unsigned long *heap_fence;
unsigned long *eheap_fence;
unsigned long *stack_fence;
Uint save_op;
#endif /* DMC_DEBUG */
mpsp = get_match_pseudo_process(c_p, prog->heap_size);
psp = &mpsp->process;
/* We need to lure the scheduler into believing in the pseudo process,
because of floating point exceptions. Do *after* mpsp is set!!! */
esdp = ERTS_GET_SCHEDULER_DATA_FROM_PROC(c_p);
ASSERT(esdp != NULL);
current_scheduled = esdp->current_process;
esdp->current_process = psp;
/* SMP: psp->scheduler_data is set by get_match_pseudo_process */
atomic_trace = 0;
#define BEGIN_ATOMIC_TRACE(p) \
do { \
if (! atomic_trace) { \
erts_smp_proc_unlock((p), ERTS_PROC_LOCK_MAIN); \
erts_smp_block_system(0); \
atomic_trace = !0; \
} \
} while (0)
#define END_ATOMIC_TRACE(p) \
do { \
if (atomic_trace) { \
erts_smp_release_system(); \
erts_smp_proc_lock((p), ERTS_PROC_LOCK_MAIN); \
atomic_trace = 0; \
} \
} while (0)
#ifdef DMC_DEBUG
save_op = 0;
heap_fence = (unsigned long *) mpsp->heap + prog->eheap_offset - 1;
eheap_fence = (unsigned long *) mpsp->heap + prog->stack_offset - 1;
stack_fence = (unsigned long *) mpsp->heap + prog->heap_size - 1;
*heap_fence = FENCE_PATTERN;
*eheap_fence = FENCE_PATTERN;
*stack_fence = FENCE_PATTERN;
#endif /* DMC_DEBUG */
#ifdef HARDDEBUG
#define FAIL() {erts_printf("Fail line %d\n",__LINE__); goto fail;}
#else
#define FAIL() goto fail
#endif
#define FAIL_TERM am_EXIT /* The term to set as return when bif fails and
do_catch != 0 */
*return_flags = 0U;
restart:
ep = &term;
esp = mpsp->heap + prog->stack_offset;
sp = (Eterm **) esp;
hp = mpsp->heap;
ehp = mpsp->heap + prog->eheap_offset;
ret = am_true;
do_catch = 0;
fail_label = -1;
for (;;) {
#ifdef DMC_DEBUG
if (*heap_fence != FENCE_PATTERN) {
erl_exit(1, "Heap fence overwritten in db_prog_match after op "
"0x%08x, overwritten with 0x%08x.", save_op, *heap_fence);
}
if (*eheap_fence != FENCE_PATTERN) {
erl_exit(1, "Eheap fence overwritten in db_prog_match after op "
"0x%08x, overwritten with 0x%08x.", save_op,
*eheap_fence);
}
if (*stack_fence != FENCE_PATTERN) {
erl_exit(1, "Stack fence overwritten in db_prog_match after op "
"0x%08x, overwritten with 0x%08x.", save_op,
*stack_fence);
}
save_op = *pc;
#endif
switch (*pc++) {
case matchTryMeElse:
fail_label = *pc++;
break;
case matchArray: /* only when DCOMP_TRACE, is always first
instruction. */
n = *pc++;
if ((int) n != arity)
FAIL();
ep = (Eterm *) *ep;
break;
case matchArrayBind: /* When the array size is unknown. */
n = *pc++;
hp[n] = dpm_array_to_list(psp, (Eterm *) term, arity);
break;
case matchTuple: /* *ep is a tuple of arity n */
if (!is_tuple(*ep))
FAIL();
ep = tuple_val(*ep);
n = *pc++;
if (arityval(*ep) != n)
FAIL();
++ep;
break;
case matchPushT: /* *ep is a tuple of arity n,
push ptr to first element */
if (!is_tuple(*ep))
FAIL();
tp = tuple_val(*ep);
n = *pc++;
if (arityval(*tp) != n)
FAIL();
*sp++ = tp + 1;
++ep;
break;
case matchList:
if (!is_list(*ep))
FAIL();
ep = list_val(*ep);
break;
case matchPushL:
if (!is_list(*ep))
FAIL();
*sp++ = list_val(*ep);
++ep;
break;
case matchPop:
ep = *(--sp);
break;
case matchBind:
n = *pc++;
hp[n] = *ep++;
break;
case matchCmp:
n = *pc++;
if (!eq(hp[n],*ep))
FAIL();
++ep;
break;
case matchEqBin:
t = (Eterm) *pc++;
if (!eq(*ep,t))
FAIL();
++ep;
break;
case matchEqFloat:
if (!is_float(*ep))
FAIL();
if (memcmp(float_val(*ep) + 1, pc, sizeof(double)))
FAIL();
pc += 2;
++ep;
break;
case matchEqRef:
if (!is_ref(*ep))
FAIL();
if (!eq(*ep, make_internal_ref(pc)))
FAIL();
i = thing_arityval(*pc);
pc += i+1;
++ep;
break;
case matchEqBig:
if (!is_big(*ep))
FAIL();
tp = big_val(*ep);
if (*tp != *pc)
FAIL();
i = BIG_ARITY(pc);
while(i--)
if (*++tp != *++pc)
FAIL();
++pc;
++ep;
break;
case matchEq:
t = (Eterm) *pc++;
if (t != *ep++)
FAIL();
break;
case matchSkip:
++ep;
break;
/*
* Here comes guard instructions
*/
case matchPushC: /* Push constant */
*esp++ = *pc++;
break;
case matchConsA:
ehp[1] = *--esp;
ehp[0] = esp[-1];
esp[-1] = make_list(ehp);
ehp += 2;
break;
case matchConsB:
ehp[0] = *--esp;
ehp[1] = esp[-1];
esp[-1] = make_list(ehp);
ehp += 2;
break;
case matchMkTuple:
n = *pc++;
t = make_tuple(ehp);
*ehp++ = make_arityval(n);
while (n--) {
*ehp++ = *--esp;
}
*esp++ = t;
break;
case matchCall0:
bif = (Eterm (*)(Process*, ...)) *pc++;
t = (*bif)(psp);
if (is_non_value(t)) {
if (do_catch)
t = FAIL_TERM;
else
FAIL();
}
*esp++ = t;
break;
case matchCall1:
bif = (Eterm (*)(Process*, ...)) *pc++;
t = (*bif)(psp, esp[-1]);
if (is_non_value(t)) {
if (do_catch)
t = FAIL_TERM;
else
FAIL();
}
esp[-1] = t;
break;
case matchCall2:
bif = (Eterm (*)(Process*, ...)) *pc++;
t = (*bif)(psp, esp[-1], esp[-2]);
if (is_non_value(t)) {
if (do_catch)
t = FAIL_TERM;
else
FAIL();
}
--esp;
esp[-1] = t;
break;
case matchCall3:
bif = (Eterm (*)(Process*, ...)) *pc++;
t = (*bif)(psp, esp[-1], esp[-2], esp[-3]);
if (is_non_value(t)) {
if (do_catch)
t = FAIL_TERM;
else
FAIL();
}
esp -= 2;
esp[-1] = t;
break;
case matchPushV:
*esp++ = hp[*pc++];
break;
case matchPushExpr:
*esp++ = term;
break;
case matchPushArrayAsList:
n = arity; /* Only happens when 'term' is an array */
tp = (Eterm *) term;
*esp++ = make_list(ehp);
while (n--) {
*ehp++ = *tp++;
*ehp = make_list(ehp + 1);
ehp++; /* As pointed out by Mikael Pettersson the expression
(*ehp++ = make_list(ehp + 1)) that I previously
had written here has undefined behaviour. */
}
ehp[-1] = NIL;
break;
case matchPushArrayAsListU:
/* This instruction is NOT efficient. */
*esp++ = dpm_array_to_list(psp, (Eterm *) term, arity);
break;
case matchTrue:
if (*--esp != am_true)
FAIL();
break;
case matchOr:
n = *pc++;
t = am_false;
while (n--) {
if (*--esp == am_true) {
t = am_true;
} else if (*esp != am_false) {
esp -= n;
if (do_catch) {
t = FAIL_TERM;
break;
} else {
FAIL();
}
}
}
*esp++ = t;
break;
case matchAnd:
n = *pc++;
t = am_true;
while (n--) {
if (*--esp == am_false) {
t = am_false;
} else if (*esp != am_true) {
esp -= n;
if (do_catch) {
t = FAIL_TERM;
break;
} else {
FAIL();
}
}
}
*esp++ = t;
break;
case matchOrElse:
n = *pc++;
if (*--esp == am_true) {
++esp;
pc += n;
} else if (*esp != am_false) {
if (do_catch) {
*esp++ = FAIL_TERM;
pc += n;
} else {
FAIL();
}
}
break;
case matchAndAlso:
n = *pc++;
if (*--esp == am_false) {
esp++;
pc += n;
} else if (*esp != am_true) {
if (do_catch) {
*esp++ = FAIL_TERM;
pc += n;
} else {
FAIL();
}
}
break;
case matchJump:
n = *pc++;
pc += n;
break;
case matchSelf:
*esp++ = c_p->id;
break;
case matchWaste:
--esp;
break;
case matchReturn:
ret = *--esp;
break;
case matchProcessDump: {
erts_dsprintf_buf_t *dsbufp = erts_create_tmp_dsbuf(0);
print_process_info(ERTS_PRINT_DSBUF, (void *) dsbufp, c_p);
*esp++ = new_binary(psp, (byte *)dsbufp->str, (int)dsbufp->str_len);
erts_destroy_tmp_dsbuf(dsbufp);
break;
}
case matchDisplay: /* Debugging, not for production! */
erts_printf("%T\n", esp[-1]);
esp[-1] = am_true;
break;
case matchSetReturnTrace:
*return_flags |= MATCH_SET_RETURN_TRACE;
*esp++ = am_true;
break;
case matchSetExceptionTrace:
*return_flags |= MATCH_SET_EXCEPTION_TRACE;
*esp++ = am_true;
break;
case matchIsSeqTrace:
if (SEQ_TRACE_TOKEN(c_p) != NIL)
*esp++ = am_true;
else
*esp++ = am_false;
break;
case matchSetSeqToken:
t = erts_seq_trace(c_p, esp[-1], esp[-2], 0);
if (is_non_value(t)) {
esp[-2] = FAIL_TERM;
} else {
esp[-2] = t;
}
--esp;
break;
case matchSetSeqTokenFake:
t = seq_trace_fake(c_p, esp[-1]);
if (is_non_value(t)) {
esp[-2] = FAIL_TERM;
} else {
esp[-2] = t;
}
--esp;
break;
case matchGetSeqToken:
if (SEQ_TRACE_TOKEN(c_p) == NIL)
*esp++ = NIL;
else {
*esp++ = make_tuple(ehp);
ehp[0] = make_arityval(5);
ehp[1] = SEQ_TRACE_TOKEN_FLAGS(c_p);
ehp[2] = SEQ_TRACE_TOKEN_LABEL(c_p);
ehp[3] = SEQ_TRACE_TOKEN_SERIAL(c_p);
ehp[4] = SEQ_TRACE_TOKEN_SENDER(c_p);
ehp[5] = SEQ_TRACE_TOKEN_LASTCNT(c_p);
ASSERT(SEQ_TRACE_TOKEN_ARITY(c_p) == 5);
ASSERT(is_immed(ehp[1]));
ASSERT(is_immed(ehp[2]));
ASSERT(is_immed(ehp[3]));
ASSERT(is_immed(ehp[5]));
if(!is_immed(ehp[4])) {
Eterm *sender = &ehp[4];
ehp += 6;
*sender = copy_struct(*sender,
size_object(*sender),
&ehp,
&MSO(psp));
}
else
ehp += 6;
}
break;
case matchEnableTrace:
if ( (n = erts_trace_flag2bit(esp[-1]))) {
BEGIN_ATOMIC_TRACE(c_p);
set_tracee_flags(c_p, c_p->tracer_proc, 0, n);
esp[-1] = am_true;
} else {
esp[-1] = FAIL_TERM;
}
break;
case matchEnableTrace2:
n = erts_trace_flag2bit((--esp)[-1]);
esp[-1] = FAIL_TERM;
if (n) {
BEGIN_ATOMIC_TRACE(c_p);
if ( (tmpp = get_proc(c_p, 0, esp[0], 0))) {
/* Always take over the tracer of the current process */
set_tracee_flags(tmpp, c_p->tracer_proc, 0, n);
esp[-1] = am_true;
}
}
break;
case matchDisableTrace:
if ( (n = erts_trace_flag2bit(esp[-1]))) {
BEGIN_ATOMIC_TRACE(c_p);
set_tracee_flags(c_p, c_p->tracer_proc, n, 0);
esp[-1] = am_true;
} else {
esp[-1] = FAIL_TERM;
}
break;
case matchDisableTrace2:
n = erts_trace_flag2bit((--esp)[-1]);
esp[-1] = FAIL_TERM;
if (n) {
BEGIN_ATOMIC_TRACE(c_p);
if ( (tmpp = get_proc(c_p, 0, esp[0], 0))) {
/* Always take over the tracer of the current process */
set_tracee_flags(tmpp, c_p->tracer_proc, n, 0);
esp[-1] = am_true;
}
}
break;
case matchCaller:
if (!(c_p->cp) || !(hp = find_function_from_pc(c_p->cp))) {
*esp++ = am_undefined;
} else {
*esp++ = make_tuple(ehp);
ehp[0] = make_arityval(3);
ehp[1] = hp[0];
ehp[2] = hp[1];
ehp[3] = make_small(hp[2]);
ehp += 4;
}
break;
case matchSilent:
--esp;
if (*esp == am_true) {
erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
c_p->trace_flags |= F_TRACE_SILENT;
erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
}
else if (*esp == am_false) {
erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
c_p->trace_flags &= ~F_TRACE_SILENT;
erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
}
break;
case matchTrace2:
{
/* disable enable */
Uint d_flags = 0, e_flags = 0; /* process trace flags */
Eterm tracer = c_p->tracer_proc;
/* XXX Atomicity note: Not fully atomic. Default tracer
* is sampled from current process but applied to
* tracee and tracer later after releasing main
* locks on current process, so c_p->tracer_proc
* may actually have changed when tracee and tracer
* gets updated. I do not think nobody will notice.
* It is just the default value that is not fully atomic.
* and the real argument settable from match spec
* {trace,[],[{{tracer,Tracer}}]} is much, much older.
*/
int cputs = 0;
if (! erts_trace_flags(esp[-1], &d_flags, &tracer, &cputs) ||
! erts_trace_flags(esp[-2], &e_flags, &tracer, &cputs) ||
cputs ) {
(--esp)[-1] = FAIL_TERM;
break;
}
erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
(--esp)[-1] = set_match_trace(c_p, FAIL_TERM, tracer,
d_flags, e_flags);
erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
}
break;
case matchTrace3:
{
/* disable enable */
Uint d_flags = 0, e_flags = 0; /* process trace flags */
Eterm tracer = c_p->tracer_proc;
/* XXX Atomicity note. Not fully atomic. See above.
* Above it could possibly be solved, but not here.
*/
int cputs = 0;
Eterm tracee = (--esp)[0];
if (! erts_trace_flags(esp[-1], &d_flags, &tracer, &cputs) ||
! erts_trace_flags(esp[-2], &e_flags, &tracer, &cputs) ||
cputs ||
! (tmpp = get_proc(c_p, ERTS_PROC_LOCK_MAIN,
tracee, ERTS_PROC_LOCKS_ALL))) {
(--esp)[-1] = FAIL_TERM;
break;
}
if (tmpp == c_p) {
(--esp)[-1] = set_match_trace(c_p, FAIL_TERM, tracer,
d_flags, e_flags);
erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
} else {
erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
(--esp)[-1] = set_match_trace(tmpp, FAIL_TERM, tracer,
d_flags, e_flags);
erts_smp_proc_unlock(tmpp, ERTS_PROC_LOCKS_ALL);
erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
}
}
break;
case matchCatch:
do_catch = 1;
break;
case matchHalt:
goto success;
default:
erl_exit(1, "Internal error: unexpected opcode in match program.");
}
}
fail:
*return_flags = 0U;
if (fail_label >= 0) { /* We failed during a "TryMeElse",
lets restart, with the next match
program */
pc = (prog->text) + fail_label;
cleanup_match_pseudo_process(mpsp, 1);
goto restart;
}
ret = THE_NON_VALUE;
success:
#ifdef DMC_DEBUG
if (*heap_fence != FENCE_PATTERN) {
erl_exit(1, "Heap fence overwritten in db_prog_match after op "
"0x%08x, overwritten with 0x%08x.", save_op, *heap_fence);
}
if (*eheap_fence != FENCE_PATTERN) {
erl_exit(1, "Eheap fence overwritten in db_prog_match after op "
"0x%08x, overwritten with 0x%08x.", save_op,
*eheap_fence);
}
if (*stack_fence != FENCE_PATTERN) {
erl_exit(1, "Stack fence overwritten in db_prog_match after op "
"0x%08x, overwritten with 0x%08x.", save_op,
*stack_fence);
}
#endif
esdp->current_process = current_scheduled;
END_ATOMIC_TRACE(c_p);
return ret;
#undef FAIL
#undef FAIL_TERM
#undef BEGIN_ATOMIC_TRACE
#undef END_ATOMIC_TRACE
}
/*
* Convert a match program to a "magic" binary to return up to erlang
*/
Eterm db_make_mp_binary(Process *p, Binary *mp, Eterm **hpp) {
return erts_mk_magic_binary_term(hpp, &MSO(p), mp);
}
DMCErrInfo *db_new_dmc_err_info(void)
{
DMCErrInfo *ret = erts_alloc(ERTS_ALC_T_DB_DMC_ERR_INFO,
sizeof(DMCErrInfo));
ret->var_trans = NULL;
ret->num_trans = 0;
ret->error_added = 0;
ret->first = NULL;
return ret;
}
Eterm db_format_dmc_err_info(Process *p, DMCErrInfo *ei)
{
int sl;
int vnum;
DMCError *tmp;
Eterm *shp;
Eterm ret = NIL;
Eterm tlist, tpl, sev;
char buff[DMC_ERR_STR_LEN + 20 /* for the number */];
for (tmp = ei->first; tmp != NULL; tmp = tmp->next) {
if (tmp->variable >= 0 &&
tmp->variable < ei->num_trans &&
ei->var_trans != NULL) {
vnum = (int) ei->var_trans[tmp->variable];
} else {
vnum = tmp->variable;
}
if (vnum >= 0)
sprintf(buff,tmp->error_string, vnum);
else
strcpy(buff,tmp->error_string);
sl = strlen(buff);
shp = HAlloc(p, sl * 2 + 5);
sev = (tmp->severity == dmcWarning) ?
am_atom_put("warning",7) :
am_error;
tlist = buf_to_intlist(&shp, buff, sl, NIL);
tpl = TUPLE2(shp, sev, tlist);
shp += 3;
ret = CONS(shp, tpl, ret);
shp += 2;
}
return ret;
}
void db_free_dmc_err_info(DMCErrInfo *ei){
while (ei->first != NULL) {
DMCError *ll = ei->first->next;
erts_free(ERTS_ALC_T_DB_DMC_ERROR, ei->first);
ei->first = ll;
}
if (ei->var_trans)
erts_free(ERTS_ALC_T_DB_TRANS_TAB, ei->var_trans);
erts_free(ERTS_ALC_T_DB_DMC_ERR_INFO, ei);
}
/* Calculate integer addition: counter+incr.
** Store bignum in *hpp and increase *hpp accordingly.
** *hpp is assumed to be large enough to hold the result.
*/
Eterm db_add_counter(Eterm** hpp, Eterm counter, Eterm incr)
{
Eterm big_tmp[2];
Eterm res;
Sint ires;
Eterm arg1;
Eterm arg2;
if (is_both_small(counter,incr)) {
ires = signed_val(counter) + signed_val(incr);
if (IS_SSMALL(ires)) {
return make_small(ires);
} else {
res = small_to_big(ires, *hpp);
ASSERT(BIG_NEED_SIZE(big_size(res))==2);
*hpp += 2;
return res;
}
}
else {
switch(NUMBER_CODE(counter, incr)) {
case SMALL_BIG:
arg1 = small_to_big(signed_val(counter), big_tmp);
arg2 = incr;
break;
case BIG_SMALL:
arg1 = counter;
arg2 = small_to_big(signed_val(incr), big_tmp);
break;
case BIG_BIG:
arg1 = incr;
arg2 = counter;
break;
default:
return THE_NON_VALUE;
}
res = big_plus(arg1, arg2, *hpp);
if (is_big(res)) {
*hpp += BIG_NEED_SIZE(big_size(res));
}
return res;
}
}
/*
** Update one element:
** handle: Initialized by db_lookup_dbterm()
** position: The tuple position of the elements to be updated.
** newval: The new value of the element.
** Can not fail.
*/
void db_do_update_element(DbUpdateHandle* handle,
Sint position,
Eterm newval)
{
Eterm oldval = handle->dbterm->tpl[position];
Eterm* newp;
Eterm* oldp;
Uint newval_sz;
Uint oldval_sz;
if (is_both_immed(newval,oldval)) {
handle->dbterm->tpl[position] = newval;
return;
}
else if (!handle->mustResize && is_boxed(newval)) {
newp = boxed_val(newval);
switch (*newp & _TAG_HEADER_MASK) {
case _TAG_HEADER_POS_BIG:
case _TAG_HEADER_NEG_BIG:
case _TAG_HEADER_FLOAT:
case _TAG_HEADER_HEAP_BIN:
newval_sz = header_arity(*newp) + 1;
if (is_boxed(oldval)) {
oldp = boxed_val(oldval);
switch (*oldp & _TAG_HEADER_MASK) {
case _TAG_HEADER_POS_BIG:
case _TAG_HEADER_NEG_BIG:
case _TAG_HEADER_FLOAT:
case _TAG_HEADER_HEAP_BIN:
oldval_sz = header_arity(*oldp) + 1;
if (oldval_sz == newval_sz) {
/* "self contained" terms of same size, do memcpy */
sys_memcpy(oldp, newp, newval_sz*sizeof(Eterm));
return;
}
goto both_size_set;
}
}
goto new_size_set;
}
}
/* Not possible for simple memcpy or dbterm is already non-contiguous, */
/* need to realloc... */
newval_sz = is_immed(newval) ? 0 : size_object(newval);
new_size_set:
oldval_sz = is_immed(oldval) ? 0 : size_object(oldval);
both_size_set:
handle->new_size = handle->new_size - oldval_sz + newval_sz;
/* write new value in old dbterm, finalize will make a flat copy */
handle->dbterm->tpl[position] = newval;
handle->mustResize = 1;
}
/*
** Copy the object into a possibly new DbTerm,
** offset is the offset of the DbTerm from the start
** of the sysAllocaed structure, The possibly realloced and copied
** structure is returned. Make sure (((char *) old) - offset) is a
** pointer to a ERTS_ALC_T_DB_TERM allocated data area.
*/
void* db_get_term(DbTableCommon *tb, DbTerm* old, Uint offset, Eterm obj)
{
int size = size_object(obj);
void *structp = ((char*) old) - offset;
DbTerm* p;
Eterm copy;
Eterm *top;
if (old != 0) {
erts_cleanup_offheap(&old->off_heap);
if (size == old->size) {
p = old;
} else {
Uint new_sz = offset + sizeof(DbTerm) + sizeof(Eterm)*(size-1);
Uint old_sz = offset + sizeof(DbTerm) + sizeof(Eterm)*(old->size-1);
if (erts_ets_realloc_always_moves) {
void *nstructp = erts_db_alloc(ERTS_ALC_T_DB_TERM,
(DbTable *) tb,
new_sz);
memcpy(nstructp,structp,offset);
erts_db_free(ERTS_ALC_T_DB_TERM,
(DbTable *) tb,
structp,
old_sz);
structp = nstructp;
} else {
structp = erts_db_realloc(ERTS_ALC_T_DB_TERM,
(DbTable *) tb,
structp,
old_sz,
new_sz);
}
p = (DbTerm*) ((void *)(((char *) structp) + offset));
}
}
else {
structp = erts_db_alloc(ERTS_ALC_T_DB_TERM,
(DbTable *) tb,
(offset
+ sizeof(DbTerm)
+ sizeof(Eterm)*(size-1)));
p = (DbTerm*) ((void *)(((char *) structp) + offset));
}
p->size = size;
p->off_heap.mso = NULL;
p->off_heap.externals = NULL;
#ifndef HYBRID /* FIND ME! */
p->off_heap.funs = NULL;
#endif
p->off_heap.overhead = 0;
top = DBTERM_BUF(p);
copy = copy_struct(obj, size, &top, &p->off_heap);
DBTERM_SET_TPL(p,tuple_val(copy));
return structp;
}
void db_free_term_data(DbTerm* p)
{
erts_cleanup_offheap(&p->off_heap);
}
/*
** Check if object represents a "match" variable
** i.e and atom $N where N is an integer
**
*/
int db_is_variable(Eterm obj)
{
byte *b;
int n;
int N;
if (is_not_atom(obj))
return -1;
b = atom_tab(atom_val(obj))->name;
if ((n = atom_tab(atom_val(obj))->len) < 2)
return -1;
if (*b++ != '$')
return -1;
n--;
/* Handle first digit */
if (*b == '0')
return (n == 1) ? 0 : -1;
if (*b >= '1' && *b <= '9')
N = *b++ - '0';
else
return -1;
n--;
while(n--) {
if (*b >= '0' && *b <= '9') {
N = N*10 + (*b - '0');
b++;
}
else
return -1;
}
return N;
}
/* check if obj is (or contains) a variable */
/* return 1 if obj contains a variable or underscore */
/* return 0 if obj is fully ground */
int db_has_variable(Eterm obj)
{
switch(obj & _TAG_PRIMARY_MASK) {
case TAG_PRIMARY_LIST: {
while (is_list(obj)) {
if (db_has_variable(CAR(list_val(obj))))
return 1;
obj = CDR(list_val(obj));
}
return(db_has_variable(obj)); /* Non wellformed list or [] */
}
case TAG_PRIMARY_BOXED:
if (!BOXED_IS_TUPLE(obj)) {
return 0;
} else {
Eterm *tuple = tuple_val(obj);
int arity = arityval(*tuple++);
while(arity--) {
if (db_has_variable(*tuple))
return 1;
tuple++;
}
return(0);
}
case TAG_PRIMARY_IMMED1:
if (obj == am_Underscore || db_is_variable(obj) >= 0)
return 1;
}
return 0;
}
int erts_db_is_compiled_ms(Eterm term)
{
return (is_binary(term)
&& (thing_subtag(*binary_val(term)) == REFC_BINARY_SUBTAG)
&& IsMatchProgBinary((((ProcBin *) binary_val(term))->val)));
}
/*
** Local (static) utilities.
*/
/*
***************************************************************************
** Compiled matches
***************************************************************************
*/
/*
** Utility to add an error
*/
static void add_dmc_err(DMCErrInfo *err_info,
char *str,
int variable,
Eterm term,
DMCErrorSeverity severity)
{
/* Linked in in reverse order, to ease the formatting */
DMCError *e = erts_alloc(ERTS_ALC_T_DB_DMC_ERROR, sizeof(DMCError));
if (term != 0UL) {
erts_snprintf(e->error_string, DMC_ERR_STR_LEN, str, term);
} else {
strncpy(e->error_string, str, DMC_ERR_STR_LEN);
e->error_string[DMC_ERR_STR_LEN] ='\0';
}
e->variable = variable;
e->severity = severity;
e->next = err_info->first;
#ifdef HARDDEBUG
erts_fprintf(stderr,"add_dmc_err: %s\n",e->error_string);
#endif
err_info->first = e;
if (severity >= dmcError)
err_info->error_added = 1;
}
/*
** Handle one term in the match expression (not the guard)
*/
static DMCRet dmc_one_term(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Eterm) *stack,
DMC_STACK_TYPE(Uint) *text,
Eterm c)
{
Sint n;
Eterm *hp;
ErlHeapFragment *tmp_mb;
Uint sz, sz2, sz3;
Uint i, j;
switch (c & _TAG_PRIMARY_MASK) {
case TAG_PRIMARY_IMMED1:
if ((n = db_is_variable(c)) >= 0) { /* variable */
if (n >= heap->size) {
/*
** Ouch, big integer in match variable.
*/
Eterm *save_hp;
ASSERT(heap->data == heap->def);
sz = sz2 = sz3 = 0;
for (j = 0; j < context->num_match; ++j) {
sz += size_object(context->matchexpr[j]);
sz2 += size_object(context->guardexpr[j]);
sz3 += size_object(context->bodyexpr[j]);
}
context->copy =
new_message_buffer(sz + sz2 + sz3 +
context->num_match);
save_hp = hp = context->copy->mem;
hp += context->num_match;
for (j = 0; j < context->num_match; ++j) {
context->matchexpr[j] =
copy_struct(context->matchexpr[j],
size_object(context->matchexpr[j]), &hp,
&(context->copy->off_heap));
context->guardexpr[j] =
copy_struct(context->guardexpr[j],
size_object(context->guardexpr[j]), &hp,
&(context->copy->off_heap));
context->bodyexpr[j] =
copy_struct(context->bodyexpr[j],
size_object(context->bodyexpr[j]), &hp,
&(context->copy->off_heap));
}
for (j = 0; j < context->num_match; ++j) {
/* the actual expressions can be
atoms in their selves, place them first */
*save_hp++ = context->matchexpr[j];
}
heap->size = match_compact(context->copy,
context->err_info);
for (j = 0; j < context->num_match; ++j) {
/* restore the match terms, as they
may be atoms that changed */
context->matchexpr[j] = context->copy->mem[j];
}
heap->data = erts_alloc(ERTS_ALC_T_DB_MS_CMPL_HEAP,
heap->size*sizeof(unsigned));
sys_memset(heap->data, 0,
heap->size * sizeof(unsigned));
DMC_CLEAR(*stack);
/*DMC_PUSH(*stack,NIL);*/
DMC_CLEAR(*text);
return retRestart;
}
if (heap->data[n]) { /* already bound ? */
DMC_PUSH(*text,matchCmp);
DMC_PUSH(*text,n);
} else { /* Not bound, bind! */
if (n >= heap->used)
heap->used = n + 1;
DMC_PUSH(*text,matchBind);
DMC_PUSH(*text,n);
heap->data[n] = 1;
}
} else if (c == am_Underscore) {
DMC_PUSH(*text, matchSkip);
} else { /* Any immediate value */
DMC_PUSH(*text, matchEq);
DMC_PUSH(*text, (Uint) c);
}
break;
case TAG_PRIMARY_LIST:
DMC_PUSH(*text, matchPushL);
++(context->stack_used);
DMC_PUSH(*stack, c);
break;
case TAG_PRIMARY_BOXED: {
Eterm hdr = *boxed_val(c);
switch ((hdr & _TAG_HEADER_MASK) >> _TAG_PRIMARY_SIZE) {
case (_TAG_HEADER_ARITYVAL >> _TAG_PRIMARY_SIZE):
n = arityval(*tuple_val(c));
DMC_PUSH(*text, matchPushT);
++(context->stack_used);
DMC_PUSH(*text, n);
DMC_PUSH(*stack, c);
break;
case (_TAG_HEADER_REF >> _TAG_PRIMARY_SIZE):
n = thing_arityval(*internal_ref_val(c));
DMC_PUSH(*text, matchEqRef);
DMC_PUSH(*text, *internal_ref_val(c));
for (i = 1; i <= n; ++i) {
DMC_PUSH(*text, (Uint) internal_ref_val(c)[i]);
}
break;
case (_TAG_HEADER_POS_BIG >> _TAG_PRIMARY_SIZE):
case (_TAG_HEADER_NEG_BIG >> _TAG_PRIMARY_SIZE):
n = thing_arityval(*big_val(c));
DMC_PUSH(*text, matchEqBig);
DMC_PUSH(*text, *big_val(c));
for (i = 1; i <= n; ++i) {
DMC_PUSH(*text, (Uint) big_val(c)[i]);
}
break;
case (_TAG_HEADER_FLOAT >> _TAG_PRIMARY_SIZE):
DMC_PUSH(*text,matchEqFloat);
DMC_PUSH(*text, (Uint) float_val(c)[1]);
/* XXX: this reads and pushes random junk on ARCH_64 */
DMC_PUSH(*text, (Uint) float_val(c)[2]);
break;
default: /* BINARY, FUN, VECTOR, or EXTERNAL */
/*
** Make a private copy...
*/
n = size_object(c);
tmp_mb = new_message_buffer(n);
hp = tmp_mb->mem;
DMC_PUSH(*text, matchEqBin);
DMC_PUSH(*text, copy_struct(c, n, &hp, &(tmp_mb->off_heap)));
tmp_mb->next = context->save;
context->save = tmp_mb;
break;
}
break;
}
default:
erl_exit(1, "db_match_compile: "
"Bad object on heap: 0x%08lx\n",
(unsigned long) c);
}
return retOk;
}
/*
** Match guard compilation
*/
static void do_emit_constant(DMCContext *context, DMC_STACK_TYPE(Uint) *text,
Eterm t)
{
int sz;
ErlHeapFragment *emb;
Eterm *hp;
Eterm tmp;
if (IS_CONST(t)) {
tmp = t;
} else {
sz = my_size_object(t);
emb = new_message_buffer(sz);
hp = emb->mem;
tmp = my_copy_struct(t,&hp,&(emb->off_heap));
emb->next = context->save;
context->save = emb;
}
DMC_PUSH(*text,matchPushC);
DMC_PUSH(*text,(Uint) tmp);
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
}
#define RETURN_ERROR_X(String, X, Y, ContextP, ConstantF) \
do { \
if ((ContextP)->err_info != NULL) { \
(ConstantF) = 0; \
add_dmc_err((ContextP)->err_info, String, X, Y, dmcError); \
return retOk; \
} else \
return retFail; \
} while(0)
#define RETURN_ERROR(String, ContextP, ConstantF) \
RETURN_ERROR_X(String, -1, 0UL, ContextP, ConstantF)
#define RETURN_VAR_ERROR(String, N, ContextP, ConstantF) \
RETURN_ERROR_X(String, N, 0UL, ContextP, ConstantF)
#define RETURN_TERM_ERROR(String, T, ContextP, ConstantF) \
RETURN_ERROR_X(String, -1, T, ContextP, ConstantF)
#define WARNING(String, ContextP) \
add_dmc_err((ContextP)->err_info, String, -1, 0UL, dmcWarning)
#define VAR_WARNING(String, N, ContextP) \
add_dmc_err((ContextP)->err_info, String, N, 0UL, dmcWarning)
#define TERM_WARNING(String, T, ContextP) \
add_dmc_err((ContextP)->err_info, String, -1, T, dmcWarning)
static DMCRet dmc_list(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
int c1;
int c2;
int ret;
if ((ret = dmc_expr(context, heap, text, CAR(list_val(t)), &c1)) != retOk)
return ret;
if ((ret = dmc_expr(context, heap, text, CDR(list_val(t)), &c2)) != retOk)
return ret;
if (c1 && c2) {
*constant = 1;
return retOk;
}
*constant = 0;
if (!c1) {
/* The CAR is not a constant, so if the CDR is, we just push it,
otherwise it is already pushed. */
if (c2)
do_emit_constant(context, text, CDR(list_val(t)));
DMC_PUSH(*text, matchConsA);
} else { /* !c2 && c1 */
do_emit_constant(context, text, CAR(list_val(t)));
DMC_PUSH(*text, matchConsB);
}
--context->stack_used; /* Two objects on stack becomes one */
context->eheap_need += 2;
return retOk;
}
static DMCRet dmc_tuple(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
DMC_STACK_TYPE(Uint) instr_save;
int all_constant = 1;
int textpos = DMC_STACK_NUM(*text);
Eterm *p = tuple_val(t);
Uint nelems = arityval(*p);
Uint i;
int c;
DMCRet ret;
/*
** We remember where we started to layout code,
** assume all is constant and back up and restart if not so.
** The tuple should be laid out with the last element first,
** so we can memcpy the tuple to the eheap.
*/
for (i = nelems; i > 0; --i) {
if ((ret = dmc_expr(context, heap, text, p[i], &c)) != retOk)
return ret;
if (!c && all_constant) {
all_constant = 0;
if (i < nelems) {
Uint j;
/*
* Oops, we need to relayout the constants.
* Save the already laid out instructions.
*/
DMC_INIT_STACK(instr_save);
while (DMC_STACK_NUM(*text) > textpos)
DMC_PUSH(instr_save, DMC_POP(*text));
for (j = nelems; j > i; --j)
do_emit_constant(context, text, p[j]);
while(!DMC_EMPTY(instr_save))
DMC_PUSH(*text, DMC_POP(instr_save));
DMC_FREE(instr_save);
}
} else if (c && !all_constant) {
/* push a constant */
do_emit_constant(context, text, p[i]);
}
}
if (all_constant) {
*constant = 1;
return retOk;
}
DMC_PUSH(*text, matchMkTuple);
DMC_PUSH(*text, nelems);
context->stack_used -= (nelems - 1);
context->eheap_need += (nelems + 1);
*constant = 0;
return retOk;
}
static DMCRet dmc_whole_expression(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
if (context->cflags & DCOMP_TRACE) {
/* Hmmm, convert array to list... */
if (context->special) {
DMC_PUSH(*text, matchPushArrayAsListU);
} else {
ASSERT(is_tuple(context->matchexpr
[context->current_match]));
context->eheap_need +=
arityval(*(tuple_val(context->matchexpr
[context->current_match]))) * 2;
DMC_PUSH(*text, matchPushArrayAsList);
}
} else {
DMC_PUSH(*text, matchPushExpr);
}
++context->stack_used;
if (context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
*constant = 0;
return retOk;
}
static DMCRet dmc_variable(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Uint n = db_is_variable(t);
ASSERT(n >= 0);
if (n >= heap->used)
RETURN_VAR_ERROR("Variable $%d is unbound.", n, context, *constant);
if (heap->data[n] == 0U)
RETURN_VAR_ERROR("Variable $%d is unbound.", n, context, *constant);
DMC_PUSH(*text, matchPushV);
DMC_PUSH(*text, n);
++context->stack_used;
if (context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
*constant = 0;
return retOk;
}
static DMCRet dmc_all_bindings(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
int i;
int heap_used = 0;
DMC_PUSH(*text, matchPushC);
DMC_PUSH(*text, NIL);
for (i = heap->used - 1; i >= 0; --i) {
if (heap->data[i]) {
DMC_PUSH(*text, matchPushV);
DMC_PUSH(*text, i);
DMC_PUSH(*text, matchConsB);
heap_used += 2;
}
}
++context->stack_used;
if ((context->stack_used + 1) > context->stack_need)
context->stack_need = (context->stack_used + 1);
context->eheap_need += heap_used;
*constant = 0;
return retOk;
}
static DMCRet dmc_const(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (a != 2) {
RETURN_TERM_ERROR("Special form 'const' called with more than one "
"argument in %T.", t, context, *constant);
}
*constant = 1;
return retOk;
}
static DMCRet dmc_and(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int i;
int c;
if (a < 2) {
RETURN_TERM_ERROR("Special form 'and' called without arguments "
"in %T.", t, context, *constant);
}
*constant = 0;
for (i = a; i > 1; --i) {
if ((ret = dmc_expr(context, heap, text, p[i], &c)) != retOk)
return ret;
if (c)
do_emit_constant(context, text, p[i]);
}
DMC_PUSH(*text, matchAnd);
DMC_PUSH(*text, (Uint) a - 1);
context->stack_used -= (a - 2);
return retOk;
}
static DMCRet dmc_or(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int i;
int c;
if (a < 2) {
RETURN_TERM_ERROR("Special form 'or' called without arguments "
"in %T.", t, context, *constant);
}
*constant = 0;
for (i = a; i > 1; --i) {
if ((ret = dmc_expr(context, heap, text, p[i], &c)) != retOk)
return ret;
if (c)
do_emit_constant(context, text, p[i]);
}
DMC_PUSH(*text, matchOr);
DMC_PUSH(*text, (Uint) a - 1);
context->stack_used -= (a - 2);
return retOk;
}
static DMCRet dmc_andalso(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int i;
int c;
Uint lbl;
Uint lbl_next;
Uint lbl_val;
if (a < 2) {
RETURN_TERM_ERROR("Special form 'andalso' called without"
" arguments "
"in %T.", t, context, *constant);
}
*constant = 0;
lbl = 0;
for (i = 2; i <= a; ++i) {
if ((ret = dmc_expr(context, heap, text, p[i], &c)) != retOk)
return ret;
if (c)
do_emit_constant(context, text, p[i]);
if (i == a) {
DMC_PUSH(*text, matchJump);
} else {
DMC_PUSH(*text, matchAndAlso);
}
DMC_PUSH(*text, lbl);
lbl = DMC_STACK_NUM(*text)-1;
--(context->stack_used);
}
DMC_PUSH(*text, matchPushC);
DMC_PUSH(*text, am_true);
lbl_val = DMC_STACK_NUM(*text);
while (lbl) {
lbl_next = DMC_PEEK(*text, lbl);
DMC_POKE(*text, lbl, lbl_val-lbl-1);
lbl = lbl_next;
}
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_orelse(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int i;
int c;
Uint lbl;
Uint lbl_next;
Uint lbl_val;
if (a < 2) {
RETURN_TERM_ERROR("Special form 'orelse' called without arguments "
"in %T.", t, context, *constant);
}
*constant = 0;
lbl = 0;
for (i = 2; i <= a; ++i) {
if ((ret = dmc_expr(context, heap, text, p[i], &c)) != retOk)
return ret;
if (c)
do_emit_constant(context, text, p[i]);
if (i == a) {
DMC_PUSH(*text, matchJump);
} else {
DMC_PUSH(*text, matchOrElse);
}
DMC_PUSH(*text, lbl);
lbl = DMC_STACK_NUM(*text)-1;
--(context->stack_used);
}
DMC_PUSH(*text, matchPushC);
DMC_PUSH(*text, am_false);
lbl_val = DMC_STACK_NUM(*text);
while (lbl) {
lbl_next = DMC_PEEK(*text, lbl);
DMC_POKE(*text, lbl, lbl_val-lbl-1);
lbl = lbl_next;
}
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_message(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'message' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'message' called in guard context.",
context,
*constant);
}
if (a != 2) {
RETURN_TERM_ERROR("Special form 'message' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchReturn);
DMC_PUSH(*text, matchPushC);
DMC_PUSH(*text, am_true);
/* Push as much as we remove, stack_need is untouched */
return retOk;
}
static DMCRet dmc_self(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (a != 1) {
RETURN_TERM_ERROR("Special form 'self' called with arguments "
"in %T.", t, context, *constant);
}
*constant = 0;
DMC_PUSH(*text, matchSelf);
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_return_trace(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'return_trace' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'return_trace' called in "
"guard context.", context, *constant);
}
if (a != 1) {
RETURN_TERM_ERROR("Special form 'return_trace' called with "
"arguments in %T.", t, context, *constant);
}
*constant = 0;
DMC_PUSH(*text, matchSetReturnTrace); /* Pushes 'true' on the stack */
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_exception_trace(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'exception_trace' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'exception_trace' called in "
"guard context.", context, *constant);
}
if (a != 1) {
RETURN_TERM_ERROR("Special form 'exception_trace' called with "
"arguments in %T.", t, context, *constant);
}
*constant = 0;
DMC_PUSH(*text, matchSetExceptionTrace); /* Pushes 'true' on the stack */
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_is_seq_trace(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'is_seq_trace' used in wrong dialect.",
context,
*constant);
}
if (a != 1) {
RETURN_TERM_ERROR("Special form 'is_seq_trace' called with "
"arguments in %T.", t, context, *constant);
}
*constant = 0;
DMC_PUSH(*text, matchIsSeqTrace);
/* Pushes 'true' or 'false' on the stack */
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_set_seq_token(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'set_seq_token' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'set_seq_token' called in "
"guard context.", context, *constant);
}
if (a != 3) {
RETURN_TERM_ERROR("Special form 'set_seq_token' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[3], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[3]);
}
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
if (context->cflags & DCOMP_FAKE_DESTRUCTIVE) {
DMC_PUSH(*text, matchSetSeqTokenFake);
} else {
DMC_PUSH(*text, matchSetSeqToken);
}
--context->stack_used; /* Remove two and add one */
return retOk;
}
static DMCRet dmc_get_seq_token(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'get_seq_token' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'get_seq_token' called in "
"guard context.", context, *constant);
}
if (a != 1) {
RETURN_TERM_ERROR("Special form 'get_seq_token' called with "
"arguments in %T.", t, context,
*constant);
}
*constant = 0;
DMC_PUSH(*text, matchGetSeqToken);
context->eheap_need += (6 /* A 5-tuple is built */
+ EXTERNAL_THING_HEAD_SIZE + 2 /* Sender can
be an external
pid */);
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_display(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'display' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'display' called in guard context.",
context,
*constant);
}
if (a != 2) {
RETURN_TERM_ERROR("Special form 'display' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchDisplay);
/* Push as much as we remove, stack_need is untouched */
return retOk;
}
static DMCRet dmc_process_dump(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'process_dump' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'process_dump' called in "
"guard context.", context, *constant);
}
if (a != 1) {
RETURN_TERM_ERROR("Special form 'process_dump' called with "
"arguments in %T.", t, context, *constant);
}
*constant = 0;
DMC_PUSH(*text, matchProcessDump); /* Creates binary */
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_enable_trace(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'enable_trace' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'enable_trace' called in guard context.",
context,
*constant);
}
switch (a) {
case 2:
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchEnableTrace);
/* Push as much as we remove, stack_need is untouched */
break;
case 3:
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[3], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[3]);
}
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchEnableTrace2);
--context->stack_used; /* Remove two and add one */
break;
default:
RETURN_TERM_ERROR("Special form 'enable_trace' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
return retOk;
}
static DMCRet dmc_disable_trace(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'disable_trace' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'disable_trace' called in guard context.",
context,
*constant);
}
switch (a) {
case 2:
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchDisableTrace);
/* Push as much as we remove, stack_need is untouched */
break;
case 3:
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[3], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[3]);
}
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchDisableTrace2);
--context->stack_used; /* Remove two and add one */
break;
default:
RETURN_TERM_ERROR("Special form 'disable_trace' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
return retOk;
}
static DMCRet dmc_trace(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'trace' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'trace' called in guard context.",
context,
*constant);
}
switch (a) {
case 3:
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[3], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[3]);
}
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchTrace2);
--context->stack_used; /* Remove two and add one */
break;
case 4:
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[4], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[4]);
}
if ((ret = dmc_expr(context, heap, text, p[3], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[3]);
}
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchTrace3);
context->stack_used -= 2; /* Remove three and add one */
break;
default:
RETURN_TERM_ERROR("Special form 'trace' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
return retOk;
}
static DMCRet dmc_caller(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'caller' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'caller' called in "
"guard context.", context, *constant);
}
if (a != 1) {
RETURN_TERM_ERROR("Special form 'caller' called with "
"arguments in %T.", t, context, *constant);
}
*constant = 0;
DMC_PUSH(*text, matchCaller); /* Creates binary */
context->eheap_need += 4; /* A 3-tuple is built */
if (++context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_silent(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
DMCRet ret;
int c;
if (!(context->cflags & DCOMP_TRACE)) {
RETURN_ERROR("Special form 'silent' used in wrong dialect.",
context,
*constant);
}
if (context->is_guard) {
RETURN_ERROR("Special form 'silent' called in "
"guard context.", context, *constant);
}
if (a != 2) {
RETURN_TERM_ERROR("Special form 'silent' called with wrong "
"number of arguments in %T.", t, context,
*constant);
}
*constant = 0;
if ((ret = dmc_expr(context, heap, text, p[2], &c)) != retOk) {
return ret;
}
if (c) {
do_emit_constant(context, text, p[2]);
}
DMC_PUSH(*text, matchSilent);
DMC_PUSH(*text, matchPushC);
DMC_PUSH(*text, am_true);
/* Push as much as we remove, stack_need is untouched */
return retOk;
}
static DMCRet dmc_fun(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
Eterm *p = tuple_val(t);
Uint a = arityval(*p);
int c;
int i;
DMCRet ret;
DMCGuardBif *b;
/* Special forms. */
switch (p[1]) {
case am_const:
return dmc_const(context, heap, text, t, constant);
case am_and:
return dmc_and(context, heap, text, t, constant);
case am_or:
return dmc_or(context, heap, text, t, constant);
case am_andalso:
case am_andthen:
return dmc_andalso(context, heap, text, t, constant);
case am_orelse:
return dmc_orelse(context, heap, text, t, constant);
case am_self:
return dmc_self(context, heap, text, t, constant);
case am_message:
return dmc_message(context, heap, text, t, constant);
case am_is_seq_trace:
return dmc_is_seq_trace(context, heap, text, t, constant);
case am_set_seq_token:
return dmc_set_seq_token(context, heap, text, t, constant);
case am_get_seq_token:
return dmc_get_seq_token(context, heap, text, t, constant);
case am_return_trace:
return dmc_return_trace(context, heap, text, t, constant);
case am_exception_trace:
return dmc_exception_trace(context, heap, text, t, constant);
case am_display:
return dmc_display(context, heap, text, t, constant);
case am_process_dump:
return dmc_process_dump(context, heap, text, t, constant);
case am_enable_trace:
return dmc_enable_trace(context, heap, text, t, constant);
case am_disable_trace:
return dmc_disable_trace(context, heap, text, t, constant);
case am_trace:
return dmc_trace(context, heap, text, t, constant);
case am_caller:
return dmc_caller(context, heap, text, t, constant);
case am_silent:
return dmc_silent(context, heap, text, t, constant);
case am_set_tcw:
if (context->cflags & DCOMP_FAKE_DESTRUCTIVE) {
b = dmc_lookup_bif(am_set_tcw_fake, ((int) a) - 1);
} else {
b = dmc_lookup_bif(p[1], ((int) a) - 1);
}
break;
default:
b = dmc_lookup_bif(p[1], ((int) a) - 1);
}
if (b == NULL) {
if (context->err_info != NULL) {
/* Ugly, should define a better RETURN_TERM_ERROR interface... */
char buff[100];
sprintf(buff, "Function %%T/%d does_not_exist.", (int)a - 1);
RETURN_TERM_ERROR(buff, p[1], context, *constant);
} else {
return retFail;
}
}
ASSERT(b->arity == ((int) a) - 1);
if (! (b->flags &
(1 <<
((context->cflags & DCOMP_DIALECT_MASK) +
(context->is_guard ? DBIF_GUARD : DBIF_BODY))))) {
/* Body clause used in wrong context. */
if (context->err_info != NULL) {
/* Ugly, should define a better RETURN_TERM_ERROR interface... */
char buff[100];
sprintf(buff,
"Function %%T/%d cannot be called in this context.",
(int)a - 1);
RETURN_TERM_ERROR(buff, p[1], context, *constant);
} else {
return retFail;
}
}
*constant = 0;
for (i = a; i > 1; --i) {
if ((ret = dmc_expr(context, heap, text, p[i], &c)) != retOk)
return ret;
if (c)
do_emit_constant(context, text, p[i]);
}
switch (b->arity) {
case 0:
DMC_PUSH(*text, matchCall0);
break;
case 1:
DMC_PUSH(*text, matchCall1);
break;
case 2:
DMC_PUSH(*text, matchCall2);
break;
case 3:
DMC_PUSH(*text, matchCall3);
break;
default:
erl_exit(1,"ets:match() internal error, "
"guard with more than 3 arguments.");
}
DMC_PUSH(*text, (Uint) b->biff);
context->stack_used -= (((int) a) - 2);
if (context->stack_used > context->stack_need)
context->stack_need = context->stack_used;
return retOk;
}
static DMCRet dmc_expr(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm t,
int *constant)
{
DMCRet ret;
Eterm tmp;
Eterm *p;
switch (t & _TAG_PRIMARY_MASK) {
case TAG_PRIMARY_LIST:
if ((ret = dmc_list(context, heap, text, t, constant)) != retOk)
return ret;
break;
case TAG_PRIMARY_BOXED:
if (!BOXED_IS_TUPLE(t)) {
goto simple_term;
}
p = tuple_val(t);
#ifdef HARDDEBUG
erts_fprintf(stderr,"%d %d %d %d\n",arityval(*p),is_tuple(tmp = p[1]),
is_atom(p[1]),db_is_variable(p[1]));
#endif
if (arityval(*p) == 1 && is_tuple(tmp = p[1])) {
if ((ret = dmc_tuple(context, heap, text, tmp, constant)) != retOk)
return ret;
} else if (arityval(*p) >= 1 && is_atom(p[1]) &&
!(db_is_variable(p[1]) >= 0)) {
if ((ret = dmc_fun(context, heap, text, t, constant)) != retOk)
return ret;
} else
RETURN_TERM_ERROR("%T is neither a function call, nor a tuple "
"(tuples are written {{ ... }}).", t,
context, *constant);
break;
case TAG_PRIMARY_IMMED1:
if (db_is_variable(t) >= 0) {
if ((ret = dmc_variable(context, heap, text, t, constant))
!= retOk)
return ret;
break;
} else if (t == am_DollarUnderscore) {
if ((ret = dmc_whole_expression(context, heap, text, t, constant))
!= retOk)
return ret;
break;
} else if (t == am_DollarDollar) {
if ((ret = dmc_all_bindings(context, heap, text, t, constant))
!= retOk)
return ret;
break;
}
/* Fall through */
default:
simple_term:
*constant = 1;
}
return retOk;
}
static DMCRet compile_guard_expr(DMCContext *context,
DMCHeap *heap,
DMC_STACK_TYPE(Uint) *text,
Eterm l)
{
DMCRet ret;
int constant;
Eterm t;
if (l != NIL) {
if (!is_list(l))
RETURN_ERROR("Match expression is not a list.",
context, constant);
if (!(context->is_guard)) {
DMC_PUSH(*text, matchCatch);
}
while (is_list(l)) {
constant = 0;
t = CAR(list_val(l));
if ((ret = dmc_expr(context, heap, text, t, &constant)) !=
retOk)
return ret;
if (constant) {
do_emit_constant(context, text, t);
}
l = CDR(list_val(l));
if (context->is_guard) {
DMC_PUSH(*text,matchTrue);
} else {
DMC_PUSH(*text,matchWaste);
}
--context->stack_used;
}
if (l != NIL)
RETURN_ERROR("Match expression is not a proper list.",
context, constant);
if (!(context->is_guard) && (context->cflags & DCOMP_TABLE)) {
ASSERT(matchWaste == DMC_TOP(*text));
(void) DMC_POP(*text);
DMC_PUSH(*text, matchReturn); /* Same impact on stack as
matchWaste */
}
}
return retOk;
}
/*
** Match compilation utility code
*/
/*
** Handling of bif's in match guard expressions
*/
static DMCGuardBif *dmc_lookup_bif(Eterm t, int arity)
{
/*
** Place for optimization, bsearch is slower than inlining it...
*/
DMCGuardBif node = {0,NULL,0};
node.name = t;
node.arity = arity;
return bsearch(&node,
guard_tab,
sizeof(guard_tab) / sizeof(DMCGuardBif),
sizeof(DMCGuardBif),
(int (*)(const void *, const void *)) &cmp_guard_bif);
}
#ifdef DMC_DEBUG
static Eterm dmc_lookup_bif_reversed(void *f)
{
int i;
for (i = 0; i < (sizeof(guard_tab) / sizeof(DMCGuardBif)); ++i)
if (f == guard_tab[i].biff)
return guard_tab[i].name;
return am_undefined;
}
#endif
/* For sorting. */
static int cmp_uint(void *a, void *b)
{
if (*((unsigned *)a) < *((unsigned *)b))
return -1;
else
return (*((unsigned *)a) > *((unsigned *)b));
}
static int cmp_guard_bif(void *a, void *b)
{
int ret;
if (( ret = ((int) atom_val(((DMCGuardBif *) a)->name)) -
((int) atom_val(((DMCGuardBif *) b)->name)) ) == 0) {
ret = ((DMCGuardBif *) a)->arity - ((DMCGuardBif *) b)->arity;
}
return ret;
}
/*
** Compact the variables in a match expression i e make {$1, $100, $1000}
** become {$0,$1,$2}.
*/
static int match_compact(ErlHeapFragment *expr, DMCErrInfo *err_info)
{
int i, j, a, n, x;
DMC_STACK_TYPE(unsigned) heap;
Eterm *p;
char buff[25] = "$"; /* large enough for 64 bit to */
int ret;
DMC_INIT_STACK(heap);
p = expr->mem;
i = expr->size;
while (i--) {
if (is_thing(*p)) {
a = thing_arityval(*p);
ASSERT(a <= i);
i -= a;
p += a;
} else if (is_atom(*p) && (n = db_is_variable(*p)) >= 0) {
x = DMC_STACK_NUM(heap);
for (j = 0; j < x && DMC_PEEK(heap,j) != n; ++j)
;
if (j == x)
DMC_PUSH(heap,n);
}
++p;
}
qsort(DMC_STACK_DATA(heap), DMC_STACK_NUM(heap), sizeof(unsigned),
(int (*)(const void *, const void *)) &cmp_uint);
if (err_info != NULL) { /* lint needs a translation table */
err_info->var_trans = erts_alloc(ERTS_ALC_T_DB_TRANS_TAB,
sizeof(unsigned)*DMC_STACK_NUM(heap));
sys_memcpy(err_info->var_trans, DMC_STACK_DATA(heap),
DMC_STACK_NUM(heap) * sizeof(unsigned));
err_info->num_trans = DMC_STACK_NUM(heap);
}
p = expr->mem;
i = expr->size;
while (i--) {
if (is_thing(*p)) {
a = thing_arityval(*p);
i -= a;
p += a;
} else if (is_atom(*p) && (n = db_is_variable(*p)) >= 0) {
x = DMC_STACK_NUM(heap);
#ifdef HARDDEBUG
erts_fprintf(stderr, "%T");
#endif
for (j = 0; j < x && DMC_PEEK(heap,j) != n; ++j)
;
ASSERT(j < x);
sprintf(buff+1,"%u", (unsigned) j);
/* Yes, writing directly into terms, they ARE off heap */
*p = am_atom_put(buff, strlen(buff));
}
++p;
}
ret = DMC_STACK_NUM(heap);
DMC_FREE(heap);
return ret;
}
/*
** Simple size object that takes care of function calls and constant tuples
*/
static Uint my_size_object(Eterm t)
{
Uint sum = 0;
Eterm tmp;
Eterm *p;
switch (t & _TAG_PRIMARY_MASK) {
case TAG_PRIMARY_LIST:
sum += 2 + my_size_object(CAR(list_val(t))) +
my_size_object(CDR(list_val(t)));
break;
case TAG_PRIMARY_BOXED:
if ((((*boxed_val(t)) &
_TAG_HEADER_MASK) >> _TAG_PRIMARY_SIZE) !=
(_TAG_HEADER_ARITYVAL >> _TAG_PRIMARY_SIZE)) {
goto simple_term;
}
if (arityval(*tuple_val(t)) == 1 && is_tuple(tmp = tuple_val(t)[1])) {
Uint i,n;
p = tuple_val(tmp);
n = arityval(p[0]);
sum += 1 + n;
for (i = 1; i <= n; ++i)
sum += my_size_object(p[i]);
} else if (arityval(*tuple_val(t)) == 2 &&
is_atom(tmp = tuple_val(t)[1]) &&
tmp == am_const) {
sum += size_object(tuple_val(t)[2]);
} else {
erl_exit(1,"Internal error, sizing unrecognized object in "
"(d)ets:match compilation.");
}
break;
default:
simple_term:
sum += size_object(t);
break;
}
return sum;
}
static Eterm my_copy_struct(Eterm t, Eterm **hp, ErlOffHeap* off_heap)
{
Eterm ret = NIL, a, b;
Eterm *p;
Uint sz;
switch (t & _TAG_PRIMARY_MASK) {
case TAG_PRIMARY_LIST:
a = my_copy_struct(CAR(list_val(t)), hp, off_heap);
b = my_copy_struct(CDR(list_val(t)), hp, off_heap);
ret = CONS(*hp, a, b);
*hp += 2;
break;
case TAG_PRIMARY_BOXED:
if (BOXED_IS_TUPLE(t)) {
if (arityval(*tuple_val(t)) == 1 &&
is_tuple(a = tuple_val(t)[1])) {
Uint i,n;
Eterm *savep = *hp;
ret = make_tuple(savep);
p = tuple_val(a);
n = arityval(p[0]);
*hp += n + 1;
*savep++ = make_arityval(n);
for(i = 1; i <= n; ++i)
*savep++ = my_copy_struct(p[i], hp, off_heap);
} else if (arityval(*tuple_val(t)) == 2 &&
is_atom(a = tuple_val(t)[1]) &&
a == am_const) {
/* A {const, XXX} expression */
b = tuple_val(t)[2];
sz = size_object(b);
ret = copy_struct(b,sz,hp,off_heap);
} else {
erl_exit(1, "Trying to constant-copy non constant expression "
"0x%08x in (d)ets:match compilation.", (unsigned long) t);
}
} else {
sz = size_object(t);
ret = copy_struct(t,sz,hp,off_heap);
}
break;
default:
ret = t;
}
return ret;
}
/*
** Compiled match bif interface
*/
/*
** erlang:match_spec_test(MatchAgainst, MatchSpec, Type) ->
** {ok, Return, Flags, Errors} | {error, Errors}
** MatchAgainst -> if Type == trace: list() else tuple()
** MatchSpec -> MatchSpec with body corresponding to Type
** Type -> trace | table (only trace implemented in R5C)
** Return -> if Type == trace TraceReturn else {BodyReturn, VariableBindings}
** TraceReturn -> {true | false | term()}
** BodyReturn -> term()
** VariableBindings -> [term(), ...]
** Errors -> [OneError, ...]
** OneError -> {error, string()} | {warning, string()}
** Flags -> [Flag, ...]
** Flag -> return_trace (currently only flag)
*/
BIF_RETTYPE match_spec_test_3(BIF_ALIST_3)
{
Eterm res;
#ifdef DMC_DEBUG
if (BIF_ARG_3 == am_atom_put("dis",3)) {
test_disassemble_next = 1;
BIF_RET(am_true);
} else
#endif
if (BIF_ARG_3 == am_trace) {
res = match_spec_test(BIF_P, BIF_ARG_1, BIF_ARG_2, 1);
if (is_value(res)) {
BIF_RET(res);
}
} else if (BIF_ARG_3 == am_table) {
res = match_spec_test(BIF_P, BIF_ARG_1, BIF_ARG_2, 0);
if (is_value(res)) {
BIF_RET(res);
}
}
BIF_ERROR(BIF_P, BADARG);
}
static Eterm match_spec_test(Process *p, Eterm against, Eterm spec, int trace)
{
Eterm lint_res;
Binary *mps;
Eterm res;
Eterm ret;
Eterm flg;
Eterm *hp;
Eterm *arr;
int n;
Eterm l;
Uint32 ret_flags;
Uint sz;
Eterm *save_cp;
if (trace && !(is_list(against) || against == NIL)) {
return THE_NON_VALUE;
}
if (trace) {
lint_res = db_match_set_lint(p, spec, DCOMP_TRACE | DCOMP_FAKE_DESTRUCTIVE);
mps = db_match_set_compile(p, spec, DCOMP_TRACE | DCOMP_FAKE_DESTRUCTIVE);
} else {
lint_res = db_match_set_lint(p, spec, DCOMP_TABLE | DCOMP_FAKE_DESTRUCTIVE);
mps = db_match_set_compile(p, spec, DCOMP_TABLE | DCOMP_FAKE_DESTRUCTIVE);
}
if (mps == NULL) {
hp = HAlloc(p,3);
ret = TUPLE2(hp, am_error, lint_res);
} else {
#ifdef DMC_DEBUG
if (test_disassemble_next) {
test_disassemble_next = 0;
db_match_dis(mps);
}
#endif /* DMC_DEBUG */
l = against;
n = 0;
while (is_list(l)) {
++n;
l = CDR(list_val(l));
}
if (trace) {
if (n)
arr = erts_alloc(ERTS_ALC_T_DB_TMP, sizeof(Eterm) * n);
else
arr = NULL;
l = against;
n = 0;
while (is_list(l)) {
arr[n] = CAR(list_val(l));
++n;
l = CDR(list_val(l));
}
} else {
n = 0;
arr = (Eterm *) against;
}
/* We are in the context of a BIF,
{caller} should return 'undefined' */
save_cp = p->cp;
p->cp = NULL;
res = erts_match_set_run(p, mps, arr, n, &ret_flags);
p->cp = save_cp;
if (is_non_value(res)) {
res = am_false;
}
sz = size_object(res);
if (ret_flags & MATCH_SET_EXCEPTION_TRACE) sz += 2;
if (ret_flags & MATCH_SET_RETURN_TRACE) sz += 2;
hp = HAlloc(p, 5 + sz);
res = copy_struct(res, sz, &hp, &MSO(p));
flg = NIL;
if (ret_flags & MATCH_SET_EXCEPTION_TRACE) {
flg = CONS(hp, am_exception_trace, flg);
hp += 2;
}
if (ret_flags & MATCH_SET_RETURN_TRACE) {
flg = CONS(hp, am_return_trace, flg);
hp += 2;
}
if (trace && arr != NULL) {
erts_free(ERTS_ALC_T_DB_TMP, arr);
}
erts_bin_free(mps);
ret = TUPLE4(hp, am_atom_put("ok",2), res, flg, lint_res);
}
return ret;
}
static Eterm seq_trace_fake(Process *p, Eterm arg1)
{
Eterm result = seq_trace_info_1(p,arg1);
if (is_tuple(result) && *tuple_val(result) == 2) {
return (tuple_val(result))[2];
}
return result;
}
#ifdef DMC_DEBUG
/*
** Disassemble match program
*/
static void db_match_dis(Binary *bp)
{
MatchProg *prog = Binary2MatchProg(bp);
Uint *t = prog->text;
Uint n;
Eterm p;
int first;
ErlHeapFragment *tmp;
while (t < prog->prog_end) {
switch (*t) {
case matchTryMeElse:
++t;
n = *t;
++t;
erts_printf("TryMeElse\t%bpu\n", n);
break;
case matchArray:
++t;
n = *t;
++t;
erts_printf("Array\t%bpu\n", n);
break;
case matchArrayBind:
++t;
n = *t;
++t;
erts_printf("ArrayBind\t%bpu\n", n);
break;
case matchTuple:
++t;
n = *t;
++t;
erts_printf("Tuple\t%bpu\n", n);
break;
case matchPushT:
++t;
n = *t;
++t;
erts_printf("PushT\t%bpu\n", n);
break;
case matchPushL:
++t;
erts_printf("PushL\n");
break;
case matchPop:
++t;
erts_printf("Pop\n");
break;
case matchBind:
++t;
n = *t;
++t;
erts_printf("Bind\t%bpu\n", n);
break;
case matchCmp:
++t;
n = *t;
++t;
erts_printf("Cmp\t%bpu\n", n);
break;
case matchEqBin:
++t;
p = (Eterm) *t;
++t;
erts_printf("EqBin\t%p (%T)\n", t, p);
break;
case matchEqRef:
++t;
n = thing_arityval(*t);
++t;
erts_printf("EqRef\t(%d) {", (int) n);
first = 1;
while (n--) {
if (first)
first = 0;
else
erts_printf(", ");
#ifdef ARCH_64
erts_printf("0x%016bpx", *t);
#else
erts_printf("0x%08bpx", *t);
#endif
++t;
}
erts_printf("}\n");
break;
case matchEqBig:
++t;
n = thing_arityval(*t);
++t;
erts_printf("EqBig\t(%d) {", (int) n);
first = 1;
while (n--) {
if (first)
first = 0;
else
erts_printf(", ");
#ifdef ARCH_64
erts_printf("0x%016bpx", *t);
#else
erts_printf("0x%08bpx", *t);
#endif
++t;
}
erts_printf("}\n");
break;
case matchEqFloat:
++t;
{
double num;
memcpy(&num,t, 2 * sizeof(*t));
t += 2;
erts_printf("EqFloat\t%f\n", num);
}
break;
case matchEq:
++t;
p = (Eterm) *t;
++t;
erts_printf("Eq \t%T\n", p);
break;
case matchList:
++t;
erts_printf("List\n");
break;
case matchHalt:
++t;
erts_printf("Halt\n");
break;
case matchSkip:
++t;
erts_printf("Skip\n");
break;
case matchPushC:
++t;
p = (Eterm) *t;
++t;
erts_printf("PushC\t%T\n", p);
break;
case matchConsA:
++t;
erts_printf("ConsA\n");
break;
case matchConsB:
++t;
erts_printf("ConsB\n");
break;
case matchMkTuple:
++t;
n = *t;
++t;
erts_printf("MkTuple\t%bpu\n", n);
break;
case matchOr:
++t;
n = *t;
++t;
erts_printf("Or\t%bpu\n", n);
break;
case matchAnd:
++t;
n = *t;
++t;
erts_printf("And\t%bpu\n", n);
break;
case matchOrElse:
++t;
n = *t;
++t;
erts_printf("OrElse\t%bpu\n", n);
break;
case matchAndAlso:
++t;
n = *t;
++t;
erts_printf("AndAlso\t%bpu\n", n);
break;
case matchCall0:
++t;
p = dmc_lookup_bif_reversed((void *) *t);
++t;
erts_printf("Call0\t%T\n", p);
break;
case matchCall1:
++t;
p = dmc_lookup_bif_reversed((void *) *t);
++t;
erts_printf("Call1\t%T\n", p);
break;
case matchCall2:
++t;
p = dmc_lookup_bif_reversed((void *) *t);
++t;
erts_printf("Call2\t%T\n", p);
break;
case matchCall3:
++t;
p = dmc_lookup_bif_reversed((void *) *t);
++t;
erts_printf("Call3\t%T\n", p);
break;
case matchPushV:
++t;
n = (Uint) *t;
++t;
erts_printf("PushV\t%bpu\n", n);
break;
case matchTrue:
++t;
erts_printf("True\n");
break;
case matchPushExpr:
++t;
erts_printf("PushExpr\n");
break;
case matchPushArrayAsList:
++t;
erts_printf("PushArrayAsList\n");
break;
case matchPushArrayAsListU:
++t;
erts_printf("PushArrayAsListU\n");
break;
case matchSelf:
++t;
erts_printf("Self\n");
break;
case matchWaste:
++t;
erts_printf("Waste\n");
break;
case matchReturn:
++t;
erts_printf("Return\n");
break;
case matchProcessDump:
++t;
erts_printf("ProcessDump\n");
break;
case matchDisplay:
++t;
erts_printf("Display\n");
break;
case matchIsSeqTrace:
++t;
erts_printf("IsSeqTrace\n");
break;
case matchSetSeqToken:
++t;
erts_printf("SetSeqToken\n");
break;
case matchSetSeqTokenFake:
++t;
erts_printf("SetSeqTokenFake\n");
break;
case matchGetSeqToken:
++t;
erts_printf("GetSeqToken\n");
break;
case matchSetReturnTrace:
++t;
erts_printf("SetReturnTrace\n");
break;
case matchSetExceptionTrace:
++t;
erts_printf("SetReturnTrace\n");
break;
case matchCatch:
++t;
erts_printf("Catch\n");
break;
case matchEnableTrace:
++t;
erts_printf("EnableTrace\n");
break;
case matchDisableTrace:
++t;
erts_printf("DisableTrace\n");
break;
case matchEnableTrace2:
++t;
erts_printf("EnableTrace2\n");
break;
case matchDisableTrace2:
++t;
erts_printf("DisableTrace2\n");
break;
case matchTrace2:
++t;
erts_printf("Trace2\n");
break;
case matchTrace3:
++t;
erts_printf("Trace3\n");
break;
case matchCaller:
++t;
erts_printf("Caller\n");
break;
default:
erts_printf("??? (0x%08x)\n", *t);
++t;
break;
}
}
erts_printf("\n\nterm_save: {");
first = 1;
for (tmp = prog->term_save; tmp; tmp = tmp->next) {
if (first)
first = 0;
else
erts_printf(", ");
erts_printf("0x%08x", (unsigned long) tmp);
}
erts_printf("}\n");
erts_printf("num_bindings: %d\n", prog->num_bindings);
erts_printf("heap_size: %bpu\n", prog->heap_size);
erts_printf("eheap_offset: %bpu\n", prog->eheap_offset);
erts_printf("stack_offset: %bpu\n", prog->stack_offset);
erts_printf("text: 0x%08x\n", (unsigned long) prog->text);
erts_printf("stack_size: %d (words)\n", prog->heap_size-prog->stack_offset);
}
#endif /* DMC_DEBUG */
