void
CloakedGUIDDict::remove(const char* key, CloakConn*& obj)
{
HX_ASSERT(key);
HXMutexLock(_mutex);
CloakedGUIDDictEntry* e, **ep;
UINT32 h = _hash(key);
for (ep = &_table[h%_nbuckets]; (e = *ep) != 0; ep = &e->_next)
{
if (_compare(key, e->_key) != 0)
continue;
*ep = e->_next;
obj = e->_obj;
obj->AddRef();
e->Release();
--_count;
HXMutexUnlock(_mutex);
return;
}
HXMutexUnlock(_mutex);
obj = 0;
return;
}
bool CSwordVerseKey::previous( const JumpType type ) {
bool ret = true;
switch (type) {
case UseBook: {
if ( (Book() == 1) && (Testament() == 1) ) { //Genesis
return false;
}
else if ( (Book() == 1) && (Testament() == 2) ) { //Matthew
Testament(1);
Book(BMAX[0]);
}
else {
Book( Book() - 1 );
}
break;
}
case UseChapter: {
Chapter(Chapter() - 1);
break;
}
case UseVerse: {
if (m_module && m_module->module()) {
const bool useHeaders = 1; //(Verse() == 0);
const bool oldHeadingsStatus = ((VerseKey*)(m_module->module()->getKey()))->Headings( useHeaders );
m_module->module()->getKey()->setText( key().toUtf8().constData() );
const bool oldStatus = m_module->module()->getSkipConsecutiveLinks();
m_module->module()->setSkipConsecutiveLinks(true);
( *( m_module->module() ) )--;
((VerseKey*)(m_module->module()->getKey()))->Headings( oldHeadingsStatus );
m_module->module()->setSkipConsecutiveLinks(oldStatus);
if (!m_module->module()->Error()) {
key( QString::fromUtf8(m_module->module()->KeyText()) );//don't use fromUtf8
}
else {
ret = false;
// Verse(Verse()-1);
m_module->module()->getKey()->setText( key().toUtf8().constData() ); //restore module's key
}
}
else {
Verse(Verse() - 1);
}
break;
}
default:
return false;
}
if ( CSwordBibleModuleInfo* bible = dynamic_cast<CSwordBibleModuleInfo*>(module()) ) {
if (_compare(bible->lowerBound()) < 0 ) {
key( bible->lowerBound() );
ret = false;
}
if (_compare(bible->upperBound()) > 0 ) {
key( bible->upperBound() );
ret = false;
}
return ret;
}
else if (Error()) {
return false;
}
return ret;
}
bool CSwordVerseKey::next( const JumpType type ) {
Error(); //clear Error status
bool ret = true;
switch (type) {
case UseBook: {
const int currentTestament = Testament();
const int currentBook = Book();
if ((currentTestament == 2) && (currentBook >= BMAX[currentTestament-1])) { //Revelation, i.e. end of navigation
return false;
}
else if ((currentTestament == 1) && (currentBook >= BMAX[currentTestament-1])) { //Malachi, switch to the NT
Testament(currentTestament + 1);
Book(1);
}
else {
Book(Book() + 1);
}
break;
}
case UseChapter: {
Chapter(Chapter() + 1);
break;
}
case UseVerse: {
if (m_module && m_module->module()) {
const bool oldStatus = m_module->module()->getSkipConsecutiveLinks();
m_module->module()->setSkipConsecutiveLinks(true);
//disable headings for next verse
const bool useHeaders = 1; //(Verse() == 0);
const bool oldHeadingsStatus = ((VerseKey*)(m_module->module()->getKey()))->Headings( useHeaders );
//don't use setKey(), that would create a new key without Headings set
m_module->module()->getKey()->setText( key().toUtf8().constData() );
(*(m_module->module()) )++;
((VerseKey*)(m_module->module()->getKey()))->Headings(oldHeadingsStatus);
m_module->module()->setSkipConsecutiveLinks(oldStatus);
if (!m_module->module()->Error()) {
key( QString::fromUtf8(m_module->module()->KeyText()) );
}
else {
// Verse(Verse()+1);
//don't change the key, restore the module's position
m_module->module()->getKey()->setText( key().toUtf8().constData() );
ret = false;
break;
}
}
else {
Verse(Verse() + 1);
}
break;
}
default:
return false;
}
if ( CSwordBibleModuleInfo* bible = dynamic_cast<CSwordBibleModuleInfo*>(module()) ) {
if (_compare(bible->lowerBound()) < 0 ) {
key( bible->lowerBound() );
ret = false;
}
if (_compare(bible->upperBound()) > 0 ) {
key( bible->upperBound() );
ret = false;
}
return ret;
}
else if (Error()) { //we have no module, so take care of VerseKey::Error()
return false;
}
return ret;
}
/* Faster merge (based on divide and conquer technique). */
static
void
_merge(const sauchar_t *T, const saidx_t *PA,
saidx_t *first, saidx_t *middle, saidx_t *last,
saidx_t *buf, saidx_t bufsize,
saidx_t depth) {
#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))
#define MERGE_CHECK_EQUAL(a)\
do {\
if((0 <= *(a)) &&\
(_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0)) {\
*(a) = ~*(a);\
}\
} while(0)
struct { saidx_t *a, *b, *c; int d; } stack[STACK_SIZE];
saidx_t *i, *j;
saidx_t m, len, half;
saidx_t ssize;
int check, next;
for(check = 0, ssize = 0;;) {
if((last - middle) <= bufsize) {
if((first < middle) && (middle < last)) {
_merge_backward(T, PA, buf, first, middle, last, depth);
}
if(check & 1) { MERGE_CHECK_EQUAL(first); }
if(check & 2) { MERGE_CHECK_EQUAL(last); }
STACK_POP(first, middle, last, check);
continue;
}
if((middle - first) <= bufsize) {
if(first < middle) {
_merge_forward(T, PA, buf, first, middle, last, depth);
}
if(check & 1) { MERGE_CHECK_EQUAL(first); }
if(check & 2) { MERGE_CHECK_EQUAL(last); }
STACK_POP(first, middle, last, check);
continue;
}
for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1;
0 < len;
len = half, half >>= 1) {
if(_compare(T, PA + GETIDX(*(middle + m + half)),
PA + GETIDX(*(middle - m - half - 1)), depth) < 0) {
m += half + 1;
half -= (len & 1) ^ 1;
}
}
if(0 < m) {
_block_swap(middle - m, middle, m);
i = j = middle, next = 0;
if((middle + m) < last) {
if(*(middle + m) < 0) {
for(; *(i - 1) < 0; --i) { }
*(middle + m) = ~*(middle + m);
}
for(j = middle; *j < 0; ++j) { }
next = 1;
}
if((i - first) <= (last - j)) {
STACK_PUSH(j, middle + m, last, (check & 2) | (next & 1));
middle -= m, last = i, check = (check & 1);
} else {
if((i == middle) && (middle == j)) { next <<= 1; }
STACK_PUSH(first, middle - m, i, (check & 1) | (next & 2));
first = j, middle += m, check = (check & 2) | (next & 1);
}
} else {
if(check & 1) { MERGE_CHECK_EQUAL(first); }
MERGE_CHECK_EQUAL(middle);
if(check & 2) { MERGE_CHECK_EQUAL(last); }
STACK_POP(first, middle, last, check);
}
}
}
/* Merge-backward with internal buffer. */
static
void
_merge_backward(const sauchar_t *T, const saidx_t *PA, saidx_t *buf,
saidx_t *first, saidx_t *middle, saidx_t *last,
saidx_t depth) {
const saidx_t *p1, *p2;
saidx_t *bufend;
saidx_t *i, *j, *k;
saidx_t t;
saint_t r;
saint_t x;
bufend = buf + (last - middle);
_block_swap(buf, middle, last - middle);
x = 0;
if(*(bufend - 1) < 0) { x |= 1; p1 = PA + ~*(bufend - 1); }
else { p1 = PA + *(bufend - 1); }
if(*(middle - 1) < 0) { x |= 2; p2 = PA + ~*(middle - 1); }
else { p2 = PA + *(middle - 1); }
for(t = *(last - 1), i = last - 1, j = bufend - 1, k = middle - 1;;) {
r = _compare(T, p1, p2, depth);
if(r > 0) {
if(x & 1) { do { *i-- = *j; *j-- = *i; } while(*j < 0); x ^= 1; }
*i-- = *j;
if(j <= buf) { *j = t; return; }
*j-- = *i;
if(*j < 0) { x |= 1; p1 = PA + ~*j; }
else { p1 = PA + *j; }
} else if(r < 0) {
if(x & 2) { do { *i-- = *k; *k-- = *i; } while(*k < 0); x ^= 2; }
*i-- = *k; *k-- = *i;
if(k < first) {
while(buf < j) { *i-- = *j; *j-- = *i; }
*i = *j, *j = t;
return;
}
if(*k < 0) { x |= 2; p2 = PA + ~*k; }
else { p2 = PA + *k; }
} else {
if(x & 1) { do { *i-- = *j; *j-- = *i; } while(*j < 0); x ^= 1; }
*i-- = ~*j;
if(j <= buf) { *j = t; return; }
*j-- = *i;
if(x & 2) { do { *i-- = *k; *k-- = *i; } while(*k < 0); x ^= 2; }
*i-- = *k; *k-- = *i;
if(k < first) {
while(buf < j) { *i-- = *j; *j-- = *i; }
*i = *j, *j = t;
return;
}
if(*j < 0) { x |= 1; p1 = PA + ~*j; }
else { p1 = PA + *j; }
if(*k < 0) { x |= 2; p2 = PA + ~*k; }
else { p2 = PA + *k; }
}
}
}
/* Search for the pattern P in the string T. */
saidx_t
sa_search(const sauchar_t *T, saidx_t Tsize,
const sauchar_t *P, saidx_t Psize,
const saidx_t *SA, saidx_t SAsize,
saidx_t *idx) {
saidx_t size, lsize, rsize, half;
saidx_t match, lmatch, rmatch;
saidx_t llmatch, lrmatch, rlmatch, rrmatch;
saidx_t i, j, k;
saint_t r;
if(idx != NULL) { *idx = -1; }
if((T == NULL) || (P == NULL) || (SA == NULL) ||
(Tsize < 0) || (Psize < 0) || (SAsize < 0)) { return -1; }
if((Tsize == 0) || (SAsize == 0)) { return 0; }
if(Psize == 0) { if(idx != NULL) { *idx = 0; } return SAsize; }
for(i = j = k = 0, lmatch = rmatch = 0, size = SAsize, half = size >> 1;
0 < size;
size = half, half >>= 1) {
match = MIN(lmatch, rmatch);
r = _compare(T, Tsize, P, Psize, SA[i + half], &match);
if(r < 0) {
i += half + 1;
half -= (size & 1) ^ 1;
lmatch = match;
} else if(r > 0) {
rmatch = match;
} else {
lsize = half, j = i, rsize = size - half - 1, k = i + half + 1;
/* left part */
for(llmatch = lmatch, lrmatch = match, half = lsize >> 1;
0 < lsize;
lsize = half, half >>= 1) {
lmatch = MIN(llmatch, lrmatch);
r = _compare(T, Tsize, P, Psize, SA[j + half], &lmatch);
if(r < 0) {
j += half + 1;
half -= (lsize & 1) ^ 1;
llmatch = lmatch;
} else {
lrmatch = lmatch;
}
}
/* right part */
for(rlmatch = match, rrmatch = rmatch, half = rsize >> 1;
0 < rsize;
rsize = half, half >>= 1) {
rmatch = MIN(rlmatch, rrmatch);
r = _compare(T, Tsize, P, Psize, SA[k + half], &rmatch);
if(r <= 0) {
k += half + 1;
half -= (rsize & 1) ^ 1;
rlmatch = rmatch;
} else {
rrmatch = rmatch;
}
}
break;
}
}
if(idx != NULL) { *idx = (0 < (k - j)) ? j : i; }
return k - j;
}
int TreeKeyIdx::compare(const SWKey &ikey) {
TreeKeyIdx *treeKey = SWDYNAMIC_CAST(TreeKeyIdx, (&ikey));
if (treeKey)
return _compare(*treeKey);
return SWKey::compare(ikey);
}
void OpcodeComparisonHandler::_run()
{
Logger::debug("SCRIPT") << "[8033-8038] [*] " << _cmpOpcodeName() << std::endl;
auto bValue = _vm->dataStack()->pop();
auto aValue = _vm->dataStack()->pop();
int result = 0;
switch (aValue.type())
{
case VMStackValue::Type::INTEGER:
{
int arg1 = aValue.integerValue();
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare(arg1, bValue.integerValue()); // INTEGER op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
result = _compare(arg1, bValue.floatValue()); // INTEGER op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
result = _compare(arg1, bValue.toInteger()); // INTEGER op STRING (parsed as int)
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
case VMStackValue::Type::FLOAT:
{
float arg1 = aValue.floatValue();
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare(arg1, bValue.integerValue()); // FLOAT op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
result = _compare(arg1, bValue.floatValue()); // FLOAT op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
float arg2 = 0.0;
try
{
arg2 = std::stof(bValue.stringValue());
}
catch (std::invalid_argument ex) { }
catch (std::out_of_range ex) { }
result = _compare(arg1, arg2); // FLOAT op STRING (parsed as float)
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
case VMStackValue::Type::STRING:
{
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare(aValue.toInteger(), bValue.integerValue()); // STRING (as integer) op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
float arg1 = 0.0;
try
{
arg1 = std::stof(aValue.stringValue());
}
catch (std::invalid_argument ex) { }
catch (std::out_of_range ex) { }
result = _compare(arg1, bValue.floatValue()); // STRING (as float) op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
result = _compare(aValue.stringValue(), bValue.stringValue()); // STRING op STRING
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
case VMStackValue::Type::OBJECT:
{
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare((int)aValue.toBoolean(), bValue.integerValue()); // OBJECT op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
result = _compare((float)aValue.toBoolean(), bValue.floatValue()); // OBJECT op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
result = _compare(aValue.toString(), bValue.stringValue()); // OBJECT op STRING - compare object name
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid left argument type: " + aValue.typeName());
}
}
_vm->dataStack()->push(result);
}
/**
* @brief Tests some more blitting routines.
*
* \sa
* http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
* http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
* http://wiki.libsdl.org/moin.cgi/SDL_SetTextureBlendMode
* http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
*/
int
render_testBlitBlend (void *arg)
{
int ret;
SDL_Rect rect;
SDL_Texture *tface;
SDL_Surface *referenceSurface = NULL;
Uint32 tformat;
int taccess, tw, th;
int i, j, ni, nj;
int mode;
int checkFailCount1;
int checkFailCount2;
int checkFailCount3;
int checkFailCount4;
SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
SDLTest_AssertCheck(_hasTexColor(), "_hasTexColor");
SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
/* Create face surface. */
tface = _loadTestFace();
SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
if (tface == NULL) {
return TEST_ABORTED;
}
/* Constant values. */
ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
rect.w = tw;
rect.h = th;
ni = TESTRENDER_SCREEN_W - tw;
nj = TESTRENDER_SCREEN_H - th;
/* Set alpha mod. */
ret = SDL_SetTextureAlphaMod( tface, 100 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetTextureAlphaMod, expected: 0, got: %i", ret);
/* Test None. */
_testBlitBlendMode( tface, SDL_BLENDMODE_NONE );
referenceSurface = SDLTest_ImageBlitBlendNone();
_compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
/* Test Blend. */
_testBlitBlendMode( tface, SDL_BLENDMODE_BLEND );
referenceSurface = SDLTest_ImageBlitBlend();
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
/* Test Add. */
_testBlitBlendMode( tface, SDL_BLENDMODE_ADD );
referenceSurface = SDLTest_ImageBlitBlendAdd();
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
/* Test Mod. */
_testBlitBlendMode( tface, SDL_BLENDMODE_MOD);
referenceSurface = SDLTest_ImageBlitBlendMod();
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
/* Clear surface. */
_clearScreen();
/* Loop blit. */
checkFailCount1 = 0;
checkFailCount2 = 0;
checkFailCount3 = 0;
checkFailCount4 = 0;
for (j=0; j <= nj; j+=4) {
for (i=0; i <= ni; i+=4) {
/* Set color mod. */
ret = SDL_SetTextureColorMod( tface, (255/nj)*j, (255/ni)*i, (255/nj)*j );
if (ret != 0) checkFailCount1++;
/* Set alpha mod. */
ret = SDL_SetTextureAlphaMod( tface, (100/ni)*i );
if (ret != 0) checkFailCount2++;
/* Crazy blending mode magic. */
mode = (i/4*j/4) % 4;
if (mode==0) mode = SDL_BLENDMODE_NONE;
else if (mode==1) mode = SDL_BLENDMODE_BLEND;
else if (mode==2) mode = SDL_BLENDMODE_ADD;
else if (mode==3) mode = SDL_BLENDMODE_MOD;
ret = SDL_SetTextureBlendMode( tface, (SDL_BlendMode)mode );
if (ret != 0) checkFailCount3++;
/* Blitting. */
rect.x = i;
rect.y = j;
ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
if (ret != 0) checkFailCount4++;
}
}
SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1);
SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount2);
SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetTextureBlendMode, expected: 0, got: %i", checkFailCount3);
SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount4);
/* Clean up. */
SDL_DestroyTexture( tface );
/* Check to see if final image matches. */
referenceSurface = SDLTest_ImageBlitBlendAll();
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
return TEST_COMPLETED;
}
char * method3(int *test, int n)
{
int i=0,j=0;
int a[n/2],a_sum[n/2], a_sum_sorted[n/2];
int b[n/2],b_sum[n/2],b_sum_sorted[n/2];
int negative_b_sum[n/2];
for(i=0,j=0; i<n/2; i++,j++)
a[j] = test[i];
for(j=0; i<n; i++,j++)
b[j] = test[i];
//prints what is divided
/*
printf("a: ");
for(i=0; i<n/2; i++)
printf("%d, ", a[i]);
printf("\n");
printf("b: ");
for(i=0; i<n/2; i++)
printf("%d, ",b[i]);
printf("\n");
*/
for(i=0;i<n/2;i++)
{
if(i==0)
{
a_sum[i] = a[(n/2)-i-1];
a_sum_sorted[i] = a_sum[i];
}
else
{
a_sum[i] = a_sum[i-1] + a[(n/2)-1-i];
a_sum_sorted[i] = a_sum[i];
}
}
for(i=0;i<n/2;i++)
{
if(i==0)
{
b_sum[i] = b[i];
b_sum_sorted[i] = b_sum[i];
}
else
{
b_sum[i] = b_sum[i-1] + b[i];
b_sum_sorted[i] = b_sum[i];
}
}
quickSort(a_sum_sorted,0,(n/2)-1);
quickSort(b_sum_sorted,0,(n/2)-1);
/*
for(i=0;i<(n/2);i++)
{
printf("a_sum[%d] = %d\n",i,a_sum[i]);
printf("b_sum[%d] = %d\n",i,b_sum[i]);
}
*/
for(i=0; i<n/2; i++)
negative_b_sum[i] = (-1)*b_sum_sorted[(n/2)-i-1];
//prints the sum sorted
/*
printf("a_sum_sorted: ");
for(i=0; i<n/2; i++)
printf("%d, ", a_sum_sorted[i]);
printf("\n");
printf("negative_b_sum: ");
for(i=0; i<n/2; i++)
printf("%d, ",negative_b_sum[i]);
printf("\n");
*/
struct results* r=_compare(a_sum_sorted, negative_b_sum, n);
struct results* half1=minSubArray(a,n/2);
struct results* half2=minSubArray(b,n/2);
for(i=0; i<n/2; i++)
{
if( ((-1)*negative_b_sum[r->b_index]) == b_sum[i])
{
r->b_index = i;
break;
}
}
for(i=0; i<n/2; i++)
{
if( (a_sum_sorted[r->a_index]) == a_sum[i])
{
r->a_index = i;
break;
}
}
// printf("r->sum = %d, a_ind = %d, b_ind = %d\n",r->sum,r->a_index,r->b_index);
// printf("half1->sum = %d, a_ind = %d, b_ind = %d\n",half1->sum,half1->a_index,half1->b_index);
// printf("half2->sum = %d, a_ind = %d, b_ind = %d\n",half2->sum,half2->a_index,half2->b_index);
//prints the closest to zero sum subset
char* return_str = malloc(20*sizeof(char));
if((abs(r->sum) < abs(half1->sum)) && (abs(r->sum) < abs(half2->sum)))
{
/*
printf("sum subset: ");
for(i=0; i<=r->a_index; i++)
printf("%d, ", a[(n/2)-i-1]);
for(i=0; i<=r->b_index; i++)
printf("%d, ", b[i]);
printf("\n");
printf("[........]%d,%d,%d\n",r->sum, ((n/2)-1)-r->a_index,(n/2)+r->b_index);
*/
sprintf(return_str,"%d,%d,%d\n",r->sum,((n/2)-1)-r->a_index,(n/2)+r->b_index);
}
else if(abs(half1->sum)<abs(half2->sum))
{
/*
printf("sum subset: ");
for(i=half1->a_index; i<=half1->b_index; i++)
printf("%d, ", a[i]);
printf("\n");
printf("[........]%d,%d,%d\n",half1->sum, half1->a_index,half1->b_index);
*/
sprintf(return_str,"%d,%d,%d\n",half1->sum, half1->a_index,half1->b_index);
}
else
{
/*
printf("sum subset: ");
for(i=half2->a_index; i<=half2->b_index; i++)
printf("%d, ", b[i]);
printf("\n");
printf("[........]%d,%d,%d\n",half2->sum, (n/2)+half2->a_index,(n/2)+half2->b_index);
*/
sprintf(return_str,"%d,%d,%d\n",half2->sum, (n/2)+half2->a_index,(n/2)+half2->b_index);
}
free(r);
free(half1);
free(half2);
return return_str;
}
/**
* @brief Tests blitting with alpha.
*
* \sa
* http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
* http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
* http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
*/
int
render_testBlitAlpha (void *arg)
{
int ret;
SDL_Rect rect;
SDL_Texture *tface;
SDL_Surface *referenceSurface = NULL;
Uint32 tformat;
int taccess, tw, th;
int i, j, ni, nj;
int checkFailCount1;
int checkFailCount2;
/* Need alpha or just skip test. */
SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
/* Create face surface. */
tface = _loadTestFace();
SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
if (tface == NULL) {
return TEST_ABORTED;
}
/* Constant values. */
ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
rect.w = tw;
rect.h = th;
ni = TESTRENDER_SCREEN_W - tw;
nj = TESTRENDER_SCREEN_H - th;
/* Test blitting with alpha mod. */
checkFailCount1 = 0;
checkFailCount2 = 0;
for (j=0; j <= nj; j+=4) {
for (i=0; i <= ni; i+=4) {
/* Set alpha mod. */
ret = SDL_SetTextureAlphaMod( tface, (255/ni)*i );
if (ret != 0) checkFailCount1++;
/* Blitting. */
rect.x = i;
rect.y = j;
ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
if (ret != 0) checkFailCount2++;
}
}
SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount1);
SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
/* See if it's the same. */
referenceSurface = SDLTest_ImageBlitAlpha();
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
/* Clean up. */
SDL_DestroyTexture( tface );
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
return TEST_COMPLETED;
}
/**
* @brief Tests the SDL primitives with alpha for rendering.
*
* \sa
* http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
* http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
* http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
*/
int render_testPrimitivesBlend (void *arg)
{
int ret;
int i, j;
SDL_Rect rect;
SDL_Surface *referenceSurface = NULL;
int checkFailCount1;
int checkFailCount2;
int checkFailCount3;
/* Need drawcolor and blendmode or just skip test. */
SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
/* Create some rectangles for each blend mode. */
ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
ret = SDL_RenderFillRect(renderer, NULL );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
rect.x = 10;
rect.y = 25;
rect.w = 40;
rect.h = 25;
ret = SDL_SetRenderDrawColor(renderer, 240, 10, 10, 75 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
ret = SDL_RenderFillRect(renderer, &rect );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
rect.x = 30;
rect.y = 40;
rect.w = 45;
rect.h = 15;
ret = SDL_SetRenderDrawColor(renderer, 10, 240, 10, 100 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
ret = SDL_RenderFillRect(renderer, &rect );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
rect.x = 25;
rect.y = 25;
rect.w = 25;
rect.h = 25;
ret = SDL_SetRenderDrawColor(renderer, 10, 10, 240, 125 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
ret = SDL_RenderFillRect(renderer, &rect );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
/* Draw blended lines, lines for everyone. */
checkFailCount1 = 0;
checkFailCount2 = 0;
checkFailCount3 = 0;
for (i=0; i<TESTRENDER_SCREEN_W; i+=2) {
ret = SDL_SetRenderDrawColor(renderer, 60+2*i, 240-2*i, 50, 3*i );
if (ret != 0) checkFailCount1++;
ret = SDL_SetRenderDrawBlendMode(renderer,(((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
(((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
if (ret != 0) checkFailCount2++;
ret = SDL_RenderDrawLine(renderer, 0, 0, i, 59 );
if (ret != 0) checkFailCount3++;
}
SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawLine, expected: 0, got: %i", checkFailCount3);
checkFailCount1 = 0;
checkFailCount2 = 0;
checkFailCount3 = 0;
for (i=0; i<TESTRENDER_SCREEN_H; i+=2) {
ret = SDL_SetRenderDrawColor(renderer, 60+2*i, 240-2*i, 50, 3*i );
if (ret != 0) checkFailCount1++;
ret = SDL_SetRenderDrawBlendMode(renderer,(((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
(((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
if (ret != 0) checkFailCount2++;
ret = SDL_RenderDrawLine(renderer, 0, 0, 79, i );
if (ret != 0) checkFailCount3++;
}
SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawLine, expected: 0, got: %i", checkFailCount3);
/* Draw points. */
checkFailCount1 = 0;
checkFailCount2 = 0;
checkFailCount3 = 0;
for (j=0; j<TESTRENDER_SCREEN_H; j+=3) {
for (i=0; i<TESTRENDER_SCREEN_W; i+=3) {
ret = SDL_SetRenderDrawColor(renderer, j*4, i*3, j*4, i*3 );
if (ret != 0) checkFailCount1++;
ret = SDL_SetRenderDrawBlendMode(renderer, ((((i+j)/3)%3)==0) ? SDL_BLENDMODE_BLEND :
((((i+j)/3)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
if (ret != 0) checkFailCount2++;
ret = SDL_RenderDrawPoint(renderer, i, j );
if (ret != 0) checkFailCount3++;
}
}
SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount3);
/* See if it's the same. */
referenceSurface = SDLTest_ImagePrimitivesBlend();
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
/* Clean up. */
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
return TEST_COMPLETED;
}
/**
* @brief Tests the SDL primitives for rendering.
*
* \sa
* http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
* http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
* http://wiki.libsdl.org/moin.cgi/SDL_RenderDrawLine
*
*/
int render_testPrimitives (void *arg)
{
int ret;
int x, y;
SDL_Rect rect;
SDL_Surface *referenceSurface = NULL;
int checkFailCount1;
int checkFailCount2;
/* Need drawcolor or just skip test. */
SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
/* Draw a rectangle. */
rect.x = 40;
rect.y = 0;
rect.w = 40;
rect.h = 80;
ret = SDL_SetRenderDrawColor(renderer, 13, 73, 200, SDL_ALPHA_OPAQUE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_RenderFillRect(renderer, &rect );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
/* Draw a rectangle. */
rect.x = 10;
rect.y = 10;
rect.w = 60;
rect.h = 40;
ret = SDL_SetRenderDrawColor(renderer, 200, 0, 100, SDL_ALPHA_OPAQUE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_RenderFillRect(renderer, &rect );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
/* Draw some points like so:
* X.X.X.X..
* .X.X.X.X.
* X.X.X.X.. */
checkFailCount1 = 0;
checkFailCount2 = 0;
for (y=0; y<3; y++) {
for (x = y % 2; x<TESTRENDER_SCREEN_W; x+=2) {
ret = SDL_SetRenderDrawColor(renderer, x*y, x*y/2, x*y/3, SDL_ALPHA_OPAQUE );
if (ret != 0) checkFailCount1++;
ret = SDL_RenderDrawPoint(renderer, x, y );
if (ret != 0) checkFailCount2++;
}
}
SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount2);
/* Draw some lines. */
ret = SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor");
ret = SDL_RenderDrawLine(renderer, 0, 30, TESTRENDER_SCREEN_W, 30 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
ret = SDL_SetRenderDrawColor(renderer, 55, 55, 5, SDL_ALPHA_OPAQUE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_RenderDrawLine(renderer, 40, 30, 40, 60 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
ret = SDL_SetRenderDrawColor(renderer, 5, 105, 105, SDL_ALPHA_OPAQUE );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
ret = SDL_RenderDrawLine(renderer, 0, 0, 29, 29 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
ret = SDL_RenderDrawLine(renderer, 29, 30, 0, 59 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
ret = SDL_RenderDrawLine(renderer, 79, 0, 50, 29 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
ret = SDL_RenderDrawLine(renderer, 79, 59, 50, 30 );
SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
/* See if it's the same. */
referenceSurface = SDLTest_ImagePrimitives();
_compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
/* Clean up. */
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
return TEST_COMPLETED;
}
void merge_sorted(void* _DestinationArray, void* _FirstArray, void* _SecondArray, size_t _FirstSize, size_t _SecondSize, size_t _ElementSize, int (*_compare)(void*, void*))
{
int _Index;
int _DestinationSize = _FirstSize + _SecondSize;
int _FirstEndIndex = _FirstSize - 1;
int _SecondEndIndex = _SecondSize - 1;
for (_Index = _DestinationSize - 1; _Index >= 0; --_Index)
{
/* ************************************************** */
/* Compare to see which is larger */
/* ************************************************** */
if (_FirstEndIndex < 0)
{
char* _DestinationPointer = (char*)_DestinationArray;
char* _SecondArrayPointer = (char*)_SecondArray;
memcpy((void*)(_DestinationPointer + ((_Index) * _ElementSize)), (void*)(_SecondArrayPointer + (_SecondEndIndex-- * _ElementSize)), _ElementSize);
continue;
}
if (_SecondEndIndex < 0)
{
char* _DestinationPointer = (char*)_DestinationArray;
char* _FirstArrayPointer = (char*)_FirstArray;
memcpy((void*)(_DestinationPointer + ((_Index) * _ElementSize)), (void*)(_FirstArrayPointer + (_FirstEndIndex-- * _ElementSize)), _ElementSize);
continue;
}
else if (_compare((void*)((char*)(_FirstArray + (_FirstEndIndex * (_ElementSize / sizeof(char))))), (void*)((char*)(_SecondArray + (_SecondEndIndex * (_ElementSize / sizeof(char)))))) > 0)
{
char* _DestinationPointer = (char*)_DestinationArray;
char* _FirstArrayPointer = (char*)_FirstArray;
memcpy((void*)(_DestinationPointer + ((_Index) * _ElementSize)), (void*)(_FirstArrayPointer + (_FirstEndIndex-- * _ElementSize)), _ElementSize);
}
else if (_SecondEndIndex >= 0)
{
char* _DestinationPointer = (char*)_DestinationArray;
char* _SecondArrayPointer = (char*)_SecondArray;
memcpy((void*)(_DestinationPointer + ((_Index) * (_ElementSize / sizeof(char)))), (void*)(_SecondArrayPointer + (_SecondEndIndex-- * (_ElementSize / sizeof(char)))), _ElementSize);
}
}
}
static PyObject *t_sequence_richcompare(t_sequence *self, PyObject *value,
int op)
{
PyObject *result = NULL;
int s0, s1;
if (!PySequence_Check(value))
{
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
value = PySequence_Fast(value, "not a sequence");
if (!value)
return NULL;
s0 = PySequence_Fast_GET_SIZE(value);
s1 = PySequence_Size(self->sequence);
if (s1 < 0)
{
Py_DECREF(value);
return NULL;
}
if (s0 != s1)
{
switch (op) {
case Py_EQ: result = Py_False; break;
case Py_NE: result = Py_True; break;
}
}
if (!result)
{
PyObject *sequence = PySequence_Fast(self->sequence, "not a sequence");
int i0, i1, cmp = 1;
if (!sequence)
{
Py_DECREF(value);
return NULL;
}
for (i0 = 0, i1 = 0; i0 < s0 && i1 < s1 && cmp; i0++, i1++) {
if (_compare(self, sequence, value, i0, i1, Py_EQ, &cmp) < 0)
{
Py_DECREF(sequence);
Py_DECREF(value);
return NULL;
}
}
if (cmp)
{
switch (op) {
case Py_LT: cmp = s0 < s1; break;
case Py_LE: cmp = s0 <= s1; break;
case Py_EQ: cmp = s0 == s1; break;
case Py_NE: cmp = s0 != s1; break;
case Py_GT: cmp = s0 > s1; break;
case Py_GE: cmp = s0 >= s1; break;
default: cmp = 0;
}
result = cmp ? Py_True : Py_False;
}
else if (op == Py_EQ)
result = Py_False;
else if (op == Py_NE)
result = Py_True;
else if (_compare(self, sequence, value, i0, i1, op, &cmp) < 0)
{
Py_DECREF(sequence);
Py_DECREF(value);
return NULL;
}
else
result = cmp ? Py_True : Py_False;
Py_DECREF(sequence);
}
Py_DECREF(value);
Py_INCREF(result);
return result;
}
