void Phaser::PrintCheck(my_pair ** check) {
const char separator = ' ';
const int width = 5;
if (0) {
Debug::PrintLine(2*F_len/3);
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
if (!cf && !ff && !mf) {
Debug::PrintLine(2*F_len);
printf("%i %i %i\n", mf, ff, cf);
Debug::PrintLine(2*F_len);
size_t m = m_index(mf, ff, cf);
for (size_t i = 0; i <= I_len; i++) {
for (size_t j = 0; j <= J_len; j++) {
std::cout << std::left << std::setw(width) << std::setfill(separator) <<
"(" << check[m][IJ(i, j)].first << "," << check[m][IJ(i, j)].second<< ")";
}
std::cout << std::endl;
}
}
}
}
}
printf("\n");
}
}
void Phaser::PrintFace(score_t ** face) {
const char separator = ' ';
const int width = 5;
if (verbose) {
Debug::PrintLine(2*F_len/3);
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
if (!cf && !ff && !mf) {
Debug::PrintLine(2*F_len);
printf("%i %i %i\n", mf, ff, cf);
Debug::PrintLine(2*F_len);
size_t m = m_index(mf, ff, cf);
for (size_t i = 0; i <= I_len; i++) {
for (size_t j = 0; j <= J_len; j++) {
std::cout << std::left << std::setw(width) << std::setfill(separator) <<
face[m][IJ(i, j)];
}
std::cout << std::endl;
}
}
}
}
}
printf("\n");
}
}
c_Continuation::c_Continuation(const ObjectStaticCallbacks *cb) :
ExtObjectData(cb),
#ifndef HHVM
LABEL_INIT,
#endif
m_index(-1LL),
m_value(Variant::nullInit), m_received(Variant::nullInit),
m_done(false), m_running(false), m_should_throw(false),
m_isMethod(false), m_callInfo(NULL)
#ifdef HHVM
, LABEL_INIT
#endif
{
}
#undef LABEL_INIT
c_Continuation::~c_Continuation() {
if (hhvm) {
VM::ActRec* ar = actRec();
// The first local is the object itself, and it wasn't increffed at creation
// time (see createContinuation()). Overwrite its type to exempt it from
// refcounting here.
TypedValue* contLocal = frame_local(ar, 0);
ASSERT(contLocal->m_data.pobj == this);
contLocal->m_type = KindOfNull;
if (ar->hasVarEnv()) {
VM::VarEnv::destroy(ar->getVarEnv());
} else {
frame_free_locals_inl(ar, m_vmFunc->numLocals());
}
}
}
void c_Continuation::t___construct(
int64 func, int64 extra, bool isMethod,
CStrRef origFuncName, CVarRef obj, CArrRef args) {
INSTANCE_METHOD_INJECTION_BUILTIN(Continuation, Continuation::__construct);
if (hhvm) {
m_vmFunc = (VM::Func*) extra;
ASSERT(m_vmFunc);
} else {
m_callInfo = (const CallInfo*) func;
ASSERT(m_callInfo);
}
m_isMethod = isMethod;
m_origFuncName = origFuncName;
if (!obj.isNull()) {
m_obj = obj.toObject();
ASSERT(!m_obj.isNull());
} else {
ASSERT(m_obj.isNull());
}
m_args = args;
}
// With the current scheme we store the larger i, j
// that can be aligned to mid_k in the optimal alignment.
void Phaser::UpdateGeneral(score_t ** curr_face,
score_t ** prev_face,
my_pair ** curr_check,
my_pair ** prev_check,
size_t i,
size_t j,
size_t k,
size_t mid_k,
bool mf,
bool ff,
bool cf,
char m_char,
char f_char,
char c_1,
char c_2) {
size_t m = m_index(mf, ff, cf);
score_t max_score;
my_pair max_check;
// only k decreases. Two deletions from C.
score_t c_ins_1 = prev_face[m_index(mf, ff, 0)][IJ(i, j)] + score(c_1, '-') + score(c_2, '-');
score_t c_ins_2 = prev_face[m_index(mf, ff, 1)][IJ(i, j)] + score(c_1, '-') + score(c_2, '-');
my_pair check_1 = prev_check[m_index(mf, ff, 0)][IJ(i, j)];
my_pair check_2 = prev_check[m_index(mf, ff, 1)][IJ(i, j)];
if (c_ins_1 >= c_ins_2) {
max_score = c_ins_1;
max_check = check_1;
} else {
max_score = c_ins_2;
max_check = check_2;
}
if (i > 0) {
if (m_char == '-') {
score_t p1 = curr_face[m_index(0, ff, cf)][IJ(i-1, j)];
score_t p2 = curr_face[m_index(1, ff, cf)][IJ(i-1, j)];
curr_face[m][IJ(i, j)] = std::max(p1, p2);
if (k == mid_k) {
curr_check[m][IJ(i, j)] = my_pair(i, j);
} else if (k > mid_k) {
curr_check[m][IJ(i, j)] = (p1 > p2) ?
curr_check[m_index(0, ff, cf)][IJ(i-1, j)] :
curr_check[m_index(1, ff, cf)][IJ(i-1, j)];
}
return;
}
// only i decreases. Single deletion from M.
// TODO(Readability): This might be a one-level for over pre_mf.
score_t ins_val;
my_pair ins_check;
ins_val = curr_face[m_index(0, ff, cf)][IJ(i-1, j)] + score(m_char, '-');
ins_check = curr_check[m_index(0, ff, cf)][IJ(i-1, j)];
UpdateVals(ins_val, ins_check, &max_score, &max_check);
ins_val = curr_face[m_index(1, ff, cf)][IJ(i-1, j)] + score(m_char, '-');
ins_check = curr_check[m_index(1, ff, cf)][IJ(i-1, j)];
UpdateVals(ins_val, ins_check, &max_score, &max_check);
// k and i decreases: single deletions from C, M aligns.
for (bool pre_cf : {false, true}) {
for (bool pre_mf : {false, true}) {
score_t del_val = prev_face[m_index(pre_mf, ff, pre_cf)][IJ(i-1, j)] + score(c_1, m_char) + score(c_2, '-'); // NOLINT
my_pair del_check = prev_check[m_index(pre_mf, ff, pre_cf)][IJ(i-1, j)];
UpdateVals(del_val, del_check, &max_score, &max_check);
}
}
}
if (j > 0) {
if (f_char == '-') {
score_t p1 = curr_face[m_index(mf, 0, cf)][IJ(i, j-1)];
score_t p2 = curr_face[m_index(mf, 1, cf)][IJ(i, j-1)];
curr_face[m][IJ(i, j)] = std::max(p1, p2);
if (k == mid_k) {
curr_check[m][IJ(i, j)] = my_pair(i, j);
} else if (k > mid_k) {
curr_check[m][IJ(i, j)] = (p1 > p2) ?
curr_check[m_index(mf, 0, cf)][IJ(i, j-1)] :
curr_check[m_index(mf, 1, cf)][IJ(i, j-1)];
}
return;
}
score_t ins_val;
my_pair ins_check;
// only j decreases. Single deletion from F.
ins_val = curr_face[m_index(mf, 0, cf)][IJ(i, j-1)] + score(f_char, '-');
ins_check = curr_check[m_index(mf, 0, cf)][IJ(i, j-1)];
UpdateVals(ins_val, ins_check, &max_score, &max_check);
ins_val = curr_face[m_index(mf, 1, cf)][IJ(i, j-1)] + score(f_char, '-');
ins_check = curr_check[m_index(mf, 1, cf)][IJ(i, j-1)];
UpdateVals(ins_val, ins_check, &max_score, &max_check);
// k and j decreases: single deletions from C, F aligns.
for (bool pre_cf : {false, true}) {
for (bool pre_ff : {false, true}) {
score_t del_val = prev_face[m_index(mf, pre_ff, pre_cf)][IJ(i, j-1)] + score(c_1, '-') + score(c_2, f_char); // NOLINT
my_pair del_check = prev_check[m_index(mf, pre_ff, pre_cf)][IJ(i, j-1)];
UpdateVals(del_val, del_check, &max_score, &max_check);
}
}
}
if (i > 0 && j > 0) {
for (bool pre_cf : {false, true}) {
for (bool pre_ff : {false, true}) {
for (bool pre_mf : {false, true}) {
score_t aln_val = prev_face[m_index(pre_mf, pre_ff, pre_cf)][IJ(i-1, j-1)] + score(c_1, m_char) + score(c_2, f_char); // NOLINT
my_pair aln_check = prev_check[m_index(pre_mf, pre_ff, pre_cf)][IJ(i-1, j-1)];
UpdateVals(aln_val, aln_check, &max_score, &max_check);
}
}
} }
curr_face[m][IJ(i, j)] = max_score;
if (k == mid_k) {
curr_check[m][IJ(i, j)] = my_pair(i, j);
} else if (k > mid_k) {
curr_check[m][IJ(i, j)] = max_check;
}
}
// Checkpoint algorithm.
// O(n^3) time
// O(n^2) space
score_t Phaser::partial_aligner(size_t i_ini,
size_t j_ini,
size_t k_ini,
size_t i_end,
size_t j_end,
size_t k_end,
size_t *i_med,
size_t *j_med,
size_t *k_med) {
assert(j_end >= j_ini || j_end + 1 == j_ini);
assert(i_end >= i_ini || i_end + 1 == i_ini);
assert(k_end >= k_ini);
score_t * prev_face[8];
score_t * curr_face[8];
my_pair * prev_check[8];
my_pair * curr_check[8];
// Obs: we will use local i (resp. j, k) from 0 to I_len (J_len, K_len).
// characters are stracted from i_ini+i (j, k resp.).
// checkpoint answer is shifted back at the end.
I_len = i_end - i_ini + 1;
J_len = j_end - j_ini + 1;
size_t K_len = k_end - k_ini + 1;
size_t mid_k = K_len/2;
for (size_t m = 0; m < 8; m++) {
prev_face[m] = new score_t[(I_len+1) * (J_len+1)];
prev_check[m] = new my_pair[(I_len+1) * (J_len+1)];
}
// 8 points:
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
size_t m = m_index(mf, ff, cf);
prev_face[m][IJ(0, 0)] = 0;
prev_check[m][IJ(0, 0)] = my_pair(0, 0);
}
}
}
// 8 lines (j=0):
for (size_t i = 1; i <= I_len; i++) {
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
size_t m = m_index(mf, ff, cf);
char m_char = mf ? M2[i_ini + i-1] : M1[i_ini + i-1];
prev_face[m][IJ(i, 0)] = std::max(prev_face[m_index(0, ff, cf)][IJ(i-1, 0)] + score(m_char, '-'), // NOLINT
prev_face[m_index(1, ff, cf)][IJ(i-1, 0)] + score(m_char, '-')); // NOLINT
prev_check[m][IJ(i, 0)] = my_pair(i, 0);
}
}
}
}
// 8 faces:
for (size_t j = 1; j <= J_len; j++) {
for (size_t i = 0; i <= I_len; i++) {
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
size_t m = m_index(mf, ff, cf);
char f_char = ff ? F2[j_ini + j-1] : F1[j_ini + j-1];
prev_face[m][IJ(i, j)] = std::max(prev_face[m_index(mf, 0, cf)][IJ(i, j-1)] + score(f_char, '-'), // NOLINT
prev_face[m_index(mf, 1, cf)][IJ(i, j-1)] + score(f_char, '-')); // NOLINT
prev_check[m][IJ(i, j)] = my_pair(i, j);
}
}
}
}
}
PrintFace(prev_face);
bool malloc_opt = true;
if (malloc_opt) {
for (size_t m = 0; m < 8; m++) {
curr_face[m] = new score_t[(I_len+1) * (J_len+1)];
curr_check[m] = new my_pair[(I_len+1) * (J_len+1)];
}
}
// the rest of the faces:
for (size_t k = 1; k <= K_len; k++) {
if (!malloc_opt) {
for (size_t m = 0; m < 8; m++) {
curr_face[m] = new score_t[(I_len+1) * (J_len+1)];
curr_check[m] = new my_pair[(I_len+1) * (J_len+1)];
}
}
for (size_t j = 0; j <= J_len; j++) {
for (size_t i = 0; i <= I_len; i++) {
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
// m_char anf f_char should not be used, at least i > 0 (j > 0).
// If that is not the case, we initilize with a non-accepted character that
// will trig an error if used.
char m_char, f_char;
if (i > 0) {
m_char = mf ? M2[i_ini + i-1] : M1[i_ini + i-1];
} else {
m_char = 'J'; // Not in gen alphabet, will trigger an error if used.
}
if (j > 0) {
f_char = ff ? F2[j_ini + j-1] : F1[j_ini + j-1];
} else {
f_char = 'J'; // Not in gen alphabet, will trigger an error if used.
}
char c_1 = cf ? C2[k_ini + k-1] : C1[k_ini + k-1];
char c_2 = cf ? C1[k_ini + k-1] : C2[k_ini + k-1];
UpdateGeneral(curr_face,
prev_face,
curr_check,
prev_check,
i,
j,
k,
mid_k,
mf,
ff,
cf,
m_char,
f_char,
c_1,
c_2);
}
}
}
}
}
for (size_t m = 0; m < 8; m++) {
if (malloc_opt) {
score_t * tmp_face = prev_face[m];
my_pair * tmp_check = prev_check[m];
prev_face[m] = curr_face[m];
prev_check[m] = curr_check[m];
curr_face[m] = tmp_face;
curr_check[m] = tmp_check;
} else { delete[] (prev_face[m]);
delete[] (prev_check[m]);
prev_face[m] = curr_face[m];
prev_check[m] = curr_check[m];
}
}
if (k >= mid_k) {
// verbose = true;
}
PrintFace(prev_face);
PrintCheck(prev_check);
}
// we use char_i = M[i-1]
for (int i = 0; i < 8; i++) {
assert(prev_check[i][IJ(I_len, J_len)].first <= I_len);
assert(prev_check[i][IJ(I_len, J_len)].second <= J_len);
prev_check[i][IJ(I_len, J_len)].first--;
prev_check[i][IJ(I_len, J_len)].second--;
}
mid_k--;
// extract max:
score_t ans;
bool flip_ans;
ExtractMax(prev_face, prev_check, &ans, i_med, j_med, &flip_ans);
*k_med = k_ini + mid_k;
*i_med = i_ini + (*i_med);
*j_med = j_ini + (*j_med);
assert(CorrectIniMedEnd(i_ini, *i_med, i_end));
assert(CorrectIniMedEnd(j_ini, *j_med, j_end));
assert(CorrectIniMedEnd(k_ini, *k_med, k_end));
char phase_char = flip_ans ? '1' : '0';
if (phase_string[k_end] != '?') {
assert(phase_string[k_end] == phase_char);
}
if (phase_string[k_end] == '?') {
phase_string[k_end] = phase_char;
}
for (size_t m = 0; m < 8; m++) {
delete[] (prev_face[m]);
delete[] (prev_check[m]);
if (malloc_opt) {
delete[] (curr_face[m]);
delete[] (curr_check[m]);
}
}
return ans;
}
gkBlendListIterator::gkBlendListIterator(List* list)
: m_list(list),
#if OGREKIT_USE_BPARSE
m_index(0)
#else
m_index(list ? list->first : 0)
#endif
{
}
bool gkBlendListIterator::hasMoreElements() const
{
if (m_list == 0) return false;
#if OGREKIT_USE_BPARSE
return m_index < m_list->size();
#else
return m_index != 0;
#endif
}
gkBlendListIterator::ListItem* gkBlendListIterator::getNext(void)
{
#if OGREKIT_USE_BPARSE
return m_list->at(m_index++);
#else
ListItem* item = m_index;
m_index = m_index->next;
return item;
#endif
}
//--
gkBlendInternalFile::gkBlendInternalFile()
: m_file(0)
{
}
gkBlendInternalFile::~gkBlendInternalFile()
{
delete m_file;
m_file = 0;
}
bool gkBlendInternalFile::parse(const gkString& fname)
{
if (fname.empty())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. File name is empty.");
return false;
}
#if OGREKIT_USE_BPARSE
utMemoryStream fs;
fs.open(fname.c_str(), utStream::SM_READ);
if (!fs.isOpen())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. No such file.");
return false;
}
// Write contents and inflate.
utMemoryStream buffer(utStream::SM_WRITE);
fs.inflate(buffer);
m_file = new bParse::bBlenderFile((char*)buffer.ptr(), buffer.size());
m_file->parse(false);
if (!m_file->ok())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. Data error.");
return false;
}
#else
m_file = new fbtBlend();
int status = m_file->parse(fname.c_str(), fbtFile::PM_COMPRESSED);
if (status != fbtFile::FS_OK)
{
delete m_file;
m_file = 0;
gkLogMessage("BlendFile: File " << fname << " loading failed. code: " << status);
//return false;
}
else
{
gkLogMessage("BlendFile: File " << fname << " loading end1" );
return true;
}
//gkLogMessage("BlendFile: File " << fname << " loading end" );
m_file = new fbtBlend();
Ogre::DataStreamPtr stream;
Ogre::ArchiveManager::ArchiveMapIterator beginItera = Ogre::ArchiveManager::getSingleton().getArchiveIterator();
while(beginItera.hasMoreElements())
{
typedef std::map<Ogre::String, Ogre::Archive*>::iterator ArchiveIterator;
ArchiveIterator arch = beginItera.current();
if (arch->second)
{
Ogre::FileInfoListPtr fileInfo = arch->second->findFileInfo(fname);
if (fileInfo->size() > 0)
{
stream = arch->second->open(fname);
gkLogMessage("BlendFile: File found create stream");
break;
}
}
beginItera.moveNext();
}
//gkLogMessage("malloc buffer");
unsigned char * buffer = new unsigned char[stream->size()];
//gkLogMessage(" stream->read ");
long sizeCount = stream->read(buffer,stream->size());
//gkLogMessage(" m_file->parse");
if(m_file) m_file->parse(buffer,sizeCount);
delete buffer;
//gkLogMessage(" m_file->parse end");
#endif
return true;
}
Blender::FileGlobal* gkBlendInternalFile::getFileGlobal()
{
GK_ASSERT(m_file);
#if OGREKIT_USE_BPARSE
return (Blender::FileGlobal*)m_file->getFileGlobal();
#else
return m_file->m_fg;
#endif
}
int gkBlendInternalFile::getVersion()
{
GK_ASSERT(m_file);
#if OGREKIT_USE_BPARSE
return m_file->getMain()->getVersion();
#else
return m_file->getVersion();
#endif
}
