PBMiner

• Sources
• fastfuncs
• blob_funcs.cpp

#include "pbvm.h"
 
BOOL copy_val_ptr(vm_state *vm, value *val, blob *b, DWORD &pos, int size, bool field){
    void *dest,*src;
 
    if (pos+size -1 > b->len) return FALSE;
 
    if (val->flags&IS_NULL||field){
        dest=(void *)pbstg_alc(vm, size, GET_HEAP(vm));
        val->value = (DWORD)dest;
        val->flags = val->flags - IS_NULL;
    }else{
        dest=(void *)val->value;
    }
    src=(void*)(b->data+pos -1);
 
    memcpy(dest, src, size);
    pos+=size;
 
    return TRUE;
}
 
BOOL extract(vm_state *vm, value *val, blob *b, DWORD &pos, bool field){
    if (pos > b->len) return FALSE;
 
    if (val->flags & IS_ARRAY){
        long count;
        value *v;
        pb_array *parray=(pb_array *)val->value;
        count=ot_array_num_items(vm, parray);
        for (long i=0;i<count;i++){
            v=ot_array_index(vm, parray, i);
            if (!extract(vm, v, b, pos, false)) return FALSE;
        }
        return TRUE;
    }
 
    if (val->type & 0xC000){
        long fields, first;
        value field;
        pb_class *pclass = (pb_class *)val->value;
        fields = ob_get_no_fields(vm, pclass);
        first = ob_get_first_user_field(vm, pclass);
 
        for (int i=first;i<fields;i++){
            ob_get_field(vm, pclass, i, &field);
            if (!extract(vm, &field, b, pos, true)) return FALSE;
            if (!(field.flags & IS_ARRAY)){
                ob_set_field(vm, pclass, i, &field);
            }
        }
        return TRUE;
    }
 
    //TODO, ansi / unicode conversions....
 
    switch(val->type){
        case pbvalue_int:
        case pbvalue_boolean:
        case pbvalue_uint:
        case pbvalue_char:
            {
                if (pos+1 > b->len) return FALSE;
 
                short *p = (short *)&b->data[pos -1];
                val->value = *p;
                val->flags=0x500;
                pos+=2;
            }
            return TRUE;
 
        case pbvalue_byte:
            {
                if (pos > b->len) return FALSE;
 
                char *p = (char *)&b->data[pos -1];
                val->value = *p;
                pos++;
            }
            return TRUE;
 
        case pbvalue_long:
        case pbvalue_ulong:
            {
                if (pos+3 > b->len) return FALSE;
 
                long *p = (long *)&b->data[pos -1];
                val->value = *p;
                val->flags=0x1d00;
                pos+=4;
            }
            return TRUE;
 
        case pbvalue_real:
            {
                if (pos+3 > b->len) return FALSE;
 
                long *p = (long *)&b->data[pos -1];
                val->value = *p;
                val->flags=0x0900;
                pos+=4;
            }
            return TRUE;
        case pbvalue_string:
            {
                int len;
                wchar_t *dest, *src;
 
                len=(b->len - pos +1)/2;
                src=(wchar_t*)(b->data+pos -1);
                len=wcsnlen(src, len);
 
                dest=(wchar_t *)pbstg_alc(vm, (len+1) *2, GET_HEAP(vm));
 
                if ((!field)&&(!(val->flags&IS_NULL)))
                    ot_free_val_ptr(vm, val);
 
                val->value = (DWORD)dest;
                val->flags = 0x0d00;
 
                wcsncpy(dest, src, len);
                dest[len]=0;
                pos+=(len+1)*2;
            }
            return TRUE;
 
        case pbvalue_longlong:
        case pbvalue_double:
            return copy_val_ptr(vm, val, b, pos, 8, field);
        case pbvalue_dec:
            return copy_val_ptr(vm, val, b, pos, 16, field);
        case pbvalue_date:
        case pbvalue_time:
        case pbvalue_datetime:
            return copy_val_ptr(vm, val, b, pos, 12, field);
    }
    return FALSE;
}
 
