MStatus SelectRingToolCmd2::finalize()
{
MArgList command;
command.addArg( commandString() );
command.addArg( MString(edgeFlag) );
MSelectionList sel;
sel.add( selEdgeObject, selEdgeComp );
MStringArray edges;
sel.getSelectionStrings( edges );
command.addArg( edges[0] );
command.addArg( MString(selEdgesFlag) );
command.addArg( selEdges );
command.addArg( MString(selFacesFlag) );
command.addArg( selFaces );
command.addArg( MString(selVerticesFlag) );
command.addArg( selVertices );
command.addArg( MString(listAdjustFlag) );
command.addArg( (int)listAdjust );
command.addArg( MString(selTypeFlag) );
command.addArg( selType );
return MPxToolCommand::doFinalize( command );
}
bool SQLiteCommand::execute() {
ZLLogger::Instance().println("sqlite", "execute: " + commandString());
SQLiteConnection &con = (SQLiteConnection &) connection();
if (!con.isOpened()) {
myStatements.clear();
return false;
}
if (!prepareStatements(con)) {
return false;
}
std::vector<sqlite3_stmt *>::iterator it = myStatements.begin();
std::vector<sqlite3_stmt *>::iterator end = myStatements.end();
while (true) {
int res = sqlite3_step(*it);
switch (res) {
case SQLITE_DONE:
if (++it == end) {
resetStatements();
return true;
}
break;
case SQLITE_OK:
case SQLITE_ROW:
break;
default:
dumpError();
finalizeStatements();
return false;
}
}
}
MStatus ConnectSuggestionsToolCommand::finalize() {
std::cerr << "ConnectSuggestionsToolCommand::finalize" << std::endl;
MArgList command;
command.addArg(commandString());
return MPxToolCommand::doFinalize(command);
}
void SQLiteCommand::dumpError(const std::string &msg) const {
static const size_t cmdlimit = 129;
std::cerr << "SQLITE ERROR: " << msg << std::endl;
const std::string &cmd = commandString();
if (cmd.length() > cmdlimit) {
std::cerr << "SQLITE ERROR: in command \"" << cmd.substr(0, cmdlimit - 3) << "...\"" << std::endl;
} else {
std::cerr << "SQLITE ERROR: in command \"" << cmd << "\"" << std::endl;
}
}
void SQLiteCommand::dumpError() const {
static const size_t cmdlimit = 114;
((SQLiteConnection &) connection()).dumpError();
const std::string &cmd = commandString();
if (cmd.length() > cmdlimit) {
std::cerr << "SQLITE IMPLEMENTATION ERROR: in command \"" << cmd.substr(0, cmdlimit - 3) << "...\"" << std::endl;
} else {
std::cerr << "SQLITE IMPLEMENTATION ERROR: in command \"" << cmd << "\"" << std::endl;
}
}
shared_ptr<DBDataReader> SQLiteCommand::executeReader() {
ZLLogger::Instance().println("sqlite", "executeReader: " + commandString());
SQLiteConnection &con = (SQLiteConnection &) connection();
if (!con.isOpened()) {
myStatements.clear();
return 0;
}
if (!prepareStatements(con)) {
return 0;
}
myLocked = true;
return new SQLiteDataReader(*this);
}
MStatus brushToolCommand::finalize()
{
MArgList command;
command.addArg(commandString());
command.addArg(MString(radiusFlag));
command.addArg(radius);
command.addArg(MString(intensityFlag));
command.addArg(inten);
command.addArg(MString(lockBaseFlag));
command.addArg(lockbase);
command.addArg(MString(brushModeFlag));
command.addArg(brushModeVal);
return MPxToolCommand::doFinalize( command );
}
MStatus moveCmd::finalize()
//
// Description
// Command is finished, construct a string for the command
// for journalling.
//
{
MArgList command;
command.addArg( commandString() );
command.addArg( delta.x );
command.addArg( delta.y );
command.addArg( delta.z );
// This call adds the command to the undo queue and sets
// the journal string for the command.
//
return MPxToolCommand::doFinalize( command );
}
_THyPhyString * _THyPhy::ExecuteBF (const char * buffer, bool doPurge)
{
if (doPurge) {
PurgeAll (true); // cleanup results of previous analysis
}
_String commandString (buffer);
if (commandString.beginswith ("#NEXUS"),false) {
lastNexusDataMatrix = ReadDataSetFile (nil, 2, &commandString);
commandString = nexusBFBody;
}
_ExecutionList compiledCode (commandString);
ApplyPreferences ();
DeleteObject ((_String*)errors);
DeleteObject ((_String*)warnings);
DeleteObject ((_String*)textout);
errors = new _String (128L,true);
warnings = new _String (128L,true);
textout = new _String (128L,true);
askFID = compiledCode.ExecuteAndClean (0x7ffffff,&_tHYPHYAskFor);
_PMathObj bfReturn = compiledCode.GetResult ();
((_String*)errors)->Finalize();
((_String*)warnings)->Finalize();
((_String*)textout)->Finalize();
if (currentResultHolder->sData) {
free (currentResultHolder->sData);
currentResultHolder->sData = nil;
}
if (bfReturn) {
_String * serializedReturn = (_String*) bfReturn->toStr();
currentResultHolder->sData = serializedReturn->sData;
serializedReturn->sData = nil;
currentResultHolder->sLength = serializedReturn->sLength;
}
return currentResultHolder;
}
bool SQLiteCommand::prepareStatements(SQLiteConnection &conn) {
sqlite3 *db = conn.database();
if (myLocked) {
return false;
}
if (myStatements.size() != 0) {
const size_t size = myStatements.size();
int res = SQLITE_OK;
for (size_t i = 0; i < size && res == SQLITE_OK; ++i) {
res = sqlite3_reset(myStatements[i]);
}
if (res == SQLITE_OK) {
bindParameters();
return true;
}
finalizeStatements();
}
const std::string sql = commandString();
const int length = -1;
const char *tail = sql.c_str();
while (true) {
sqlite3_stmt *statement;
int res = sqlite3_prepare_v2(db, tail, length, &statement, &tail);
if (res != SQLITE_OK) {
dumpError();
finalizeStatements();
return false;
}
if (statement == 0) {
break;
}
myStatements.push_back(statement);
conn.addStatement(statement);
}
if (!bindParameters()) {
finalizeStatements();
return false;
}
return true;
}
MStatus customAttrCmd::finalize()
//
// Description
// This method constructs the final command syntax which will be called
// to execute/undo/redo the action. The syntax of the generated command
// will be:
//
// customAttrToolCmd <deltaVal>
//
// where <deltaVal> is the most recently set value from the call to
// customAttrCmd::setDelta().
//
{
MArgList command;
command.addArg( commandString() );
command.addArg( delta );
// This call adds the command to the undo queue and sets
// the journal string for the command.
//
return MPxToolCommand::doFinalize( command );
}
shared_ptr<DBValue> SQLiteCommand::executeScalar() {
ZLLogger::Instance().println("sqlite", "executeScalar: " + commandString());
SQLiteConnection &con = (SQLiteConnection &) connection();
if (!con.isOpened()) {
myStatements.clear();
return 0;
}
if (!prepareStatements(con)) {
return 0;
}
std::vector<sqlite3_stmt *>::iterator it = myStatements.begin();
std::vector<sqlite3_stmt *>::iterator end = myStatements.end();
while (true) {
int res = sqlite3_step(*it);
switch (res) {
case SQLITE_DONE:
if (++it == end) {
resetStatements();
return 0;
}
break;
case SQLITE_OK:
break;
case SQLITE_ROW: {
shared_ptr<DBValue> val = SQLiteDataReader::makeDBValue(*it, /* column = */ 0);
resetStatements();
return val;
}
default:
dumpError();
finalizeStatements();
return 0;
}
}
}
QString Schedule::toString() const {
return QString("%1 %2").arg(cronString(), commandString());
}
QString Command::toString() const
{
return QString("%1 %2")
.arg(commandString())
.arg(parametersList().join(ARGUMENT_SEPARATOR));
}
char const* GetBest()
{
g_bestCommands = commandString(g_best.solution().commands);
return g_bestCommands.c_str();
}
int K3b::Device::ScsiCommand::transport( TransportDirection dir,
void* data,
size_t len )
{
bool needToClose = false;
ULONG returned = 0;
BOOL status = TRUE;
// closing device every time breaks scsi operation, disabled for now
//needToClose = !m_device->isOpen();
m_device->open( dir == TR_DIR_WRITE );
if( !m_device->isOpen() ) {
qDebug() << "(K3bScsiCommand::transport) could not perform Win32 IOCTL on invalid handle value" << endl;
return -1;
}
if ( dir == TR_DIR_READ )
d->m_cmd.spt.DataIn = SCSI_IOCTL_DATA_IN;
else if ( dir == TR_DIR_WRITE )
d->m_cmd.spt.DataIn = SCSI_IOCTL_DATA_OUT;
else
d->m_cmd.spt.DataIn = SCSI_IOCTL_DATA_UNSPECIFIED;
d->m_cmd.spt.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
d->m_cmd.spt.SenseInfoLength = SENSE_LEN_SPTI;
d->m_cmd.spt.DataTransferLength = len;
d->m_cmd.spt.TimeOutValue = 2;
d->m_cmd.spt.DataBuffer = len ? data : NULL;
d->m_cmd.spt.SenseInfoOffset = offsetof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, ucSenseBuf);
status = DeviceIoControl( m_device->handle(),
IOCTL_SCSI_PASS_THROUGH_DIRECT,
&(d->m_cmd), sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER),
&(d->m_cmd), sizeof(SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER),
&returned, NULL);
if( needToClose )
m_device->close();
// get the sense data on error
if ( !status ) {
qDebug() << "(K3bScsiCommand::transport) ioctl failed: " << GetLastError() << ", returned=" << returned << endl;
::memcpy( &(d->m_senseData), d->m_cmd.ucSenseBuf, SENSE_LEN_SPTI );
debugError( d->m_cmd.spt.Cdb[0],
d->m_senseData.SD_Error,
d->m_senseData.SD_SenseKey,
d->m_senseData.SD_ASC,
d->m_senseData.SD_ASCQ );
int errCode =
(d->m_senseData.SD_Error << 24) & 0xF000 |
(d->m_senseData.SD_SenseKey << 16) & 0x0F00 |
(d->m_senseData.SD_ASC << 8) & 0x00F0 |
(d->m_senseData.SD_ASCQ) & 0x000F;
return ( errCode != 0 ? errCode : 1 );
}
qDebug()
<< "len:" << d->m_cmd.spt.CdbLength
<< "cmd:" << commandString(d->m_cmd.spt.Cdb[0])
<< d->m_cmd.spt.Cdb[0]
<< d->m_cmd.spt.Cdb[1]
<< d->m_cmd.spt.Cdb[2]
<< d->m_cmd.spt.Cdb[3]
<< d->m_cmd.spt.Cdb[4]
<< d->m_cmd.spt.Cdb[5]
<< d->m_cmd.spt.Cdb[6]
<< d->m_cmd.spt.Cdb[7]
<< d->m_cmd.spt.Cdb[8]
<< d->m_cmd.spt.Cdb[9]
<< "datalen=" << d->m_cmd.spt.DataTransferLength
<< "returned=" << returned
;
return 0;
}
