bool _sort_compare(HSQUIRRELVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
{
if(func < 0) {
if(!v->ObjCmp(a,b,ret)) return false;
}
else {
SQInteger top = sq_gettop(v);
sq_push(v, func);
sq_pushroottable(v);
v->Push(a);
v->Push(b);
if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
if(!sq_isstring( v->_lasterror))
v->Raise_Error(_SC("compare func failed"));
return false;
}
if(SQ_FAILED(sq_getinteger(v, -1, &ret))) {
v->Raise_Error(_SC("numeric value expected as return value of the compare function"));
return false;
}
sq_settop(v, top);
return true;
}
return true;
}
//QSORT ala Sedgewick
bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
{
SQInteger i, j;
SQArray *a=_array(arr);
SQObjectPtr pivot,t;
if( l < r ){
pivot = a->_values[l];
i = l; j = r+1;
while(1){
SQInteger ret;
do {
++i;
if(i > r) break;
if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
return false;
} while( ret <= 0);
do {
--j;
if ( j < 0 ) {
v->Raise_Error( _SC("Invalid qsort, probably compare function defect") );
return false;
}
if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
return false;
}
while( ret > 0 );
if( i >= j ) break;
t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
}
t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
if(!_qsort( v, arr, l, j-1,func)) return false;
if(!_qsort( v, arr, j+1, r,func)) return false;
}
return true;
}
bool ReadObject(HSQUIRRELVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o)
{
SQObjectType t;
_CHECK_IO(SafeRead(v,read,up,&t,sizeof(SQObjectType)));
switch(t){
case OT_STRING:{
SQInteger len;
_CHECK_IO(SafeRead(v,read,up,&len,sizeof(SQInteger)));
_CHECK_IO(SafeRead(v,read,up,_ss(v)->GetScratchPad(rsl(len)),rsl(len)));
o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len);
}
break;
case OT_INTEGER:{
SQInteger i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o = i; break;
}
case OT_FLOAT:{
SQFloat f;
_CHECK_IO(SafeRead(v,read,up,&f,sizeof(SQFloat))); o = f; break;
}
case OT_NULL:
o=_null_;
break;
default:
v->Raise_Error(_SC("cannot serialize a %s"),IdType2Name(t));
return false;
}
return true;
}
bool SafeRead( HSQUIRRELVM v, SQWRITEFUNC read, SQUserPointer up, SQUserPointer dest, SQInteger size ) {
if ( size && read( up, dest, size ) != size ) {
v->Raise_Error( _SC( "io error, read function failure, the origin stream could be corrupted/trucated" ) );
return false;
}
return true;
}
bool SafeWrite( HSQUIRRELVM v, SQWRITEFUNC write, SQUserPointer up, SQUserPointer dest, SQInteger size ) {
if ( write( up, dest, size ) != size ) {
v->Raise_Error( _SC( "io error (write function failure)" ) );
return false;
}
return true;
}
SQRESULT at(HSQUIRRELVM vm) {
SQObjectPtr self = vm->GetAt(vm->_top-2);
if (type(self) == OT_STRING) {
SQString *selfString = _string(self);
SQInteger index = selfString->_len;
sq_getinteger(vm, -1, &index);
auto begin = selfString->_val;
auto end = begin+selfString->_len;
try {
SQChar *from = NULL;
if (index >= 0) {
from = begin; utf8::advance(from, index, end);
}
else {
from = end;
for (auto i = index; i < 0; ++i) {
utf8::prior(from, begin);
}
}
auto to = from; utf8::advance(to, 1, end);
SQInteger resultLen = to-from;
assert((resultLen >= 0) && "Length of the resulting string should not be negative");
if (resultLen < 0) {
sq_pushnull(vm);
return 1;
}
SQChar *resultSequence = vm->_sharedstate->GetScratchPad(resultLen+1);
memset(resultSequence, 0, (resultLen+1)*sizeof(SQChar));
memcpy(resultSequence, from, resultLen*sizeof(SQChar));
SQString *result = SQString::Create(vm->_sharedstate, resultSequence);
vm->Push(result);
} catch (...) {
sq_pushnull(vm);
}
}
else {
vm->Raise_Error("string::at - Invalid receiver of type %s", GetTypeName(self));
return SQ_ERROR;
}
return 1;
}
bool CheckTag( HSQUIRRELVM v, SQWRITEFUNC read, SQUserPointer up, SQInteger tag ) {
SQInteger t;
_CHECK_IO( SafeRead( v, read, up, &t, sizeof( t ) ) );
if ( t != tag ) {
v->Raise_Error( _SC( "invalid or corrupted closure stream" ) );
return false;
}
return true;
}
bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o)
{
*o = &stack_get(v,idx);
if(type(**o) != type){
SQObjectPtr oval = v->PrintObjVal(**o);
v->Raise_Error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval));
return false;
}
return true;
}
bool WriteObject( HSQUIRRELVM v, SQUserPointer up, SQWRITEFUNC write, SQObjectPtr &o ) {
_CHECK_IO( SafeWrite( v, write, up, &type( o ), sizeof( SQObjectType ) ) );
switch ( type( o ) ) {
case OT_STRING:
_CHECK_IO( SafeWrite( v, write, up, &_string( o )->_len, sizeof( SQInteger ) ) );
_CHECK_IO( SafeWrite( v, write, up, _stringval( o ), rsl( _string( o )->_len ) ) );
break;
case OT_INTEGER:
_CHECK_IO( SafeWrite( v, write, up, &_integer( o ), sizeof( SQInteger ) ) );break;
case OT_FLOAT:
_CHECK_IO( SafeWrite( v, write, up, &_float( o ), sizeof( SQFloat ) ) );break;
case OT_NULL:
break;
default:
v->Raise_Error( _SC( "cannot serialize a %s" ), GetTypeName( o ) );
return false;
}
return true;
}
static SQInteger base_array(HSQUIRRELVM v)
{
SQArray *a;
SQInteger nInitialSize = tointeger(stack_get(v,2));
SQInteger ret = 1;
if (nInitialSize < 0) {
v->Raise_Error(_SC("can't create/resize array with/to size %d"), nInitialSize);
nInitialSize = 0;
ret = -1;
}
if(sq_gettop(v) > 2) {
a = SQArray::Create(_ss(v),0);
a->Resize(nInitialSize,stack_get(v,3));
}
else {
a = SQArray::Create(_ss(v),nInitialSize);
}
v->Push(a);
return ret;
}
bool _hsort_sift_down(HSQUIRRELVM v,SQArray *arr, SQInteger root, SQInteger bottom, SQInteger func)
{
SQInteger maxChild;
SQInteger done = 0;
SQInteger ret;
SQInteger root2;
while (((root2 = root * 2) <= bottom) && (!done))
{
if (root2 == bottom) {
maxChild = root2;
}
else {
if(!_sort_compare(v,arr->_values[root2],arr->_values[root2 + 1],func,ret))
return false;
if (ret > 0) {
maxChild = root2;
}
else {
maxChild = root2 + 1;
}
}
if(!_sort_compare(v,arr->_values[root],arr->_values[maxChild],func,ret))
return false;
if (ret < 0) {
if (root == maxChild) {
v->Raise_Error(_SC("inconsistent compare function"));
return false; // We'd be swapping ourselve. The compare function is incorrect
}
_Swap(arr->_values[root],arr->_values[maxChild]);
root = maxChild;
}
else {
done = 1;
}
}
return true;
}