// boolean blob_extract(ref any value, readonly blob data, ref ulong al_pos)
DWORD __declspec(dllexport) __stdcall Blob_Extract (vm_state *vm, DWORD arg_count){
    DWORD isnull;
    lvalue_ref *lv_val, *lv_pos;
    value ret, *val, *v_pos;
    blob *source;
 
    last_vm = vm;
 
    lv_val = ot_get_next_lvalue_arg(vm,&isnull);
    val = get_lvalue(vm, lv_val);
 
    source = (blob *)ot_get_valptr_arg(vm, &isnull);
 
    lv_pos=ot_get_next_lvalue_arg(vm, &isnull);
    v_pos = get_lvalue(vm, lv_pos);
 
    ret.value=extract(vm, val, source, v_pos->value, false);
 
    ret.type=pbvalue_boolean;
    ret.flags=0x500;
 
    ot_assign_ref_long(vm, lv_pos->ptr, v_pos->value, 0);
    ot_set_return_val(vm, &ret);
    return 1;
}
 
// PB10 only util function
DWORD __declspec(dllexport) __stdcall Get_Byte_Array (vm_state *vm, DWORD arg_count){
    DWORD start=0, len, isnull;
    blob *source;
    value ret;
 
    last_vm = vm;
 
    source=(blob *)ot_get_valptr_arg(vm, &isnull);
    len=source->len;
    if (arg_count>=2){
        start=ot_get_ulongarg(vm, &isnull) -1;
        if (start<0) start=0;
        len -= start;
        if (arg_count>=3){
            len=ot_get_ulongarg(vm, &isnull);
            if (len + start > source->len) len=source->len - start;
            if (len<0) len=0;
        }
    }
 
    pb_array *parray=ot_array_create_unbounded(vm, MAKELONG(-1,pbvalue_uint), 0);
    ret.value = (DWORD)parray;
    ret.type = pbvalue_uint;
    ret.flags = IS_ARRAY;
 
    for (DWORD i=0;i<len;i++){
        value *v=ot_array_index(vm, parray, i);
 
        v->value=source->data[start+i] & 0xFF;
        v->flags=0x0d00;
        v->type=pbvalue_uint;
    }
    ot_set_return_val(vm, &ret);
    return 1;
}
 
void expand_blob(vm_state *vm, value *bv, DWORD len){
    blob *b = (blob*)bv->value;
    if (b->len >= len) return;
 
    DWORD buff_size = pbstg_sz(vm, b);
 
    if (len+4 > buff_size){
        buff_size = len+4;
        if (buff_size>6144)
            buff_size|=0xFFF;
 
        b = (blob *)pbstg_realc(vm, b, buff_size, GET_HEAP(vm));
        bv->value = (DWORD)b;
    }
    b->len = len;
}
 
BOOL import(vm_state *vm, value *val, value *bv, DWORD &pos){
    if (val->flags&IS_NULL) return FALSE;
 
    if (val->flags & IS_ARRAY){
        long count;
        value *v;
        pb_array *parray=(pb_array *)val->value;
        count=ot_array_num_items(vm, parray);
        for (long i=0;i<count;i++){
            v=ot_array_index(vm, parray, i);
            if (!import(vm, v, bv, pos)) return FALSE;
        }
        return TRUE;
    }
 
    if (val->type & 0xC000){
        long fields, first;
        value field;
        pb_class *pclass=(pb_class *)val->value;
        fields = ob_get_no_fields(vm, pclass);
        first = ob_get_first_user_field(vm, pclass);
 
        for (int i=first;i<fields;i++){
            ob_get_field(vm, pclass, i, &field);
            if (!import(vm, &field, bv, pos)) return FALSE;
        }
        return TRUE;
    }
 
    int len;
    char *p;
 
    switch(val->type){
        case pbvalue_int:
        case pbvalue_boolean:
        case pbvalue_uint:
        case pbvalue_char:
            len=2;
            p=(char*)&val->value;
            break;
        case pbvalue_byte:
            len=1;
            p=(char*)&val->value;
            break;
        case pbvalue_long:
        case pbvalue_ulong:
        case pbvalue_real:
            len=4;
            p=(char*)&val->value;
            break;
        case pbvalue_string:
            len = (wcslen((wchar_t *)val->value)+1)*2;
            p=(char*)val->value;
            break;
        case pbvalue_longlong:
        case pbvalue_double:
            len=8;
            p=(char*)val->value;
            break;
        case pbvalue_dec:
            len=16;
            p=(char*)val->value;
            break;
        case pbvalue_date:
        case pbvalue_time:
        case pbvalue_datetime:
            len=12;
            p=(char*)val->value;
            break;
        case pbvalue_blob:
            {
                blob *b = (blob *)val->value;
                len=b->len;
                p=(char*)&b->data;
            }
    }
 
    expand_blob(vm, bv, pos+len-1);
    blob *b = (blob *)bv->value;
 
    memcpy(b->data+pos -1, p, len);
    pos+=len;
    return TRUE;
}
 
