The R13B03 release.OTP_R13B03

1 files changed, 1142 insertions, 0 deletions

diff --git a/erts/emulator/beam/erl_bif_re.c b/erts/emulator/beam/erl_bif_re.c
new file mode 100644
index 0000000000..16abab65b0
--- /dev/null
+++ b/erts/emulator/beam/erl_bif_re.c
@@ -0,0 +1,1142 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 2008-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%
+ */
+
+#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"
+#include "bif.h"
+#include "erl_binary.h"
+#include "big.h"
+#define ERLANG_INTEGRATION 1
+#define PCRE_STATIC
+#include "pcre.h"
+
+#define PCRE_DEFAULT_COMPILE_OPTS 0 
+#define PCRE_DEFAULT_EXEC_OPTS 0 
+#define LOOP_FACTOR 10
+
+
+static const unsigned char *default_table;
+static Uint max_loop_limit;
+static Export re_exec_trap_export;
+static Export *grun_trap_exportp = NULL;
+static Export *urun_trap_exportp = NULL;
+static Export *ucompile_trap_exportp = NULL;
+
+static BIF_RETTYPE re_exec_trap(BIF_ALIST_3);
+
+static void *erts_erts_pcre_malloc(size_t size) {
+    return erts_alloc(ERTS_ALC_T_RE_HEAP,size);
+}
+
+static void erts_erts_pcre_free(void *ptr) {
+    erts_free(ERTS_ALC_T_RE_HEAP,ptr);
+}
+
+static void *erts_erts_pcre_stack_malloc(size_t size) {
+    return erts_alloc(ERTS_ALC_T_RE_STACK,size);
+}
+
+static void erts_erts_pcre_stack_free(void *ptr) {
+    erts_free(ERTS_ALC_T_RE_STACK,ptr);
+}
+
+void erts_init_bif_re(void)
+{
+    erts_pcre_malloc = &erts_erts_pcre_malloc;
+    erts_pcre_free = &erts_erts_pcre_free;
+    erts_pcre_stack_malloc = &erts_erts_pcre_stack_malloc;
+    erts_pcre_stack_free = &erts_erts_pcre_stack_free;
+    default_table = NULL; /* ISO8859-1 default, forced into pcre */
+    max_loop_limit = CONTEXT_REDS * LOOP_FACTOR;
+ 
+    sys_memset((void *) &re_exec_trap_export, 0, sizeof(Export));
+    re_exec_trap_export.address = &re_exec_trap_export.code[3];
+    re_exec_trap_export.code[0] = am_erlang;
+    re_exec_trap_export.code[1] = am_re_run_trap;
+    re_exec_trap_export.code[2] = 3;
+    re_exec_trap_export.code[3] = (Eterm) em_apply_bif;
+    re_exec_trap_export.code[4] = (Eterm) &re_exec_trap;
+
+    grun_trap_exportp =  erts_export_put(am_re,am_grun,3);
+    urun_trap_exportp =  erts_export_put(am_re,am_urun,3);
+    ucompile_trap_exportp =  erts_export_put(am_re,am_ucompile,2);
+
+    return;
+}
+
+Sint erts_re_set_loop_limit(Sint limit) 
+{
+    Sint save = (Sint) max_loop_limit;
+    if (limit <= 0) {
+	max_loop_limit = CONTEXT_REDS * LOOP_FACTOR;
+    } else {
+	max_loop_limit = (Uint) limit;
+    }
+    return save;
+}
+
+/*
+ * Deal with plain int's and so on for the library interface
+ */
+
+static int term_to_int(Eterm term, int *sp)
+{
+#ifdef ARCH_64
+
+    if (is_small(term)) {
+	Uint x = signed_val(term);
+	if (x > INT_MAX) {
+	    return 0;
+	}
+	*sp = (int) x;
+	return 1;
+    } 
+    return 0;
+
+#else
+
+    if (is_small(term)) {
+	*sp = signed_val(term);
+	return 1;
+    } else if (is_big(term)) {
+	ErtsDigit* xr = big_v(term);
+	dsize_t xl = big_size(term);
+	int sign = big_sign(term);
+	unsigned uval = 0;
+	int n = 0;
+
+	if (xl*D_EXP > sizeof(unsigned)*8) {
+	    return 0;
+	}
+	while (xl-- > 0) {
+	    uval |= ((unsigned)(*xr++)) << n;
+	    n += D_EXP;
+	}
+	if (sign) {
+	    uval = -uval;
+	    if ((int)uval > 0)
+		return 0;
+	} else {
+	    if ((int)uval < 0)
+		return 0;
+	}
+	*sp = uval;
+	return 1;
+    } else {
+	return 0;
+    }
+
+#endif
+
+}
+
+static Eterm make_signed_integer(int x, Process *p)
+{
+#ifdef ARCH_64
+    return make_small(x);
+#else
+    Eterm* hp;
+    if (IS_SSMALL(x))
+	return make_small(x);
+    else {
+	hp = HAlloc(p, BIG_UINT_HEAP_SIZE);
+	if (x >= 0) {
+	    *hp = make_pos_bignum_header(1);
+	} else {
+	    x = -x;
+	    *hp = make_neg_bignum_header(1);
+	}
+	BIG_DIGIT(hp, 0) = x;
+	return make_big(hp);
+    }
+#endif
+}
+
+/*
+ * Parse option lists
+ */
+
+#define PARSE_FLAG_UNIQUE_COMPILE_OPT 1
+#define PARSE_FLAG_UNIQUE_EXEC_OPT 2
+#define PARSE_FLAG_UNICODE 4
+#define PARSE_FLAG_STARTOFFSET 8
+#define PARSE_FLAG_CAPTURE_OPT 16
+#define PARSE_FLAG_GLOBAL 32
+
+#define CAPSPEC_VALUES 0
+#define CAPSPEC_TYPE 1
+#define CAPSPEC_SIZE 2
+
+static int /* 0 == ok, < 0 == error */ 
+parse_options(Eterm listp, /* in */
+	      int *compile_options, /* out */ 
+	      int *exec_options, /* out */
+	      int *flags,/* out */
+	      int *startoffset, /* out */
+	      Eterm *capture_spec) /* capture_spec[CAPSPEC_SIZE] */ /* out */
+{
+    int copt,eopt,fl;
+    Eterm item;
+
+    if (listp  == NIL) {
+	copt = PCRE_DEFAULT_COMPILE_OPTS;
+	eopt = PCRE_DEFAULT_EXEC_OPTS;
+	fl = 0;
+    } else {
+	copt = 0;
+	eopt = 0;
+	fl = 0;
+	for (;is_list(listp); listp = CDR(list_val(listp))) {
+	    item = CAR(list_val(listp));
+	    if (is_tuple(item)) {
+		Eterm *tp = tuple_val(item);
+		if (arityval(*tp) != 2 || is_not_atom(tp[1])) {
+		    if (arityval(*tp) == 3 && tp[1] == am_capture) {
+			if (capture_spec != NULL) {
+			    capture_spec[CAPSPEC_VALUES] = tp[2];
+			    capture_spec[CAPSPEC_TYPE] = tp[3];
+			}
+			fl |= (PARSE_FLAG_CAPTURE_OPT | 
+			       PARSE_FLAG_UNIQUE_EXEC_OPT);
+			continue;
+		    } else {
+			return -1;
+		    } 
+		}
+		switch(tp[1]) {
+		case am_capture:
+		    if (capture_spec != NULL) {
+			capture_spec[CAPSPEC_VALUES] = tp[2];
+			capture_spec[CAPSPEC_TYPE] = am_index;
+		    }
+		    fl |= (PARSE_FLAG_CAPTURE_OPT | 
+			   PARSE_FLAG_UNIQUE_EXEC_OPT);
+		    break;
+		case am_offset:
+		    { 
+			int tmp;
+			if (!term_to_int(tp[2],&tmp)) {
+			    return -1; 
+			}
+			if (startoffset != NULL) {
+			    *startoffset = tmp;
+			}
+		    }
+		    fl |= (PARSE_FLAG_UNIQUE_EXEC_OPT|PARSE_FLAG_STARTOFFSET);
+		    break;
+		case am_newline:
+		    if (!is_atom(tp[2])) {
+			return -1; 
+		    }
+		    switch (tp[2]) {
+		    case am_cr: 
+			copt |= PCRE_NEWLINE_CR; 
+			eopt |= PCRE_NEWLINE_CR; 
+			break;
+		    case am_crlf: 
+			copt |= PCRE_NEWLINE_CRLF; 
+			eopt |= PCRE_NEWLINE_CRLF; 
+			break;
+		    case am_lf: 
+			copt |= PCRE_NEWLINE_LF; 
+			eopt |= PCRE_NEWLINE_LF; 
+			break;
+		    case am_anycrlf: 
+			copt |= PCRE_NEWLINE_ANYCRLF; 
+			eopt |= PCRE_NEWLINE_ANYCRLF; 
+			break;
+		    case am_any: 
+			eopt |= PCRE_NEWLINE_ANY; 
+			copt |= PCRE_NEWLINE_ANY; 
+			break;
+		    default:
+			return -1; 
+			break;
+		    }    
+		    break;
+		default:
+		    return -1; 
+		}
+	    }else if (is_not_atom(item)) {
+		return -1;
+	    } else {
+		switch(item) {
+		case am_anchored:
+		    copt |= PCRE_ANCHORED; 
+		    eopt |= PCRE_ANCHORED; 
+		    break;
+		case am_notempty:
+		    eopt |= PCRE_NOTEMPTY; 
+		    fl |= PARSE_FLAG_UNIQUE_EXEC_OPT;
+		    break;
+		case am_notbol:
+		    eopt |= PCRE_NOTBOL; 
+		    fl |= PARSE_FLAG_UNIQUE_EXEC_OPT;
+		    break;
+		case am_noteol:
+		    eopt |= PCRE_NOTEOL; 
+		    fl |= PARSE_FLAG_UNIQUE_EXEC_OPT;
+		    break;
+		case am_caseless:
+		    copt |= PCRE_CASELESS; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_dollar_endonly:
+		    copt |= PCRE_DOLLAR_ENDONLY; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_dotall:
+		    copt |= PCRE_DOTALL; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_extended:
+		    copt |= PCRE_EXTENDED; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_firstline:
+		    copt |= PCRE_FIRSTLINE; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_multiline:
+		    copt |= PCRE_MULTILINE; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_no_auto_capture:
+		    copt |= PCRE_NO_AUTO_CAPTURE; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_dupnames:
+		    copt |= PCRE_DUPNAMES; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_ungreedy:
+		    copt |= PCRE_UNGREEDY; 
+		    fl |= PARSE_FLAG_UNIQUE_COMPILE_OPT;
+		    break;
+		case am_unicode:
+		    copt |= PCRE_UTF8; 
+		    fl |= (PARSE_FLAG_UNIQUE_COMPILE_OPT | PARSE_FLAG_UNICODE);
+		    break;
+		case am_global:
+		    fl |= (PARSE_FLAG_UNIQUE_EXEC_OPT | PARSE_FLAG_GLOBAL);
+		    break;
+		case am_bsr_anycrlf: 
+		    eopt |= PCRE_BSR_ANYCRLF; 
+		    copt |= PCRE_BSR_ANYCRLF; 
+		    break;
+		case am_bsr_unicode: 
+		    eopt |= PCRE_BSR_UNICODE; 
+		    copt |= PCRE_BSR_UNICODE; 
+		    break;
+		default:
+		    return -1;
+		}
+	    }
+	}
+	if (is_not_nil(listp)) {
+	    return -1;
+	}
+    }
+    if (compile_options != NULL) {
+	*compile_options = copt;
+    }
+    if (exec_options != NULL) {
+	*exec_options = eopt;
+    }
+    if (flags != NULL) {
+	*flags = fl;
+    }
+    return 0;
+}
+
+/*
+ * Build Erlang term result from compilation
+ */
+
+static Eterm 
+build_compile_result(Process *p, Eterm error_tag, pcre *result, int errcode, const char *errstr, int errofset, int unicode, int with_ok) 
+{
+    Eterm *hp;
+    Eterm ret;
+    size_t pattern_size;
+    int capture_count;
+    if (!result) {
+	/* Return {error_tag, {Code, String, Offset}} */
+	int elen = sys_strlen(errstr);
+	int need = 3 /* tuple of 2 */ + 
+	    3 /* tuple of 2 */ + 
+	    (2 * elen) /* The error string list */;
+	hp = HAlloc(p, need);
+	ret = buf_to_intlist(&hp, (char *) errstr, elen, NIL);
+	ret = TUPLE2(hp, ret, make_small(errofset));
+	hp += 3;
+	ret = TUPLE2(hp, error_tag, ret);
+    } else {
+	erts_pcre_fullinfo(result, NULL, PCRE_INFO_SIZE, &pattern_size);
+	erts_pcre_fullinfo(result, NULL, PCRE_INFO_CAPTURECOUNT, &capture_count);
+	/* XXX: Optimize - keep in offheap binary to allow this to 
+	   be kept across traps w/o need of copying */
+	ret = new_binary(p, (byte *) result, pattern_size);
+	erts_pcre_free(result);
+	hp = HAlloc(p, (with_ok) ? (3+5) : 5);
+	ret = TUPLE4(hp,am_re_pattern, make_small(capture_count), make_small(unicode),ret);
+	if (with_ok) {
+	    hp += 5;
+	    ret = TUPLE2(hp,am_ok,ret);
+	}	    
+    }
+    return ret;
+}
+
+/*
+ * Compile BIFs
+ */
+
+BIF_RETTYPE
+re_compile_2(BIF_ALIST_2)
+{
+    int slen;
+    char *expr;
+    pcre *result;
+    int errcode = 0;
+    const char *errstr = "";
+    int errofset = 0;
+    Eterm ret;
+    int options = 0;
+    int pflags = 0;
+    int unicode = 0;
+
+
+    if (parse_options(BIF_ARG_2,&options,NULL,&pflags,NULL,NULL)
+	< 0) {
+	BIF_ERROR(BIF_P,BADARG);
+    }
+
+    if (pflags & PARSE_FLAG_UNIQUE_EXEC_OPT) {
+	BIF_ERROR(BIF_P,BADARG);
+    }
+
+    unicode = (pflags & PARSE_FLAG_UNICODE) ? 1 : 0;
+
+    if (pflags & PARSE_FLAG_UNICODE && !is_binary(BIF_ARG_1)) { 
+	BIF_TRAP2(ucompile_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2);
+    }
+
+    if ((slen = io_list_len(BIF_ARG_1)) < 0) {
+        BIF_ERROR(BIF_P,BADARG);
+    }
+    expr = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, slen + 1);
+    if (io_list_to_buf(BIF_ARG_1, expr, slen) != 0) {
+	erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
+	BIF_ERROR(BIF_P,BADARG);
+    }
+    expr[slen]='\0';
+    result = erts_pcre_compile2(expr, options, &errcode, 
+			   &errstr, &errofset, default_table);
+
+    ret = build_compile_result(BIF_P, am_error, result, errcode, 
+			       errstr, errofset, unicode, 1);
+    erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
+    BIF_RET(ret);
+}
+
+BIF_RETTYPE
+re_compile_1(BIF_ALIST_1)
+{
+    return re_compile_2(BIF_P,BIF_ARG_1,NIL);
+}
+
+/*
+ * Restart contexts for the re:run bif
+ */
+
+/*
+ * When erts_pcre_exec is restarted, only the actual extra-structure with
+ * it's restart-data need to be kept. The match is then called with
+ * watever is saved. The code is pointed out by this and cannot be
+ * reallocated or GC'ed, why it's passed along as a off-heap-binary,
+ * but not actually passed in the erts_pcre_exec restart calls.
+ */
+
+typedef enum { RetIndex, RetString, RetBin, RetNone } ReturnType;
+
+typedef struct _return_info {
+    ReturnType type;
+    int num_spec; /* 0 == all, -1 == all_but first, > 0 specified in vector */
+    int v[1];
+} ReturnInfo;
+
+typedef struct _restart_context {
+    pcre_extra extra;
+    void *restart_data;
+    Uint32 flags;
+    char *subject; /* to be able to free it when done */
+    pcre *code; /* Keep a copy */
+    int *ovector; /* Keep until done */
+    ReturnInfo *ret_info;
+} RestartContext;
+
+#define RESTART_FLAG_SUBJECT_IN_BINARY 0x1
+
+static void cleanup_restart_context(RestartContext *rc) 
+{
+    if (rc->restart_data != NULL) {
+	erts_pcre_free_restart_data(rc->restart_data);
+	rc->restart_data = NULL;
+    }
+    if (rc->ovector != NULL) {
+	erts_free(ERTS_ALC_T_RE_SUBJECT, rc->ovector);
+	rc->ovector = NULL;
+    }
+    if (rc->subject != NULL && !(rc->flags & RESTART_FLAG_SUBJECT_IN_BINARY)) {
+	erts_free(ERTS_ALC_T_RE_SUBJECT, rc->subject);    
+    }
+    rc->subject = NULL;
+    if (rc->code != NULL) {
+	erts_free(ERTS_ALC_T_RE_SUBJECT, rc->code);
+	rc->code = NULL;
+    }
+    if (rc->ret_info != NULL) {
+	erts_free(ERTS_ALC_T_RE_SUBJECT, rc->ret_info);
+	rc->ret_info = NULL;
+    }
+}
+
+static void cleanup_restart_context_bin(Binary *bp)
+{
+    RestartContext *rc = ERTS_MAGIC_BIN_DATA(bp);
+    cleanup_restart_context(rc);
+}
+
+/*
+ * Build the return value for Erlang from result and restart context
+ */
+
+static Eterm build_exec_return(Process *p, int rc, RestartContext *restartp, Eterm orig_subject) 
+{
+    Eterm res;
+    Eterm *hp;
+    if (rc <= 0) {
+	res = am_nomatch;
+    } else {
+	ReturnInfo *ri = restartp->ret_info; 
+	ReturnInfo defri = {RetIndex,0,{0}};
+	if (ri == NULL) {
+	    ri = &defri;
+	}
+	if (ri->type == RetNone) {
+	    res = am_match;
+	} else if (ri->type == RetIndex){
+	    Eterm *tmp_vect;
+	    Eterm tpl;
+	    int i;
+	    if (ri->num_spec <= 0) {
+		tmp_vect = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, 
+				      rc * 2 * sizeof(Eterm));
+		for(i = -(ri->num_spec) ;i < rc; ++i) {
+		    tmp_vect[i*2] = make_signed_integer(restartp->ovector[i*2],p);
+		    tmp_vect[i*2+1] = make_signed_integer(restartp->ovector[i*2+1] - restartp->ovector[i*2],p);
+		}
+		hp = HAlloc(p, 3+(3+2)*(rc + ri->num_spec));
+		res = NIL;
+		for(i = rc-1 ;i >= -(ri->num_spec); --i) {
+		    tpl = TUPLE2(hp,tmp_vect[i*2],tmp_vect[i*2+1]);
+		    hp += 3;
+		    res = CONS(hp,tpl,res);
+		    hp += 2;
+		}
+	    } else {
+		int n = 0;
+		int x;
+		tmp_vect = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, 
+				      ri->num_spec * 2 * sizeof(Eterm));
+		for (i = 0; i < ri->num_spec; ++i) {
+		    x = ri->v[i];
+		    if (x < rc && x >= 0) {
+			tmp_vect[n*2] = make_signed_integer(restartp->ovector[x*2],p);
+			tmp_vect[n*2+1] = make_signed_integer(restartp->ovector[x*2+1]-restartp->ovector[x*2],p);
+		    } else {
+			tmp_vect[n*2] = make_small(-1);
+			tmp_vect[n*2+1] = make_small(0);
+		    }
+		    ++n;
+		}
+		hp = HAlloc(p, 3+(3+2)*n);
+		res = NIL;
+		for(i = n-1 ;i >= 0; --i) {
+		    tpl = TUPLE2(hp,tmp_vect[i*2],tmp_vect[i*2+1]);
+		    hp += 3;
+		    res = CONS(hp,tpl,res);
+		    hp += 2;
+		}
+	    }
+	    res = TUPLE2(hp,am_match,res);
+	    erts_free(ERTS_ALC_T_RE_TMP_BUF, tmp_vect);
+	} else {
+	    Eterm *tmp_vect;
+	    int i;
+	    Eterm orig = NIL;
+	    Uint offset = 0;
+	    Uint bitoffs = 0;
+	    Uint bitsize = 0;
+	    if (restartp->flags & RESTART_FLAG_SUBJECT_IN_BINARY) {
+		ERTS_GET_REAL_BIN(orig_subject, orig, offset, bitoffs, bitsize);
+	    }
+	    if (ri->num_spec <= 0) {
+		tmp_vect = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, 
+				      rc * sizeof(Eterm));
+		for(i = -(ri->num_spec) ;i < rc; ++i) { /* XXX: Unicode */
+		    char *cp;
+		    int len;
+		    if (restartp->ovector[i*2] < 0) {
+			cp = restartp->subject;
+			len = 0;
+		    } else {
+			cp = restartp->subject + restartp->ovector[i*2];
+			len = restartp->ovector[i*2+1] - restartp->ovector[i*2];
+		    }
+		    if (ri->type == RetBin) { 
+			if (restartp->flags & RESTART_FLAG_SUBJECT_IN_BINARY) {
+			    /* Optimized - if subject was binary to begin 
+			       with, we can make sub-binaries. */
+			    ErlSubBin *sb;
+			    Uint virtual_offset = cp - restartp->subject;
+			    hp = HAlloc(p, ERL_SUB_BIN_SIZE);
+			    sb = (ErlSubBin *) hp;
+			    sb->thing_word = HEADER_SUB_BIN;
+			    sb->size = len;
+			    sb->offs = offset + virtual_offset;
+			    sb->orig = orig;
+			    sb->bitoffs = bitoffs;
+			    sb->bitsize = bitsize;
+			    sb->is_writable = 0;
+			    tmp_vect[i] = make_binary(sb);
+			} else {
+			    tmp_vect[i] = new_binary(p, (byte *) cp, len);
+			}
+		    } else {
+			Eterm *hp2;
+			hp2 = HAlloc(p,(2*len));
+			tmp_vect[i] = buf_to_intlist(&hp2, cp, len, NIL);
+		    } 
+		}
+		hp = HAlloc(p, 3+2*(rc + ri->num_spec));
+		res = NIL;
+		for(i = rc-1 ;i >= -(ri->num_spec); --i) {
+		    res = CONS(hp,tmp_vect[i],res);
+		    hp += 2;
+		}
+	    } else {
+		int n = 0;
+		int x;
+		tmp_vect = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, 
+				      ri->num_spec * sizeof(Eterm));
+		for (i = 0; i < ri->num_spec; ++i) {
+		    x = ri->v[i];
+		    if (x < rc && x >= 0) {
+			char *cp;
+			int len;
+			if (restartp->ovector[x*2] < 0) {
+			    cp = restartp->subject;
+			    len = 0;
+			} else {
+			    cp = restartp->subject + restartp->ovector[x*2];
+			    len = restartp->ovector[x*2+1] - restartp->ovector[x*2];
+			}
+			if (ri->type == RetBin) { 
+			    if (restartp->flags & RESTART_FLAG_SUBJECT_IN_BINARY) {
+				/* Optimized - if subject was binary to begin 
+				   with, we could make sub-binaries. */
+				ErlSubBin *sb;
+				Uint virtual_offset = cp - restartp->subject;
+				hp = HAlloc(p, ERL_SUB_BIN_SIZE);
+				sb = (ErlSubBin *) hp;
+				sb->thing_word = HEADER_SUB_BIN;
+				sb->size = len;
+				sb->offs = offset + virtual_offset;
+				sb->orig = orig;
+				sb->bitoffs = bitoffs;
+				sb->bitsize = bitsize;
+				sb->is_writable = 0;
+				tmp_vect[n] = make_binary(sb);
+			    } else {
+				tmp_vect[n] = new_binary(p, (byte *) cp, len);
+			    }
+			} else {
+			    Eterm *hp2;
+			    hp2 = HAlloc(p,(2*len));
+			    tmp_vect[n] = buf_to_intlist(&hp2, cp, len, NIL);
+			} 
+		    } else {
+			if (ri->type == RetBin) { 
+			    tmp_vect[n] = new_binary(p, (byte *) "", 0);
+			} else {
+			    tmp_vect[n] = NIL;
+			} 
+		    }	
+		    ++n;
+		}
+		hp = HAlloc(p, 3+2*n);
+		res = NIL;
+		for(i = n-1 ;i >= 0; --i) {
+		    res = CONS(hp,tmp_vect[i],res);
+		    hp += 2;
+		}
+		
+	    }	    
+	    res = TUPLE2(hp,am_match,res);
+	    erts_free(ERTS_ALC_T_RE_TMP_BUF, tmp_vect);
+	}
+    }
+    return res;
+}
+
+/*
+ * Extra parsing function, build the ReturnInfo structure from
+ * a capture specification in the option list
+ */
+
+#define RINFO_SIZ(Num) (sizeof(ReturnInfo) + (sizeof(int) * (Num - 1)))
+
+static ReturnInfo *
+build_capture(Eterm capture_spec[CAPSPEC_SIZE], const pcre *code)
+{
+    ReturnInfo *ri = erts_alloc(ERTS_ALC_T_RE_SUBJECT, RINFO_SIZ(0));
+    int sallocated = 0;
+    char *tmpb = NULL;
+    int tmpbsiz = 0;
+    Eterm l;
+
+    ri->type = RetIndex;
+    ri->num_spec = 0;
+
+
+    switch(capture_spec[CAPSPEC_TYPE]) {
+    case am_index:
+	ri->type = RetIndex;
+	break;
+    case am_list:
+	ri->type = RetString;
+	break;
+    case am_binary:
+	ri->type = RetBin;
+	break;
+    default:
+	goto error;
+    }
+
+    switch(capture_spec[CAPSPEC_VALUES]) {
+    case am_all:
+	ri->num_spec = 0;
+	break;
+    case am_none:
+    case NIL:
+	ri->num_spec = 0;
+	ri->type = RetNone;
+	break;
+    case am_all_but_first:
+	ri->num_spec = -1;
+	break;
+    case am_first:
+	ri->num_spec = 1;
+	if(ri->num_spec > sallocated) {
+	    sallocated = ri->num_spec;
+	    ri = erts_realloc(ERTS_ALC_T_RE_SUBJECT, ri, RINFO_SIZ(sallocated));
+	}
+	ri->v[ri->num_spec - 1] = 0;
+	break;
+    default:
+	if (is_list(capture_spec[CAPSPEC_VALUES])) {
+	    for(l=capture_spec[CAPSPEC_VALUES];is_list(l);l = CDR(list_val(l))) {
+		int x;
+		Eterm val = CAR(list_val(l));
+		if (ri->num_spec < 0)
+		    ri->num_spec = 0;
+		++(ri->num_spec);
+		if(ri->num_spec > sallocated) {
+		    sallocated += 10;
+		    ri = erts_realloc(ERTS_ALC_T_RE_SUBJECT, ri, RINFO_SIZ(sallocated));
+		}
+		if (term_to_int(val,&x)) {
+		    ri->v[ri->num_spec - 1] = x;
+		} else if (is_atom(val) || is_binary(val) || is_list(val)) {
+		    if (is_atom(val)) {
+			Atom *ap = atom_tab(atom_val(val));
+			if ((ap->len + 1) > tmpbsiz) {
+			    if (!tmpbsiz) {
+				tmpb = erts_alloc(ERTS_ALC_T_RE_TMP_BUF,(tmpbsiz = ap->len + 1));
+			    } else {
+				tmpb = erts_realloc(ERTS_ALC_T_RE_TMP_BUF,tmpb,
+						    (tmpbsiz = ap->len + 1));
+			    }
+			}
+			memcpy(tmpb,ap->name,ap->len);
+			tmpb[ap->len] = '\0';
+		    } else {
+			int slen = io_list_len(val);
+			if (slen < 0) {
+			    goto error;
+			}
+			if ((slen + 1) > tmpbsiz) {
+			    if (!tmpbsiz) {
+				tmpb = erts_alloc(ERTS_ALC_T_RE_TMP_BUF,(tmpbsiz = slen + 1));
+			    } else {
+				tmpb = erts_realloc(ERTS_ALC_T_RE_TMP_BUF,tmpb,
+						    (tmpbsiz = slen + 1));
+			    }
+			}
+			if (io_list_to_buf(val, tmpb, slen) != 0) {
+			    goto error;
+			}
+			tmpb[slen] = '\0';
+		    }
+		    if ((ri->v[ri->num_spec - 1] = erts_pcre_get_stringnumber(code,tmpb)) ==
+			PCRE_ERROR_NOSUBSTRING) {
+			ri->v[ri->num_spec - 1] = -1;
+		    }
+		} else {
+		    goto error;
+		}
+	    }
+	    if (l != NIL) {
+		goto error;
+	    }
+	} else {
+	    goto error;
+	}
+	break;
+    }
+    
+    if(tmpb != NULL) {
+	erts_free(ERTS_ALC_T_RE_TMP_BUF,tmpb);
+    }
+    return ri;
+ error:
+    if(tmpb != NULL) {
+	erts_free(ERTS_ALC_T_RE_TMP_BUF,tmpb);
+    }
+    erts_free(ERTS_ALC_T_RE_SUBJECT, ri);
+    return NULL;
+}    
+
+
+/*
+ * The actual re:run/2,3 BIFs
+ */
+BIF_RETTYPE
+re_run_3(BIF_ALIST_3)
+{
+    const pcre *code_tmp;
+    RestartContext restart;
+    byte *temp_alloc = NULL;
+    int slength;
+    int startoffset = 0;
+    int options = 0, comp_options = 0;
+    int ovsize;
+    int pflags;
+    Eterm *tp;
+    int rc;
+    Eterm res;
+    size_t code_size;
+    Uint loop_limit_tmp;
+    unsigned long loop_count;
+    Eterm capture[CAPSPEC_SIZE];
+    int is_list_cap;
+
+    if (parse_options(BIF_ARG_3,&comp_options,&options,&pflags,&startoffset,capture)
+	< 0) {
+	BIF_ERROR(BIF_P,BADARG);
+    }
+    is_list_cap = ((pflags & PARSE_FLAG_CAPTURE_OPT) && 
+		   (capture[CAPSPEC_TYPE] == am_list));
+
+    if (is_not_tuple(BIF_ARG_2) || (arityval(*tuple_val(BIF_ARG_2)) != 4)) {
+	if (is_binary(BIF_ARG_2) || is_list(BIF_ARG_2) || is_nil(BIF_ARG_2)) { 
+	    /* Compile from textual RE */
+	    int slen;
+	    char *expr;
+	    pcre *result;
+	    int errcode = 0;
+	    const char *errstr = "";
+	    int errofset = 0;
+	    int capture_count;
+
+	    if (pflags & PARSE_FLAG_UNICODE && 
+		(!is_binary(BIF_ARG_1) || 
+		 (is_list_cap && !(pflags & PARSE_FLAG_GLOBAL)))) { 
+		BIF_TRAP3(urun_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+	    }
+	    
+	    if ((slen = io_list_len(BIF_ARG_2)) < 0) {
+		BIF_ERROR(BIF_P,BADARG);
+	    }
+	    
+	    expr = erts_alloc(ERTS_ALC_T_RE_TMP_BUF, slen + 1);
+	    if (io_list_to_buf(BIF_ARG_2, expr, slen) != 0) {
+		erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
+		BIF_ERROR(BIF_P,BADARG);
+	    }
+	    expr[slen]='\0';
+	    result = erts_pcre_compile2(expr, comp_options, &errcode, 
+				   &errstr, &errofset, default_table);
+	    if (!result) {
+		erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
+		/* Compilation error gives badarg except in the compile 
+		   function */
+		BIF_ERROR(BIF_P,BADARG);
+	    }
+	    if (pflags & PARSE_FLAG_GLOBAL) {
+		Eterm precompiled = 
+		    build_compile_result(BIF_P, am_error, 
+					 result, errcode, 
+					 errstr, errofset, 
+					 (pflags & 
+					  PARSE_FLAG_UNICODE) ? 1 : 0,
+					 0);
+		Eterm *hp,r;
+		erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
+		hp = HAlloc(BIF_P,4);
+		/* BIF_ARG_2 is in the tuple just to make exceptions right */
+		r = TUPLE3(hp,BIF_ARG_3,
+			   ((pflags & PARSE_FLAG_UNIQUE_COMPILE_OPT) ? 
+			    am_true : 
+			    am_false), BIF_ARG_2);
+		BIF_TRAP3(grun_trap_exportp, BIF_P, BIF_ARG_1, precompiled, r);
+	    }
+
+	    erts_pcre_fullinfo(result, NULL, PCRE_INFO_SIZE, &code_size);
+	    erts_pcre_fullinfo(result, NULL, PCRE_INFO_CAPTURECOUNT, &capture_count);
+	    ovsize = 3*(capture_count+1);
+	    restart.code = erts_alloc(ERTS_ALC_T_RE_SUBJECT, code_size);
+	    memcpy(restart.code, result, code_size);
+	    erts_pcre_free(result);
+	    erts_free(ERTS_ALC_T_RE_TMP_BUF, expr);
+	    /*unicode = (pflags & PARSE_FLAG_UNICODE) ? 1 : 0;*/
+	} else {  
+	    BIF_ERROR(BIF_P,BADARG);
+	}
+    } else {
+	if (pflags & PARSE_FLAG_UNIQUE_COMPILE_OPT) {
+	    BIF_ERROR(BIF_P,BADARG);
+	}
+
+	tp = tuple_val(BIF_ARG_2);
+	if (tp[1] != am_re_pattern || is_not_small(tp[2]) || 
+	    is_not_small(tp[3]) || is_not_binary(tp[4])) {
+	    BIF_ERROR(BIF_P,BADARG);
+	}
+
+	if (unsigned_val(tp[3]) && 
+	    (!is_binary(BIF_ARG_1) || 
+	     (is_list_cap && !(pflags & PARSE_FLAG_GLOBAL)))) { /* unicode */
+	    BIF_TRAP3(urun_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2, 
+		      BIF_ARG_3);
+	}
+
+	if (pflags & PARSE_FLAG_GLOBAL) {
+	    Eterm *hp,r;
+	    hp = HAlloc(BIF_P,3);
+	    r = TUPLE2(hp,BIF_ARG_3,am_false);
+	    BIF_TRAP3(grun_trap_exportp, BIF_P, BIF_ARG_1, BIF_ARG_2, 
+		      r);
+	}
+
+	ovsize = 3*(unsigned_val(tp[2])+1);
+	code_size = binary_size(tp[4]);
+	if ((code_tmp = (const pcre *) 
+	     erts_get_aligned_binary_bytes(tp[4], &temp_alloc)) == NULL) {
+	    erts_free_aligned_binary_bytes(temp_alloc);
+	    BIF_ERROR(BIF_P, BADARG);
+	}
+	restart.code = erts_alloc(ERTS_ALC_T_RE_SUBJECT, code_size);
+	memcpy(restart.code, code_tmp, code_size);
+	erts_free_aligned_binary_bytes(temp_alloc);
+
+    }
+
+
+    restart.ovector =  erts_alloc(ERTS_ALC_T_RE_SUBJECT, ovsize * sizeof(int));
+    restart.extra.flags = PCRE_EXTRA_TABLES | PCRE_EXTRA_LOOP_LIMIT;
+    restart.extra.tables = default_table;
+    restart.extra.loop_limit = ERTS_BIF_REDS_LEFT(BIF_P) * LOOP_FACTOR;
+    loop_limit_tmp = max_loop_limit; /* To lesser probability of race in debug
+					situation (erts_debug) */
+    if (restart.extra.loop_limit > loop_limit_tmp) {
+	restart.extra.loop_limit = loop_limit_tmp;
+    }
+    restart.restart_data = NULL;
+    restart.extra.restart_data = &restart.restart_data;
+    restart.extra.restart_flags = 0;
+    restart.extra.loop_counter_return = &loop_count;
+    restart.ret_info = NULL;
+    
+    if (pflags & PARSE_FLAG_CAPTURE_OPT) {
+	if ((restart.ret_info = build_capture(capture,restart.code)) == NULL) {
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ovector);
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.code);
+	    BIF_ERROR(BIF_P,BADARG);
+	}
+    }
+	    
+    /*  Optimized - if already in binary off heap, keep that and avoid
+       copying, also binary returns can be sub binaries in that case */
+
+    restart.flags = 0;
+    if (is_binary(BIF_ARG_1)) {
+	Eterm real_bin;
+	Uint offset;
+	Eterm* bptr;
+	int bitoffs;
+	int bitsize;
+	ProcBin* pb;
+
+	ERTS_GET_REAL_BIN(BIF_ARG_1, real_bin, offset, bitoffs, bitsize);
+
+	slength = binary_size(BIF_ARG_1);
+	bptr = binary_val(real_bin);
+	if (bitsize != 0 || bitoffs != 0 ||  (*bptr != HEADER_PROC_BIN)) {
+	    goto handle_iolist;
+	}
+	pb = (ProcBin *) bptr;
+	restart.subject = (char *) (pb->bytes+offset);
+	restart.flags |= RESTART_FLAG_SUBJECT_IN_BINARY;
+    } else {
+handle_iolist:
+	if ((slength = io_list_len(BIF_ARG_1)) < 0) {
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ovector);
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.code);
+	    if (restart.ret_info != NULL) {
+		erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ret_info);
+	    }
+	    BIF_ERROR(BIF_P,BADARG);
+	}
+	restart.subject = erts_alloc(ERTS_ALC_T_RE_SUBJECT, slength);
+
+	if (io_list_to_buf(BIF_ARG_1, restart.subject, slength) != 0) {
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ovector);
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.code);
+	    erts_free(ERTS_ALC_T_RE_SUBJECT, restart.subject);
+	    if (restart.ret_info != NULL) {
+		erts_free(ERTS_ALC_T_RE_SUBJECT, restart.ret_info);
+	    }
+	    BIF_ERROR(BIF_P,BADARG);
+	}
+    }
+
+
+#ifdef DEBUG
+    loop_count = 0xFFFFFFFF;
+#endif
+    
+    rc = erts_pcre_exec(restart.code, &(restart.extra), restart.subject, slength, startoffset, 
+		   options, restart.ovector, ovsize);
+    ASSERT(loop_count != 0xFFFFFFFF);
+    BUMP_REDS(BIF_P, loop_count / LOOP_FACTOR);
+    if (rc == PCRE_ERROR_LOOP_LIMIT) {
+	/* Trap */
+	Binary *mbp = erts_create_magic_binary(sizeof(RestartContext),
+					       cleanup_restart_context_bin);
+	RestartContext *restartp = ERTS_MAGIC_BIN_DATA(mbp);
+	Eterm magic_bin;
+	Eterm *hp;
+	memcpy(restartp,&restart,sizeof(RestartContext));
+	BUMP_ALL_REDS(BIF_P);
+	hp = HAlloc(BIF_P, PROC_BIN_SIZE);
+	magic_bin = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), mbp);
+	BIF_TRAP3(&re_exec_trap_export, 
+		  BIF_P, 
+		  BIF_ARG_1, 
+		  BIF_ARG_2 /* To avoid GC of precompiled code, XXX: not utilized yet */, 
+		  magic_bin);
+    }
+    
+    res = build_exec_return(BIF_P, rc, &restart, BIF_ARG_1);
+ 
+    cleanup_restart_context(&restart);
+
+    BIF_RET(res);
+}
+
+BIF_RETTYPE
+re_run_2(BIF_ALIST_2) 
+{
+    return re_run_3(BIF_P,BIF_ARG_1, BIF_ARG_2, NIL);
+}
+
+/*
+ * The "magic" trap target, continue a re:run
+ */
+
+static BIF_RETTYPE re_exec_trap(BIF_ALIST_3) 
+     /* XXX: Optimize - arg 1 and 2 to be utilized for keeping binary 
+	code and subject */
+{
+    Binary *mbp;
+    RestartContext *restartp;
+    int rc;
+    unsigned long loop_count;
+    Uint loop_limit_tmp;
+    Eterm res;
+
+    ASSERT(ERTS_TERM_IS_MAGIC_BINARY(BIF_ARG_3));
+
+    mbp = ((ProcBin *) binary_val(BIF_ARG_3))->val;
+
+    ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(mbp)
+	   == cleanup_restart_context_bin);
+
+    restartp = (RestartContext *) ERTS_MAGIC_BIN_DATA(mbp);
+
+    restartp->extra.loop_limit = ERTS_BIF_REDS_LEFT(BIF_P) * LOOP_FACTOR;
+    loop_limit_tmp = max_loop_limit; /* To lesser probability of race in debug
+					situation (erts_debug) */
+    if (restartp->extra.loop_limit > loop_limit_tmp) {
+	restartp->extra.loop_limit = loop_limit_tmp;
+    }
+    restartp->extra.loop_counter_return = &loop_count;
+    restartp->extra.restart_data = &restartp->restart_data;
+    restartp->extra.restart_flags = 0;
+    
+#ifdef DEBUG
+    loop_count = 0xFFFFFFFF;
+#endif
+    rc = erts_pcre_exec(NULL, &(restartp->extra), NULL, 0, 0, 0, NULL, 0);
+    ASSERT(loop_count != 0xFFFFFFFF);
+    BUMP_REDS(BIF_P, loop_count / LOOP_FACTOR);
+    if (rc == PCRE_ERROR_LOOP_LIMIT) {
+	/* Trap */
+	BUMP_ALL_REDS(BIF_P);
+	BIF_TRAP3(&re_exec_trap_export, BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
+    }
+    res = build_exec_return(BIF_P, rc, restartp, BIF_ARG_1);
+ 
+    cleanup_restart_context(restartp);
+
+    BIF_RET(res);
+}
+    
+    
+
+