*/ static void Accept_New_Port(REBVAL *ds, REBSER *port, REBREQ *sock)
/*
** Clone a listening port as a new accept port.
**
***********************************************************************/
{
REBREQ *nsock;
// Get temp sock struct created by the device:
nsock = sock->common.sock;
if (!nsock) return; // false alarm
sock->common.sock = nsock->next;
nsock->common.data = 0;
nsock->next = 0;
// Create a new port using ACCEPT request passed by sock->common.sock:
port = Copy_Block(port, 0);
SET_PORT(DS_OUT, port); // Also for GC protect
SET_NONE(OFV(port, STD_PORT_DATA)); // just to be sure.
SET_NONE(OFV(port, STD_PORT_STATE)); // just to be sure.
// Copy over the new sock data:
sock = cast(REBREQ*, Use_Port_State(port, RDI_NET, sizeof(*sock)));
*sock = *nsock;
sock->clen = sizeof(*sock);
sock->port = port;
OS_FREE(nsock); // allocated by dev_net.c (MT issues?)
}
*/ REBSER *As_Typesets(REBSER *types)
/*
***********************************************************************/
{
REBVAL *val;
types = Copy_Block(types, 1);
for (val = BLK_HEAD(types); NOT_END(val); val++) {
SET_TYPE(val, REB_TYPESET);
}
return types;
}
*/ void Clone_Function(REBVAL *value, REBVAL *func)
/*
***********************************************************************/
{
REBSER *src_frame = VAL_FUNC_ARGS(func);
VAL_FUNC_SPEC(value) = VAL_FUNC_SPEC(func);
VAL_FUNC_BODY(value) = Clone_Block(VAL_FUNC_BODY(func));
VAL_FUNC_ARGS(value) = Copy_Block(src_frame, 0);
// VAL_FUNC_BODY(value) = Clone_Block(VAL_FUNC_BODY(func));
VAL_FUNC_BODY(value) = Copy_Block_Values(VAL_FUNC_BODY(func), 0, SERIES_TAIL(VAL_FUNC_BODY(func)), TS_CLONE);
Rebind_Block(src_frame, VAL_FUNC_ARGS(value), BLK_HEAD(VAL_FUNC_BODY(value)), 0);
}
*/ REBFLG Copy_Function(REBVAL *value, REBVAL *args)
/*
***********************************************************************/
{
REBVAL *spec;
REBVAL *body;
if (!args || ((spec = VAL_BLK(args)) && IS_END(spec))) {
body = 0;
if (IS_FUNCTION(value) || IS_CLOSURE(value))
VAL_FUNC_ARGS(value) = Copy_Block(VAL_FUNC_ARGS(value), 0);
} else {
body = VAL_BLK_SKIP(args, 1);
// Spec given, must be block or *
if (IS_BLOCK(spec)) {
VAL_FUNC_SPEC(value) = VAL_SERIES(spec);
VAL_FUNC_ARGS(value) = Check_Func_Spec(VAL_SERIES(spec));
} else {
if (!IS_STAR(spec)) return FALSE;
VAL_FUNC_ARGS(value) = Copy_Block(VAL_FUNC_ARGS(value), 0);
}
}
if (body && !IS_END(body)) {
if (!IS_FUNCTION(value) && !IS_CLOSURE(value)) return FALSE;
// Body must be block:
if (!IS_BLOCK(body)) return FALSE;
VAL_FUNC_BODY(value) = VAL_SERIES(body);
}
// No body, use prototype:
else if (IS_FUNCTION(value) || IS_CLOSURE(value))
VAL_FUNC_BODY(value) = Clone_Block(VAL_FUNC_BODY(value));
// Rebind function words:
if (IS_FUNCTION(value) || IS_CLOSURE(value))
Bind_Relative(VAL_FUNC_ARGS(value), VAL_FUNC_ARGS(value), VAL_FUNC_BODY(value));
return TRUE;
}
*/ REBSER *Parse_Lines(REBSER *src)
/*
** Convert a string buffer to a block of strings.
** Note that the string must already be converted
** to REBOL LF format (no CRs).
**
***********************************************************************/
{
REBSER *blk;
REBUNI c;
REBCNT i;
REBCNT s;
REBVAL *val;
REBOOL uni = !BYTE_SIZE(src);
REBYTE *bp = BIN_HEAD(src);
REBUNI *up = UNI_HEAD(src);
blk = BUF_EMIT;
RESET_SERIES(blk);
// Scan string, looking for LF and CR terminators:
for (i = s = 0; i < SERIES_TAIL(src); i++) {
c = uni ? up[i] : bp[i];
if (c == LF || c == CR) {
val = Append_Value(blk);
Set_String(val, Copy_String(src, s, i - s));
VAL_SET_LINE(val);
// Skip CRLF if found:
if (c == CR && LF == uni ? up[i] : bp[i]) i++;
s = i;
}
}
// Partial line (no linefeed):
if (s + 1 != i) {
val = Append_Value(blk);
Set_String(val, Copy_String(src, s, i - s));
VAL_SET_LINE(val);
}
return Copy_Block(blk, 0);
}
*/ void Modify_Blockx(REBCNT action, REBVAL *block, REBVAL *arg)
/*
** Actions: INSERT, APPEND, CHANGE
**
** block [block!] {Series at point to insert}
** value [any-type!] {The value to insert}
** /part {Limits to a given length or position.}
** length [number! series! pair!]
** /only {Inserts a series as a series.}
** /dup {Duplicates the insert a specified number of times.}
** count [number! pair!]
**
** Add:
** Handle insert [] () case
** What does insert () [] do?
** /deep option for cloning subcontents?
**
***********************************************************************/
{
REBSER *series = VAL_SERIES(block);
REBCNT index = VAL_INDEX(block);
REBCNT tail = VAL_TAIL(block);
REBFLG only = DS_REF(AN_ONLY);
REBINT rlen; // length to be removed
REBINT ilen = 1; // length to be inserted
REBINT cnt = 1; // DUP count
REBINT size;
REBFLG is_blk = FALSE; // arg is a block not a value
// Length of target (may modify index): (arg can be anything)
rlen = Partial1((action == A_CHANGE) ? block : arg, DS_ARG(AN_LENGTH));
index = VAL_INDEX(block);
if (action == A_APPEND || index > tail) index = tail;
// Check /PART, compute LEN:
if (!only && ANY_BLOCK(arg)) {
is_blk = TRUE; // arg is a block
// Are we modifying ourselves? If so, copy arg block first:
if (series == VAL_SERIES(arg)) {
VAL_SERIES(arg) = Copy_Block(VAL_SERIES(arg), VAL_INDEX(arg));
VAL_INDEX(arg) = 0;
}
// Length of insertion:
ilen = (action != A_CHANGE && DS_REF(AN_PART)) ? rlen : VAL_LEN(arg);
}
// Get /DUP count:
if (DS_REF(AN_DUP)) {
cnt = Int32(DS_ARG(AN_COUNT));
if (cnt <= 0) return; // no changes
}
// Total to insert:
size = cnt * ilen;
if (action != A_CHANGE) {
// Always expand series for INSERT and APPEND actions:
Expand_Series(series, index, size);
} else {
if (size > rlen)
Expand_Series(series, index, size-rlen);
else if (size < rlen && DS_REF(AN_PART))
Remove_Series(series, index, rlen-size);
else if (size + index > tail) {
EXPAND_SERIES_TAIL(series, size - (tail - index));
}
}
if (is_blk) arg = VAL_BLK_DATA(arg);
// For dup count:
VAL_INDEX(block) = (action == A_APPEND) ? 0 : size + index;
index *= SERIES_WIDE(series); // loop invariant
ilen *= SERIES_WIDE(series); // loop invariant
for (; cnt > 0; cnt--) {
memcpy(series->data + index, (REBYTE *)arg, ilen);
index += ilen;
}
BLK_TERM(series);
}
*/ REBCNT Modify_Block(REBCNT action, REBSER *dst_ser, REBCNT dst_idx, const REBVAL *src_val, REBCNT flags, REBINT dst_len, REBINT dups)
/*
** action: INSERT, APPEND, CHANGE
**
** dst_ser: target
** dst_idx: position
** src_val: source
** flags: AN_ONLY, AN_PART
** dst_len: length to remove
** dups: dup count
**
** return: new dst_idx
**
***********************************************************************/
{
REBCNT tail = SERIES_TAIL(dst_ser);
REBINT ilen = 1; // length to be inserted
REBINT size; // total to insert
if (dups < 0) return (action == A_APPEND) ? 0 : dst_idx;
if (action == A_APPEND || dst_idx > tail) dst_idx = tail;
// Check /PART, compute LEN:
if (!GET_FLAG(flags, AN_ONLY) && ANY_BLOCK(src_val)) {
// Adjust length of insertion if changing /PART:
if (action != A_CHANGE && GET_FLAG(flags, AN_PART))
ilen = dst_len;
else
ilen = VAL_LEN(src_val);
// Are we modifying ourselves? If so, copy src_val block first:
if (dst_ser == VAL_SERIES(src_val)) {
REBSER *series = Copy_Block(
VAL_SERIES(src_val), VAL_INDEX(src_val)
);
src_val = BLK_HEAD(series);
}
else
src_val = VAL_BLK_DATA(src_val); // skips by VAL_INDEX values
}
// Total to insert:
size = dups * ilen;
if (action != A_CHANGE) {
// Always expand dst_ser for INSERT and APPEND actions:
Expand_Series(dst_ser, dst_idx, size);
} else {
if (size > dst_len)
Expand_Series(dst_ser, dst_idx, size-dst_len);
else if (size < dst_len && GET_FLAG(flags, AN_PART))
Remove_Series(dst_ser, dst_idx, dst_len-size);
else if (size + dst_idx > tail) {
EXPAND_SERIES_TAIL(dst_ser, size - (tail - dst_idx));
}
}
tail = (action == A_APPEND) ? 0 : size + dst_idx;
dst_idx *= SERIES_WIDE(dst_ser); // loop invariant
ilen *= SERIES_WIDE(dst_ser); // loop invariant
for (; dups > 0; dups--) {
memcpy(dst_ser->data + dst_idx, src_val, ilen);
dst_idx += ilen;
}
BLK_TERM(dst_ser);
return tail;
}
*/ REBSER *Parse_String(REBSER *series, REBCNT index, REBVAL *rules, REBCNT flags)
/*
***********************************************************************/
{
REBCNT tail = series->tail;
REBSER *blk;
REBSER *set;
REBCNT begin;
REBCNT end;
REBOOL skip_spaces = !(flags & PF_ALL);
REBUNI uc;
blk = BUF_EMIT; // shared series
RESET_SERIES(blk);
// String of delimiters or single character:
if (IS_STRING(rules) || IS_CHAR(rules)) {
begin = Find_Max_Bit(rules);
if (begin <= ' ') begin = ' ' + 1;
set = Make_Bitset(begin);
Set_Bits(set, rules, TRUE);
}
// None, so use defaults ",;":
else {
set = Make_Bitset(1+MAX(',',';'));
Set_Bit(set, ',', TRUE);
Set_Bit(set, ';', TRUE);
}
SAVE_SERIES(set);
// If required, make space delimiters too:
if (skip_spaces) {
for (uc = 1; uc <= ' '; uc++) Set_Bit(set, uc, TRUE);
}
while (index < tail) {
if (--Eval_Count <= 0 || Eval_Signals) Do_Signals();
// Skip whitespace if not /all refinement:
if (skip_spaces) {
uc = 0;
for (; index < tail; index++) {
uc = GET_ANY_CHAR(series, index);
if (!IS_WHITE(uc)) break;
}
}
else
uc = GET_ANY_CHAR(series, index); // prefetch
if (index < tail) {
// Handle quoted strings (in a simple way):
if (uc == '"') {
begin = ++index; // eat quote
for (; index < tail; index++) {
uc = GET_ANY_CHAR(series, index);
if (uc == '"') break;
}
end = index;
if (index < tail) index++;
}
// All other tokens:
else {
begin = index;
for (; index < tail; index++) {
if (Check_Bit(set, GET_ANY_CHAR(series, index), !(flags & PF_CASE))) break;
}
end = index;
}
// Skip trailing spaces:
if (skip_spaces)
for (; index < tail; index++) {
uc = GET_ANY_CHAR(series, index);
if (!IS_WHITE(uc)) break;
}
// Check for and remove separator:
if (Check_Bit(set, GET_ANY_CHAR(series, index), !(flags & PF_CASE))) index++;
// Append new string:
Set_String(Append_Value(blk), Copy_String(series, begin, end - begin));
}
}
UNSAVE_SERIES(set);
return Copy_Block(blk, 0);
}