// boolean blob_import(readonly any value, ref blob data, ref ulong al_pos)
DWORD __declspec(dllexport) __stdcall Blob_Import (vm_state *vm, DWORD arg_count){
    DWORD isnull;
    DWORD pos;
    value ret;
    lvalue_ref *lv_pos;
    value *v_pos;
 
    last_vm = vm;
 
    value *v_value = ot_get_next_evaled_arg_no_convert(vm);
 
    lvalue_ref *lv_data = ot_get_next_lvalue_arg(vm,&isnull);
    value *data = get_lvalue(vm, lv_data);
 
    if (arg_count==3){
        lv_pos=ot_get_next_lvalue_arg(vm, &isnull);
        v_pos = get_lvalue(vm, lv_pos);
        pos=v_pos->value;
    }else{
        pos=((blob *)data->value)->len +1;
    }
 
    ret.value=import(vm, v_value, data, pos);
    ret.type=pbvalue_boolean;
    ret.flags=0x500;
 
    if (arg_count==3){
        v_pos->value=pos;
        ot_assign_ref_long(vm, lv_pos->ptr, v_pos->value, 0);
    }
    ot_set_return_val(vm, &ret);
    return 1;
}
 
DWORD __declspec(dllexport) __stdcall Blob_Mid (vm_state *vm, DWORD arg_count){
    DWORD start, len, isnull;
    blob *source, *dest;
    value v;
 
    last_vm = vm;
 
    source = (blob *)ot_get_valptr_arg(vm, &isnull);
    if (isnull || source==NULL || source->len==0){
        len =0;
    }else{
        start=ot_get_ulongarg(vm, &isnull);
        if (isnull||start<1) start=1;
        if (start>source->len){
            len=0;
        }else{
            if (arg_count>=3){
                len=ot_get_ulongarg(vm, &isnull);
                if (isnull) len=0;
                if (len>source->len - start+1) len = source->len - start+1;
            }else{
                len=source->len - start+1;
            }
        }
    }
 
    v.type=pbvalue_blob;
    v.flags=0xd00;
 
    dest = (blob *)pbstg_alc(vm, len +5, GET_HEAP(vm));
    dest->len=len;
    v.value=(DWORD)dest;
    if (len>0)
        memcpy(&dest->data[0], &source->data[start -1], len);
    ot_set_return_val(vm, &v);
    return 1;
}
 
DWORD __declspec(dllexport) __stdcall Blob_Alloc (vm_state *vm, DWORD arg_count){
    DWORD isnull, new_size;
    blob *dest;
    int zero_memory=FALSE;
    value v;
 
    last_vm = vm;
 
    new_size=ot_get_ulongarg(vm, &isnull);
    if (isnull) new_size=0;
 
    if (arg_count>=2){
        zero_memory=ot_get_simple_intarg(vm, &isnull);
        if (isnull) zero_memory=FALSE;
    }
 
    v.type=pbvalue_blob;
    v.flags=0xd00;
 
    dest = (blob *)pbstg_alc(vm, new_size +5, GET_HEAP(vm));
    dest->len=new_size;
    if (zero_memory){
        ZeroMemory(&dest->data[0],new_size);
    }
    v.value=(DWORD)dest;
 
    ot_set_return_val(vm, &v);
    return 1;
}