static YogVal
end(YogEnv* env, YogVal self, YogVal pkg, YogVal args, YogVal kw, YogVal block)
{
SAVE_ARGS5(env, self, pkg, args, kw, block);
YogVal group = YNIL;
YogVal retval = YUNDEF;
PUSH_LOCALS2(env, group, retval);
YogCArg params[] = { { "|", NULL }, { "group", &group }, { NULL, NULL } };
YogGetArgs_parse_args(env, "end", params, args, kw);
CHECK_SELF_MATCH(env, self);
if (IS_FIXNUM(group)) {
retval = end_num(env, self, VAL2INT(group));
}
else if (IS_NIL(group)) {
retval = end_num(env, self, 0);
}
else if (IS_PTR(group) && (BASIC_OBJ_TYPE(group) == TYPE_STRING)) {
retval = end_str(env, self, group);
}
else {
raise_invalid_group(env, group);
}
RETURN(env, retval);
}
void _show(value_t p, FILE* stream) {
if (IS_FIXNUM(p)) {
fprintf(stream, "%ld", VALUE_TO_FIXNUM(p));
} else if (IS_PAIR(p)) {
pair_t pair = VALUE_TO_PAIR(p);
fprintf(stream, "(");
_show(pair.first, stream);
fprintf(stream, " ");
_show(pair.second, stream);
fprintf(stream, ")");
} else if (IS_CLOSURE(p)) {
fprintf(stream, "#<closure 0x%08lx>", p);
} else if (IS_IMMEDIATE(p)) {
if (p == BOOL_F) {
fprintf(stream, "#f");
} else if (p == BOOL_T) {
fprintf(stream, "#t");
} else if (p == NIL) {
fprintf(stream, "()");
} else {
fprintf(stream, "#<immediate 0x%08lx>", p);
}
} else {
fprintf(stream, "#<unknown 0x%08lx>", p);
}
}
static int string_ref(vm_thread_t *thread, obj_t *ostr, obj_t *opos)
{
SAFE_ASSERT(IS_STRING(*ostr));
SAFE_ASSERT(IS_FIXNUM(*opos));
string_t *str = PTR(*ostr);
int pos = FIXNUM(*opos);
SAFE_ASSERT(pos < str->size-1);
RETURN_CHAR(str->str[pos]);
}
static int string_set(vm_thread_t *thread, obj_t *ostr,
obj_t *opos, obj_t *oval)
{
SAFE_ASSERT(IS_STRING(*ostr));
SAFE_ASSERT(IS_FIXNUM(*opos));
SAFE_ASSERT(IS_CHAR(*oval));
string_t *str = PTR(*ostr);
int pos = FIXNUM(*opos);
SAFE_ASSERT((pos >= 0) && (pos < str->size-1));
str->str[pos] = CHAR(*oval);
RETURN_OBJ(cvoid);
}
static int substring(vm_thread_t *thread, obj_t *ostr, obj_t *ostart, obj_t *oend)
{
SAFE_ASSERT(IS_STRING(*ostr));
SAFE_ASSERT(IS_FIXNUM(*ostart));
SAFE_ASSERT(IS_FIXNUM(*oend));
int start = FIXNUM(*ostart);
int end = FIXNUM(*oend);
string_t *str = PTR(*ostr);
SAFE_ASSERT((start >= 0)
&& (start <= end)
&& (end < str->size));
size_t nsize = end-start;
void *mem = heap_alloc(&thread->heap, nsize+sizeof(string_t), t_string);
string_t *dstr = mem;
dstr->str = mem+sizeof(string_t);
dstr->allocated = 1;
dstr->size = nsize+1;
memcpy(dstr->str, &CSTRING(*ostr)[start], nsize);
RETURN_OBJ(MAKE_HEAP_PTR(dstr));
}
static YogVal
group(YogEnv* env, YogHandle* self, YogHandle* pkg, YogHandle* group)
{
CHECK_SELF_MATCH2(env, self);
if ((group == NULL) || IS_NIL(HDL2VAL(group))) {
return group_num(env, self, 0);
}
if (IS_FIXNUM(HDL2VAL(group))) {
return group_num(env, self, VAL2INT(HDL2VAL(group)));
}
if (IS_PTR(HDL2VAL(group)) && (BASIC_OBJ_TYPE(HDL2VAL(group)) == TYPE_STRING)) {
return group_str(env, self, group);
}
raise_invalid_group(env, HDL2VAL(group));
return YUNDEF;
}
static int string_copy_to(vm_thread_t *thread, obj_t *odest, obj_t *opos, obj_t *osrc)
{
SAFE_ASSERT(IS_STRING(*odest));
SAFE_ASSERT(IS_HEAP_PTR(*odest));
SAFE_ASSERT(IS_STRING(*osrc));
SAFE_ASSERT(IS_FIXNUM(*opos));
string_t *src = PTR(*osrc);
string_t *dst = PTR(*odest);
SAFE_ASSERT(dst->allocated);
int pos = FIXNUM(*opos);
SAFE_ASSERT((pos >= 0)
&& (pos+src->size <= dst->size));
memcpy(&dst->str[pos], src->str, src->size-1);
RETURN_OBJ(cvoid);
}
static int make_string(vm_thread_t *thread, obj_t *olen, obj_t *ofill)
{
SAFE_ASSERT(IS_FIXNUM(*olen));
SAFE_ASSERT(IS_CHAR(*ofill));
size_t len = FIXNUM(*olen);
void *mem = heap_alloc(&thread->heap, sizeof(string_t)+len+1, t_string);
string_t *str = mem;
str->str = mem+sizeof(string_t);
str->size = len+1;
str->allocated = 1;
char fill = CHAR(*ofill);
int i;
for (i = 0; i < len; i++)
str->str[i] = fill;
str->str[len] = '\0';
RETURN_OBJ(MAKE_HEAP_PTR(str));
}
