void User::createHelper()
{
Address * a = address();
if ( !d->q ) {
if ( !a->id() ) {
AddressCreator * ac = new AddressCreator( a, d->t );
ac->execute();
}
d->q = new Query( "select name from namespaces where id="
"(select max(id) from namespaces)", this );
d->t->enqueue( d->q );
d->t->execute();
}
if ( d->q->done() && a->id() && !d->inbox ) {
Row *r = d->q->nextRow();
if ( !r ) {
d->t->commit();
return;
}
UString m = r->getUString( "name" );
m.append( '/' );
m.append( d->login );
m.append( "/INBOX" );
d->inbox = Mailbox::obtain( m, true );
d->inbox->create( d->t, 0 );
Query * q1
= new Query( "insert into aliases (address, mailbox) values "
"($1, (select id from mailboxes where name=$2))", 0 );
q1->bind( 1, a->id() );
q1->bind( 2, m );
d->t->enqueue( q1 );
Query * q2
= new Query( "insert into users "
"(alias,parentspace,login,secret,quota) values "
"((select id from aliases where address=$1), "
"(select max(id) from namespaces), $2, $3, "
"coalesce((select quota from users group by quota"
" order by count(*) desc limit 1), 2147483647))", 0 );
q2->bind( 1, a->id() );
q2->bind( 2, d->login );
q2->bind( 3, d->secret );
d->t->enqueue( q2 );
Query *q3 =
new Query( "update mailboxes set "
"owner=(select id from users where login=$1) "
"where name=$2 or name like $2||'/%'", 0 );
q3->bind( 1, d->login );
q3->bind( 2, m );
d->t->enqueue( q3 );
d->t->commit();
}
if ( !d->t->done() )
return;
if ( d->t->failed() ) {
d->state = Nonexistent;
d->result->setError( d->t->error() );
}
else {
d->state = Refreshed;
d->result->setState( Query::Completed );
}
d->result->notify();
}
/**
* This test covers methods on CWalletDB
* WriteZKey()
*/
TEST(wallet_zkeys_tests, write_zkey_direct_to_db) {
SelectParams(CBaseChainParams::TESTNET);
// Get temporary and unique path for file.
// Note: / operator to append paths
boost::filesystem::path pathTemp = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
boost::filesystem::create_directories(pathTemp);
mapArgs["-datadir"] = pathTemp.string();
bool fFirstRun;
CWallet wallet("wallet.dat");
ASSERT_EQ(DB_LOAD_OK, wallet.LoadWallet(fFirstRun));
// No default CPubKey set
ASSERT_TRUE(fFirstRun);
// wallet should be empty
std::set<libzcash::PaymentAddress> addrs;
wallet.GetPaymentAddresses(addrs);
ASSERT_EQ(0, addrs.size());
// Add random key to the wallet
auto paymentAddress = wallet.GenerateNewZKey();
// wallet should have one key
wallet.GetPaymentAddresses(addrs);
ASSERT_EQ(1, addrs.size());
// create random key and add it to database directly, bypassing wallet
auto sk = libzcash::SpendingKey::random();
auto addr = sk.address();
int64_t now = GetTime();
CKeyMetadata meta(now);
CWalletDB db("wallet.dat");
db.WriteZKey(addr, sk, meta);
// wallet should not be aware of key
ASSERT_FALSE(wallet.HaveSpendingKey(addr));
// wallet sees one key
wallet.GetPaymentAddresses(addrs);
ASSERT_EQ(1, addrs.size());
// wallet should have default metadata for addr with null createtime
CKeyMetadata m = wallet.mapZKeyMetadata[addr];
ASSERT_EQ(m.nCreateTime, 0);
ASSERT_NE(m.nCreateTime, now);
// load the wallet again
ASSERT_EQ(DB_LOAD_OK, wallet.LoadWallet(fFirstRun));
// wallet can now see the spending key
ASSERT_TRUE(wallet.HaveSpendingKey(addr));
// check key is the same
libzcash::SpendingKey keyOut;
wallet.GetSpendingKey(addr, keyOut);
ASSERT_EQ(sk, keyOut);
// wallet should have two keys
wallet.GetPaymentAddresses(addrs);
ASSERT_EQ(2, addrs.size());
// check metadata is now the same
m = wallet.mapZKeyMetadata[addr];
ASSERT_EQ(m.nCreateTime, now);
}
KABC::AddresseeList OperaXXPort::importContacts(const QString &) const
{
KABC::AddresseeList addrList;
QString fileName = KFileDialog::getOpenFileName(QDir::homeDirPath() + QString::fromLatin1("/.opera/contacts.adr"));
if(fileName.isEmpty())
return addrList;
QFile file(fileName);
if(!file.open(IO_ReadOnly))
{
QString msg = i18n("<qt>Unable to open <b>%1</b> for reading.</qt>");
KMessageBox::error(parentWidget(), msg.arg(fileName));
return addrList;
}
QTextStream stream(&file);
stream.setEncoding(QTextStream::UnicodeUTF8);
QString line, key, value;
bool parseContact = false;
KABC::Addressee addr;
QRegExp separator("\x02\x02");
while(!stream.atEnd())
{
line = stream.readLine();
line = line.stripWhiteSpace();
if(line == QString::fromLatin1("#CONTACT"))
{
parseContact = true;
addr = KABC::Addressee();
continue;
}
else if(line.isEmpty())
{
parseContact = false;
if(!addr.isEmpty())
{
addrList.append(addr);
addr = KABC::Addressee();
}
continue;
}
if(parseContact == true)
{
int sep = line.find('=');
key = line.left(sep).lower();
value = line.mid(sep + 1);
if(key == QString::fromLatin1("name"))
addr.setNameFromString(value);
else if(key == QString::fromLatin1("mail"))
{
QStringList emails = QStringList::split(separator, value);
QStringList::Iterator it = emails.begin();
bool preferred = true;
for(; it != emails.end(); ++it)
{
addr.insertEmail(*it, preferred);
preferred = false;
}
}
else if(key == QString::fromLatin1("phone"))
addr.insertPhoneNumber(KABC::PhoneNumber(value));
else if(key == QString::fromLatin1("fax"))
addr.insertPhoneNumber(KABC::PhoneNumber(value,
KABC::PhoneNumber::Fax | KABC::PhoneNumber::Home));
else if(key == QString::fromLatin1("postaladdress"))
{
KABC::Address address(KABC::Address::Home);
address.setLabel(value.replace(separator, "\n"));
addr.insertAddress(address);
}
else if(key == QString::fromLatin1("description"))
addr.setNote(value.replace(separator, "\n"));
else if(key == QString::fromLatin1("url"))
addr.setUrl(KURL(value));
else if(key == QString::fromLatin1("pictureurl"))
{
KABC::Picture pic(value);
addr.setPhoto(pic);
}
}
}
file.close();
return addrList;
}
//------------------------------------------------------------------------
// DecomposeStoreInd: Decompose GT_STOREIND.
//
// Arguments:
// use - the LIR::Use object for the def that needs to be decomposed.
//
// Return Value:
// The next node to process.
//
GenTree* DecomposeLongs::DecomposeStoreInd(LIR::Use& use)
{
assert(use.IsInitialized());
assert(use.Def()->OperGet() == GT_STOREIND);
GenTree* tree = use.Def();
assert(tree->gtOp.gtOp2->OperGet() == GT_LONG);
// Example input (address expression omitted):
//
// t51 = const int 0x37C05E7D
// t154 = const int 0x2A0A3C80
// / --* t51 int
// + --* t154 int
// t155 = *gt_long long
// / --* t52 byref
// + --* t155 long
// * storeIndir long
GenTree* gtLong = tree->gtOp.gtOp2;
// Save address to a temp. It is used in storeIndLow and storeIndHigh trees.
LIR::Use address(Range(), &tree->gtOp.gtOp1, tree);
address.ReplaceWithLclVar(m_compiler, m_blockWeight);
JITDUMP("[DecomposeStoreInd]: Saving address tree to a temp var:\n");
DISPTREERANGE(Range(), address.Def());
if (!gtLong->gtOp.gtOp1->OperIsLeaf())
{
LIR::Use op1(Range(), >Long->gtOp.gtOp1, gtLong);
op1.ReplaceWithLclVar(m_compiler, m_blockWeight);
JITDUMP("[DecomposeStoreInd]: Saving low data tree to a temp var:\n");
DISPTREERANGE(Range(), op1.Def());
}
if (!gtLong->gtOp.gtOp2->OperIsLeaf())
{
LIR::Use op2(Range(), >Long->gtOp.gtOp2, gtLong);
op2.ReplaceWithLclVar(m_compiler, m_blockWeight);
JITDUMP("[DecomposeStoreInd]: Saving high data tree to a temp var:\n");
DISPTREERANGE(Range(), op2.Def());
}
GenTree* addrBase = tree->gtOp.gtOp1;
GenTree* dataHigh = gtLong->gtOp.gtOp2;
GenTree* dataLow = gtLong->gtOp.gtOp1;
GenTree* storeIndLow = tree;
Range().Remove(gtLong);
Range().Remove(dataHigh);
storeIndLow->gtOp.gtOp2 = dataLow;
storeIndLow->gtType = TYP_INT;
GenTree* addrBaseHigh = new (m_compiler, GT_LCL_VAR)
GenTreeLclVar(GT_LCL_VAR, addrBase->TypeGet(), addrBase->AsLclVarCommon()->GetLclNum(), BAD_IL_OFFSET);
GenTree* addrHigh =
new (m_compiler, GT_LEA) GenTreeAddrMode(TYP_REF, addrBaseHigh, nullptr, 0, genTypeSize(TYP_INT));
GenTree* storeIndHigh = new (m_compiler, GT_STOREIND) GenTreeStoreInd(TYP_INT, addrHigh, dataHigh);
storeIndHigh->gtFlags = (storeIndLow->gtFlags & (GTF_ALL_EFFECT | GTF_LIVENESS_MASK));
storeIndHigh->gtFlags |= GTF_REVERSE_OPS;
m_compiler->lvaIncRefCnts(addrBaseHigh);
Range().InsertAfter(storeIndLow, dataHigh, addrBaseHigh, addrHigh, storeIndHigh);
return storeIndHigh;
// Example final output:
//
// /--* t52 byref
// * st.lclVar byref V07 rat0
// t158 = lclVar byref V07 rat0
// t51 = const int 0x37C05E7D
// /--* t158 byref
// +--* t51 int
// * storeIndir int
// t154 = const int 0x2A0A3C80
// t159 = lclVar byref V07 rat0
// /--* t159 byref
// t160 = * lea(b + 4) ref
// /--* t154 int
// +--* t160 ref
// * storeIndir int
}
void MultisigDialog::on_transaction_textChanged()
{
while(ui->inputs->count())
delete ui->inputs->takeAt(0)->widget();
while(ui->outputs->count())
delete ui->outputs->takeAt(0)->widget();
if(ui->transaction->text().size() > 0)
ui->signTransactionButton->setEnabled(true);
else
ui->signTransactionButton->setEnabled(false);
// Decode the raw transaction
std::vector<unsigned char> txData(ParseHex(ui->transaction->text().toStdString()));
CDataStream ss(txData, SER_NETWORK, PROTOCOL_VERSION);
CTransaction tx;
try
{
ss >> tx;
}
catch(std::exception &e)
{
(void)e;
return;
}
// Fill input list
int index = -1;
BOOST_FOREACH(const CTxIn& txin, tx.vin)
{
uint256 prevoutHash = txin.prevout.hash;
addInput();
index++;
MultisigInputEntry *entry = qobject_cast<MultisigInputEntry *>(ui->inputs->itemAt(index)->widget());
if(entry)
{
entry->setTransactionId(QString(prevoutHash.GetHex().c_str()));
entry->setTransactionOutputIndex(txin.prevout.n);
}
}
// Fill output list
index = -1;
BOOST_FOREACH(const CTxOut& txout, tx.vout)
{
CScript scriptPubKey = txout.scriptPubKey;
CTxDestination addr;
ExtractDestination(scriptPubKey, addr);
CBitcoinAddress address(addr);
SendCoinsRecipient recipient;
recipient.address = QString(address.ToString().c_str());
recipient.amount = txout.nValue;
addOutput();
index++;
SendCoinsEntry *entry = qobject_cast<SendCoinsEntry *>(ui->outputs->itemAt(index)->widget());
if(entry)
{
entry->setValue(recipient);
}
}
updateRemoveEnabled();
}
address_type address(boost::system::error_code &) const noexcept
{
return address();
}
static bool address_validate(const ek_salt& salt, const ec_secret& secret,
uint8_t version, bool compressed)
{
payment_address address({ secret, version, compressed });
return address ? address_validate(salt, address) : false;
}
void CProtocolDLT_645_07::CGI_SetDataTypeMap(const QDomElement &DeviceListElement_)
{
QDomNodeList DeviceList = DeviceListElement_.childNodes();
for (int i = 0; i <DeviceList.count(); ++i)
{
QDomElement DeviceElement = DeviceList.at(i).toElement();
QString strDeviceAddress;
QByteArray arrayDeviceAddress;
DLT_645_07PointMap_2 *pDLT_645_07PointMap = new DLT_645_07PointMap_2;
for (int nType = 0; nType < DeviceElement.childNodes().count(); ++nType)
{
QDomElement TypeElem = DeviceElement.childNodes().at(nType).toElement();
if (TypeElem.tagName() == "Attribute")///
{
/// 设备地址左侧补0，一共12个字符
strDeviceAddress = TypeElem.attribute("Device_Address");
strDeviceAddress = strDeviceAddress.trimmed();///< 修整 将左侧和右侧的空格和换行符移除
strDeviceAddress = "000000000000" + strDeviceAddress;
strDeviceAddress = strDeviceAddress.right(12);
}else
{
for (int nPoint = 0; nPoint < TypeElem.childNodes().count(); ++nPoint)
{
QDomElement tagElement = TypeElem.childNodes().at(nPoint).toElement();
CPointDLT_645_07 *pPoint = new CPointDLT_645_07;
pPoint->m_strPointName = tagElement.attribute("Device_YC_Name_Strings");
pPoint->m_strPointComment = tagElement.attribute("Device_YC_Desc_Strings");
pPoint->m_nID = tagElement.attribute("Device_YC_SN_Strings").toInt();
pPoint->m_strRTDBName = tagElement.attribute("Device_YC_Link_Strings");
pPoint->m_nScanTime = tagElement.attribute("ScanTime").toInt();
pPoint->m_fKValue = tagElement.attribute("Device_YC_KValue_Strings").toFloat();
if (pPoint->m_fKValue == 0)
{
pPoint->m_fKValue = 1;
}
pPoint->m_fBaseValue = tagElement.attribute("Device_YC_BaseValue_Strings").toFloat();
pPoint->m_nByteCount = tagElement.attribute("Device_YC_ByteCount_Strings").toInt();
pPoint->m_nStartByte = tagElement.attribute("Device_YC_StartByte_Strings").toInt();
pPoint->m_nDecimalPlaces = tagElement.attribute("Device_YC_DecimalPlaces_Strings").toInt();
pPoint->m_pProtocol = this;
pPoint->m_pTag = m_pRTDB->FindTag(pPoint->m_strRTDBName);
if (pPoint->m_pTag)
{
pPoint->m_pTag->SetCollection(pPoint);///设置采集点
}
char *p = NULL;
pPoint->m_bDI3 = (BYTE)strtoul(tagElement.attribute("Device_YC_DI3_Strings").toLatin1().mid(0,2),&p,16);
pPoint->m_bDI2 = (BYTE)strtoul(tagElement.attribute("Device_YC_DI2_Strings").toLatin1().mid(0,2),&p,16);
pPoint->m_bDI1 = (BYTE)strtoul(tagElement.attribute("Device_YC_DI1_Strings").toLatin1().mid(0,2),&p,16);
pPoint->m_bDI0 = (BYTE)strtoul(tagElement.attribute("Device_YC_DI0_Strings").toLatin1().mid(0,2),&p,16);
BYTE DI[4];/// = {pPoint->m_bDI0+0x33,pPoint->m_bDI1+0x33,pPoint->m_bDI2+0x33,pPoint->m_bDI3+0x33};
DI[0] = pPoint->m_bDI0+0x33;///,pPoint->m_bDI1+0x33,pPoint->m_bDI2+0x33,pPoint->m_bDI3+0x33};
DI[1] = pPoint->m_bDI1+0x33;///,pPoint->m_bDI2+0x33,pPoint->m_bDI3+0x33};
DI[2] = pPoint->m_bDI2+0x33;///,pPoint->m_bDI3+0x33};
DI[3] = pPoint->m_bDI3+0x33;
unsigned int value = 0;/// = (unsigned int)(*((unsigned int *)DI));
memcpy((void *)(&value),DI,sizeof(unsigned int));
// pPoint->m_unDI = (unsigned int)(*((unsigned int *)DI));
pPoint->m_unDI = value;
qDebug()<<pPoint->m_unDI<<"===========";
BYTE *pCur = pPoint->m_bDeviceAddr+5;
for (int nStart = 0; nStart < 6; ++nStart)
{
*pCur-- = (BYTE)strtoul(strDeviceAddress.toLatin1().mid(nStart*2,2),&p,16);
}
QByteArray address((char *)pPoint->m_bDeviceAddr,6);
arrayDeviceAddress = address;
pPoint->m_strDeviceAddr = address.toHex();
pPoint->m_arrayDeviceAddr = address;
qDebug()<<"----------AA"<<pPoint->m_strDeviceAddr<<pPoint->m_arrayDeviceAddr.toHex();
// strDeviceAddress = pPoint->m_strDeviceAddr;
BYTE bDI[4];
bDI[0] = pPoint->m_bDI0;
bDI[1] = pPoint->m_bDI1;
bDI[2] = pPoint->m_bDI2;
bDI[3] = pPoint->m_bDI3;
QByteArray arrayDI((char *)bDI,4);
pPoint->m_strDI = arrayDI.toHex();
qDebug()<<tagElement.attribute("Device_YC_DI3_Strings")<<pPoint->m_bDI1<<tagElement.attribute("Device_YC_DI2_Strings")
<<tagElement.attribute("Device_YC_DI1_Strings")<<tagElement.attribute("Device_YC_DI0_Strings")
<<strDeviceAddress<<address.toHex()<<pPoint->m_strDeviceAddr<<pPoint->m_strDI;
pDLT_645_07PointMap->insert(pPoint->m_unDI,pPoint);
m_PointNode.AddPoint(pPoint);
CDLT_645_07Query *pQuery = new CDLT_645_07Query;
pQuery->m_arrayAddress = address;
pQuery->MakeQuery(address.data(),0x11,arrayDI.data(),4);
qDebug()<<pQuery->m_ByteArrayFrame.toHex();
DLT_645_07QueryList.append(pQuery);
}
}
}
if (!pDLT_645_07PointMap->isEmpty())
{
Device_Read_Map.insert(arrayDeviceAddress,pDLT_645_07PointMap);
}
}
}
void CProtocolDLT_645_07::ProcessRespond(CDLT_645_07Response &response)
{
if (response.GetUIntValue(8,1) & 0x40)
{
return;
}
else
{
QByteArray address((char *)(response.GetBuffer(0)+1),6);/// 设备地址
unsigned int unDeviceAddress = response.GetUIntValue(10,4);
qDebug()<<"response.GetUIntValue(10,4);"<<unDeviceAddress;
m_PointNode.FindPointMap(address,unDeviceAddress);
DLT_645_07PointMap *pPointMap = m_PointNode.FindPointMap(address,unDeviceAddress);
if (pPointMap)
{
qDebug()<<"if (pPointMap)"<<pPointMap->count()<<address.toHex()<<unDeviceAddress;
DLT_645_07PointMap::iterator iterator;
for (iterator = pPointMap->begin(); iterator != pPointMap->end(); ++iterator)
{
CPointDLT_645_07 *pPoint = iterator.value();
if (pPoint)
{
QString strLink = pPoint->m_strRTDBName;
int nByteCount = pPoint->m_nByteCount;
int nStartByte = pPoint->m_nStartByte;
qDebug()<<"if (pPoint)"<<pPoint->m_strRTDBName<<pPoint->m_nByteCount<<pPoint->m_nStartByte;
BYTE nLength = response.GetUIntValue(9,1);
if ((nByteCount+4) <= nLength)
{
qDebug()<<"if ((nByteCount+4) <= nLength)";
BYTE Value[nByteCount];
for (int i = 0; i < nByteCount; ++i)
{
Value[i] = response.GetUIntValue(i+14+nStartByte,1);
Value[i]-= 0x33;
}
BYTE Temp[nByteCount];
for (int i = 0; i < nByteCount; ++i)
{
Temp[i] = Value[nByteCount-1-i];
}
QByteArray baValue((char *)Temp,nByteCount);
baValue = baValue.toHex();
ShowMessage(2,baValue);
int nDecimalPlaces = pPoint->m_nDecimalPlaces;/// @note 小数点位数
QString Project_(baValue);
if (nDecimalPlaces)
{
if (Project_.count()<nDecimalPlaces)
{
Project_ = "00000000000000000000"+Project_;
Project_.insert(Project_.count()-nDecimalPlaces,'.');
Project_ = Project_.right(nDecimalPlaces+2);
}else
{
Project_.insert(Project_.count()-nDecimalPlaces,'.');
}
}
while(Project_.count())
{
if (Project_.at(0)!='0')
{
break;
}else
{
Project_.remove(0,1);
}
}
if (Project_.count())
{
if (Project_.at(0)=='.')
Project_.insert(0,'0');
}
QVariant VarProject_;
QVariant VarOriginal_;
if (Project_.contains('.'))
{
VarProject_ = QVariant(Project_.toFloat());
VarOriginal_ = QVariant(Project_.toFloat());
}else
{
VarProject_ = QVariant(Project_.toInt());
VarOriginal_ = QVariant(Project_.toInt());
}
qDebug()<<"Project_:="<< Project_<<Project_.toFloat()<<Project_.toInt()<<VarProject_;
ShowMessage(2,VarProject_.toString()+"---"+VarOriginal_.toString());
CTagI *pTag = pPoint->GetTag();;
if (pTag)
{
pTag->SetValue(pPoint,VarProject_,VarOriginal_);
}
}
}
}
}else
{
qDebug()<<"if (pPointMap) NULL";
}
}
#if 0
else
{
void
operate(int c, int cnt)
{
register int i;
void (*moveop)(), (*deleteop)();
void (*opf)();
bool subop = 0;
char *oglobp, *ocurs;
register line *addr;
static char lastFKND, lastFCHR;
char d;
moveop = vmove, deleteop = vdelete;
wcursor = cursor;
wdot = NOLINE;
notecnt = 0;
dir = 1;
switch (c) {
/*
* d delete operator.
*/
case 'd':
moveop = vdelete;
deleteop = beep;
break;
/*
* s substitute characters, like c\040, i.e. change space.
*/
case 's':
ungetkey(' ');
subop++;
/* fall into ... */
/*
* c Change operator.
*/
case 'c':
if ((c == 'c' && workcmd[0] == 'C') || workcmd[0] == 'S')
subop++;
moveop = vchange;
deleteop = beep;
break;
/*
* ! Filter through a UNIX command.
*/
case '!':
moveop = vfilter;
deleteop = beep;
break;
/*
* y Yank operator. Place specified text so that it
* can be put back with p/P. Also yanks to named buffers.
*/
case 'y':
moveop = vyankit;
deleteop = beep;
break;
/*
* = Reformat operator (for LISP).
*/
#ifdef LISP
case '=':
forbid(!value(LISP));
/* fall into ... */
#endif
/*
* > Right shift operator.
* < Left shift operator.
*/
case '<':
case '>':
moveop = vshftop;
deleteop = beep;
break;
/*
* r Replace character under cursor with single following
* character.
*/
case 'r':
vrep(cnt);
return;
default:
goto nocount;
}
/*
* Had an operator, so accept another count.
* Multiply counts together.
*/
if (isdigit(peekkey()) && peekkey() != '0') {
cnt *= vgetcnt();
Xcnt = cnt;
forbid (cnt <= 0);
}
/*
* Get next character, mapping it and saving as
* part of command for repeat.
*/
c = map(getesc());
if (c == 0)
return;
if (!subop)
*lastcp++ = c;
nocount:
opf = moveop;
switch (c) {
/*
* b Back up a word.
* B Back up a word, liberal definition.
*/
case 'b':
case 'B':
dir = -1;
/* fall into ... */
/*
* w Forward a word.
* W Forward a word, liberal definition.
*/
case 'W':
case 'w':
wdkind = c & ' ';
if (edge()) {
forbid (opf == vmove);
wcursor = dir == -1 ? linebuf : strend(linebuf);
} else
while (cnt > 0 && !edge())
word(opf, cnt), cnt--;
vmoving = 0;
break;
/*
* E to end of following blank/nonblank word
*/
case 'E':
wdkind = 0;
goto ein;
/*
* e To end of following word.
*/
case 'e':
wdkind = 1;
ein:
if (edge()) {
forbid(opf == vmove);
wcursor = dir == -1 ? linebuf : strend(linebuf);
} else {
while (cnt > 1 && !edge()) {
word(opf, cnt);
cnt--;
}
eend(opf, cnt);
}
vmoving = 0;
break;
/*
* ( Back an s-expression.
*/
case '(':
dir = -1;
/* fall into... */
/*
* ) Forward an s-expression.
*/
case ')':
forbid(lfind(0, cnt, opf, (line *) 0) < 0);
if (wdot)
markpr(wdot);
break;
/*
* { Back an s-expression, but don't stop on atoms.
* In text mode, a paragraph. For C, a balanced set
* of {}'s.
*/
case '{':
dir = -1;
/* fall into... */
/*
* } Forward an s-expression, but don't stop on atoms.
* In text mode, back paragraph. For C, back a balanced
* set of {}'s.
*/
case '}':
forbid(lfind(1, cnt, opf, (line *) 0) < 0);
if (wdot)
markpr(wdot);
break;
/*
* % To matching () or {}. If not at ( or { scan for
* first such after cursor on this line.
*/
case '%':
vsave();
i = lmatchp((line *) 0);
getDOT();
forbid(!i);
if (opf != vmove)
if (dir > 0)
wcursor++;
else
cursor++;
else
if (wdot)
markpr(wdot);
break;
/*
* [ Back to beginning of defun, i.e. an ( in column 1.
* For text, back to a section macro.
* For C, back to a { in column 1 (~~ beg of function.)
*/
case '[':
dir = -1;
/* fall into ... */
/*
* ] Forward to next defun, i.e. a ( in column 1.
* For text, forward section.
* For C, forward to a } in column 1 (if delete or such)
* or if a move to a { in column 1.
*/
case ']':
if (!vglobp)
forbid(getkey() != c);
if (Xhadcnt)
vsetsiz(Xcnt);
vsave();
i = lbrack(c, opf);
getDOT();
forbid(!i);
if (wdot)
markpr(wdot);
if (ex_ospeed > B300)
hold |= HOLDWIG;
break;
/*
* , Invert last find with f F t or T, like inverse
* of ;.
*/
case ',':
forbid (lastFKND == 0);
c = isupper((int)lastFKND) ? tolower((int)lastFKND) : toupper((int)lastFKND);
ungetkey(lastFCHR);
if (vglobp == 0)
vglobp = "";
subop++;
goto nocount;
/*
* 0 To beginning of real line.
*/
case '0':
wcursor = linebuf;
vmoving = 0;
break;
/*
* ; Repeat last find with f F t or T.
*/
case ';':
forbid (lastFKND == 0);
c = lastFKND;
ungetkey(lastFCHR);
subop++;
goto nocount;
/*
* F Find single character before cursor in current line.
* T Like F, but stops before character.
*/
case 'F': /* inverted find */
case 'T':
dir = -1;
/* fall into ... */
/*
* f Find single character following cursor in current line.
* t Like f, but stope before character.
*/
case 'f': /* find */
case 't':
i = getesc();
if (i == 0)
return;
if (!subop)
*lastcp++ = i;
if (vglobp == 0)
lastFKND = c, lastFCHR = i;
for (; cnt > 0; cnt--)
forbid (find(i) == 0);
switch (c) {
case 'T':
wcursor++;
break;
case 't':
wcursor--;
case 'f':
fixup:
if (moveop != vmove)
wcursor++;
break;
}
vmoving = 0;
break;
/*
* | Find specified print column in current line.
*/
case '|':
if (Pline == numbline)
cnt += 8;
vmovcol = cnt;
vmoving = 1;
wcursor = vfindcol(cnt);
break;
/*
* ^ To beginning of non-white space on line.
*/
case '^':
wcursor = vskipwh(linebuf);
vmoving = 0;
break;
/*
* $ To end of line.
*/
case '$':
if (cnt > 1) {
if (opf == vmove) {
wcursor = 0;
vmoving = 1;
vmovcol = 20000;
cnt--;
} else
wcursor = linebuf;
wdot = dot + cnt;
break;
}
if (linebuf[0]) {
wcursor = strend(linebuf) - 1;
goto fixup;
}
wcursor = linebuf;
vmoving = 0;
break;
/*
* h Back a character.
* ^H Back a character.
*/
case 'h':
case CTRL('h'):
dir = -1;
/* fall into ... */
/*
* space Forward a character.
*/
case ' ':
forbid (margin() || (opf == vmove && edge()));
while (cnt > 0 && !margin())
wcursor += dir, cnt--;
if ((margin() && opf == vmove) || wcursor < linebuf)
wcursor -= dir;
vmoving = 0;
break;
/*
* D Delete to end of line, short for d$.
*/
case 'D':
cnt = INF;
goto deleteit;
/*
* X Delete character before cursor.
*/
case 'X':
dir = -1;
/* fall into ... */
deleteit:
/*
* x Delete character at cursor, leaving cursor where it is.
*/
case 'x':
if (margin())
goto errlab;
while (cnt > 0 && !margin())
wcursor += dir, cnt--;
opf = deleteop;
vmoving = 0;
break;
default:
/*
* Stuttered operators are equivalent to the operator on
* a line, thus turn dd into d_.
*/
if (opf == vmove || c != workcmd[0]) {
errlab:
beep();
return;
}
/* fall into ... */
/*
* _ Target for a line or group of lines.
* Stuttering is more convenient; this is mostly
* for aesthetics.
*/
case '_':
wdot = dot + cnt - 1;
vmoving = 0;
wcursor = 0;
break;
/*
* H To first, home line on screen.
* Count is for count'th line rather than first.
*/
case 'H':
wdot = (dot - vcline) + cnt - 1;
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* - Backwards lines, to first non-white character.
*/
case '-':
wdot = dot - cnt;
vmoving = 0;
wcursor = 0;
break;
/*
* ^P To previous line same column. Ridiculous on the
* console of the VAX since it puts console in LSI mode.
*/
case CTRL('p'):
wdot = dot - cnt;
if (vmoving == 0)
vmoving = 1, vmovcol = column(cursor);
wcursor = 0;
break;
/*
* L To last line on screen, or count'th line from the
* bottom.
*/
case 'L':
wdot = dot + vcnt - vcline - cnt;
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* M To the middle of the screen.
*/
case 'M':
wdot = dot + ((vcnt + 1) / 2) - vcline - 1;
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* + Forward line, to first non-white.
*
* CR Convenient synonym for +.
*/
case '+':
case CR:
wdot = dot + cnt;
vmoving = 0;
wcursor = 0;
break;
/*
* ^N To next line, same column if possible.
*
* LF Linefeed is a convenient synonym for ^N.
*/
case CTRL('n'):
case NL:
wdot = dot + cnt;
if (vmoving == 0)
vmoving = 1, vmovcol = column(cursor);
wcursor = 0;
break;
/*
* n Search to next match of current pattern.
*/
case 'n':
vglobp = vscandir;
c = *vglobp++;
goto nocount;
/*
* N Like n but in reverse direction.
*/
case 'N':
vglobp = vscandir[0] == '/' ? "?" : "/";
c = *vglobp++;
goto nocount;
/*
* ' Return to line specified by following mark,
* first white position on line.
*
* ` Return to marked line at remembered column.
*/
case '\'':
case '`':
d = c;
c = getesc();
if (c == 0)
return;
c = markreg(c);
forbid (c == 0);
wdot = getmark(c);
forbid (wdot == NOLINE);
if (Xhadcnt)
vsetsiz(Xcnt);
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = d == '`' ? ncols[c - 'a'] : 0;
if (wcursor) {
vsave();
ex_getline(*wdot);
if (wcursor > strend(linebuf))
wcursor = 0;
getDOT();
}
if (ex_ospeed > B300)
hold |= HOLDWIG;
break;
/*
* G Goto count'th line, or last line if no count
* given.
*/
case 'G':
if (!Xhadcnt)
cnt = lineDOL();
wdot = zero + cnt;
forbid (wdot < one || wdot > dol);
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* / Scan forward for following re.
* ? Scan backward for following re.
*/
case '/':
case '?':
if (Xhadcnt)
vsetsiz(Xcnt);
vsave();
ocurs = cursor;
wcursor = 0;
if (readecho(c))
return;
if (!vglobp)
vscandir[0] = genbuf[0];
oglobp = globp; CP(vutmp, genbuf); globp = vutmp;
d = peekc; ungetchar(0); fixech();
CATCH
#ifdef V6
/*
* Lose typeahead (ick).
*/
vcook();
#endif
addr = address();
#ifdef V6
vraw();
#endif
ONERR
#ifdef V6
vraw();
#endif
globp = oglobp;
ungetchar(d);
splitw = 0;
vclean();
vjumpto(dot, ocurs, 0);
return;
ENDCATCH
if (globp == 0)
globp = "";
else if (peekc)
--globp;
ungetchar(d);
c = 0;
if (*globp == 'z')
globp++, c = '\n';
if (any(*globp, "^+-."))
c = *globp++;
i = 0;
while (isdigit((int)*globp))
i = i * 10 + *globp++ - '0';
if (*globp)
c = *globp++;
globp = oglobp;
splitw = 0;
vmoving = 0;
if (i != 0)
vsetsiz(i);
if (opf == vmove) {
if (state == ONEOPEN || state == HARDOPEN)
outline = destline = WBOT;
markit(addr);
if (loc1 > linebuf && *loc1 == 0)
loc1--;
if (c)
vjumpto(addr, loc1, c);
else {
vmoving = 0;
if (loc1) {
vmoving++;
vmovcol = column(loc1);
}
getDOT();
if (state == CRTOPEN && addr != dot)
vup1();
vupdown(addr - dot, NOSTR);
}
return;
}
lastcp[-1] = 'n';
getDOT();
wdot = addr;
break;
}
/*
* Apply.
*/
if (vreg && wdot == 0)
wdot = dot;
(*opf)(c);
wdot = NOLINE;
}
void
RemoteView::_DrawThread()
{
RemoteMessage reply(NULL, fSendBuffer);
RemoteMessage message(fReceiveBuffer, NULL);
// cursor
BPoint cursorHotSpot(0, 0);
while (!fStopThread) {
uint16 code;
status_t status = message.NextMessage(code);
if (status != B_OK) {
TRACE_ERROR("failed to read message from receiver\n");
break;
}
TRACE("code %u with %ld bytes data\n", code, message.DataLeft());
BAutolock locker(this->Looper());
if (!locker.IsLocked())
break;
// handle stuff that doesn't go to a specicifc engine
switch (code) {
case RP_INIT_CONNECTION:
{
uint16 port;
status_t result = message.Read(port);
if (result != B_OK) {
TRACE_ERROR("failed to read remote port\n");
continue;
}
BNetEndpoint *endpoint = fReceiver->Endpoint();
if (endpoint == NULL) {
TRACE_ERROR("receiver not connected anymore\n");
continue;
}
in_addr remoteHost;
char hostName[MAXHOSTNAMELEN + 1];
BNetAddress address(endpoint->RemoteAddr());
address.GetAddr(remoteHost);
address.GetAddr(hostName, NULL);
address.SetTo(remoteHost, port);
TRACE("connecting to host \"%s\" port %u\n", hostName, port);
result = fSendEndpoint->Connect(address);
if (result != B_OK) {
TRACE_ERROR("failed to connect to host \"%s\" port %u\n",
hostName, port);
continue;
}
BRect bounds = fOffscreenBitmap->Bounds();
reply.Start(RP_UPDATE_DISPLAY_MODE);
reply.Add(bounds.IntegerWidth() + 1);
reply.Add(bounds.IntegerHeight() + 1);
if (reply.Flush() == B_OK)
fIsConnected = true;
continue;
}
case RP_CLOSE_CONNECTION:
{
be_app->PostMessage(B_QUIT_REQUESTED);
continue;
}
case RP_CREATE_STATE:
case RP_DELETE_STATE:
{
uint32 token;
message.Read(token);
if (code == RP_CREATE_STATE)
_CreateState(token);
else
_DeleteState(token);
continue;
}
case RP_SET_CURSOR:
{
BBitmap *bitmap;
BPoint oldHotSpot = cursorHotSpot;
message.Read(cursorHotSpot);
if (message.ReadBitmap(&bitmap) != B_OK)
continue;
delete fCursorBitmap;
fCursorBitmap = bitmap;
Invalidate(fCursorFrame);
BRect bounds = fCursorBitmap->Bounds();
fCursorFrame.right = fCursorFrame.left
+ bounds.IntegerWidth() + 1;
fCursorFrame.bottom = fCursorFrame.bottom
+ bounds.IntegerHeight() + 1;
fCursorFrame.OffsetBy(oldHotSpot - cursorHotSpot);
Invalidate(fCursorFrame);
continue;
}
case RP_SET_CURSOR_VISIBLE:
{
bool wasVisible = fCursorVisible;
message.Read(fCursorVisible);
if (wasVisible != fCursorVisible)
Invalidate(fCursorFrame);
continue;
}
case RP_MOVE_CURSOR_TO:
{
BPoint position;
message.Read(position);
if (fCursorVisible)
Invalidate(fCursorFrame);
fCursorFrame.OffsetTo(position - cursorHotSpot);
Invalidate(fCursorFrame);
continue;
}
case RP_INVALIDATE_RECT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
Invalidate(rect);
continue;
}
case RP_INVALIDATE_REGION:
{
BRegion region;
if (message.ReadRegion(region) != B_OK)
continue;
Invalidate(®ion);
continue;
}
case RP_FILL_REGION_COLOR_NO_CLIPPING:
{
BRegion region;
rgb_color color;
message.ReadRegion(region);
if (message.Read(color) != B_OK)
continue;
fOffscreen->LockLooper();
fOffscreen->SetHighColor(color);
fOffscreen->FillRegion(®ion);
fOffscreen->UnlockLooper();
Invalidate(®ion);
continue;
}
case RP_COPY_RECT_NO_CLIPPING:
{
int32 xOffset, yOffset;
BRect rect;
message.Read(xOffset);
message.Read(yOffset);
if (message.Read(rect) != B_OK)
continue;
BRect dest = rect.OffsetByCopy(xOffset, yOffset);
fOffscreen->LockLooper();
fOffscreen->CopyBits(rect, dest);
fOffscreen->UnlockLooper();
continue;
}
}
uint32 token;
message.Read(token);
engine_state *state = _FindState(token);
if (state == NULL) {
TRACE_ERROR("didn't find state for token %lu\n", token);
continue;
}
BView *offscreen = state->view;
::pattern &pattern = state->pattern;
BRegion &clippingRegion = state->clipping_region;
float &penSize = state->pen_size;
bool &syncDrawing = state->sync_drawing;
BRegion invalidRegion;
BAutolock offscreenLocker(offscreen->Looper());
if (!offscreenLocker.IsLocked())
break;
switch (code) {
case RP_ENABLE_SYNC_DRAWING:
syncDrawing = true;
continue;
case RP_DISABLE_SYNC_DRAWING:
syncDrawing = false;
continue;
case RP_SET_OFFSETS:
{
int32 xOffset, yOffset;
message.Read(xOffset);
if (message.Read(yOffset) != B_OK)
continue;
offscreen->MovePenTo(xOffset, yOffset);
break;
}
case RP_SET_HIGH_COLOR:
case RP_SET_LOW_COLOR:
{
rgb_color color;
if (message.Read(color) != B_OK)
continue;
if (code == RP_SET_HIGH_COLOR)
offscreen->SetHighColor(color);
else
offscreen->SetLowColor(color);
break;
}
case RP_SET_PEN_SIZE:
{
float newPenSize;
if (message.Read(newPenSize) != B_OK)
continue;
offscreen->SetPenSize(newPenSize);
penSize = newPenSize / 2;
break;
}
case RP_SET_STROKE_MODE:
{
cap_mode capMode;
join_mode joinMode;
float miterLimit;
message.Read(capMode);
message.Read(joinMode);
if (message.Read(miterLimit) != B_OK)
continue;
offscreen->SetLineMode(capMode, joinMode, miterLimit);
break;
}
case RP_SET_BLENDING_MODE:
{
source_alpha sourceAlpha;
alpha_function alphaFunction;
message.Read(sourceAlpha);
if (message.Read(alphaFunction) != B_OK)
continue;
offscreen->SetBlendingMode(sourceAlpha, alphaFunction);
break;
}
case RP_SET_PATTERN:
{
if (message.Read(pattern) != B_OK)
continue;
break;
}
case RP_SET_DRAWING_MODE:
{
drawing_mode drawingMode;
if (message.Read(drawingMode) != B_OK)
continue;
offscreen->SetDrawingMode(drawingMode);
break;
}
case RP_SET_FONT:
{
BFont font;
if (message.ReadFontState(font) != B_OK)
continue;
offscreen->SetFont(&font);
break;
}
case RP_CONSTRAIN_CLIPPING_REGION:
{
if (message.ReadRegion(clippingRegion) != B_OK)
continue;
offscreen->ConstrainClippingRegion(&clippingRegion);
break;
}
case RP_INVERT_RECT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
offscreen->InvertRect(rect);
invalidRegion.Include(rect);
break;
}
case RP_DRAW_BITMAP:
{
BBitmap *bitmap;
BRect bitmapRect, viewRect;
uint32 options;
message.Read(bitmapRect);
message.Read(viewRect);
message.Read(options);
if (message.ReadBitmap(&bitmap) != B_OK || bitmap == NULL)
continue;
offscreen->DrawBitmap(bitmap, bitmapRect, viewRect, options);
invalidRegion.Include(viewRect);
delete bitmap;
break;
}
case RP_STROKE_ARC:
case RP_FILL_ARC:
case RP_FILL_ARC_GRADIENT:
{
BRect rect;
float angle, span;
message.Read(rect);
message.Read(angle);
if (message.Read(span) != B_OK)
continue;
if (code == RP_STROKE_ARC) {
offscreen->StrokeArc(rect, angle, span, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ARC)
offscreen->FillArc(rect, angle, span, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillArc(rect, angle, span, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_BEZIER:
case RP_FILL_BEZIER:
case RP_FILL_BEZIER_GRADIENT:
{
BPoint points[4];
if (message.ReadList(points, 4) != B_OK)
continue;
BRect bounds = _BuildInvalidateRect(points, 4);
if (code == RP_STROKE_BEZIER) {
offscreen->StrokeBezier(points, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_BEZIER)
offscreen->FillBezier(points, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillBezier(points, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_ELLIPSE:
case RP_FILL_ELLIPSE:
case RP_FILL_ELLIPSE_GRADIENT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
if (code == RP_STROKE_ELLIPSE) {
offscreen->StrokeEllipse(rect, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ELLIPSE)
offscreen->FillEllipse(rect, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillEllipse(rect, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_POLYGON:
case RP_FILL_POLYGON:
case RP_FILL_POLYGON_GRADIENT:
{
BRect bounds;
bool closed;
int32 numPoints;
message.Read(bounds);
message.Read(closed);
if (message.Read(numPoints) != B_OK)
continue;
BPoint points[numPoints];
for (int32 i = 0; i < numPoints; i++)
message.Read(points[i]);
if (code == RP_STROKE_POLYGON) {
offscreen->StrokePolygon(points, numPoints, bounds, closed,
pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_POLYGON)
offscreen->FillPolygon(points, numPoints, bounds, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillPolygon(points, numPoints, bounds,
*gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_RECT:
case RP_FILL_RECT:
case RP_FILL_RECT_GRADIENT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
if (code == RP_STROKE_RECT) {
offscreen->StrokeRect(rect, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_RECT)
offscreen->FillRect(rect, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRect(rect, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_ROUND_RECT:
case RP_FILL_ROUND_RECT:
case RP_FILL_ROUND_RECT_GRADIENT:
{
BRect rect;
float xRadius, yRadius;
message.Read(rect);
message.Read(xRadius);
if (message.Read(yRadius) != B_OK)
continue;
if (code == RP_STROKE_ROUND_RECT) {
offscreen->StrokeRoundRect(rect, xRadius, yRadius,
pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ROUND_RECT)
offscreen->FillRoundRect(rect, xRadius, yRadius, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRoundRect(rect, xRadius, yRadius,
*gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_SHAPE:
case RP_FILL_SHAPE:
case RP_FILL_SHAPE_GRADIENT:
{
BRect bounds;
int32 opCount, pointCount;
message.Read(bounds);
if (message.Read(opCount) != B_OK)
continue;
BMessage archive;
for (int32 i = 0; i < opCount; i++) {
int32 op;
message.Read(op);
archive.AddInt32("ops", op);
}
if (message.Read(pointCount) != B_OK)
continue;
for (int32 i = 0; i < pointCount; i++) {
BPoint point;
message.Read(point);
archive.AddPoint("pts", point);
}
// the shape is in absolute coordinates
offscreen->MovePenTo(0, 0);
BShape shape(&archive);
if (code == RP_STROKE_SHAPE) {
offscreen->StrokeShape(&shape, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_SHAPE)
offscreen->FillShape(&shape, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillShape(&shape, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_TRIANGLE:
case RP_FILL_TRIANGLE:
case RP_FILL_TRIANGLE_GRADIENT:
{
BRect bounds;
BPoint points[3];
message.ReadList(points, 3);
if (message.Read(bounds) != B_OK)
continue;
if (code == RP_STROKE_TRIANGLE) {
offscreen->StrokeTriangle(points[0], points[1], points[2],
bounds, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_TRIANGLE) {
offscreen->FillTriangle(points[0], points[1], points[2],
bounds, pattern);
} else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillTriangle(points[0], points[1], points[2],
bounds, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_LINE:
{
BPoint points[2];
if (message.ReadList(points, 2) != B_OK)
continue;
offscreen->StrokeLine(points[0], points[1], pattern);
BRect bounds = _BuildInvalidateRect(points, 2);
invalidRegion.Include(bounds.InsetBySelf(-penSize, -penSize));
break;
}
case RP_STROKE_LINE_ARRAY:
{
int32 numLines;
if (message.Read(numLines) != B_OK)
continue;
BRect bounds;
offscreen->BeginLineArray(numLines);
for (int32 i = 0; i < numLines; i++) {
rgb_color color;
BPoint start, end;
message.ReadArrayLine(start, end, color);
offscreen->AddLine(start, end, color);
bounds.left = min_c(bounds.left, min_c(start.x, end.x));
bounds.top = min_c(bounds.top, min_c(start.y, end.y));
bounds.right = max_c(bounds.right, max_c(start.x, end.x));
bounds.bottom = max_c(bounds.bottom, max_c(start.y, end.y));
}
offscreen->EndLineArray();
invalidRegion.Include(bounds);
break;
}
case RP_FILL_REGION:
case RP_FILL_REGION_GRADIENT:
{
BRegion region;
if (message.ReadRegion(region) != B_OK)
continue;
if (code == RP_FILL_REGION)
offscreen->FillRegion(®ion, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRegion(®ion, *gradient);
delete gradient;
}
invalidRegion.Include(®ion);
break;
}
case RP_STROKE_POINT_COLOR:
{
BPoint point;
rgb_color color;
message.Read(point);
if (message.Read(color) != B_OK)
continue;
rgb_color oldColor = offscreen->HighColor();
offscreen->SetHighColor(color);
offscreen->StrokeLine(point, point);
offscreen->SetHighColor(oldColor);
invalidRegion.Include(
BRect(point, point).InsetBySelf(-penSize, -penSize));
break;
}
case RP_STROKE_LINE_1PX_COLOR:
{
BPoint points[2];
rgb_color color;
message.ReadList(points, 2);
if (message.Read(color) != B_OK)
continue;
float oldSize = offscreen->PenSize();
rgb_color oldColor = offscreen->HighColor();
drawing_mode oldMode = offscreen->DrawingMode();
offscreen->SetPenSize(1);
offscreen->SetHighColor(color);
offscreen->SetDrawingMode(B_OP_OVER);
offscreen->StrokeLine(points[0], points[1]);
offscreen->SetDrawingMode(oldMode);
offscreen->SetHighColor(oldColor);
offscreen->SetPenSize(oldSize);
invalidRegion.Include(_BuildInvalidateRect(points, 2));
break;
}
case RP_STROKE_RECT_1PX_COLOR:
case RP_FILL_RECT_COLOR:
{
BRect rect;
rgb_color color;
message.Read(rect);
if (message.Read(color) != B_OK)
continue;
rgb_color oldColor = offscreen->HighColor();
offscreen->SetHighColor(color);
if (code == RP_STROKE_RECT_1PX_COLOR) {
float oldSize = PenSize();
offscreen->SetPenSize(1);
offscreen->StrokeRect(rect);
offscreen->SetPenSize(oldSize);
} else
offscreen->FillRect(rect);
offscreen->SetHighColor(oldColor);
invalidRegion.Include(rect);
break;
}
case RP_DRAW_STRING:
{
BPoint point;
size_t length;
char *string;
bool hasDelta;
message.Read(point);
message.ReadString(&string, length);
if (message.Read(hasDelta) != B_OK) {
free(string);
continue;
}
if (hasDelta) {
escapement_delta delta[length];
message.ReadList(delta, length);
offscreen->DrawString(string, point, delta);
} else
offscreen->DrawString(string, point);
free(string);
reply.Start(RP_DRAW_STRING_RESULT);
reply.Add(token);
reply.Add(offscreen->PenLocation());
reply.Flush();
font_height height;
offscreen->GetFontHeight(&height);
BRect bounds(point, offscreen->PenLocation());
bounds.top -= height.ascent;
bounds.bottom += height.descent;
invalidRegion.Include(bounds);
break;
}
case RP_READ_BITMAP:
{
BRect bounds;
bool drawCursor;
message.Read(bounds);
if (message.Read(drawCursor) != B_OK)
continue;
// TODO: support the drawCursor flag
BBitmap bitmap(bounds, B_BITMAP_NO_SERVER_LINK, B_RGB32);
bitmap.ImportBits(fOffscreenBitmap, bounds.LeftTop(),
BPoint(0, 0), bounds.IntegerWidth() + 1,
bounds.IntegerHeight() + 1);
reply.Start(RP_READ_BITMAP_RESULT);
reply.Add(token);
reply.AddBitmap(&bitmap);
reply.Flush();
break;
}
default:
TRACE_ERROR("unknown protocol code: %u\n", code);
break;
}
if (syncDrawing) {
offscreen->Sync();
Invalidate(&invalidRegion);
}
}
}
void release_escrow_operation::evaluate( transaction_evaluation_state& eval_state )
{ try {
FC_ASSERT( !"This operation is not enabled yet!" );
auto escrow_balance_record = eval_state._current_state->get_balance_record( this->escrow_id );
FC_ASSERT( escrow_balance_record.valid() );
if( !eval_state.check_signature( this->released_by ) )
FC_ASSERT( !"transaction not signed by releasor" );
auto escrow_condition = escrow_balance_record->condition.as<withdraw_with_escrow>();
auto total_released = amount_to_sender + amount_to_receiver;
FC_ASSERT( total_released <= escrow_balance_record->balance );
FC_ASSERT( total_released >= amount_to_sender ); // check for addition overflow
escrow_balance_record->balance -= total_released;
auto asset_rec = eval_state._current_state->get_asset_record( escrow_balance_record->condition.asset_id );
if( asset_rec->is_restricted() )
{
FC_ASSERT( eval_state._current_state->get_authorization( escrow_balance_record->condition.asset_id, escrow_condition.receiver ) );
}
if( asset_rec->is_retractable() )
{
if( eval_state.verify_authority( asset_rec->authority ) )
{
//
}
}
if( escrow_condition.sender == this->released_by )
{
FC_ASSERT( amount_to_sender == 0 );
FC_ASSERT( amount_to_receiver <= escrow_balance_record->balance );
if( !eval_state.check_signature( escrow_condition.sender ) )
FC_CAPTURE_AND_THROW( missing_signature, (escrow_condition.sender) );
balance_record new_balance_record( escrow_condition.receiver,
asset( amount_to_receiver, escrow_balance_record->asset_id() ),
escrow_balance_record->slate_id() );
auto current_receiver_balance = eval_state._current_state->get_balance_record( new_balance_record.id());
if( current_receiver_balance )
current_receiver_balance->balance += amount_to_receiver;
else
current_receiver_balance = new_balance_record;
eval_state._current_state->store_balance_record( *current_receiver_balance );
}
else if( escrow_condition.receiver == this->released_by )
{
FC_ASSERT( amount_to_receiver == 0 );
FC_ASSERT( amount_to_sender <= escrow_balance_record->balance );
if( !eval_state.check_signature( escrow_condition.receiver ) )
FC_CAPTURE_AND_THROW( missing_signature, (escrow_condition.receiver) );
balance_record new_balance_record( escrow_condition.sender,
asset( amount_to_sender, escrow_balance_record->asset_id() ),
escrow_balance_record->slate_id() );
auto current_sender_balance = eval_state._current_state->get_balance_record( new_balance_record.id());
if( current_sender_balance )
current_sender_balance->balance += amount_to_sender;
else
current_sender_balance = new_balance_record;
eval_state._current_state->store_balance_record( *current_sender_balance );
}
else if( escrow_condition.escrow == this->released_by )
{
if( !eval_state.check_signature( escrow_condition.escrow ) )
FC_CAPTURE_AND_THROW( missing_signature, (escrow_condition.escrow) );
// get a balance record for the receiver, create it if necessary and deposit funds
{
balance_record new_balance_record( escrow_condition.receiver,
asset( amount_to_receiver, escrow_balance_record->asset_id() ),
escrow_balance_record->slate_id() );
auto current_receiver_balance = eval_state._current_state->get_balance_record( new_balance_record.id());
if( current_receiver_balance )
current_receiver_balance->balance += amount_to_receiver;
else
current_receiver_balance = new_balance_record;
eval_state._current_state->store_balance_record( *current_receiver_balance );
}
// get a balance record for the sender, create it if necessary and deposit funds
{
balance_record new_balance_record( escrow_condition.sender,
asset( amount_to_sender, escrow_balance_record->asset_id() ),
escrow_balance_record->slate_id() );
auto current_sender_balance = eval_state._current_state->get_balance_record( new_balance_record.id());
if( current_sender_balance )
current_sender_balance->balance += amount_to_sender;
else
current_sender_balance = new_balance_record;
eval_state._current_state->store_balance_record( *current_sender_balance );
}
}
else if( address() == this->released_by )
{
if( !eval_state.check_signature( escrow_condition.sender ) )
FC_CAPTURE_AND_THROW( missing_signature, (escrow_condition.sender) );
if( !eval_state.check_signature( escrow_condition.receiver ) )
FC_CAPTURE_AND_THROW( missing_signature, (escrow_condition.receiver) );
// get a balance record for the receiver, create it if necessary and deposit funds
{
balance_record new_balance_record( escrow_condition.receiver,
asset( amount_to_receiver, escrow_balance_record->asset_id() ),
escrow_balance_record->slate_id() );
auto current_receiver_balance = eval_state._current_state->get_balance_record( new_balance_record.id());
if( current_receiver_balance )
current_receiver_balance->balance += amount_to_receiver;
else
current_receiver_balance = new_balance_record;
eval_state._current_state->store_balance_record( *current_receiver_balance );
}
// get a balance record for the sender, create it if necessary and deposit funds
{
balance_record new_balance_record( escrow_condition.sender,
asset( amount_to_sender, escrow_balance_record->asset_id() ),
escrow_balance_record->slate_id() );
auto current_sender_balance = eval_state._current_state->get_balance_record( new_balance_record.id());
if( current_sender_balance )
current_sender_balance->balance += amount_to_sender;
else
current_sender_balance = new_balance_record;
eval_state._current_state->store_balance_record( *current_sender_balance );
}
}
else
{
FC_ASSERT( !"not released by a party to the escrow transaction" );
}
eval_state._current_state->store_balance_record( *escrow_balance_record );
} FC_CAPTURE_AND_RETHROW( (*this) ) }
void
main(int argc, char *argv[])
{
char *p;
Sym *s;
Binit(&bso, 1, OWRITE);
listinit();
nerrors = 0;
outfile = "5.out";
HEADTYPE = -1;
INITTEXT = -1;
INITDAT = -1;
INITRND = -1;
INITENTRY = 0;
linkmode = LinkAuto;
nuxiinit();
p = getgoarm();
if(p != nil)
goarm = atoi(p);
else
goarm = 6;
if(goarm == 5)
debug['F'] = 1;
flagcount("1", "use alternate profiling code", &debug['1']);
flagfn1("B", "info: define ELF NT_GNU_BUILD_ID note", addbuildinfo);
flagstr("E", "sym: entry symbol", &INITENTRY);
flagint32("D", "addr: data address", &INITDAT);
flagcount("G", "debug pseudo-ops", &debug['G']);
flagfn1("I", "interp: set ELF interp", setinterp);
flagfn1("L", "dir: add dir to library path", Lflag);
flagfn1("H", "head: header type", setheadtype);
flagcount("K", "add stack underflow checks", &debug['K']);
flagcount("M", "disable software div/mod", &debug['M']);
flagcount("O", "print pc-line tables", &debug['O']);
flagcount("P", "debug code generation", &debug['P']);
flagint32("R", "rnd: address rounding", &INITRND);
flagint32("T", "addr: text address", &INITTEXT);
flagfn0("V", "print version and exit", doversion);
flagcount("W", "disassemble input", &debug['W']);
flagfn2("X", "name value: define string data", addstrdata);
flagcount("Z", "clear stack frame on entry", &debug['Z']);
flagcount("a", "disassemble output", &debug['a']);
flagcount("c", "dump call graph", &debug['c']);
flagcount("d", "disable dynamic executable", &debug['d']);
flagstr("extld", "linker to run in external mode", &extld);
flagstr("extldflags", "flags for external linker", &extldflags);
flagcount("f", "ignore version mismatch", &debug['f']);
flagcount("g", "disable go package data checks", &debug['g']);
flagstr("k", "sym: set field tracking symbol", &tracksym);
flagfn1("linkmode", "mode: set link mode (internal, external, auto)", setlinkmode);
flagcount("n", "dump symbol table", &debug['n']);
flagstr("o", "outfile: set output file", &outfile);
flagcount("p", "insert profiling code", &debug['p']);
flagstr("r", "dir1:dir2:...: set ELF dynamic linker search path", &rpath);
flagcount("race", "enable race detector", &flag_race);
flagcount("s", "disable symbol table", &debug['s']);
flagcount("shared", "generate shared object (implies -linkmode external)", &flag_shared);
flagstr("tmpdir", "leave temporary files in this directory", &tmpdir);
flagcount("u", "reject unsafe packages", &debug['u']);
flagcount("v", "print link trace", &debug['v']);
flagcount("w", "disable DWARF generation", &debug['w']);
flagparse(&argc, &argv, usage);
if(argc != 1)
usage();
if(flag_shared)
linkmode = LinkExternal;
mywhatsys();
if(HEADTYPE == -1)
HEADTYPE = headtype(goos);
// getgoextlinkenabled is based on GO_EXTLINK_ENABLED when
// Go was built; see ../../make.bash.
if(linkmode == LinkAuto && strcmp(getgoextlinkenabled(), "0") == 0)
linkmode = LinkInternal;
switch(HEADTYPE) {
default:
if(linkmode == LinkAuto)
linkmode = LinkInternal;
if(linkmode == LinkExternal && strcmp(getgoextlinkenabled(), "1") != 0)
sysfatal("cannot use -linkmode=external with -H %s", headstr(HEADTYPE));
break;
case Hlinux:
break;
}
libinit();
switch(HEADTYPE) {
default:
diag("unknown -H option");
errorexit();
case Hnoheader: /* no header */
HEADR = 0L;
if(INITTEXT == -1)
INITTEXT = 0;
if(INITDAT == -1)
INITDAT = 0;
if(INITRND == -1)
INITRND = 4;
break;
case Hrisc: /* aif for risc os */
HEADR = 128L;
if(INITTEXT == -1)
INITTEXT = 0x10005000 + HEADR;
if(INITDAT == -1)
INITDAT = 0;
if(INITRND == -1)
INITRND = 4;
break;
case Hplan9x32: /* plan 9 */
HEADR = 32L;
if(INITTEXT == -1)
INITTEXT = 4128;
if(INITDAT == -1)
INITDAT = 0;
if(INITRND == -1)
INITRND = 4096;
break;
case Hixp1200: /* boot for IXP1200 */
HEADR = 0L;
if(INITTEXT == -1)
INITTEXT = 0x0;
if(INITDAT == -1)
INITDAT = 0;
if(INITRND == -1)
INITRND = 4;
break;
case Hipaq: /* boot for ipaq */
HEADR = 16L;
if(INITTEXT == -1)
INITTEXT = 0xC0008010;
if(INITDAT == -1)
INITDAT = 0;
if(INITRND == -1)
INITRND = 1024;
break;
case Hlinux: /* arm elf */
case Hfreebsd:
case Hnetbsd:
debug['d'] = 0; // with dynamic linking
tlsoffset = -8; // hardcoded number, first 4-byte word for g, and then 4-byte word for m
// this number is known to ../../pkg/runtime/rt0_*_arm.s
elfinit();
HEADR = ELFRESERVE;
if(INITTEXT == -1)
INITTEXT = 0x10000 + HEADR;
if(INITDAT == -1)
INITDAT = 0;
if(INITRND == -1)
INITRND = 4096;
break;
}
if(INITDAT != 0 && INITRND != 0)
print("warning: -D0x%ux is ignored because of -R0x%ux\n",
INITDAT, INITRND);
if(debug['v'])
Bprint(&bso, "HEADER = -H0x%d -T0x%ux -D0x%ux -R0x%ux\n",
HEADTYPE, INITTEXT, INITDAT, INITRND);
Bflush(&bso);
zprg.as = AGOK;
zprg.scond = 14;
zprg.reg = NREG;
zprg.from.name = D_NONE;
zprg.from.type = D_NONE;
zprg.from.reg = NREG;
zprg.to = zprg.from;
buildop();
histgen = 0;
pc = 0;
dtype = 4;
version = 0;
cbp = buf.cbuf;
cbc = sizeof(buf.cbuf);
// embed goarm to runtime.goarm
s = lookup("runtime.goarm", 0);
s->dupok = 1;
adduint8(s, goarm);
addlibpath("command line", "command line", argv[0], "main");
loadlib();
// mark some functions that are only referenced after linker code editing
if(debug['F'])
mark(rlookup("_sfloat", 0));
mark(lookup("runtime.read_tls_fallback", 0));
deadcode();
if(textp == nil) {
diag("no code");
errorexit();
}
patch();
if(debug['p'])
if(debug['1'])
doprof1();
else
doprof2();
doelf();
follow();
softfloat();
// 5l -Z means zero the stack frame on entry.
// This slows down function calls but can help avoid
// false positives in garbage collection.
if(debug['Z'])
dozerostk();
noops(); // generate stack split prolog, handle div/mod, etc.
dostkcheck();
span();
addexport();
// textaddress() functionality is handled in span()
pclntab();
symtab();
dodata();
address();
doweak();
reloc();
asmb();
undef();
hostlink();
if(debug['c'])
print("ARM size = %d\n", armsize);
if(debug['v']) {
Bprint(&bso, "%5.2f cpu time\n", cputime());
Bprint(&bso, "%d sizeof adr\n", sizeof(Adr));
Bprint(&bso, "%d sizeof prog\n", sizeof(Prog));
}
Bflush(&bso);
errorexit();
}
int AppSettings::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 13)
qt_static_metacall(this, _c, _id, _a);
_id -= 13;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
*reinterpret_cast< QString*>(_v) = token();
break;
case 1:
*reinterpret_cast< QUrl*>(_v) = address();
break;
case 2:
*reinterpret_cast< QString*>(_v) = email();
break;
case 3:
*reinterpret_cast< QString*>(_v) = username();
break;
case 4:
*reinterpret_cast< QString*>(_v) = password();
break;
case 5:
*reinterpret_cast< QString*>(_v) = userid();
break;
}
_id -= 6;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
setToken(*reinterpret_cast< QString*>(_v));
break;
case 1:
setAddress(*reinterpret_cast< QUrl*>(_v));
break;
case 2:
setEmail(*reinterpret_cast< QString*>(_v));
break;
case 3:
setUsername(*reinterpret_cast< QString*>(_v));
break;
case 4:
setPassword(*reinterpret_cast< QString*>(_v));
break;
case 5:
setUserid(*reinterpret_cast< QString*>(_v));
break;
}
_id -= 6;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 6;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void networkDialog::setCurrentServer() {
if (ui->serversComboBox->currentIndex()>=0) {
QHostAddress address(ui->serversComboBox->currentText());
gpib->setServerAddress(address);
}
}
void CellmlFileRuntime::update()
{
// Reset the runtime's properties
reset(true, true);
// Check that the model is either a 'simple' ODE model or a DAE model
// Note #1: we don't check whether a model is valid, since all we want is to
// update its runtime (which has nothing to do with editing or even
// validating a model), so if it can be done then great otherwise
// tough luck (so to speak)...
// Note #2: in order to do so, we need to get a 'normal' code generator (as
// opposed to an IDA, i.e. DAE, code generator) since if the model
// is correctly constrained, then we can check whether some of its
// equations were flagged as needing a Newton-Raphson evaluation,
// in which case we would be dealing with a DAE model...
// Note #3: ideally, there would be a more convenient way to determine the
// type of a model, but there isn't...
iface::cellml_api::Model *model = mCellmlFile->model();
if (!model)
return;
// Retrieve the model's type
// Note: this can be done by checking whether some equations were flagged
// as needing a Newton-Raphson evaluation...
retrieveOdeCodeInformation(model);
if (!mOdeCodeInformation)
return;
ObjRef<iface::mathml_dom::MathMLNodeList> flaggedEquations = mOdeCodeInformation->flaggedEquations();
mModelType = flaggedEquations->length()?CellmlFileRuntime::Dae:CellmlFileRuntime::Ode;
// If the model is of DAE type, then we don't want the ODE-specific code
// information, but the DAE-specific code one
ObjRef<iface::cellml_services::CodeInformation> genericCodeInformation;
if (mModelType == CellmlFileRuntime::Ode) {
genericCodeInformation = mOdeCodeInformation;
} else {
retrieveDaeCodeInformation(model);
if (!mDaeCodeInformation)
return;
genericCodeInformation = mDaeCodeInformation;
}
// Retrieve the number of constants, states/rates, algebraic and conditional
// variables in the model
// Note: this is to avoid having to go through the ODE/DAE code information
// an unnecessary number of times when we want to retrieve either of
// those numbers (e.g. see
// SingleCellViewSimulationResults::addPoint())...
if (mModelType == CellmlFileRuntime::Ode) {
mConstantsCount = mOdeCodeInformation->constantIndexCount();
mStatesRatesCount = mOdeCodeInformation->rateIndexCount();
mAlgebraicCount = mOdeCodeInformation->algebraicIndexCount();
mCondVarCount = 0;
} else {
mConstantsCount = mDaeCodeInformation->constantIndexCount();
mStatesRatesCount = mDaeCodeInformation->rateIndexCount();
mAlgebraicCount = mDaeCodeInformation->algebraicIndexCount();
mCondVarCount = mDaeCodeInformation->conditionVariableCount();
}
// Retrieve all the parameters and sort them by component/variable name
ObjRef<iface::cellml_services::ComputationTargetIterator> computationTargetIter = genericCodeInformation->iterateTargets();
for (ObjRef<iface::cellml_services::ComputationTarget> computationTarget = computationTargetIter->nextComputationTarget();
computationTarget; computationTarget = computationTargetIter->nextComputationTarget()) {
// Determine the type of the parameter
ObjRef<iface::cellml_api::CellMLVariable> variable = computationTarget->variable();
CellmlFileRuntimeParameter::ParameterType parameterType;
switch (computationTarget->type()) {
case iface::cellml_services::VARIABLE_OF_INTEGRATION:
parameterType = CellmlFileRuntimeParameter::Voi;
break;
case iface::cellml_services::CONSTANT:
// We are dealing with a constant, but the question is whether that
// constant is a 'proper' constant, a 'computed' constant or even a
// rate, and this can be determined by checking whether the computed
// target has an initial value or even a degree
// Note: a state variable that is initialised using the initial
// value of another variable will have its rate considered as
// a constant. However, when it comes to the GUI, we really
// want it to be seen as a rate hence we check for the degree
// of the computed target...
if (QString::fromStdWString(variable->initialValue()).isEmpty()) {
// The computed target doesn't have an initial value, so it must
// be a 'computed' constant
parameterType = CellmlFileRuntimeParameter::ComputedConstant;
} else if (computationTarget->degree()) {
// The computed target has a degree, so it is effectively a rate
parameterType = CellmlFileRuntimeParameter::Rate;
} else {
// The computed target has an initial value, so it must be a
// 'proper' constant
parameterType = CellmlFileRuntimeParameter::Constant;
}
break;
case iface::cellml_services::STATE_VARIABLE:
case iface::cellml_services::PSEUDOSTATE_VARIABLE:
parameterType = CellmlFileRuntimeParameter::State;
break;
case iface::cellml_services::ALGEBRAIC:
// We are dealing with either a 'proper' algebraic variable or a
// rate variable
// Note: if the variable's degree is equal to zero, then we are
// dealing with a 'proper' algebraic variable otherwise we
// are dealing with a rate variable...
if (computationTarget->degree())
parameterType = CellmlFileRuntimeParameter::Rate;
else
parameterType = CellmlFileRuntimeParameter::Algebraic;
break;
case iface::cellml_services::FLOATING:
parameterType = CellmlFileRuntimeParameter::Floating;
break;
case iface::cellml_services::LOCALLY_BOUND:
parameterType = CellmlFileRuntimeParameter::LocallyBound;
break;
}
// Keep track of the parameter, should its type be of interest
if ( (parameterType != CellmlFileRuntimeParameter::Floating)
&& (parameterType != CellmlFileRuntimeParameter::LocallyBound)) {
CellmlFileRuntimeParameter *parameter = new CellmlFileRuntimeParameter(QString::fromStdWString(variable->name()),
computationTarget->degree(),
QString::fromStdWString(variable->unitsName()),
componentHierarchy(variable),
parameterType,
computationTarget->assignedIndex());
if (parameterType == CellmlFileRuntimeParameter::Voi)
mVariableOfIntegration = parameter;
mParameters.append(parameter);
}
}
std::sort(mParameters.begin(), mParameters.end(), sortParameters);
// Generate the model code, after having prepended to it all the external
// functions that may, or not, be needed
// Note: indeed, we cannot include header files since we don't (and don't
// want in order to avoid complications) deploy them with OpenCOR. So,
// instead, we must declare as external functions all the functions
// that we would normally use through header files...
QString modelCode = "extern double fabs(double);\n"
"\n"
"extern double exp(double);\n"
"extern double log(double);\n"
"\n"
"extern double ceil(double);\n"
"extern double floor(double);\n"
"\n"
"extern double factorial(double);\n"
"\n"
"extern double sin(double);\n"
"extern double cos(double);\n"
"extern double tan(double);\n"
"extern double sinh(double);\n"
"extern double cosh(double);\n"
"extern double tanh(double);\n"
"extern double asin(double);\n"
"extern double acos(double);\n"
"extern double atan(double);\n"
"extern double asinh(double);\n"
"extern double acosh(double);\n"
"extern double atanh(double);\n"
"\n"
"extern double arbitrary_log(double, double);\n"
"\n"
"extern double pow(double, double);\n"
"\n"
"extern double gcd_multi(int, ...);\n"
"extern double lcm_multi(int, ...);\n"
"extern double multi_max(int, ...);\n"
"extern double multi_min(int, ...);\n"
"\n";
QString functionsString = QString::fromStdWString(genericCodeInformation->functionsString());
if (!functionsString.isEmpty()) {
// We will need to solve at least one NLA system
mAtLeastOneNlaSystem = true;
modelCode += "struct rootfind_info\n"
"{\n"
" double aVOI;\n"
"\n"
" double *aCONSTANTS;\n"
" double *aRATES;\n"
" double *aSTATES;\n"
" double *aALGEBRAIC;\n"
"\n"
" int *aPRET;\n"
"};\n"
"\n"
"extern void doNonLinearSolve(char *, void (*)(double *, double *, void*), double *, int *, int, void *);\n"
"\n"
+functionsString.replace("do_nonlinearsolve(", QString("doNonLinearSolve(\"%1\", ").arg(address()))
+"\n";
// Note: we rename do_nonlinearsolve() to doNonLinearSolve() because
// CellML's CIS service already defines do_nonlinearsolve(), yet
// we want to use our own non-linear solve routine defined in our
// Compiler plugin. Also, we add a new parameter to all our calls
// to doNonLinearSolve() so that doNonLinearSolve() can retrieve
// the correct instance of our NLA solver...
}
// Retrieve the body of the function that initialises constants and extract
// the statements that are related to computed variables (since we want to
// be able to recompute those whenever the user modifies a parameter)
// Note: ideally, we wouldn't have to do that, but the CellML API doesn't
// distinguish between 'proper' and 'computed' constants...
// (See https://tracker.physiomeproject.org/show_bug.cgi?id=3499)
static const QRegularExpression InitializationStatementRegEx = QRegularExpression("^(CONSTANTS|RATES|STATES)\\[\\d*\\] = [+-]?\\d*\\.?\\d+([eE][+-]?\\d+)?;$");
QStringList initConstsList = QString::fromStdWString(genericCodeInformation->initConstsString()).split("\r\n");
QString initConsts = QString();
QString compCompConsts = QString();
foreach (const QString &initConst, initConstsList) {
// Add the statement either to our list of 'proper' constants or
// 'computed' constants
if (InitializationStatementRegEx.match(initConst).hasMatch()) {
// We are dealing with a 'proper' constant (or a rate or a state)
if (!initConsts.isEmpty())
initConsts += "\n";
initConsts += initConst;
} else {
// We are dealing with a 'computed' constant
if (!compCompConsts.isEmpty())
compCompConsts += "\n";
compCompConsts += initConst;
}
}
modelCode += functionCode("int initializeConstants(double *CONSTANTS, double *RATES, double *STATES)",
initConsts, true);
modelCode += "\n";
modelCode += functionCode("int computeComputedConstants(double *CONSTANTS, double *RATES, double *STATES)",
compCompConsts, true);
modelCode += "\n";
// Retrieve the body of the remaining functions
if (mModelType == CellmlFileRuntime::Ode) {
modelCode += functionCode("int computeOdeRates(double VOI, double *CONSTANTS, double *RATES, double *STATES, double *ALGEBRAIC)",
QString::fromStdWString(mOdeCodeInformation->ratesString()));
modelCode += "\n";
modelCode += functionCode("int computeOdeVariables(double VOI, double *CONSTANTS, double *RATES, double *STATES, double *ALGEBRAIC)",
QString::fromStdWString(genericCodeInformation->variablesString()));
} else {
modelCode += functionCode("int computeDaeEssentialVariables(double VOI, double *CONSTANTS, double *RATES, double *OLDRATES, double *STATES, double *OLDSTATES, double *ALGEBRAIC, double *CONDVAR)",
QString::fromStdWString(mDaeCodeInformation->essentialVariablesString()));
modelCode += "\n";
modelCode += functionCode("int computeDaeResiduals(double VOI, double *CONSTANTS, double *RATES, double *OLDRATES, double *STATES, double *OLDSTATES, double *ALGEBRAIC, double *CONDVAR, double *resid)",
QString::fromStdWString(mDaeCodeInformation->ratesString()));
modelCode += "\n";
modelCode += functionCode("int computeDaeRootInformation(double VOI, double *CONSTANTS, double *RATES, double *OLDRATES, double *STATES, double *OLDSTATES, double *ALGEBRAIC, double *CONDVAR)",
QString::fromStdWString(mDaeCodeInformation->rootInformationString()));
modelCode += functionCode("int computeDaeStateInformation(double *SI)",
QString::fromStdWString(mDaeCodeInformation->stateInformationString()));
modelCode += "\n";
modelCode += functionCode("int computeDaeVariables(double VOI, double *CONSTANTS, double *RATES, double *STATES, double *ALGEBRAIC, double *CONDVAR)",
QString::fromStdWString(genericCodeInformation->variablesString()));
}
// Check whether the model code contains a definite integral, otherwise
// compute it and check that everything went fine
if (modelCode.contains("defint(func")) {
mIssues << CellmlFileIssue(CellmlFileIssue::Error,
QObject::tr("definite integrals are not yet supported"));
} else if (!mCompilerEngine->compileCode(modelCode)) {
mIssues << CellmlFileIssue(CellmlFileIssue::Error,
QString("%1").arg(mCompilerEngine->error()));
}
// Keep track of the ODE/DAE functions, but only if no issues were reported
if (mIssues.count()) {
reset(true, false);
} else {
// Add the symbol of any required external function, if any
if (mAtLeastOneNlaSystem)
llvm::sys::DynamicLibrary::AddSymbol("doNonLinearSolve",
(void *) (intptr_t) doNonLinearSolve);
// Retrieve the ODE/DAE functions
mInitializeConstants = (InitializeConstantsFunction) (intptr_t) mCompilerEngine->getFunction("initializeConstants");
mComputeComputedConstants = (ComputeComputedConstantsFunction) (intptr_t) mCompilerEngine->getFunction("computeComputedConstants");
if (mModelType == CellmlFileRuntime::Ode) {
mComputeOdeRates = (ComputeOdeRatesFunction) (intptr_t) mCompilerEngine->getFunction("computeOdeRates");
mComputeOdeVariables = (ComputeOdeVariablesFunction) (intptr_t) mCompilerEngine->getFunction("computeOdeVariables");
} else {
mComputeDaeEssentialVariables = (ComputeDaeEssentialVariablesFunction) (intptr_t) mCompilerEngine->getFunction("computeDaeEssentialVariables");
mComputeDaeResiduals = (ComputeDaeResidualsFunction) (intptr_t) mCompilerEngine->getFunction("computeDaeResiduals");
mComputeDaeRootInformation = (ComputeDaeRootInformationFunction) (intptr_t) mCompilerEngine->getFunction("computeDaeRootInformation");
mComputeDaeStateInformation = (ComputeDaeStateInformationFunction) (intptr_t) mCompilerEngine->getFunction("computeDaeStateInformation");
mComputeDaeVariables = (ComputeDaeVariablesFunction) (intptr_t) mCompilerEngine->getFunction("computeDaeVariables");
}
// Make sure that we managed to retrieve all the ODE/DAE functions
bool functionsOk = mInitializeConstants
&& mComputeComputedConstants;
if (mModelType == CellmlFileRuntime::Ode) {
functionsOk = functionsOk
&& mComputeOdeRates
&& mComputeOdeVariables;
} else {
functionsOk = functionsOk
&& mComputeDaeEssentialVariables
&& mComputeDaeResiduals
&& mComputeDaeRootInformation
&& mComputeDaeStateInformation
&& mComputeDaeVariables;
}
if (!functionsOk) {
mIssues << CellmlFileIssue(CellmlFileIssue::Error,
QObject::tr("an unexpected problem occurred while trying to retrieve the model functions"));
reset(true, false);
}
}
}
/*----------------------------------------------------------------------
| PLT_SsdpSearchTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_SsdpSearchTask::DoRun()
{
NPT_HttpResponse* response = NULL;
NPT_Timeout timeout = 30000;
NPT_HttpRequestContext context;
do {
// get the address of the server
NPT_IpAddress server_address;
NPT_CHECK_LABEL_SEVERE(server_address.ResolveName(
m_Request->GetUrl().GetHost(),
timeout),
done);
NPT_SocketAddress address(server_address,
m_Request->GetUrl().GetPort());
// send 2 requests in a row
NPT_OutputStreamReference output_stream(
new PLT_OutputDatagramStream(m_Socket,
4096,
&address));
NPT_CHECK_LABEL_SEVERE(NPT_HttpClient::WriteRequest(
*output_stream.AsPointer(),
*m_Request,
false),
done);
NPT_CHECK_LABEL_SEVERE(NPT_HttpClient::WriteRequest(
*output_stream.AsPointer(),
*m_Request,
false),
done);
output_stream = NULL;
// keep track of when we sent the request
NPT_TimeStamp last_send;
NPT_System::GetCurrentTimeStamp(last_send);
while (!IsAborting(0)) {
// read response
PLT_InputDatagramStreamReference input_stream(
new PLT_InputDatagramStream(m_Socket));
NPT_InputStreamReference stream = input_stream;
NPT_Result res = NPT_HttpClient::ReadResponse(
stream,
false,
false,
response);
// callback to process response
if (NPT_SUCCEEDED(res)) {
// get source info
NPT_SocketInfo info;
input_stream->GetInfo(info);
context.SetLocalAddress(info.local_address);
context.SetRemoteAddress(info.remote_address);
// process response
ProcessResponse(NPT_SUCCESS, *m_Request, context, response);
delete response;
response = NULL;
} else if (res != NPT_ERROR_TIMEOUT) {
NPT_LOG_WARNING_1("PLT_SsdpSearchTask got an error (%d) waiting for response", res);
NPT_System::Sleep(NPT_TimeInterval(.5f));
}
input_stream = NULL;
// check if it's time to resend request
NPT_TimeStamp now;
NPT_System::GetCurrentTimeStamp(now);
if (now >= last_send + m_Frequency)
break;
}
} while (!IsAborting(0) && m_Repeat);
done:
return;
}
void address(std::string const &a)
{
address(boost::asio::ip::address::from_string(a));
}
static bool address_salt(ek_salt& salt, const ec_compressed& point,
uint8_t version, bool compressed)
{
payment_address address({ point, compressed }, version);
return address ? address_salt(salt, address) : false;
}
void ServerSocket::bind(Poco::UInt16 port, bool reuseAddress)
{
IPAddress wildcardAddr;
SocketAddress address(wildcardAddr, port);
impl()->bind(address, reuseAddress);
}
extern "C" JNIEXPORT int
JVM_handle_linux_signal(int sig,
siginfo_t* info,
void* ucVoid,
int abort_if_unrecognized) {
// in fact this isn't ucontext_t* at all, but struct sigcontext*
// but Linux porting layer uses ucontext_t, so to minimize code change
// we cast as needed
ucontext_t* ucFake = (ucontext_t*) ucVoid;
sigcontext* uc = (sigcontext*)ucVoid;
Thread* t = ThreadLocalStorage::get_thread_slow();
// Must do this before SignalHandlerMark, if crash protection installed we will longjmp away
// (no destructors can be run)
os::WatcherThreadCrashProtection::check_crash_protection(sig, t);
SignalHandlerMark shm(t);
// Note: it's not uncommon that JNI code uses signal/sigset to install
// then restore certain signal handler (e.g. to temporarily block SIGPIPE,
// or have a SIGILL handler when detecting CPU type). When that happens,
// JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To
// avoid unnecessary crash when libjsig is not preloaded, try handle signals
// that do not require siginfo/ucontext first.
if (sig == SIGPIPE || sig == SIGXFSZ) {
// allow chained handler to go first
if (os::Linux::chained_handler(sig, info, ucVoid)) {
return true;
} else {
if (PrintMiscellaneous && (WizardMode || Verbose)) {
char buf[64];
warning("Ignoring %s - see bugs 4229104 or 646499219",
os::exception_name(sig, buf, sizeof(buf)));
}
return true;
}
}
JavaThread* thread = NULL;
VMThread* vmthread = NULL;
if (os::Linux::signal_handlers_are_installed) {
if (t != NULL ){
if(t->is_Java_thread()) {
thread = (JavaThread*)t;
}
else if(t->is_VM_thread()){
vmthread = (VMThread *)t;
}
}
}
// decide if this trap can be handled by a stub
address stub = NULL;
address pc = NULL;
address npc = NULL;
//%note os_trap_1
if (info != NULL && uc != NULL && thread != NULL) {
pc = address(SIG_PC(uc));
npc = address(SIG_NPC(uc));
// Check to see if we caught the safepoint code in the
// process of write protecting the memory serialization page.
// It write enables the page immediately after protecting it
// so we can just return to retry the write.
if ((sig == SIGSEGV) && checkSerializePage(thread, (address)info->si_addr)) {
// Block current thread until the memory serialize page permission restored.
os::block_on_serialize_page_trap();
return 1;
}
if (checkPrefetch(uc, pc)) {
return 1;
}
// Handle ALL stack overflow variations here
if (sig == SIGSEGV) {
if (checkOverflow(uc, pc, (address)info->si_addr, thread, &stub)) {
return 1;
}
}
if (sig == SIGBUS &&
thread->thread_state() == _thread_in_vm &&
thread->doing_unsafe_access()) {
stub = StubRoutines::handler_for_unsafe_access();
}
if (thread->thread_state() == _thread_in_Java) {
do {
// Java thread running in Java code => find exception handler if any
// a fault inside compiled code, the interpreter, or a stub
if ((sig == SIGSEGV) && checkPollingPage(pc, (address)info->si_addr, &stub)) {
break;
}
if ((sig == SIGBUS) && checkByteBuffer(pc, &stub)) {
break;
}
if ((sig == SIGSEGV || sig == SIGBUS) &&
checkVerifyOops(pc, (address)info->si_addr, &stub)) {
break;
}
if ((sig == SIGSEGV) && checkZombie(uc, &pc, &stub)) {
break;
}
if ((sig == SIGILL) && checkICMiss(uc, &pc, &stub)) {
break;
}
if ((sig == SIGFPE) && checkFPFault(pc, info->si_code, thread, &stub)) {
break;
}
if ((sig == SIGSEGV) &&
checkNullPointer(pc, (intptr_t)info->si_addr, thread, &stub)) {
break;
}
} while (0);
// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in
// and the heap gets shrunk before the field access.
if ((sig == SIGSEGV) || (sig == SIGBUS)) {
checkFastJNIAccess(pc, &stub);
}
}
if (stub != NULL) {
// save all thread context in case we need to restore it
thread->set_saved_exception_pc(pc);
thread->set_saved_exception_npc(npc);
os::Linux::ucontext_set_pc((ucontext_t*)uc, stub);
return true;
}
}
// signal-chaining
if (os::Linux::chained_handler(sig, info, ucVoid)) {
return true;
}
if (!abort_if_unrecognized) {
// caller wants another chance, so give it to him
return false;
}
if (pc == NULL && uc != NULL) {
pc = os::Linux::ucontext_get_pc((ucontext_t*)uc);
}
// unmask current signal
sigset_t newset;
sigemptyset(&newset);
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
ShouldNotReachHere();
}
void ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool ipV6Only)
{
IPAddress wildcardAddr(IPAddress::IPv6);
SocketAddress address(wildcardAddr, port);
impl()->bind6(address, reuseAddress, ipV6Only);
}
operator address()const { return address(pub_key); }
UniValue getaddednodeinfo(const JSONRPCRequest& request)
{
if (request.fHelp || request.params.size() > 1)
throw std::runtime_error(
"getaddednodeinfo ( \"node\" )\n"
"\nReturns information about the given added node, or all added nodes\n"
"(note that onetry addnodes are not listed here)\n"
"\nArguments:\n"
"1. \"node\" (string, optional) If provided, return information about this specific node, otherwise all nodes are returned.\n"
"\nResult:\n"
"[\n"
" {\n"
" \"addednode\" : \"192.168.0.201\", (string) The node IP address or name (as provided to addnode)\n"
" \"connected\" : true|false, (boolean) If connected\n"
" \"addresses\" : [ (list of objects) Only when connected = true\n"
" {\n"
" \"address\" : \"192.168.0.201:8333\", (string) The bitcoin server IP and port we're connected to\n"
" \"connected\" : \"outbound\" (string) connection, inbound or outbound\n"
" }\n"
" ]\n"
" }\n"
" ,...\n"
"]\n"
"\nExamples:\n"
+ HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"")
+ HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")
);
if(!g_connman)
throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
std::vector<AddedNodeInfo> vInfo = g_connman->GetAddedNodeInfo();
if (!request.params[0].isNull()) {
bool found = false;
for (const AddedNodeInfo& info : vInfo) {
if (info.strAddedNode == request.params[0].get_str()) {
vInfo.assign(1, info);
found = true;
break;
}
}
if (!found) {
throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
}
}
UniValue ret(UniValue::VARR);
for (const AddedNodeInfo& info : vInfo) {
UniValue obj(UniValue::VOBJ);
obj.pushKV("addednode", info.strAddedNode);
obj.pushKV("connected", info.fConnected);
UniValue addresses(UniValue::VARR);
if (info.fConnected) {
UniValue address(UniValue::VOBJ);
address.pushKV("address", info.resolvedAddress.ToString());
address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
addresses.push_back(address);
}
obj.pushKV("addresses", addresses);
ret.push_back(obj);
}
return ret;
}
Node::Node(string name) throw (myExceptions){
int shmid, datagramport = -1, streamport, identifier, count;
char folder[100];
struct dirent **files;
struct data *d;
myExceptions e;
if ((shmid = shmget(KEY, 200, 0666)) == -1) {
shmid = shmget(KEY, 200, 0666 | IPC_CREAT);
if ((d = (struct data*)shmat(shmid, 0, 0)) == NULL) {
perror("attach");
e.setmsg("Error in shared memory attachment");
throw e;
}
d->portlist[0][0] = 10000; d->portlist[0][1] = 1;
d->portlist[1][0] = 10002; d->portlist[1][1] = 0;
d->portlist[2][0] = 10004; d->portlist[2][1] = 0;
d->portlist[3][0] = 10006; d->portlist[3][1] = 0;
d->portlist[4][0] = 10008; d->portlist[4][1] = 0;
d->portlist[5][0] = 10010; d->portlist[5][1] = 0;
d->portlist[6][0] = 10012; d->portlist[6][1] = 0;
d->portlist[7][0] = 10014; d->portlist[7][1] = 0;
d->portlist[8][0] = 10016; d->portlist[8][1] = 0;
d->portlist[9][0] = 10018; d->portlist[9][1] = 0;
d->port = datagramport = 10000;
strcpy(d->name, (char*)name.c_str());
}
else {
if ((d = (struct data*)shmat(shmid, 0, 0)) == NULL) {
perror("attach");
e.setmsg("Error in shared memory attachment");
throw e;
}
for (int i = 0; i < 10; ++i) {
if (d->portlist[i][1] == 0) {
datagramport = d->portlist[i][0];
d->portlist[i][1] = 1;
break;
}
}
}
streamport = datagramport + 1;
identifier = dohash(datagramport);
enode = address(dohash(d->port), d->port, d->name);
node = address(identifier, datagramport, name);
datagram = Connect(DATAGRAM, datagramport);
stream = Connect(STREAM, streamport);
sprintf(folder, "/Users/Sabyasachee/%d", datagramport);
strcat(folder, "shared");
if (access(folder, F_OK) != 0) {
if (mkdir(folder, 0777) == -1) {
perror("mkdir");
e.setmsg("Error in creating directory");
throw e;
}
}
count = scandir(folder, &files, file_select, alphasort);
for (int i = 0; i < count; ++i) {
filelist.push_back(files[i]->d_name);
}
state = NEW;
shmdt(d);
}
QString Fixture::status() const
{
QString info;
QString t;
QString title("<TR><TD CLASS='hilite' COLSPAN='3'>%1</TD></TR>");
QString subTitle("<TR><TD CLASS='subhi' COLSPAN='3'>%1</TD></TR>");
QString genInfo("<TR><TD CLASS='emphasis'>%1</TD><TD COLSPAN='2'>%2</TD></TR>");
/********************************************************************
* General info
********************************************************************/
info += "<TABLE COLS='3' WIDTH='100%'>";
// Fixture title
info += title.arg(name());
// Manufacturer
if (isDimmer() == false)
{
info += genInfo.arg(tr("Manufacturer")).arg(m_fixtureDef->manufacturer());
info += genInfo.arg(tr("Model")).arg(m_fixtureDef->model());
info += genInfo.arg(tr("Mode")).arg(m_fixtureMode->name());
info += genInfo.arg(tr("Type")).arg(m_fixtureDef->type());
}
else
{
info += genInfo.arg(tr("Type")).arg(tr("Generic Dimmer"));
}
// Universe
info += genInfo.arg(tr("Universe")).arg(universe() + 1);
// Address
QString range = QString("%1 - %2").arg(address() + 1).arg(address() + channels());
info += genInfo.arg(tr("Address Range")).arg(range);
// Channels
info += genInfo.arg(tr("Channels")).arg(channels());
// Binary address
QString binaryStr = QString("%1").arg(address() + 1, 10, 2, QChar('0'));
QString dipTable("<TABLE COLS='33' cellspacing='0'><TR><TD COLSPAN='33'><IMG SRC=\"" ":/ds_top.png\"></TD></TR>");
dipTable += "<TR><TD><IMG SRC=\"" ":/ds_border.png\"></TD><TD><IMG SRC=\"" ":/ds_border.png\"></TD>";
for (int i = 9; i >= 0; i--)
{
if (binaryStr.at(i) == '0')
dipTable += "<TD COLSPAN='3'><IMG SRC=\"" ":/ds_off.png\"></TD>";
else
dipTable += "<TD COLSPAN='3'><IMG SRC=\"" ":/ds_on.png\"></TD>";
}
dipTable += "<TD><IMG SRC=\"" ":/ds_border.png\"></TD></TR>";
dipTable += "<TR><TD COLSPAN='33'><IMG SRC=\"" ":/ds_bottom.png\"></TD></TR>";
dipTable += "</TABLE>";
info += genInfo.arg(tr("Binary Address (DIP)"))
.arg(QString("%1").arg(dipTable));
/********************************************************************
* Channels
********************************************************************/
// Title row
info += QString("<TR><TD CLASS='subhi'>%1</TD>").arg(tr("Channel"));
info += QString("<TD CLASS='subhi'>%1</TD>").arg(tr("DMX"));
info += QString("<TD CLASS='subhi'>%1</TD></TR>").arg(tr("Name"));
// Fill table with the fixture's channels
for (quint32 ch = 0; ch < channels(); ch++)
{
QString chInfo("<TR><TD>%1</TD><TD>%2</TD><TD>%3</TD></TR>");
info += chInfo.arg(ch + 1).arg(address() + ch + 1)
.arg(channel(ch)->name());
}
/********************************************************************
* Extended device information for non-dimmers
********************************************************************/
if (isDimmer() == false)
{
QLCPhysical physical = m_fixtureMode->physical();
info += title.arg(tr("Physical"));
float mmInch = 0.0393700787;
float kgLbs = 2.20462262;
QString mm("%1mm (%2\")");
QString kg("%1kg (%2 lbs)");
QString W("%1W");
info += genInfo.arg(tr("Width")).arg(mm.arg(physical.width()))
.arg(physical.width() * mmInch, 0, 'g', 4);
info += genInfo.arg(tr("Height")).arg(mm.arg(physical.height()))
.arg(physical.height() * mmInch, 0, 'g', 4);
info += genInfo.arg(tr("Depth")).arg(mm.arg(physical.depth()))
.arg(physical.depth() * mmInch, 0, 'g', 4);
info += genInfo.arg(tr("Weight")).arg(kg.arg(physical.weight()))
.arg(physical.weight() * kgLbs, 0, 'g', 4);
info += genInfo.arg(tr("Power consumption")).arg(W.arg(physical.powerConsumption()));
info += genInfo.arg(tr("DMX Connector")).arg(physical.dmxConnector());
// Bulb
QString K("%1K");
QString lm("%1lm");
info += subTitle.arg(tr("Bulb"));
info += genInfo.arg(tr("Type")).arg(physical.bulbType());
info += genInfo.arg(tr("Luminous Flux")).arg(lm.arg(physical.bulbLumens()));
info += genInfo.arg(tr("Colour Temperature")).arg(K.arg(physical.bulbColourTemperature()));
// Lens
QString angle1("%1°");
QString angle2("%1° – %2°");
info += subTitle.arg(tr("Lens"));
info += genInfo.arg(tr("Name")).arg(physical.lensName());
if (physical.lensDegreesMin() == physical.lensDegreesMax())
{
info += genInfo.arg(tr("Beam Angle"))
.arg(angle1.arg(physical.lensDegreesMin()));
}
else
{
info += genInfo.arg(tr("Beam Angle"))
.arg(angle2.arg(physical.lensDegreesMin())
.arg(physical.lensDegreesMax()));
}
// Focus
QString range("%1°");
info += subTitle.arg(tr("Focus"));
info += genInfo.arg(tr("Type")).arg(physical.focusType());
info += genInfo.arg(tr("Pan Range")).arg(range.arg(physical.focusPanMax()));
info += genInfo.arg(tr("Tilt Range")).arg(range.arg(physical.focusTiltMax()));
}
// HTML document & table closure
info += "</TABLE>";
if (isDimmer() == false)
{
info += "<HR>";
info += "<DIV CLASS='author' ALIGN='right'>";
info += tr("Fixture definition author: ") + fixtureDef()->author();
info += "</DIV>";
}
return info;
}
/** \brief Thread function checking if data is received.
* This function tries to get data from network low-level functions as
* often as possible. When something is received, it generates an
* event and passes it to the Network Manager.
* \param self : used to pass the ENet host to the function.
*/
void* STKHost::mainLoop(void* self)
{
VS::setThreadName("STKHost");
ENetEvent event;
STKHost* myself = (STKHost*)(self);
ENetHost* host = myself->m_network->getENetHost();
if(NetworkConfig::get()->isServer() &&
NetworkConfig::get()->isLAN() )
{
TransportAddress address(0, 2757);
ENetAddress eaddr = address.toEnetAddress();
myself->m_lan_network = new Network(1, 1, 0, 0, &eaddr);
}
while (!myself->mustStopListening())
{
if(myself->m_lan_network)
{
myself->handleLANRequests();
} // if discovery host
while (enet_host_service(host, &event, 20) != 0)
{
if (event.type == ENET_EVENT_TYPE_NONE)
continue;
// Create an STKEvent with the event data. This will also
// create the peer if it doesn't exist already
Event* stk_event = new Event(&event);
if (stk_event->getType() == EVENT_TYPE_MESSAGE)
Network::logPacket(stk_event->data(), true);
Log::verbose("STKHost", "Event of type %d received",
(int)(stk_event->getType()));
STKPeer* peer = stk_event->getPeer();
if (stk_event->getType() == EVENT_TYPE_CONNECTED)
{
Log::info("STKHost", "A client has just connected. There are "
"now %lu peers.", myself->m_peers.size());
Log::debug("STKHost", "Addresses are : %lx, %lx",
stk_event->getPeer(), peer);
} // EVENT_TYPE_CONNECTED
else if (stk_event->getType() == EVENT_TYPE_MESSAGE)
{
TransportAddress stk_addr(peer->getAddress());
Log::verbose("NetworkManager",
"Message, Sender : %s, message = \"%s\"",
stk_addr.toString(/*show port*/false).c_str(),
stk_event->data().std_string().c_str());
} // if message event
// notify for the event now.
ProtocolManager::getInstance()->propagateEvent(stk_event);
} // while enet_host_service
} // while !mustStopListening
free(myself->m_listening_thread);
myself->m_listening_thread = NULL;
Log::info("STKHost", "Listening has been stopped");
return NULL;
} // mainLoop
bool Fixture::saveXML(QDomDocument* doc, QDomElement* wksp_root) const
{
QDomElement root;
QDomElement tag;
QDomText text;
QString str;
Q_ASSERT(doc != NULL);
/* Fixture Instance entry */
root = doc->createElement(KXMLFixture);
wksp_root->appendChild(root);
/* Manufacturer */
tag = doc->createElement(KXMLQLCFixtureDefManufacturer);
root.appendChild(tag);
if (m_fixtureDef != NULL)
text = doc->createTextNode(m_fixtureDef->manufacturer());
else
text = doc->createTextNode(KXMLFixtureGeneric);
tag.appendChild(text);
/* Model */
tag = doc->createElement(KXMLQLCFixtureDefModel);
root.appendChild(tag);
if (m_fixtureDef != NULL)
text = doc->createTextNode(m_fixtureDef->model());
else
text = doc->createTextNode(KXMLFixtureGeneric);
tag.appendChild(text);
/* Fixture mode */
tag = doc->createElement(KXMLQLCFixtureMode);
root.appendChild(tag);
if (m_fixtureMode != NULL)
text = doc->createTextNode(m_fixtureMode->name());
else
text = doc->createTextNode(KXMLFixtureGeneric);
tag.appendChild(text);
/* RGB Panel physical dimensions */
if (m_fixtureDef != NULL && m_fixtureDef->model() == KXMLFixtureRGBPanel && m_fixtureMode != NULL)
{
tag = doc->createElement(KXMLQLCPhysicalDimensionsWeight);
root.appendChild(tag);
text = doc->createTextNode(QString::number(m_fixtureMode->physical().width()));
tag.appendChild(text);
tag = doc->createElement(KXMLQLCPhysicalDimensionsHeight);
root.appendChild(tag);
text = doc->createTextNode(QString::number(m_fixtureMode->physical().height()));
tag.appendChild(text);
}
/* ID */
tag = doc->createElement(KXMLFixtureID);
root.appendChild(tag);
str.setNum(id());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Name */
tag = doc->createElement(KXMLFixtureName);
root.appendChild(tag);
text = doc->createTextNode(m_name);
tag.appendChild(text);
/* Universe */
tag = doc->createElement(KXMLFixtureUniverse);
root.appendChild(tag);
str.setNum(universe());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Address */
tag = doc->createElement(KXMLFixtureAddress);
root.appendChild(tag);
str.setNum(address());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Channel count */
tag = doc->createElement(KXMLFixtureChannels);
root.appendChild(tag);
str.setNum(channels());
text = doc->createTextNode(str);
tag.appendChild(text);
if (m_excludeFadeIndices.count() > 0)
{
tag = doc->createElement(KXMLFixtureExcludeFade);
root.appendChild(tag);
QString list;
for (int i = 0; i < m_excludeFadeIndices.count(); i++)
{
if (list.isEmpty() == false)
list.append(QString(","));
list.append(QString("%1").arg(m_excludeFadeIndices.at(i)));
}
text = doc->createTextNode(list);
tag.appendChild(text);
}
if (m_forcedHTPIndices.count() > 0)
{
tag = doc->createElement(KXMLFixtureForcedHTP);
root.appendChild(tag);
QString list;
for (int i = 0; i < m_forcedHTPIndices.count(); i++)
{
if (list.isEmpty() == false)
list.append(QString(","));
list.append(QString("%1").arg(m_forcedHTPIndices.at(i)));
}
text = doc->createTextNode(list);
tag.appendChild(text);
}
if (m_forcedLTPIndices.count() > 0)
{
tag = doc->createElement(KXMLFixtureForcedLTP);
root.appendChild(tag);
QString list;
for (int i = 0; i < m_forcedLTPIndices.count(); i++)
{
if (list.isEmpty() == false)
list.append(QString(","));
list.append(QString("%1").arg(m_forcedLTPIndices.at(i)));
}
text = doc->createTextNode(list);
tag.appendChild(text);
}
if (m_channelModifiers.isEmpty() == false)
{
QHashIterator<quint32, ChannelModifier *> it(m_channelModifiers);
while (it.hasNext())
{
it.next();
quint32 ch = it.key();
ChannelModifier *mod = it.value();
if (mod != NULL)
{
tag = doc->createElement(KXMLFixtureChannelModifier);
tag.setAttribute(KXMLFixtureChannelIndex, ch);
tag.setAttribute(KXMLFixtureModifierName, mod->name());
root.appendChild(tag);
}
}
}
return true;
}
void dummy_server_process(const accept_server_socket_ret_t &sock,
const LIBCXX_NAMESPACE::fd &terminator,
bool passive,
bool ignore_port=false)
{
auto sock_terminated=
LIBCXX_NAMESPACE::fdtimeoutconfig::terminate_fd(terminator)
(sock.first);
auto stream=sock_terminated->getiostream();
std::string cmd,line;
LIBCXX_NAMESPACE::fdptr dataconn;
LIBCXX_NAMESPACE::sockaddrptr dataconnaddr;
LIBCXX_NAMESPACE::fdptr openconn;
bool received_allo=false;
auto make_conn=[&]
{
if (!dataconn.null())
{
LIBCXX_NAMESPACE::fd newsock=dataconn->accept();
return new_server_socket(newsock);
}
auto sock=LIBCXX_NAMESPACE::fd::base
::socket(dataconnaddr->family(), SOCK_STREAM, 0);
sock->connect(dataconnaddr);
return new_server_socket(sock);
};
do
{
line.clear();
line.reserve(cmd.size());
for (auto b=cmd.begin(), e=cmd.end(); b != e; ++b)
{
if ((unsigned char)*b == 255) // telnet escape
{
if (++b == e)
break;
continue;
}
line.push_back(*b);
}
if (line.substr(0, 8) == "AUTH TLS")
{
(*stream) << "226 Ok\r\n" << std::flush;
stream=new_server_socket(sock_terminated)
->getiostream();
continue;
}
if (line.substr(0, 4) == "PASV" && passive)
{
received_allo=false;
dataconn=({
std::list<LIBCXX_NAMESPACE::fd> fds;
LIBCXX_NAMESPACE::netaddr
::create(sock.second
->address(),
0)->bind(fds, false);
fds.front();
});
dataconn->listen();
dataconnaddr=LIBCXX_NAMESPACE::sockaddrptr();
auto sockname=dataconn->getsockname();
std::string portname=({
std::ostringstream o;
int portnum=sockname->port();
o << sockname->address() << "."
<< portnum / 256 << "."
<< portnum % 256;
o.str();
});
// Logon Challenge command handler
bool AuthSocket::_HandleLogonChallenge()
{
sLog->outStaticDebug("Entering _HandleLogonChallenge");
if (socket().recv_len() < sizeof(sAuthLogonChallenge_C))
return false;
// Read the first 4 bytes (header) to get the length of the remaining of the packet
std::vector<uint8> buf;
buf.resize(4);
socket().recv((char *)&buf[0], 4);
#if TRINITY_ENDIAN == TRINITY_BIGENDIAN
EndianConvert(*((uint16*)(buf[0])));
#endif
uint16 remaining = ((sAuthLogonChallenge_C *)&buf[0])->size;
sLog->outStaticDebug("[AuthChallenge] got header, body is %#04x bytes", remaining);
if ((remaining < sizeof(sAuthLogonChallenge_C) - buf.size()) || (socket().recv_len() < remaining))
return false;
//No big fear of memory outage (size is int16, i.e. < 65536)
buf.resize(remaining + buf.size() + 1);
buf[buf.size() - 1] = 0;
sAuthLogonChallenge_C *ch = (sAuthLogonChallenge_C*)&buf[0];
// Read the remaining of the packet
socket().recv((char *)&buf[4], remaining);
sLog->outStaticDebug("[AuthChallenge] got full packet, %#04x bytes", ch->size);
sLog->outStaticDebug("[AuthChallenge] name(%d): '%s'", ch->I_len, ch->I);
// BigEndian code, nop in little endian case
// size already converted
#if TRINITY_ENDIAN == TRINITY_BIGENDIAN
EndianConvert(*((uint32*)(&ch->gamename[0])));
EndianConvert(ch->build);
EndianConvert(*((uint32*)(&ch->platform[0])));
EndianConvert(*((uint32*)(&ch->os[0])));
EndianConvert(*((uint32*)(&ch->country[0])));
EndianConvert(ch->timezone_bias);
EndianConvert(ch->ip);
#endif
ByteBuffer pkt;
_login = (const char*)ch->I;
_build = ch->build;
_expversion = (AuthHelper::IsPostWotLKAcceptedClientBuild(_build) ? POST_WOTLK_EXP_FLAG : NO_VALID_EXP_FLAG) | (AuthHelper::IsPostBCAcceptedClientBuild(_build) ? POST_BC_EXP_FLAG : NO_VALID_EXP_FLAG) | (AuthHelper::IsPreBCAcceptedClientBuild(_build) ? PRE_BC_EXP_FLAG : NO_VALID_EXP_FLAG);
_os = (const char*)ch->os;
if(_os.size() > 4)
return false;
// Restore string order as its byte order is reversed
std::reverse(_os.begin(), _os.end());
pkt << (uint8)AUTH_LOGON_CHALLENGE;
pkt << (uint8)0x00;
// Verify that this IP is not in the ip_banned table
// No SQL injection possible (paste the IP address as passed by the socket)
LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
std::string address(socket().getRemoteAddress().c_str());
LoginDatabase.EscapeString(address);
QueryResult_AutoPtr result = LoginDatabase.PQuery("SELECT * FROM ip_banned WHERE ip = '%s'", address.c_str());
if (result)
{
pkt << (uint8)WOW_FAIL_BANNED;
sLog->outBasic("[AuthChallenge] Banned ip %s tried to login!", address.c_str());
}
else
{
// Get the account details from the account table
// No SQL injection (prepared statement)
result = LoginDatabase.PQuery("SELECT a.sha_pass_hash, a.id, a.locked, a.last_ip, aa.gmlevel, a.v, a.s "
"FROM account a "
"LEFT JOIN account_access aa "
"ON (a.id = aa.id) "
"LEFT JOIN tournament_access ta "
"ON (a.id = ta.id) "
"WHERE a.username = '******'", _login.c_str());
if (result)
{
///- If the IP is 'locked', check that the player comes indeed from the correct IP address
bool locked = false;
if ((*result)[2].GetUInt8() == 1) // if ip is locked
{
sLog->outStaticDebug("[AuthChallenge] Account '%s' is locked to IP - '%s'", _login.c_str(), (*result)[3].GetString());
sLog->outStaticDebug("[AuthChallenge] Player address is '%s'", address.c_str());
if (strcmp((*result)[3].GetString(),socket().getRemoteAddress().c_str()))
{
sLog->outStaticDebug("[AuthChallenge] Account IP differs");
pkt << (uint8) WOW_FAIL_SUSPENDED;
locked = true;
}
else
sLog->outStaticDebug("[AuthChallenge] Account IP matches");
}
else
sLog->outStaticDebug("[AuthChallenge] Account '%s' is not locked to ip", _login.c_str());
LoginDatabase.Execute("UPDATE account_banned SET active = '0' WHERE unbandate <= UNIX_TIMESTAMP() AND unbandate <> bandate");
if (!locked)
{
//set expired bans to inactive
//LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_SET_EXPIREDACCBANS));
// If the account is banned, reject the logon attempt
LoginDatabase.Execute("UPDATE account_banned SET active = 0 WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
///- If the account is banned, reject the logon attempt
QueryResult_AutoPtr banresult = LoginDatabase.PQuery("SELECT bandate,unbandate FROM account_banned WHERE id = %u AND active = 1", (*result)[1].GetUInt32());
if (banresult)
{
if ((*banresult)[0].GetUInt64() == (*banresult)[1].GetUInt64())
{
pkt << (uint8)WOW_FAIL_BANNED;
sLog->outBasic("'%s:%d' [AuthChallenge] Banned account %s tried to login!", socket().getRemoteAddress().c_str(), socket().getRemotePort(), _login.c_str ());
}
else
{
pkt << (uint8)WOW_FAIL_SUSPENDED;
sLog->outBasic("'%s:%d' [AuthChallenge] Temporarily banned account %s tried to login!", socket().getRemoteAddress().c_str(), socket().getRemotePort(), _login.c_str ());
}
}
else
{
// Get the password from the account table, upper it, and make the SRP6 calculation
std::string rI = (*result)[0].GetCppString();
// Don't calculate (v, s) if there are already some in the database
std::string databaseV = (*result)[5].GetCppString();
std::string databaseS = (*result)[6].GetCppString();
sLog->outDebug("database authentication values: v='%s' s='%s'", databaseV.c_str(), databaseS.c_str());
// multiply with 2 since bytes are stored as hexstring
if (databaseV.size() != s_BYTE_SIZE * 2 || databaseS.size() != s_BYTE_SIZE * 2)
_SetVSFields(rI);
else
{
s.SetHexStr(databaseS.c_str());
v.SetHexStr(databaseV.c_str());
}
b.SetRand(19 * 8);
BigNumber gmod = g.ModExp(b, N);
B = ((v * 3) + gmod) % N;
ASSERT(gmod.GetNumBytes() <= 32);
BigNumber unk3;
unk3.SetRand(16 * 8);
// Fill the response packet with the result
pkt << uint8(WOW_SUCCESS);
// B may be calculated < 32B so we force minimal length to 32B
pkt.append(B.AsByteArray(32), 32); // 32 bytes
pkt << uint8(1);
pkt.append(g.AsByteArray(), 1);
pkt << uint8(32);
pkt.append(N.AsByteArray(32), 32);
pkt.append(s.AsByteArray(), s.GetNumBytes()); // 32 bytes
pkt.append(unk3.AsByteArray(16), 16);
uint8 securityFlags = 0;
pkt << uint8(securityFlags); // security flags (0x0...0x04)
if (securityFlags & 0x01) // PIN input
{
pkt << uint32(0);
pkt << uint64(0) << uint64(0); // 16 bytes hash?
}
if (securityFlags & 0x02) // Matrix input
{
pkt << uint8(0);
pkt << uint8(0);
pkt << uint8(0);
pkt << uint8(0);
pkt << uint64(0);
}
if (securityFlags & 0x04) // Security token input
pkt << uint8(1);
uint8 secLevel = (*result)[4].GetUInt8();
_accountSecurityLevel = secLevel <= SEC_ADMINISTRATOR ? AccountTypes(secLevel) : SEC_ADMINISTRATOR;
_localizationName.resize(4);
for (int i = 0; i < 4; ++i)
_localizationName[i] = ch->country[4-i-1];
sLog->outBasic("'%s:%d' [AuthChallenge] account %s is using '%c%c%c%c' locale (%u)", socket().getRemoteAddress().c_str(), socket().getRemotePort(),
_login.c_str (), ch->country[3], ch->country[2], ch->country[1], ch->country[0], GetLocaleByName(_localizationName)
);
}
}
}
else //no account
pkt << (uint8)WOW_FAIL_UNKNOWN_ACCOUNT;
}
socket().send((char const*)pkt.contents(), pkt.size());
return true;
}