uint8_t RF24::write_register(uint8_t reg, uint8_t value)
{
uint8_t status;
IF_SERIAL_DEBUG(printf_P(PSTR("write_register(%02x,%02x)\r\n"),reg,value));
#if defined (RF24_LINUX)
beginTransaction();
uint8_t * prx = spi_rxbuff;
uint8_t * ptx = spi_txbuff;
*ptx++ = ( W_REGISTER | ( REGISTER_MASK & reg ) );
*ptx = value ;
_SPI.transfernb( (char *) spi_txbuff, (char *) spi_rxbuff, 2);
status = *prx++; // status is 1st byte of receive buffer
endTransaction();
#else
beginTransaction();
status = _SPI.transfer( W_REGISTER | ( REGISTER_MASK & reg ) );
_SPI.transfer(value);
endTransaction();
#endif
return status;
}
uint8_t RF24::read_register(uint8_t reg)
{
uint8_t result;
#if defined (RF24_LINUX)
beginTransaction();
uint8_t * prx = spi_rxbuff;
uint8_t * ptx = spi_txbuff;
*ptx++ = ( R_REGISTER | ( REGISTER_MASK & reg ) );
*ptx++ = NOP ; // Dummy operation, just for reading
_SPI.transfernb( (char *) spi_txbuff, (char *) spi_rxbuff, 2);
result = *++prx; // result is 2nd byte of receive buffer
endTransaction();
#else
beginTransaction();
_SPI.transfer( R_REGISTER | ( REGISTER_MASK & reg ) );
result = _SPI.transfer(0xff);
endTransaction();
#endif
return result;
}
uint8_t RF24::write_register(uint8_t reg, const uint8_t* buf, uint8_t len)
{
uint8_t status;
#if defined (RF24_LINUX)
beginTransaction();
uint8_t * prx = spi_rxbuff;
uint8_t * ptx = spi_txbuff;
uint8_t size = len + 1; // Add register value to transmit buffer
*ptx++ = ( W_REGISTER | ( REGISTER_MASK & reg ) );
while ( len-- )
*ptx++ = *buf++;
_SPI.transfernb( (char *) spi_txbuff, (char *) spi_rxbuff, size);
status = *prx; // status is 1st byte of receive buffer
endTransaction();
#else
beginTransaction();
status = _SPI.transfer( W_REGISTER | ( REGISTER_MASK & reg ) );
while ( len-- )
_SPI.transfer(*buf++);
endTransaction();
#endif
return status;
}
uint8_t RF24::read_register(uint8_t reg, uint8_t* buf, uint8_t len)
{
uint8_t status;
#if defined (RF24_LINUX)
beginTransaction(); //configures the spi settings for RPi, locks mutex and setting csn low
uint8_t * prx = spi_rxbuff;
uint8_t * ptx = spi_txbuff;
uint8_t size = len + 1; // Add register value to transmit buffer
*ptx++ = ( R_REGISTER | ( REGISTER_MASK & reg ) );
while (len--){ *ptx++ = NOP; } // Dummy operation, just for reading
_SPI.transfernb( (char *) spi_txbuff, (char *) spi_rxbuff, size);
status = *prx++; // status is 1st byte of receive buffer
// decrement before to skip status byte
while ( --size ){ *buf++ = *prx++; }
endTransaction(); //unlocks mutex and setting csn high
#else
beginTransaction();
status = _SPI.transfer( R_REGISTER | ( REGISTER_MASK & reg ) );
while ( len-- ){
*buf++ = _SPI.transfer(0xff);
}
endTransaction();
#endif
return status;
}
int I2C::writeRead(const void *wbuf, size_t wlength, void *rbuf, size_t rlength,
bool ignoreNack, bool noAck)
{
bool was_transaction = true;
// If not already in a transaction, make a transaction state
if (!transactionState)
{
was_transaction = false;
beginTransaction();
}
if (write(wbuf, wlength, ignoreNack) < 0)
return -1;
if (read(rbuf, rlength, noAck) < 0)
return -1;
// Commit transaction if the system was not already in a
// transaction state
if (!was_transaction)
{
if (endTransaction() < 0)
{
iooo_error(
"I2C::writeRead() Unable to perform consecutive write and read\n");
return -1;
}
}
return 0;
}
/*
Send data to a register of a GPIO chip,
this is the main function that send data to the GPIO chip once is inited.
Parameters
reg: a legal 8bit MCP23Sxx register.
data: 16 bit data to transfer.
forceByte: not used till now, experimental. Maybe I will use in future.
*/
void gpio_MCP23SXX::_sendData(byte reg,uint16_t data,bool forceByte)
{
#if defined(SPI_LEGACY_METHOD)
startTransaction();
writeByte_cont(_writeCmd);
writeByte_cont(reg);
if (_ports < 16 || (forceByte == true)){
uint8_t temp = (uint8_t)(data & 0xFF);
writeByte_last(temp);
} else {
data = _reverseWordOrder(data);
writeWord_last(data);
}
endTransaction();
#else
_spi.startTransaction();//cs low
_spi.writeByte_cont(_writeCmd);
_spi.writeByte_cont(reg);
if (_ports < 16 || forceByte){
uint8_t temp = (uint8_t)(data & 0xFF);
_spi.writeByte_last(temp);
} else {
data = _reverseWordOrder(data);
_spi.writeWord_last(data);
}
_spi.endTransaction();
#endif
}
void Device::addMiniDriver( void ) {
if( 0 != memcmp( g_DotNetSmartCardAtr, m_DeviceState.rgbAtr, m_DeviceState.cbAtr ) ) {
throw MiniDriverException( SCARD_E_UNKNOWN_CARD );
}
try {
// Create a card module service
m_MiniDriver.reset( new MiniDriver( ) );
m_MiniDriver->setSmartCardReader( m_SmartCardReader.get( ) );
beginTransaction( );
m_MiniDriver->read( s_bEnableCache );
m_SmartCardReader->setCardHandle( m_MiniDriver->getCardHandle( ) );
m_bIsLastAuth = m_MiniDriver->isAuthenticated( );
} catch( ... ) {
}
endTransaction( );
}
FlowWriter::~FlowWriter() {
_closed=true;
endTransaction();
clear();
if(!signature.empty())
DEBUG("FlowWriter %s consumed",NumberFormatter::format(id).c_str());
}
Transaction* IncrementalParser::Parse(llvm::StringRef input,
const CompilationOptions& Opts) {
Transaction* CurT = beginTransaction(Opts);
ParseInternal(input);
Transaction* EndedT = endTransaction(CurT);
assert(EndedT == CurT && "Not ending the expected transaction.");
return EndedT;
}
void IncrementalParser::codeGenTransaction(Transaction* T) {
// codegen the transaction
assert(T->getCompilationOpts().CodeGeneration && "CodeGen turned off");
assert(T->getState() == Transaction::kCompleted && "Must be completed");
assert(hasCodeGenerator() && "No CodeGen");
// Could trigger derserialization of decls.
Transaction* deserT = beginTransaction(CompilationOptions());
// Commit this transaction first - T might need symbols from it, so
// trigger emission of weak symbols by providing use.
ParseResultTransaction PRT = endTransaction(deserT);
commitTransaction(PRT);
deserT = PRT.getPointer();
// This llvm::Module is done; finalize it and pass it to the execution
// engine.
if (!T->isNestedTransaction() && hasCodeGenerator()) {
// The initializers are emitted to the symbol "_GLOBAL__sub_I_" + filename.
// Make that unique!
deserT = beginTransaction(CompilationOptions());
// Reset the module builder to clean up global initializers, c'tors, d'tors
getCodeGenerator()->HandleTranslationUnit(getCI()->getASTContext());
auto PRT = endTransaction(deserT);
commitTransaction(PRT);
deserT = PRT.getPointer();
std::unique_ptr<llvm::Module> M(getCodeGenerator()->ReleaseModule());
if (M) {
m_Interpreter->addModule(M.get(), T->getCompilationOpts().OptLevel);
T->setModule(std::move(M));
}
if (T->getIssuedDiags() != Transaction::kNone) {
// Module has been released from Codegen, reset the Diags now.
DiagnosticsEngine& Diags = getCI()->getSema().getDiagnostics();
Diags.Reset(/*soft=*/true);
Diags.getClient()->clear();
}
// Create a new module.
StartModule();
}
}
void ad75019SPIMgr::send(const uint8_t vec[], int size) const{ // a vector of bytes, the vector is not overwritten by the reply
uint8_t newVec[size];
for (int i=0;i<size;i++){
newVec[i] = vec[i];
}
beginTransaction();
SPI.transfer(newVec,size);
endTransaction();
}
void QPCSCReader::disconnect( Reset reset )
{
if(d->isTransacted)
endTransaction();
if( d->card )
SC(Disconnect, d->card, reset);
d->proto = 0;
d->card = 0;
d->featuresList.clear();
updateState();
}
void
AutomaticIPod::PlayCountsDatabase::bootstrap()
{
qDebug() << "Starting bootstrapping...";
static_cast<TwiddlyApplication*>(qApp)->sendBusMessage( "container://Notification/Twiddly/Bootstrap/Started" );
beginTransaction();
QSqlQuery query( m_db );
// this will fail if the metadata table doesn't exist, which is fine
query.exec( "DELETE FROM metadata WHERE key='bootstrap_complete'" );
query.exec( "DELETE FROM metadata WHERE key='plugin_ctime'" );
query.exec( "DELETE FROM " TABLE_NAME_OLD );
query.exec( "DELETE FROM " TABLE_NAME );
ITunesLibrary lib;
// for wizard progress screen
std::cout << lib.trackCount() << std::endl;
int i = 0;
while (lib.hasTracks())
{
try
{
ITunesLibrary::Track const t = lib.nextTrack();
QString const plays = QString::number( t.playCount() );
query.exec( "INSERT OR IGNORE INTO " TABLE_NAME " ( persistent_id, play_count ) "
"VALUES ( '" + t.uniqueId() + "', '" + plays + "' )" );
}
catch ( ... )
{
// Move on...
}
std::cout << ++i << std::endl;
}
// if either INSERTS fail we'll rebootstrap next time
query.exec( "CREATE TABLE metadata (key VARCHAR( 32 ), value VARCHAR( 32 ))" );
query.exec( "INSERT INTO metadata (key, value) VALUES ('bootstrap_complete', 'true')" );
QString const t = QString::number( common::fileCreationTime( pluginPath() ) );
query.exec( "INSERT INTO metadata (key, value) VALUES ('plugin_ctime', '"+t+"')" );
endTransaction();
static_cast<TwiddlyApplication*>(qApp)->sendBusMessage( "container://Notification/Twiddly/Bootstrap/Finished" );
}
void IncrementalParser::Initialize() {
if (hasCodeGenerator())
getCodeGenerator()->Initialize(getCI()->getASTContext());
CompilationOptions CO;
CO.DeclarationExtraction = 0;
CO.ValuePrinting = CompilationOptions::VPDisabled;
CO.CodeGeneration = hasCodeGenerator();
// pull in PCHs
const std::string& PCHFileName
= m_CI->getInvocation ().getPreprocessorOpts().ImplicitPCHInclude;
if (!PCHFileName.empty()) {
Transaction* CurT = beginTransaction(CO);
m_CI->createPCHExternalASTSource(PCHFileName,
true /*DisablePCHValidation*/,
true /*AllowPCHWithCompilerErrors*/,
0 /*DeserializationListener*/);
Transaction* EndedT = endTransaction(CurT);
commitTransaction(EndedT);
}
Transaction* CurT = beginTransaction(CO);
Sema* TheSema = &m_CI->getSema();
m_Parser.reset(new Parser(m_CI->getPreprocessor(), *TheSema,
false /*skipFuncBodies*/));
m_CI->getPreprocessor().EnterMainSourceFile();
// Initialize the parser after we have entered the main source file.
m_Parser->Initialize();
// Perform initialization that occurs after the parser has been initialized
// but before it parses anything. Initializes the consumers too.
TheSema->Initialize();
ExternalASTSource *External = TheSema->getASTContext().getExternalSource();
if (External)
External->StartTranslationUnit(m_Consumer);
Transaction* EndedT = endTransaction(CurT);
commitTransaction(EndedT);
}
void KFileItemListView::setPreviewsShown(bool show)
{
if (!m_modelRolesUpdater) {
return;
}
if (m_modelRolesUpdater->previewsShown() != show) {
beginTransaction();
m_modelRolesUpdater->setPreviewsShown(show);
onPreviewsShownChanged(show);
endTransaction();
}
}
typename IndexedTransactionsList<itemT>::transaction_boundaries_t*
IndexedTransactionsList<itemT>::endTransaction(
itemT* end_index, int32_t max_candidate,
itemT* &end_prefix) {
transaction_boundaries_t* desc_trans = endTransaction(end_index);
end_prefix = std::upper_bound(
desc_trans->start_transaction,
desc_trans->end_transaction,
max_candidate
);
return desc_trans;
}
Transaction* IncrementalParser::Compile(llvm::StringRef input,
const CompilationOptions& Opts) {
Transaction* CurT = beginTransaction(Opts);
EParseResult ParseRes = ParseInternal(input);
if (ParseRes == kSuccessWithWarnings)
CurT->setIssuedDiags(Transaction::kWarnings);
else if (ParseRes == kFailed)
CurT->setIssuedDiags(Transaction::kErrors);
endTransaction();
commitTransaction(CurT);
return CurT;
}
//--------------------------------- LOW LEVEL SPI ROUTINES --------------------------------------------------------
// Send a byte to a chip register...
void gpio_MCP23SXX::_GPIOwriteByte(byte reg, byte data)
{
#if defined(SPI_LEGACY_METHOD)
startTransaction();
writeByte_cont(_writeCmd);
writeByte_cont(reg);
writeByte_last(data);
endTransaction();
#else
_spi.startTransaction();
_spi.writeByte_cont(_writeCmd);
_spi.writeByte_cont(reg);
_spi.writeByte_last(data);
_spi.endTransaction();
#endif
}
void CStateDB::updateCollectionTable( CSession const * const session, int minrev, int maxrev ) {
beginTansaction();
if(minrev == -1) minrev = session->getMinCollectionRevision();
if(maxrev == -1) maxrev = session->getCollectionRevision();
for(int rev = minrev; rev <= maxrev; rev++) {
CCollection<CCollectionItem>* collection = session->getCollection(rev);
for(int i = 0; i < collection->size(); i++) {
CCollectionItem* item = collection->getItem(i);
updateCollectionItem(item);
updateCollectionRevItem(i, item->getHash(), rev );
}
}
endTransaction();
}
/*
Return register content from bank A & B of a 16 bit GPIO chip,
combined in a 16 bit data. An 8 Bit chip will return always bank A.
Parameters
reg: a legal 8bit MCP23Sxx register.
*/
uint16_t gpio_MCP23SXX::gpioReadRegisterBoth(byte reg)
{
if (_ports < 16){
return gpioReadRegister(reg);
} else {
uint16_t result = 0;
#if defined(SPI_LEGACY_METHOD)
startTransaction();
writeByte_cont(_readCmd);
writeByte_cont(reg);
#if defined(SPI_HAS_TRANSACTION)
setSpiSettings(SPISettings(10000000, MSBFIRST, SPI_MODE0));
result = readWord_cont();
setSpiSettings(SPISettings(_maxGpioSPIspeed, MSBFIRST, SPI_MODE0));
#else
result = readWord_cont();
#endif
disableCS();
endTransaction();
#else
_spi.startTransaction();
_spi.writeByte_cont(_readCmd);
_spi.writeByte_cont(reg);
#if (defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__))
_spi.waitTransmitComplete();
#endif
#if defined(SPI_HAS_TRANSACTION)
_spi.setSpiSettings(SPISettings(10000000, MSBFIRST, SPI_MODE0));
result = _spi.readWord_cont(false);//command mode
_spi.setSpiSettings(SPISettings(_maxGpioSPIspeed, MSBFIRST, SPI_MODE0));
#else
result = _spi.readWord_cont(false);//command mode
#endif
#if (defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__))
_spi.writeByte_last(0xFF);//NOP?
#else
_spi.disableCS();
#endif
_spi.endTransaction();
#endif
return result;
}
}
// none of the send methods returns a reply
void ad75019SPIMgr::send(uint8_t b) const{ // a single byte
beginTransaction();
SPI.transfer(b);
endTransaction();
}
void generateSqlite3()
{
// + classes
// + namespaces
// + files
// - groups
// - related pages
// - examples
//QCString outputDirectory = Config_getString("SQLITE3_OUTPUT");
QCString outputDirectory = Config_getString("OUTPUT_DIRECTORY");
QDir sqlite3Dir(outputDirectory);
sqlite3 *db;
sqlite3_initialize();
int rc = sqlite3_open_v2(outputDirectory+"/doxygen_sqlite3.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
if (rc != SQLITE_OK)
{
sqlite3_close(db);
msg("database open failed: %s\n", "doxygen_sqlite3.db");
exit(-1);
}
beginTransaction(db);
pragmaTuning(db);
initializeSchema(db);
if ( -1 == prepareStatements(db) )
{
err("sqlite generator: prepareStatements failed!");
return;
}
// + classes
ClassSDict::Iterator cli(*Doxygen::classSDict);
ClassDef *cd;
for (cli.toFirst();(cd=cli.current());++cli)
{
msg("Generating Sqlite3 output for class %s\n",cd->name().data());
generateSqlite3ForClass(db,cd);
}
// + namespaces
NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
NamespaceDef *nd;
for (nli.toFirst();(nd=nli.current());++nli)
{
msg("Generating Sqlite3 output for namespace %s\n",nd->name().data());
generateSqlite3ForNamespace(db,nd);
}
// + files
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (;(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
msg("Generating Sqlite3 output for file %s\n",fd->name().data());
generateSqlite3ForFile(db,fd);
}
}
endTransaction(db);
}
bool
IncrementalParser::Initialize(llvm::SmallVectorImpl<ParseResultTransaction>&
result, bool isChildInterpreter) {
m_TransactionPool.reset(new TransactionPool);
if (hasCodeGenerator())
getCodeGenerator()->Initialize(getCI()->getASTContext());
CompilationOptions CO = m_Interpreter->makeDefaultCompilationOpts();
Transaction* CurT = beginTransaction(CO);
Preprocessor& PP = m_CI->getPreprocessor();
DiagnosticsEngine& Diags = m_CI->getSema().getDiagnostics();
// Pull in PCH.
const std::string& PCHFileName
= m_CI->getInvocation().getPreprocessorOpts().ImplicitPCHInclude;
if (!PCHFileName.empty()) {
Transaction* PchT = beginTransaction(CO);
DiagnosticErrorTrap Trap(Diags);
m_CI->createPCHExternalASTSource(PCHFileName,
true /*DisablePCHValidation*/,
true /*AllowPCHWithCompilerErrors*/,
0 /*DeserializationListener*/,
true /*OwnsDeserializationListener*/);
result.push_back(endTransaction(PchT));
if (Trap.hasErrorOccurred()) {
result.push_back(endTransaction(CurT));
return false;
}
}
addClingPragmas(*m_Interpreter);
// Must happen after attaching the PCH, else PCH elements will end up
// being lexed.
PP.EnterMainSourceFile();
Sema* TheSema = &m_CI->getSema();
m_Parser.reset(new Parser(PP, *TheSema, false /*skipFuncBodies*/));
// Initialize the parser after PP has entered the main source file.
m_Parser->Initialize();
ExternalASTSource *External = TheSema->getASTContext().getExternalSource();
if (External)
External->StartTranslationUnit(m_Consumer);
// Start parsing the "main file" to warm up lexing (enter caching lex mode
// for ParseInternal()'s call EnterSourceFile() to make sense.
while (!m_Parser->ParseTopLevelDecl()) {}
// If I belong to the parent Interpreter, am using C++, and -noruntime
// wasn't given on command line, then #include <new> and check ABI
if (!isChildInterpreter && m_CI->getLangOpts().CPlusPlus &&
!m_Interpreter->getOptions().NoRuntime) {
// <new> is needed by the ValuePrinter so it's a good thing to include it.
// We need to include it to determine the version number of the standard
// library implementation.
ParseInternal("#include <new>");
// That's really C++ ABI compatibility. C has other problems ;-)
CheckABICompatibility(*m_Interpreter);
}
// DO NOT commit the transactions here: static initialization in these
// transactions requires gCling through local_cxa_atexit(), but that has not
// been defined yet!
ParseResultTransaction PRT = endTransaction(CurT);
result.push_back(PRT);
return true;
}
void IncrementalParser::commitTransaction(ParseResultTransaction& PRT,
bool ClearDiagClient) {
Transaction* T = PRT.getPointer();
if (!T) {
if (PRT.getInt() != kSuccess) {
// Nothing has been emitted to Codegen, reset the Diags.
DiagnosticsEngine& Diags = getCI()->getSema().getDiagnostics();
Diags.Reset(/*soft=*/true);
if (ClearDiagClient)
Diags.getClient()->clear();
}
return;
}
assert(T->isCompleted() && "Transaction not ended!?");
assert(T->getState() != Transaction::kCommitted
&& "Committing an already committed transaction.");
assert((T->getIssuedDiags() == Transaction::kErrors || !T->empty())
&& "Valid Transactions must not be empty;");
// If committing a nested transaction the active one should be its parent
// from now on.
if (T->isNestedTransaction())
m_Consumer->setTransaction(T->getParent());
// Check for errors...
if (T->getIssuedDiags() == Transaction::kErrors) {
// Make module visible to TransactionUnloader.
bool MustStartNewModule = false;
if (!T->isNestedTransaction() && hasCodeGenerator()) {
MustStartNewModule = true;
std::unique_ptr<llvm::Module> M(getCodeGenerator()->ReleaseModule());
if (M) {
T->setModule(std::move(M));
}
}
// Module has been released from Codegen, reset the Diags now.
DiagnosticsEngine& Diags = getCI()->getSema().getDiagnostics();
Diags.Reset(/*soft=*/true);
if (ClearDiagClient)
Diags.getClient()->clear();
PRT.setPointer(nullptr);
PRT.setInt(kFailed);
m_Interpreter->unload(*T);
// Create a new module if necessary.
if (MustStartNewModule)
StartModule();
return;
}
if (T->hasNestedTransactions()) {
Transaction* TopmostParent = T->getTopmostParent();
EParseResult PR = kSuccess;
if (TopmostParent->getIssuedDiags() == Transaction::kErrors)
PR = kFailed;
else if (TopmostParent->getIssuedDiags() == Transaction::kWarnings)
PR = kSuccessWithWarnings;
for (Transaction::const_nested_iterator I = T->nested_begin(),
E = T->nested_end(); I != E; ++I)
if ((*I)->getState() != Transaction::kCommitted) {
ParseResultTransaction PRT(*I, PR);
commitTransaction(PRT);
}
}
// If there was an error coming from the transformers.
if (T->getIssuedDiags() == Transaction::kErrors) {
m_Interpreter->unload(*T);
return;
}
// Here we expect a template instantiation. We need to open the transaction
// that we are currently work with.
{
Transaction* prevConsumerT = m_Consumer->getTransaction();
m_Consumer->setTransaction(T);
Transaction* nestedT = beginTransaction(T->getCompilationOpts());
// Pull all template instantiations in that came from the consumers.
getCI()->getSema().PerformPendingInstantiations();
ParseResultTransaction nestedPRT = endTransaction(nestedT);
commitTransaction(nestedPRT);
m_Consumer->setTransaction(prevConsumerT);
}
m_Consumer->HandleTranslationUnit(getCI()->getASTContext());
// The static initializers might run anything and can thus cause more
// decls that need to end up in a transaction. But this one is done
// with CodeGen...
if (T->getCompilationOpts().CodeGeneration && hasCodeGenerator()) {
Transaction* prevConsumerT = m_Consumer->getTransaction();
m_Consumer->setTransaction(T);
codeGenTransaction(T);
T->setState(Transaction::kCommitted);
if (!T->getParent()) {
if (m_Interpreter->executeTransaction(*T)
>= Interpreter::kExeFirstError) {
// Roll back on error in initializers.
// T maybe pointing to freed memory after this call:
// Interpreter::unload
// IncrementalParser::deregisterTransaction
// TransactionPool::releaseTransaction
m_Interpreter->unload(*T);
return;
}
}
m_Consumer->setTransaction(prevConsumerT);
}
T->setState(Transaction::kCommitted);
if (InterpreterCallbacks* callbacks = m_Interpreter->getCallbacks())
callbacks->TransactionCommitted(*T);
}
PCSC::PCSC( std::string& a_stInputReaderName, u2& a_u2PortNumber, std::string& a_stURI, u4& a_NameSpaceHivecode, u2& a_TypeHivecode, u4& a_Index ) {
Log::begin( "PCSC::PCSC" );
m_bDoTransact = true;
std::string stIdentifiedReaderName = "";
LPTSTR pReaderList = NULL;
if( a_stInputReaderName.empty( ) ) {
a_stInputReaderName = "selfdiscover";
}
m_hContextPCSC = 0;
m_hCardPCSC = 0;
LONG lReturn = SCardEstablishContext( 0, NULL, NULL, &m_hContextPCSC );
if( SCARD_S_SUCCESS != lReturn )
{
std::string msg = "";
Log::toString( msg, "SCardEstablishContext <%#02x>", lReturn );
Log::error( "PCSC::PCSC", msg.c_str( ) );
throw RemotingException((lpCharPtr)"PCSC: SCardEstablishContext error",lReturn);
}
// self-discovery mechanism
#ifdef WIN32
if (_stricmp("selfdiscover", a_stInputReaderName.c_str()) == 0) {
#else
if (strncasecmp("selfdiscover", a_stInputReaderName.c_str(),a_stInputReaderName.length()) == 0) {
#endif
// In Windows SCARD_AUTOALLOCATE (-1) as a value of readerListChatLength
// would signal the SCardListReaders to determine the size of reader string
// This is not available in Linux so we call the SCardListReaders twice. First
// to get the length and then the reader names.
#ifdef WIN32
DWORD readerListCharLength = SCARD_AUTOALLOCATE;
lReturn = SCardListReaders( m_hContextPCSC, NULL, (LPTSTR)&pReaderList, &readerListCharLength);
#else
DWORD readerListCharLength = 0;
lReturn = SCardListReaders(m_hContextPCSC,NULL,NULL,&readerListCharLength);
if(lReturn != SCARD_S_SUCCESS)
throw RemotingException((lpCharPtr)"PCSC: SCardListReaders error",lReturn);
pReaderList = (lpCharPtr)malloc(sizeof(char)*readerListCharLength);
lReturn = SCardListReaders(m_hContextPCSC, NULL,pReaderList, &readerListCharLength);
#endif
if(lReturn != SCARD_S_SUCCESS) {
std::string msg = "";
Log::toString( msg, "SCardListReaders <%#02x>", lReturn );
Log::error( "PCSC::PCSC", msg.c_str( ) );
throw RemotingException((lpCharPtr)"PCSC: SCardListReaders error",lReturn);
} else {
u4 count = 0;
u1 foundReader = FALSE;
SCARDHANDLE finalCardHandle = 0;
try {
lpTCharPtr pReader = pReaderList;
while ('\0' != *pReader ) {
size_t readerNameLen = strlen((const char*)pReader);
SCARD_READERSTATE readerStates[1];
readerStates[0].dwCurrentState = SCARD_STATE_UNAWARE;
readerStates[0].szReader = pReader;
if ( SCardGetStatusChange( m_hContextPCSC, 0, readerStates, 1) == SCARD_S_SUCCESS) {
if ((readerStates[0].dwEventState & SCARD_STATE_PRESENT) == SCARD_STATE_PRESENT) {
// we found a card in this reader
stIdentifiedReaderName = pReader;
DWORD activeProtocol;
lReturn = SCardConnect( m_hContextPCSC, (LPTSTR)stIdentifiedReaderName.c_str(), SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &m_hCardPCSC, &activeProtocol);
if (lReturn == SCARD_S_SUCCESS) {
// try to identify if we're dealing with a .NetCard
u1 answerData[258];
DWORD answerLen = 258;
Log::log( "PCSC::PCSC SCardTransmit..." );
lReturn = SCardTransmit( m_hCardPCSC, SCARD_PCI_T0, isNetCardAPDU, sizeof(isNetCardAPDU), NULL, (LPBYTE)answerData, &answerLen);
Log::log( "PCSC::PCSC - SCardTransmit <%#02x>", lReturn );
if (lReturn == SCARD_S_SUCCESS)
{
u1 rethrowException = FALSE;
try {
if (answerData[answerLen - 2] == 0x61)
{
if (answerData[answerLen - 1] > 10)
{
u1Array invokeAPDU(0);
invokeAPDU += (u1)0xD8;
invokeAPDU += (u2)CARDMANAGER_SERVICE_PORT;
invokeAPDU += (u1)0x6F;
invokeAPDU += (u4)HIVECODE_NAMESPACE_SMARTCARD;
invokeAPDU += (u2)HIVECODE_TYPE_SMARTCARD_CONTENTMANAGER;
invokeAPDU += (u2)HIVECODE_METHOD_SMARTCARD_CONTENTMANAGER_GETASSOCIATEDPORT;
std::string* cmServicem_stURI = new std::string(CARDMANAGER_SERVICE_NAME);
invokeAPDU.Append(cmServicem_stURI);
delete cmServicem_stURI;
invokeAPDU += (u4)a_NameSpaceHivecode;
invokeAPDU += (u2)a_TypeHivecode;
invokeAPDU.Append(&a_stURI);
// construct call
if(invokeAPDU.GetLength() <= (s4)APDU_TO_CARD_MAX_SIZE) {
u1Array apdu(5);
apdu.GetBuffer()[0] = 0x80;
apdu.GetBuffer()[1] = 0xC2;
apdu.GetBuffer()[2] = 0x00;
apdu.GetBuffer()[3] = 0x00;
apdu.GetBuffer()[4] = (u1)invokeAPDU.GetLength();
apdu += invokeAPDU;
u1Array answer(0);
Log::log( "PCSC::PCSC - ExchangeData..." );
exchangeData(apdu, answer);
Log::log( "PCSC::PCSC - ExchangeData ok" );
Log::log( "PCSC::PCSC - CheckForException..." );
u4 protocolOffset = m_MarshallerUtil.CheckForException(answer, HIVECODE_NAMESPACE_SYSTEM, HIVECODE_TYPE_SYSTEM_INT32);
Log::log( "PCSC::PCSC - CheckForException ok" );
u4 discoveredPortNumber = m_MarshallerUtil.ComReadU4At(answer, protocolOffset);
if ((a_u2PortNumber == 0) || (discoveredPortNumber == a_u2PortNumber))
{
a_u2PortNumber = (u2)discoveredPortNumber;
if (foundReader == TRUE)
{
if (a_Index == 0)
{
// this is the second reader/card/app that matches - we error at this point
rethrowException = TRUE;
std::string errorMessage( "At least 2 cards posses \"");
errorMessage += a_stURI.c_str( );
errorMessage += "\" service\r\nRemove conflicting cards from your system";
Log::error( "PCSC::PCSC", errorMessage.c_str( ) );
throw RemotingException(errorMessage);
}
}
foundReader = TRUE;
finalCardHandle = m_hCardPCSC;
// Advance to the next value.
count++;
if (count == a_Index)
{
// we enumerate one by one the valid readers - so stop here
break;
}
pReader = (lpTCharPtr)((lpTCharPtr)pReader + readerNameLen + 1);
continue;
}
}
}
}
}
catch (...)
{
if (rethrowException == TRUE)
{
throw;
}
else
{
// swallow exception
}
}
SCardDisconnect( m_hCardPCSC, SCARD_LEAVE_CARD);
m_hCardPCSC = 0;
}
// this is not a .NetCard, or the service was not found - let's try another reader/card
else
{
Log::error( "PCSC::PCSC", "SCardTransmit failed" );
}
}
else
{
Log::error( "PCSC::PCSC", "SCardConnect failed" );
}
}
else
{
Log::error( "PCSC::PCSC", "SCARD_STATE_PRESENT not present" );
}
}
else
{
Log::error( "PCSC::PCSC", "SCardGetStatusChange != SCARD_S_SUCCESS" );
}
// Advance to the next value.
pReader = (lpTCharPtr)((lpTCharPtr)pReader + readerNameLen + 1);
}
} catch (...) {
stIdentifiedReaderName = "";
#ifdef WIN32
/*lReturn = */SCardFreeMemory( m_hContextPCSC, pReaderList);
/*if(lReturn != SCARD_S_SUCCESS) {
throw RemotingException((lpCharPtr)"PCSC: SCardFreeMemory error",lReturn);
}*/
#else
if( pReaderList ) {
free(pReaderList);
}
#endif
throw;
}
// have we found anything ?
if( !foundReader) {
stIdentifiedReaderName = "";
#ifdef WIN32
/*lReturn = */SCardFreeMemory( m_hContextPCSC, pReaderList);
//if(lReturn != SCARD_S_SUCCESS) {
// throw RemotingException((lpCharPtr)"PCSC: SCardFreeMemory error",lReturn);
//}
#else
if(pReaderList ) {
free(pReaderList);
}
#endif
throw RemotingException((lpCharPtr)"Could not find any .NET smart card", SCARD_E_NO_SMARTCARD );
}
m_hCardPCSC = finalCardHandle;
}
m_stReaderName = stIdentifiedReaderName;
} else {
m_stReaderName = a_stInputReaderName;
}
Log::end( "PCSC::PCSC" );
}
/*
*/
void PCSC::exchangeData( u1Array &dataIn, u1Array &dataout ) {
// check validity of handle
if ( SCARD_S_SUCCESS != SCardIsValidContext( m_hContextPCSC ) ) {
throw RemotingException( (lpCharPtr)"PCSC: Invalid handle", SCARD_E_INVALID_HANDLE );
}
try {
if( m_bDoTransact ) {
beginTransaction( );
}
unsigned char ucRetry = 0;
do {
ucRetry++;
unsigned char answerData[ 258 ];
memset( answerData, 0, sizeof( answerData ) );
DWORD answerLen = sizeof( answerData );
#ifdef __DEBUG_APDU__
Log::logCK_UTF8CHAR_PTR( "PCSC::ExchangeData - Command", dataIn.GetBuffer( ), dataIn.GetLength( ) );
Timer t;
t.start( );
#endif
LONG lReturn = SCardTransmit( m_hCardPCSC, SCARD_PCI_T0, dataIn.GetBuffer( ), dataIn.GetLength( ), NULL, (lpByte)answerData, &answerLen );
if( SCARD_S_SUCCESS != lReturn ) {
std::string msg = "";
Log::toString( msg, "SCardTransmit <%#02x>", lReturn );
Log::error( "PCSC::ExchangeData", msg.c_str( ) );
}
if( ( SCARD_W_REMOVED_CARD == lReturn ) || ( SCARD_W_RESET_CARD == lReturn ) ) {
DWORD dwActiveProtocol = SCARD_PROTOCOL_T0;
lReturn = SCardReconnect( m_hCardPCSC, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, SCARD_LEAVE_CARD, &dwActiveProtocol );
if( SCARD_S_SUCCESS != lReturn ) {
std::string msg = "";
Log::toString( msg, "SCardReconnect <%#02x>", lReturn );
Log::error( "PCSC::ExchangeData", msg.c_str( ) );
throw RemotingException( (lpCharPtr)"PCSC: SCardReconnect error", lReturn );
}
lReturn = SCardTransmit( m_hCardPCSC, SCARD_PCI_T0, dataIn.GetBuffer( ), dataIn.GetLength( ), NULL, (lpByte)answerData, &answerLen );
if( SCARD_S_SUCCESS != lReturn ) {
Log::log( "PCSC::ExchangeData - SCardTransmit <%#02x>", lReturn );
}
} else if( SCARD_S_SUCCESS != lReturn ) {
std::string s;
Log::toString( s, "SCardTransmit failed <%#02x>", lReturn );
Log::error( "PCSC::ExchangeData", s.c_str( ) );
throw RemotingException( (lpCharPtr)"PCSC: SCardTransmit error", lReturn );
}
if (answerLen < 2) {
Log::error( "PCSC::ExchangeData", "Incorrect length returned" );
throw RemotingException((lpCharPtr)"PCSC: SCardTransmit error - Incorrect length returned",SCARD_F_COMM_ERROR);
}
if (answerLen > 2) {
u1Array temp(answerLen - 2);
temp.SetBuffer(answerData);
dataout += temp;
}
u1 sw1 = answerData[answerLen - 2];
u1 sw2 = answerData[answerLen - 1];
#ifdef __DEBUG_APDU__
Log::log( "PCSC::ExchangeData - Status (1) <%02x%02x>", sw1, sw2 );
Log::logCK_UTF8CHAR_PTR( "PCSC::ExchangeData - Response", answerData, answerLen );
t.stop( "PCSC::ExchangeData - Response" );
#endif
while( (sw1 == 0x61 ) || ( sw1 == 0x9F ) ) {
memset( answerData, 0, sizeof( answerData ) );
unsigned char GetResponse[ 5 ];
memset( GetResponse, 0, sizeof( GetResponse ) );
if (sw1 == 0x9F) {
GetResponse[0] = 0xA0;
} else {
GetResponse[0] = 0x00;
}
GetResponse[1] = 0xC0;
GetResponse[2] = 0x00;
GetResponse[3] = 0x00;
GetResponse[4] = sw2;
answerLen = 258;
#ifdef __DEBUG_APDU__
Log::logCK_UTF8CHAR_PTR( "PCSC::ExchangeData - Command", GetResponse, sizeof( GetResponse ) );
t.start( );
#endif
lReturn = SCardTransmit( m_hCardPCSC, SCARD_PCI_T0, (lpCByte)GetResponse, 5, NULL, (lpByte)answerData, &answerLen );
if( ( SCARD_W_REMOVED_CARD == lReturn ) || ( SCARD_W_RESET_CARD == lReturn ) ) {
DWORD dwActiveProtocol = SCARD_PROTOCOL_T0;
lReturn = SCardReconnect( m_hCardPCSC, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, SCARD_LEAVE_CARD, &dwActiveProtocol );
lReturn = SCardTransmit( m_hCardPCSC, SCARD_PCI_T0, (lpCByte)GetResponse, 5, NULL, (lpByte)answerData, &answerLen );
} else if( SCARD_S_SUCCESS != lReturn ) {
std::string s;
Log::toString( s, "SCardTransmit failed <%02x>", lReturn );
Log::error( "PCSC::ExchangeData", s.c_str( ) );
throw RemotingException( (lpCharPtr)"PCSC: SCardTransmit error", lReturn );
}
if( answerLen < 2 ) {
Log::error( "PCSC::ExchangeData", "Incorrect length returned" );
throw RemotingException( (lpCharPtr)"PCSC: SCardTransmit error - Incorrect length returned", SCARD_F_COMM_ERROR );
}
if( answerLen > 2 ) {
u1Array temp( answerLen - 2 );
temp.SetBuffer( answerData );
dataout += temp;
}
sw1 = answerData[ answerLen - 2 ];
sw2 = answerData[ answerLen - 1 ];
#ifdef __DEBUG_APDU__
Log::log( "PCSC::ExchangeData - Status (2) <%02x%02x>", sw1, sw2 );
Log::logCK_UTF8CHAR_PTR( "PCSC::ExchangeData - Response", answerData, answerLen );
t.stop( "PCSC::ExchangeData - Response" );
#endif
}
// The response is not acceptable. We have to retry the data transmission
if( ( 0x63 == sw1 ) || ( ( 0x69 == sw1 ) && ( 0x99 == sw2 ) ) ) {
Log::log( "PCSC::ExchangeData - Invalid response. Retry" );
} else {
break;
}
/* if( ( 0x90 == sw1 ) && ( 0x00 == sw2 ) ) {
break;
}*/
} while ( 3 > ucRetry );
} catch (...) {
if( m_bDoTransact ) {
endTransaction( );
}
throw;
}
if( m_bDoTransact ) {
endTransaction( );
}
}
/* Cleanup the context and card handle
*/
PCSC::~PCSC( ) {
if( m_hCardPCSC ) {
SCardDisconnect( m_hCardPCSC, SCARD_LEAVE_CARD );
m_hCardPCSC = 0;
}
if( m_hContextPCSC ) {
SCardReleaseContext( m_hContextPCSC );
m_hContextPCSC = 0;
}
}
MARSHALLER_NS_END
void
AutomaticIPod::PlayCountsDatabase::bootstrap()
{
qDebug() << "Starting bootstrapping...";
static_cast<TwiddlyApplication*>(qApp)->sendBusMessage( "container://Notification/Twiddly/Bootstrap/Started" );
beginTransaction();
QSqlQuery query( m_db );
// this will fail if the metadata table doesn't exist, which is fine
query.exec( "DELETE FROM metadata WHERE key='bootstrap_complete'" );
query.exec( "DELETE FROM metadata WHERE key='plugin_ctime'" );
query.exec( "DELETE FROM itunes_db" );
#ifdef Q_OS_MAC
ITunesLibrary lib;
// for wizard progress screen
std::cout << lib.trackCount() << std::endl;
int i = 0;
while (lib.hasTracks())
{
ITunesLibrary::Track const t = lib.nextTrack();
QString const plays = QString::number( t.playCount() );
query.exec( "INSERT OR IGNORE INTO itunes_db ( persistent_id, play_count ) "
"VALUES ( '" + t.uniqueId() + "', '" + plays + "' )" );
std::cout << ++i << std::endl;
}
#else
ITunesLibrary lib;
int i = 0;
// These cout statements are for the progress indicator in the client,
// do not remove!
std::cout << lib.trackCount() << std::endl;
while ( lib.hasTracks() )
{
try
{
ITunesLibrary::Track t = lib.nextTrack();
if ( !t.isNull() )
{
QString sql = "INSERT OR IGNORE INTO itunes_db ( persistent_id, path, play_count ) "
"VALUES ( :pid, :path, :plays )";
exec( sql, t );
}
}
catch ( ITunesException& )
{
// Move on...
}
std::cout << ++i << std::endl;
}
#endif
// if either INSERTS fail we'll rebootstrap next time
query.exec( "CREATE TABLE metadata (key VARCHAR( 32 ), value VARCHAR( 32 ))" );
query.exec( "INSERT INTO metadata (key, value) VALUES ('bootstrap_complete', 'true')" );
QString const t = QString::number( common::fileCreationTime( pluginPath() ) );
query.exec( "INSERT INTO metadata (key, value) VALUES ('plugin_ctime', '"+t+"')" );
endTransaction();
static_cast<TwiddlyApplication*>(qApp)->sendBusMessage( "container://Notification/Twiddly/Bootstrap/Finished" );
}
bool Oracle8Query::joinTransaction(CosTransactions::Control_ptr control)
{
#ifdef USE_OB_XA
if (xa_) {
// all work is in XA intercaeptor
return true;
}
#endif
if (flags_.get_sz("NoTransaction")!=NULL) {
return false;
}
if (is_nil(control)) {
// we are not part of transaction, so we can work
// without transaction, if this is allowed.
if (flags_.get_sz("TransactionRequired")!=NULL) {
throw CORBA::TRANSACTION_REQUIRED();
}else{
OCITransSet::detach(*handles_p_);
return false;
}
}
CosTransactions::Coordinator_var foreign;
try {
foreign = control->get_coordinator();
}catch(const CORBA::OBJECT_NOT_EXIST& ){
// timeout;
endTransaction(transactionXID_);
throwQueryProcessingError(1004,"transaction timeout", false);
}
//
// now we know, that foreign transaction exists
//
bool add_resource = false;
CORBA::String_var transactionName=foreign->get_transaction_name();
if (CORBA::is_nil(coordinator_)) {
coordinator_=CosTransactions::Coordinator::_duplicate(foreign);
add_resource = true;
}else{
if (!strcmp(transactionName.in(),transactionName_.in())) {
// i. e. same transaction
return true;
}
}
transactionMutex_.lock(); // from now we in new transaction
CosTransactions::PropagationContext_var ctx =
coordinator_->get_txcontext();
XID xid;
UAKGQueryUtils::otid_to_xid(ctx->current.otid,xid);
transactionName_ = CORBA::string_dup(transactionName.in());
transactionXID_ = xid;
try {
OCITransSet::attach(*handles_p_,xid,ctx->timeout,add_resource);
}catch(const OCIException& ex){
fillDBError();
}
if (add_resource){
UAKGQueryResource* r_impl = new UAKGQueryResource(this,xid);
CORBA::Object_var o = r_impl->_this();
r_impl->_remove_ref();
CosTransactions::Resource_var r = CosTransactions::Resource::_narrow(o);
coordinator_->register_resource(r);
}
return true;
}
void generateSqlite3()
{
// + classes
// + namespaces
// + files
// + groups
// + related pages
// + examples
// + main page
QCString outputDirectory = Config_getString("OUTPUT_DIRECTORY");
QDir sqlite3Dir(outputDirectory);
sqlite3 *db;
sqlite3_initialize();
int rc = sqlite3_open_v2(outputDirectory+"/doxygen_sqlite3.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
if (rc != SQLITE_OK)
{
sqlite3_close(db);
msg("database open failed: %s\n", "doxygen_sqlite3.db");
return;
}
beginTransaction(db);
pragmaTuning(db);
if (-1==initializeSchema(db))
return;
if ( -1 == prepareStatements(db) )
{
err("sqlite generator: prepareStatements failed!");
return;
}
// + classes
ClassSDict::Iterator cli(*Doxygen::classSDict);
ClassDef *cd;
for (cli.toFirst();(cd=cli.current());++cli)
{
msg("Generating Sqlite3 output for class %s\n",cd->name().data());
generateSqlite3ForClass(db,cd);
}
// + namespaces
NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
NamespaceDef *nd;
for (nli.toFirst();(nd=nli.current());++nli)
{
msg("Generating Sqlite3 output for namespace %s\n",nd->name().data());
generateSqlite3ForNamespace(db,nd);
}
// + files
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (;(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
msg("Generating Sqlite3 output for file %s\n",fd->name().data());
generateSqlite3ForFile(db,fd);
}
}
// + groups
GroupSDict::Iterator gli(*Doxygen::groupSDict);
GroupDef *gd;
for (;(gd=gli.current());++gli)
{
msg("Generating Sqlite3 output for group %s\n",gd->name().data());
generateSqlite3ForGroup(db,gd);
}
// + page
{
PageSDict::Iterator pdi(*Doxygen::pageSDict);
PageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
msg("Generating Sqlite3 output for page %s\n",pd->name().data());
generateSqlite3ForPage(db,pd,FALSE);
}
}
// + dirs
{
DirDef *dir;
DirSDict::Iterator sdi(*Doxygen::directories);
for (sdi.toFirst();(dir=sdi.current());++sdi)
{
msg("Generating Sqlite3 output for dir %s\n",dir->name().data());
generateSqlite3ForDir(db,dir);
}
}
// + examples
{
PageSDict::Iterator pdi(*Doxygen::exampleSDict);
PageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
msg("Generating Sqlite3 output for example %s\n",pd->name().data());
generateSqlite3ForPage(db,pd,TRUE);
}
}
// + main page
if (Doxygen::mainPage)
{
msg("Generating Sqlite3 output for the main page\n");
generateSqlite3ForPage(db,Doxygen::mainPage,FALSE);
}
endTransaction(db);
}
Transaction* IncrementalParser::Parse(llvm::StringRef input,
const CompilationOptions& Opts) {
beginTransaction(Opts);
ParseInternal(input);
return endTransaction();
}
