static void reload(){
VIDEO_SetBlack(true);
VIDEO_Flush();
VIDEO_WaitVSync (); /*** Wait for VBL ***/
void (*rld)() = (void (*)()) 0x80001800;
rld();
}
void Compression::AriVLC()
{
ac_encoder ace;
ac_model acm;
ac_encoder_init (&ace, (path + std::string(".ari")).c_str());
ac_model_init (&acm, NSYM1, NULL, ADAPT);
std::fstream rld(path + std::string(".rlc"),std::ios::in);
std::string str;
while(rld >> str){
for(size_t i = 0;i < str.size();++i){
ac_encode_symbol (&ace, &acm, (int)str[i]);
++loop_num;
}
}
ac_encoder_done (&ace);
ac_model_done (&acm);
ari_total_byte = (double)ac_encoder_bits (&ace) / 8.0f;
}
void Z80_Exec_ED(Z80_State *state, uint8_t opcode)
{
uint16_t addr;
uint8_t tmp;
//uint16_t tmp_16;
switch (opcode)
{
case 0x40: // in b, (c)
rB = in(rBC);
in_f(rB);
break;
case 0x41: // out (c), b
out(rBC, rB);
break;
case 0x42: // sbc hl, bc
t_states(7);
sbc_16(rHL, rBC);
break;
case 0x43: // ld (**), bc
addr = arg_16();
write_16(addr, rBC);
break;
case 0x44: // neg
neg();
break;
case 0x45: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x46: // im 0
S(IM) = 0;
break;
case 0x47: // ld i, a
t_states(1);
rI = rA;
break;
case 0x48: // in c, (c)
rC = in(rBC);
in_f(rC);
break;
case 0x49: // out (c), c
out(rBC, rC);
break;
case 0x4A: // adc hl, bc
t_states(7);
adc_16(rHL, rBC);
break;
case 0x4B: // ld bc, (**)
addr = arg_16();
rBC = read_16(addr);
break;
case 0x4C: // neg
neg();
break;
case 0x4D: // reti
rPC = pop_16();
break;
case 0x4E: // im 0/1
S(IM) = 0;
break;
case 0x4F: // ld r, a
t_states(1);
rR = rA;
break;
case 0x50: // in d, (c)
rD = in(rBC);
in_f(rD);
break;
case 0x51: // out (c), d
out(rBC, rD);
break;
case 0x52: // sbc hl, de
t_states(7);
sbc_16(rHL, rDE);
break;
case 0x53: // ld (**), de
addr = arg_16();
write_16(addr, rDE);
break;
case 0x54: // neg
neg();
break;
case 0x55: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x56: // im 1
S(IM) = 1;
break;
case 0x57: // ld a, i
t_states(1);
rA = rI;
ld_f(rA);
break;
case 0x58: // in e, (c)
rE = in(rBC);
in_f(rE);
break;
case 0x59: // out (c), e
out(rBC, rE);
break;
case 0x5A: // adc hl, de
t_states(7);
adc_16(rHL, rDE);
break;
case 0x5B: // ld de, (**)
addr = arg_16();
rDE = read_16(addr);
break;
case 0x5C: // neg
neg();
break;
case 0x5D: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x5E: // im 2
S(IM) = 2;
break;
case 0x5F: // ld a, r
t_states(1);
rA = rR;
ld_f(rA);
break;
case 0x60: // in h, (c)
rH = in(rBC);
in_f(rH);
break;
case 0x61: // out (c), h
out(rBC, rH);
break;
case 0x62: // sbc hl, hl
t_states(7);
sbc_16(rHL, rHL);
break;
case 0x63: // ld (**), hl
addr = arg_16();
write_16(addr, rHL);
break;
case 0x64: // neg
neg();
break;
case 0x65: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x66: // im 0
S(IM) = 0;
break;
case 0x67: // rrd
tmp = read(rHL);
t_states(4);
rrd(tmp);
write(rHL, tmp);
break;
case 0x68: // in l, (c)
rL = in(rBC);
in_f(rL);
break;
case 0x69: // out (c), l
out(rBC, rL);
break;
case 0x6A: // adc hl, hl
t_states(7);
adc_16(rHL, rHL);
break;
case 0x6B: // ld hl, (**)
addr = arg_16();
rHL = read_16(addr);
break;
case 0x6C: // neg
neg();
break;
case 0x6D: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x6E: // im 0/1
S(IM) = 0;
break;
case 0x6F: // rld
tmp = read(rHL);
t_states(4);
rld(tmp);
write(rHL, tmp);
break;
case 0x70: // in (c)
tmp = in(rBC);
in_f(tmp);
break;
case 0x71: // out (c), 0
out(rBC, 0);
break;
case 0x72: // sbc hl, sp
t_states(7);
sbc_16(rHL, rSP);
break;
case 0x73: // ld (**), sp
addr = arg_16();
write_16(addr, rSP);
break;
case 0x74: // neg
neg();
break;
case 0x75: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x76: // im 1
S(IM) = 1;
break;
case 0x78: // in a, (c)
rA = in(rBC);
in_f(rA);
break;
case 0x79: // out (c), a
out(rBC, rA);
break;
case 0x7A: // adc hl, sp
t_states(7);
adc_16(rHL, rSP);
break;
case 0x7B: // ld sp, (**)
addr = arg_16();
rSP = read_16(addr);
break;
case 0x7C: // neg
neg();
break;
case 0x7D: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x7E: // im 2
S(IM) = 2;
break;
case 0xA0: // ldi
tmp = read(rHL++);
write(rDE++, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
break;
case 0xA1: // cpi
tmp = read(rHL++);
t_states(5);
rBC--;
cpr_f(tmp);
break;
case 0xA2: // ini
t_states(1);
tmp = in(rBC);
write(rHL++, tmp);
rB--;
inir_f(tmp);
break;
case 0xA3: // outi
t_states(1);
tmp = read(rHL++);
rB--;
out(rBC, tmp);
outr_f(tmp);
break;
case 0xA8: // ldd
tmp = read(rHL--);
write(rDE--, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
break;
case 0xA9: // cpd
tmp = read(rHL--);
t_states(5);
rBC--;
cpr_f(tmp);
break;
case 0xAA: // ind
t_states(1);
tmp = in(rBC);
write(rHL--, tmp);
rB--;
indr_f(tmp);
break;
case 0xAB: // outd
t_states(1);
tmp = read(rHL--);
rB--;
out(rBC, tmp);
outr_f(tmp);
break;
case 0xB0: // ldir
tmp = read(rHL++);
write(rDE++, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
if (rBC) {
t_states(5);
rep();
}
break;
case 0xB1: // cpir
tmp = read(rHL++);
t_states(5);
rBC--;
cpr_f(tmp);
if (rBC && !(rF & fZ)) {
t_states(5);
rep();
}
break;
case 0xB2: // inir
t_states(1);
tmp = in(rBC);
write(rHL++, tmp);
rB--;
inir_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
case 0xB3: // otir
t_states(1);
tmp = read(rHL++);
rB--;
out(rBC, tmp);
outr_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
case 0xB8: // lddr
tmp = read(rHL--);
write(rDE--, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
if (rBC) {
t_states(5);
rep();
}
break;
case 0xB9: // cpdr
tmp = read(rHL--);
t_states(5);
rBC--;
cpr_f(tmp);
if (rBC && !(rF & fZ)) {
t_states(5);
rep();
}
break;
case 0xBA: // indr
t_states(1);
tmp = in(rBC);
write(rHL--, tmp);
rB--;
indr_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
case 0xBB: // otdr
t_states(1);
tmp = read(rHL--);
rB--;
out(rBC, tmp);
outr_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
}
}
void FLFormRecordDB::setMainWidget( QWidget * w ) {
if ( !cursor_ || !w )
return ;
if ( !cursor_->metadata() )
return ;
if ( showed ) {
if ( mainWidget_ && mainWidget_ != w )
initMainWidget( w );
} else
w->hide();
if ( pushButtonAcceptContinue )
pushButtonAcceptContinue->hide();
if ( pushButtonAccept )
pushButtonAccept->hide();
if ( pushButtonCancel )
pushButtonCancel->hide();
if ( pushButtonFirst )
pushButtonFirst->hide();
if ( pushButtonPrevious )
pushButtonPrevious->hide();
if ( pushButtonNext )
pushButtonNext->hide();
if ( pushButtonLast )
pushButtonLast->hide();
if ( layoutButtons )
delete layoutButtons;
if ( layout )
delete layout;
w->setFont( qApp->font() );
layout = new QVBoxLayout( this, 2, 3, "vlay" + name_ );
layout->add( w );
layoutButtons = new QHBoxLayout( layout, 3, "hlay" + name_ ) ;
QSpacerItem *spacer_2 = new QSpacerItem( 20, 20, QSizePolicy::Expanding,
QSizePolicy::Minimum );
QSize pbSize( 26, 26 );
#ifdef FL_DEBUGGER
if ( !pushButtonIDE ) {
pushButtonIDE = new QPushButton( this, "pushButtonIDE" );
connect( pushButtonIDE, SIGNAL( clicked() ), this, SLOT( openIde() ) );
}
pushButtonIDE->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonIDE->sizePolicy().hasHeightForWidth() ) );
pushButtonIDE->setMinimumSize( pbSize );
pushButtonIDE->setMaximumSize( pbSize );
QPixmap qsa( QPixmap::fromMimeSource( "bug.png" ) );
pushButtonIDE->setIconSet( qsa );
pushButtonIDE->setAccel( QKeySequence( Qt::Key_F3 ) );
QToolTip::add( pushButtonIDE, tr( "Abrir Depurador (F3)" ) );
QWhatsThis::add( pushButtonIDE, tr( "Abrir Depurador (F3)" ) );
pushButtonIDE->setFocusPolicy( QWidget::NoFocus );
layoutButtons->addWidget( pushButtonIDE );
connect( pushButtonIDE, SIGNAL( clicked() ), this, SLOT( openIde() ) );
#endif
layoutButtons->addItem( spacer_2 );
if ( cursor_->modeAccess() == FLSqlCursor::EDIT ||
cursor_->modeAccess() == FLSqlCursor::BROWSE ) {
if ( !pushButtonFirst ) {
pushButtonFirst = new QPushButton( this, "pushButtonFirst" );
connect( pushButtonFirst, SIGNAL( clicked() ), this, SLOT( firstRecord() ) );
}
pushButtonFirst->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonFirst->sizePolicy().hasHeightForWidth() ) );
pushButtonFirst->setMinimumSize( pbSize );
pushButtonFirst->setMaximumSize( pbSize );
QPixmap rld( QPixmap::fromMimeSource( "first.png" ) );
pushButtonFirst->setIconSet( rld );
pushButtonFirst->setAccel( QKeySequence( Qt::Key_F5 ) );
QToolTip::add( pushButtonFirst, tr( "Aceptar los cambios e ir al primer registro (F5)" ) );
QWhatsThis::add( pushButtonFirst, tr( "Aceptar los cambios e ir al primer registro (F5)" ) );
pushButtonFirst->setFocusPolicy( QWidget::NoFocus );
layoutButtons->addWidget( pushButtonFirst );
pushButtonFirst->show();
if ( !pushButtonPrevious ) {
pushButtonPrevious = new QPushButton( this, "pushButtonPrevious" );
connect( pushButtonPrevious, SIGNAL( clicked() ), this, SLOT( previousRecord() ) );
}
pushButtonPrevious->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonPrevious->sizePolicy().hasHeightForWidth() ) );
pushButtonPrevious->setMinimumSize( pbSize );
pushButtonPrevious->setMaximumSize( pbSize );
QPixmap rld2( QPixmap::fromMimeSource( "previous.png" ) );
pushButtonPrevious->setIconSet( rld2 );
pushButtonPrevious->setAccel( QKeySequence( Qt::Key_F6 ) );
QToolTip::add( pushButtonPrevious, tr( "Aceptar los cambios e ir al registro anterior (F6)" ) );
QWhatsThis::add( pushButtonPrevious, tr( "Aceptar los cambios e ir al registro anterior (F6)" ) );
pushButtonPrevious->setFocusPolicy( QWidget::NoFocus );
layoutButtons->addWidget( pushButtonPrevious );
pushButtonPrevious->show();
if ( !pushButtonNext ) {
pushButtonNext = new QPushButton( this, "pushButtonNext" );
connect( pushButtonNext, SIGNAL( clicked() ), this, SLOT( nextRecord() ) );
}
pushButtonNext->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonNext->sizePolicy().hasHeightForWidth() ) );
pushButtonNext->setMinimumSize( pbSize );
pushButtonNext->setMaximumSize( pbSize );
QPixmap rld3( QPixmap::fromMimeSource( "next.png" ) );
pushButtonNext->setIconSet( rld3 );
pushButtonNext->setAccel( QKeySequence( Qt::Key_F7 ) );
QToolTip::add( pushButtonNext, tr( "Aceptar los cambios e ir al registro siguiente (F7)" ) );
QWhatsThis::add( pushButtonNext, tr( "Aceptar los cambios e ir al registro siguiente (F7)" ) );
pushButtonNext->setFocusPolicy( QWidget::NoFocus );
layoutButtons->addWidget( pushButtonNext );
pushButtonNext->show();
if ( !pushButtonLast ) {
pushButtonLast = new QPushButton( this, "pushButtonLast" );
connect( pushButtonLast, SIGNAL( clicked() ), this, SLOT( lastRecord() ) );
}
pushButtonLast->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonLast->sizePolicy().hasHeightForWidth() ) );
pushButtonLast->setMinimumSize( pbSize );
pushButtonLast->setMaximumSize( pbSize );
QPixmap rld4( QPixmap::fromMimeSource( "last.png" ) );
pushButtonLast->setIconSet( rld4 );
pushButtonLast->setAccel( QKeySequence( Qt::Key_F8 ) );
QToolTip::add( pushButtonLast, tr( "Aceptar los cambios e ir al último registro (F8)" ) );
QWhatsThis::add( pushButtonLast, tr( "Aceptar los cambios e ir al último registro (F8)" ) );
pushButtonLast->setFocusPolicy( QWidget::NoFocus );
layoutButtons->addWidget( pushButtonLast );
pushButtonLast->show();
}
if ( cursor_->modeAccess() != FLSqlCursor::BROWSE ) {
if ( showAcceptContinue_ ) {
if ( !pushButtonAcceptContinue ) {
pushButtonAcceptContinue = new QPushButton( this, "pushButtonAcceptContinue" );
connect( pushButtonAcceptContinue, SIGNAL( clicked() ), this, SLOT( acceptContinue() ) );
}
pushButtonAcceptContinue->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonAcceptContinue->sizePolicy().hasHeightForWidth() ) );
pushButtonAcceptContinue->setMinimumSize( pbSize );
pushButtonAcceptContinue->setMaximumSize( pbSize );
QPixmap rld( QPixmap::fromMimeSource( "reload.png" ) );
pushButtonAcceptContinue->setIconSet( rld );
pushButtonAcceptContinue->setFocusPolicy( QWidget::NoFocus );
pushButtonAcceptContinue->setAccel( QKeySequence( Qt::Key_F9 ) );
QToolTip::add( pushButtonAcceptContinue, tr( "Aceptar los cambios y continuar con la edición de un nuevo registro (F9)" ) );
QWhatsThis::add( pushButtonAcceptContinue, tr( "Aceptar los cambios y continuar con la edición de un nuevo registro (F9)" ) );
layoutButtons->addWidget( pushButtonAcceptContinue );
pushButtonAcceptContinue->show();
}
if ( !pushButtonAccept ) {
pushButtonAccept = new QPushButton( this, "pushButtonAccept" );
connect( pushButtonAccept, SIGNAL( clicked() ), this, SLOT( accept() ) );
}
pushButtonAccept->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonAccept->sizePolicy().hasHeightForWidth() ) );
pushButtonAccept->setMinimumSize( pbSize );
pushButtonAccept->setMaximumSize( pbSize );
QPixmap ok( QPixmap::fromMimeSource( "button_ok.png" ) );
pushButtonAccept->setIconSet( ok );
pushButtonAccept->setFocusPolicy( QWidget::NoFocus );
pushButtonAccept->setAccel( QKeySequence( Qt::Key_F10 ) );
QToolTip::add( pushButtonAccept, tr( "Aceptar los cambios y cerrar formulario (F10)" ) );
QWhatsThis::add( pushButtonAccept, tr( "Aceptar los cambios y cerrar formulario (F10)" ) );
layoutButtons->addWidget( pushButtonAccept );
pushButtonAccept->show();
}
if ( !pushButtonCancel ) {
pushButtonCancel = new QPushButton( this, "pushButtonCancel" );
connect( cursor_, SIGNAL( autoCommit() ), this, SLOT( disablePushButtonCancel() ) );
connect( pushButtonCancel, SIGNAL( clicked() ), this, SLOT( reject() ) );
}
pushButtonCancel->setSizePolicy( QSizePolicy(( QSizePolicy::SizeType ) 0, ( QSizePolicy::SizeType ) 0, 0, 0,
pushButtonCancel->sizePolicy().hasHeightForWidth() ) );
pushButtonCancel->setMinimumSize( pbSize );
pushButtonCancel->setMaximumSize( pbSize );
QPixmap cancel( QPixmap::fromMimeSource( "button_cancel.png" ) );
pushButtonCancel->setIconSet( cancel );
if ( cursor_->modeAccess() != FLSqlCursor::BROWSE ) {
pushButtonCancel->setFocusPolicy( QWidget::NoFocus );
pushButtonCancel->setAccel( 4096 );
QToolTip::add( pushButtonCancel, tr( "Cancelar los cambios y cerrar formulario (Esc)" ) );
QWhatsThis::add( pushButtonCancel, tr( "Cancelar los cambios y cerrar formulario (Esc)" ) );
} else {
QPixmap ok( QPixmap::fromMimeSource( "button_cancel.png" ) );
pushButtonCancel->setIconSet( ok );
pushButtonCancel->setFocusPolicy( QWidget::StrongFocus );
pushButtonCancel->setFocus();
pushButtonCancel->setAccel( 4096 );
QToolTip::add( pushButtonCancel, tr( "Aceptar y cerrar formulario (Esc)" ) );
QWhatsThis::add( pushButtonCancel, tr( "Aceptar y cerrar formulario (Esc)" ) );
}
pushButtonCancel->setDefault( true );
layoutButtons->addWidget( pushButtonCancel );
pushButtonCancel->show();
mainWidget_ = w;
mainWidget_->setFocusPolicy( QWidget::NoFocus );
int mWidth = mainWidget_->width();
int mHeight = mainWidget_->height();
QWidget * actWin = qApp->activeWindow();
QRect screen = ( actWin ? actWin->geometry() : qApp->mainWidget()->geometry() );
QRect desk = QApplication::desktop()->geometry();
QPoint p = screen.center() - QPoint( mWidth / 2, mHeight / 2 );
if ( p.x() + mWidth > desk.width() )
p.setX( desk.width() - mWidth );
if ( p.y() + mHeight > desk.height() )
p.setY( desk.height() - mHeight );
if ( p.x() < 0 )
p.setX( 0 );
if ( p.y() < 0 )
p.setY( 0 );
move( p );
}
void Gui::draw()
{
// printf("Gui draw\n");
Input::getInstance().refreshInput();
Cursor::getInstance().updateCursor();
Focus::getInstance().updateFocus();
if(padAutoAssign) auto_assign_controllers();
//Update time??
//Get graphics framework and pass to Frame draw fns?
gfx->drawInit();
drawBackground();
FrameList::const_iterator iteration;
for (iteration = frameList.begin(); iteration != frameList.end(); iteration++)
{
(*iteration)->updateTime(0.0f); //TODO: Pass deltaTime
(*iteration)->drawChildren(*gfx);
}
// menuLogo->drawComponent(*gfx);
menuLogo->draw(*gfx);
if (MessageBox::getInstance().getActive()) MessageBox::getInstance().drawMessageBox(*gfx);
if (LoadingBar::getInstance().getActive()) LoadingBar::getInstance().drawLoadingBar(*gfx);
Cursor::getInstance().drawCursor(*gfx);
if(shutdown)
{
Cursor::getInstance().setFreezeAction(true);
Focus::getInstance().setFreezeAction(true);
gfx->enableBlending(true);
gfx->setTEV(GX_PASSCLR);
gfx->setDepth(-10.0f);
gfx->newModelView();
gfx->loadModelView();
gfx->loadOrthographic();
gfx->setColor((GXColor){0, 0, 0, fade});
if(screenMode) gfx->fillRect(-104, 0, 848, 480);
else gfx->fillRect(0, 0, 640, 480);
if(fade == 255)
{
VIDEO_SetBlack(true);
VIDEO_Flush();
VIDEO_WaitVSync();
if(shutdown==1) //Power off System
SYS_ResetSystem(SYS_POWEROFF, 0, 0);
else //Return to Loader
{
#ifdef WII
if(dvd_hard_init) {
DI_Close();
}
#endif
void (*rld)() = (void (*)()) 0x80001800;
rld();
}
}
char increment = 3;
fade = fade +increment > 255 ? 255 : fade + increment;
}
gfx->swapBuffers();
}
static void
executeOneCommand(JNIEnv* env) {
switch (saCmdType) {
case SA_CMD_SUSPEND_ALL: {
if (suspended) {
reportErrorToSA("Target process already suspended");
return;
}
// We implement this by getting all of the threads and calling
// SuspendThread on each one, except for the thread object
// corresponding to this thread. Each thread for which the call
// succeeded (i.e., did not return JVMDI_ERROR_INVALID_THREAD)
// is added to a list which is remembered for later resumption.
// Note that this currently has race conditions since a thread
// might be started after we call GetAllThreads and since a
// thread for which we got an error earlier might be resumed by
// the VM while we are busy suspending other threads. We could
// solve this by looping until there are no more threads we can
// suspend, but a more robust and scalable solution is to add
// this functionality to the JVMDI interface (i.e.,
// "suspendAll"). Probably need to provide an exclude list for
// such a routine.
jint threadCount;
jthread* threads;
if (jvmdi->GetAllThreads(&threadCount, &threads) != JVMDI_ERROR_NONE) {
reportErrorToSA("Error while getting thread list");
return;
}
for (int i = 0; i < threadCount; i++) {
jthread thr = threads[i];
if (!env->IsSameObject(thr, debugThreadObj)) {
jvmdiError err = jvmdi->SuspendThread(thr);
if (err == JVMDI_ERROR_NONE) {
// Remember this thread and do not free it
suspendedThreads.push_back(thr);
continue;
} else {
fprintf(stderr, " SA: Error %d while suspending thread\n", err);
// FIXME: stop, resume all threads, report error
}
}
env->DeleteGlobalRef(thr);
}
// Free up threads
jvmdi->Deallocate((jbyte*) threads);
// Suspension is complete
suspended = true;
break;
}
case SA_CMD_RESUME_ALL: {
if (!suspended) {
reportErrorToSA("Target process already suspended");
return;
}
saCmdResult = 0;
bool errorOccurred = false;
jvmdiError firstError;
for (int i = 0; i < suspendedThreads.size(); i++) {
jthread thr = suspendedThreads[i];
jvmdiError err = jvmdi->ResumeThread(thr);
env->DeleteGlobalRef(thr);
if (err != JVMDI_ERROR_NONE) {
if (!errorOccurred) {
errorOccurred = true;
firstError = err;
}
}
}
suspendedThreads.clear();
suspended = false;
if (errorOccurred) {
reportErrorToSA("Error %d while resuming threads", firstError);
return;
}
break;
}
case SA_CMD_TOGGLE_BREAKPOINT: {
saCmdBkptResWasError = 1;
// Search line number info for all loaded classes
jint classCount;
jclass* classes;
jvmdiError glcRes = jvmdi->GetLoadedClasses(&classCount, &classes);
if (glcRes != JVMDI_ERROR_NONE) {
reportErrorToSA("Error %d while getting loaded classes", glcRes);
return;
}
JvmdiRefListDeallocator rld(env, (jobject*) classes, classCount);
bool done = false;
bool gotOne = false;
jclass targetClass;
jmethodID targetMethod;
jlocation targetLocation;
jint targetLineNumber;
for (int i = 0; i < classCount && !done; i++) {
fflush(stderr);
jclass clazz = classes[i];
char* srcName;
jvmdiError sfnRes = jvmdi->GetSourceFileName(clazz, &srcName);
if (sfnRes == JVMDI_ERROR_NONE) {
JvmdiDeallocator de1(srcName);
if (!strcmp(srcName, saCmdBkptSrcFileName)) {
// Got a match. Now see whether the package name of the class also matches
char* clazzName;
jvmdiError sigRes = jvmdi->GetClassSignature(clazz, &clazzName);
if (sigRes != JVMDI_ERROR_NONE) {
reportErrorToSA("Error %d while getting a class's signature", sigRes);
return;
}
JvmdiDeallocator de2(clazzName);
if (packageNameMatches(clazzName + 1, saCmdBkptPkgName)) {
// Iterate through all methods
jint methodCount;
jmethodID* methods;
if (jvmdi->GetClassMethods(clazz, &methodCount, &methods) != JVMDI_ERROR_NONE) {
reportErrorToSA("Error while getting methods of class %s", clazzName);
return;
}
JvmdiDeallocator de3(methods);
for (int j = 0; j < methodCount && !done; j++) {
jmethodID m = methods[j];
jint entryCount;
JVMDI_line_number_entry* table;
jvmdiError lnRes = jvmdi->GetLineNumberTable(clazz, m, &entryCount, &table);
if (lnRes == JVMDI_ERROR_NONE) {
JvmdiDeallocator de4(table);
// Look for line number greater than or equal to requested line
for (int k = 0; k < entryCount && !done; k++) {
JVMDI_line_number_entry& entry = table[k];
if (entry.line_number >= saCmdBkptLineNumber &&
(!gotOne || entry.line_number < targetLineNumber)) {
gotOne = true;
targetClass = clazz;
targetMethod = m;
targetLocation = entry.start_location;
targetLineNumber = entry.line_number;
done = (targetLineNumber == saCmdBkptLineNumber);
}
}
} else if (lnRes != JVMDI_ERROR_ABSENT_INFORMATION) {
reportErrorToSA("Unexpected error %d while fetching line number table", lnRes);
return;
}
}
}
}
} else if (sfnRes != JVMDI_ERROR_ABSENT_INFORMATION) {
reportErrorToSA("Unexpected error %d while fetching source file name", sfnRes);
return;
}
}
bool wasSet = true;
if (gotOne) {
// Really toggle this breakpoint
jvmdiError bpRes;
bpRes = jvmdi->SetBreakpoint(targetClass, targetMethod, targetLocation);
if (bpRes == JVMDI_ERROR_DUPLICATE) {
bpRes = jvmdi->ClearBreakpoint(targetClass, targetMethod, targetLocation);
wasSet = false;
}
if (bpRes != JVMDI_ERROR_NONE) {
reportErrorToSA("Unexpected error %d while setting or clearing breakpoint at bci %d, line %d",
bpRes, targetLocation, targetLineNumber);
return;
}
} else {
saCmdBkptResWasError = 0;
reportErrorToSA("No debug information found covering this line");
return;
}
// Provide result
saCmdBkptResLineNumber = targetLineNumber;
saCmdBkptResBCI = targetLocation;
saCmdBkptResWasSet = (wasSet ? 1 : 0);
{
char* methodName;
char* methodSig;
if (jvmdi->GetMethodName(targetClass, targetMethod, &methodName, &methodSig)
== JVMDI_ERROR_NONE) {
JvmdiDeallocator mnd(methodName);
JvmdiDeallocator msd(methodSig);
strncpy(saCmdBkptResMethodName, methodName, SA_CMD_BUF_SIZE);
strncpy(saCmdBkptResMethodSig, methodSig, SA_CMD_BUF_SIZE);
} else {
strncpy(saCmdBkptResMethodName, "<error>", SA_CMD_BUF_SIZE);
strncpy(saCmdBkptResMethodSig, "<error>", SA_CMD_BUF_SIZE);
}
}
break;
}
default:
reportErrorToSA("Command %d not yet supported", saCmdType);
return;
}
// Successful command execution
saCmdResult = 0;
saCmdPending = 0;
}
void Compression::HuffmanVLD()
{
std::fstream huf(path + std::string(".huf"),std::ios::in);
std::fstream rld(path + std::string(".rlc"),std::ios::out);
std::string str;
huf >> str;
std::stringstream ss(str);
std::vector<std::string> split;
for (std::string each;std::getline(ss, each, '/');split.push_back(each));
//std::cout << split.size() << std::endl;
std::map<char,int> prob_table;
for(size_t i = 0;i < split.size();i += 2){
prob_table.insert(std::make_pair(split[i].at(0),std::stoi(split[i + 1])));
}
std::vector<HuffmanNode*> huffman_array;
CreateHuffmanTree(prob_table,huffman_array);
std::vector<HuffmanNode> huffman_table;
CreateHuffmanCode(huffman_table,huffman_array[huffman_array.size()-1],std::string(""));
bool null_flag = false;
HuffmanNode *root = huffman_array[huffman_array.size()-1];
HuffmanNode *it = root;
while(huf >> str){
for(size_t i = 0;i < str.size();++i){
char c = str[i];
if(c == '0'){
if(it->L){
it = it->L;
}
else{
null_flag = true;
}
}
else if(c == '1'){
if(it->R){
it = it->R;
}
else{
null_flag = true;
}
}
if(null_flag){
rld << it->data;
null_flag = false;
it = root;
--i;
}
else if(i == str.size() - 1){
rld << it->data;
null_flag = false;
it = root;
}
}
rld << std::endl;
}
huf.close();
}
void Compression::HuffmanVLC()
{
std::fstream rld(path + std::string(".rlc"),std::ios::in);
std::fstream huf(path + std::string(".huf"),std::ios::out);
std::vector<std::string> rlc;
std::string str;
while(rld >> str){
rlc.push_back(str);
}
std::map<char,int> prob_table;
for(size_t i = 0;i < rlc.size();++i){
for(size_t j = 0;j < rlc[i].size();++j){
if(prob_table.insert(std::make_pair(rlc[i][j],1)).second){
}
else{
++prob_table[rlc[i][j]];
}
}
}
for(std::map<char,int>::iterator it = prob_table.begin();it != prob_table.end();++it){
huf << it->first << "/" << it->second << "/";
}
huf << std::endl;
std::vector<HuffmanNode*> huffman_array;
CreateHuffmanTree(prob_table,huffman_array);
std::vector<HuffmanNode> huffman_table;
CreateHuffmanCode(huffman_table,huffman_array[huffman_array.size()-1],std::string(""));
for(size_t i = 0;i < rlc.size();++i){
for(size_t j = 0;j < rlc[i].size();++j){
huf << std::find(huffman_table.begin(),huffman_table.end(),rlc[i][j])->code;
huffman_total_byte += std::find(huffman_table.begin(),huffman_table.end(),rlc[i][j])->code.size();
}
huf << std::endl;
}
huffman_total_byte /= 8.0f;
/* //binary file
std::vector<std::vector<bool> > binary;
for(size_t i = 0;i < rlc.size();++i){
std::vector<bool> temp;
for(size_t j = 0;j < rlc[i].size();++j){
std::string code = std::find(huffman_table.begin(),huffman_table.end(),rlc[i][j])->code;
for(size_t k = 0;k < code.size();++k){
temp.push_back(((code[k] == '0')?0:1));
}
}
binary.push_back(temp);
}
char c;
for(size_t i = 0;i < binary.size();++i){
for(size_t j = 0;j < binary[i].size();++j){
if((j % 8) == 0){
huf << c;
c = 0;
}
c += (binary[i][j] << (j % 8));
}
}
//
std::fstream huf2(path + std::string(".huf"),std::ios::in);
std::fstream hufd(path + std::string(".ddhuf"),std::ios::out);
huf2 >> str;
hufd << str;
hufd << std::endl;
while(!huf2.eof()){
huf2.get(c);
for(int j = 0;j < 8;++j){
hufd << ((c & (1 << j))?'1':'0');
}
hufd << std::endl;
}
*/
rld.close();
huf.close();
}
void Compression::RLD()
{
std::fstream rld(path + std::string(".rlc"),std::ios::in);
std::vector<std::string> rlc;
std::vector<std::vector<int> > rld_table;
std::vector<std::vector<int> > number_table;
std::string str;
while(rld >> str){
rlc.push_back(str);
}
for(size_t i = 0;i < rlc.size();++i){
std::vector<int> temp;
std::string number;
for(size_t j = 0;j < rlc[i].size();++j){
if((rlc[i][j] >= '0' && rlc[i][j] <= '9') || rlc[i][j] == '-'){
std::stringstream ss;
ss << rlc[i][j];
number += ss.str();
}
else{
if(number.size()){
temp.push_back(std::stoi(number));
number.clear();
}
}
}
number_table.push_back(temp);
}
for(size_t i = 0;i < number_table.size();++i){
std::vector<int> temp;
for(size_t j = 0;j < number_table[i].size();++j){
if(!(j % 2)){
for(int k = number_table[i][j];k > 0;--k){
temp.push_back(0);
}
}
else{
if(number_table[i][j] != 0){
temp.push_back(number_table[i][j]);
}
}
}
for(size_t j = temp.size();j < (block_size * block_size);++j){
temp.push_back(0);
}
rld_table.push_back(temp);
}
for(int x = 0;x < raw_width;x += block_size){
for(int y = 0;y < raw_height;y += block_size){
unsigned int count = 0;
for(size_t i = 0;i < rld_table[x + (y / block_size)].size();++i){
dct[x + zigzag_x[count / block_size][count % block_size]][y + zigzag_y[count / block_size][count % block_size]] = rld_table[x + (y / block_size)][i];
++count;
}
}
}
rld.close();
}
