bool JsonDbObject::computeVersion(const int oldUpdateCount, const QString& oldHash, int *newUpdateCount, QString *newHash) const
{
QCryptographicHash md5(QCryptographicHash::Md5);
for (const_iterator ii = begin(); ii != end(); ii++) {
QString key = ii.key();
if (key == JsonDbString::kUuidStr || key == JsonDbString::kVersionStr || key == JsonDbString::kMetaStr)
continue;
md5.addData((char *) key.constData(), key.size() * 2);
char kar = ii.value().type();
md5.addData((char *) &kar, 1);
switch (ii.value().type()) {
case QJsonValue::Bool:
kar = ii.value().toBool() ? '1' : '0';
md5.addData((char *) &kar, 1);
break;
case QJsonValue::Double: {
double value = ii.value().toDouble();
md5.addData((char *) &value, sizeof(double));
break;
}
case QJsonValue::String: {
QString value = ii.value().toString();
md5.addData((char *) value.constData(), value.size() * 2);
break;
}
case QJsonValue::Array: {
QJsonDocument doc(ii.value().toArray());
int size;
const char *data = doc.rawData(&size);
md5.addData(data, size);
break;
}
case QJsonValue::Object: {
QJsonDocument doc(ii.value().toObject());
int size;
const char *data = doc.rawData(&size);
md5.addData(data, size);
break;
}
default:;
// do nothing
}
}
QString computedHash = QString::fromLatin1(md5.result().toHex().constData(), 10);
if (computedHash != oldHash) {
if (newUpdateCount)
*newUpdateCount = oldUpdateCount + 1;
if (newHash)
*newHash = computedHash;
return true;
}
return false;
}
bool Pack::ExecuteCmd(QString exe, QStringList argument, QProcess &pprocess, QString workPath)
{
QString enterPath = QStringLiteral("cd ") + "\"" + workPath + "\"" + QStringLiteral("\n");
QString arg;
arg.append(exe);
for (QStringList::Iterator ite = argument.begin(); ite != argument.end(); ite++)
{
arg.append(" ");
arg.append(*ite);
}
arg.append("\n");
pprocess.start("cmd");
pprocess.waitForStarted();
QTextCodec *gbk = QTextCodec::codecForName("GBK");
QByteArray byteEnterPath = gbk->fromUnicode(enterPath.constData(), enterPath.length());
QByteArray byteCommand = gbk->fromUnicode(arg.constData(), arg.length());
char *charEnterPath = byteEnterPath.data();
char *charCommand = byteCommand.data();
pprocess.write(byteEnterPath);
pprocess.write(charCommand);
pprocess.closeWriteChannel();
if (!pprocess.waitForFinished(1000 * 60 * 20)){
return false;
}
return true;
//mpprocess->setWorkingDirectory(workPath);
//mpprocess->start(exe,argument);
}
void
QGraphicsMozView::sendAsyncMessage(const QString& name, const QString& message)
{
if (!d->mViewInitialized)
return;
d->mView->SendAsyncMessage((const PRUnichar*)name.constData(), (const PRUnichar*)message.constData());
}
bool SQLiteResult::prepare(const QString &query)
{
if (!driver() || !driver()->isOpen() || driver()->isOpenError())
return false;
d->cleanup();
setSelect(false);
const void *pzTail = NULL;
#if (SQLITE_VERSION_NUMBER >= 3003011)
int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
&d->stmt, &pzTail);
#else
int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
&d->stmt, &pzTail);
#endif
if (res != SQLITE_OK) {
#if defined(SQLITEDRIVER_DEBUG)
trace(NULL, query.toUtf8().constData());
#endif
setLastError(qMakeError(d->access, QCoreApplication::translate("SQLiteResult",
"Unable to execute statement"), QSqlError::StatementError, res));
d->finalize();
return false;
} else if (pzTail && !stringFromUnicode(reinterpret_cast<const QChar *>(pzTail)).trimmed().isEmpty()) {
setLastError(qMakeError(d->access, QCoreApplication::translate("SQLiteResult",
"Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE));
d->finalize();
return false;
}
return true;
}
QCollatorSortKey QCollator::sortKey(const QString &string) const
{
if (d->dirty)
d->init();
#ifndef USE_COMPARESTRINGEX
int size = LCMapStringW(d->localeID, LCMAP_SORTKEY | d->collator,
reinterpret_cast<const wchar_t*>(string.constData()), string.size(),
0, 0);
#else
int size = LCMapStringEx(LPCWSTR(d->localeName.utf16()), LCMAP_SORTKEY | d->collator,
reinterpret_cast<LPCWSTR>(string.constData()), string.size(),
0, 0, NULL, NULL, 0);
#endif
QString ret(size, Qt::Uninitialized);
#ifndef USE_COMPARESTRINGEX
int finalSize = LCMapStringW(d->localeID, LCMAP_SORTKEY | d->collator,
reinterpret_cast<const wchar_t*>(string.constData()), string.size(),
reinterpret_cast<wchar_t*>(ret.data()), ret.size());
#else
int finalSize = LCMapStringEx(LPCWSTR(d->localeName.utf16()), LCMAP_SORTKEY | d->collator,
reinterpret_cast<LPCWSTR>(string.constData()), string.size(),
reinterpret_cast<LPWSTR>(ret.data()), ret.size(),
NULL, NULL, 0);
#endif
if (finalSize == 0) {
qWarning() << "there were problems when generating the ::sortKey by LCMapStringW with error:" << GetLastError();
}
return QCollatorSortKey(new QCollatorSortKeyPrivate(ret));
}
bool QSpatiaLiteResult::prepare(const QString &query)
{
if (!driver() || !driver()->isOpen() || driver()->isOpenError())
return false;
d->cleanup();
setSelect(false);
const void *pzTail = NULL;
#if (SQLITE_VERSION_NUMBER >= 3003011)
int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
&d->stmt, &pzTail);
#else
int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
&d->stmt, &pzTail);
#endif
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult",
"Unable to execute statement"), QSqlError::StatementError, res));
d->finalize();
return false;
} else if (pzTail && !QString::fromUtf16( (const ushort *) pzTail ).trimmed().isEmpty()) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult",
"Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE));
d->finalize();
return false;
}
return true;
}
void QCopX11Client::send
( const QString& ch, const QString& msg, const QByteArray& data )
{
int len = ch.length() * 2 + msg.length() * 2 + data.length();
len += sizeof(QCopPacketHeader);
int writelen;
char *buf;
if ( len <= minPacketSize ) {
buf = outBuffer;
memset( buf + len, 0, minPacketSize - len );
writelen = minPacketSize;
} else {
buf = new char [len];
writelen = len;
}
QCopPacketHeader *header = (QCopPacketHeader *)buf;
header->command = QCopCmd_Send;
header->totalLength = len;
header->chLength = ch.length();
header->msgLength = msg.length();
header->forwardToLength = 0;
header->dataLength = data.length();
char *ptr = buf + sizeof(QCopPacketHeader);
memcpy( ptr, ch.constData(), ch.length() * 2 );
ptr += ch.length() * 2;
memcpy( ptr, msg.constData(), msg.length() * 2 );
ptr += msg.length() * 2;
memcpy( ptr, data.constData(), data.length() );
write( buf, writelen );
if ( buf != outBuffer )
delete[] buf;
}
QString escapeCpp(const QByteArray &key, QString value) {
if (value.isEmpty()) return "QString()";
QString res;
res.reserve(value.size() * 10);
bool instr = false;
for (const QChar *ch = value.constData(), *e = value.constData() + value.size(); ch != e; ++ch) {
if (ch->unicode() > 0x007F) {
if (instr) {
res.append('"');
instr = false;
}
res.append(' ').append('u').append('"').append('\\').append('x').append(QString("%1").arg(ch->unicode(), 4, 16, QChar('0'))).append('"');
} else {
if (ch->unicode() == '\\' || ch->unicode() == '\n' || ch->unicode() == '\r' || ch->unicode() == '"') {
if (!instr) {
res.append(' ').append('u').append('"');
instr = true;
}
res.append('\\');
if (ch->unicode() == '\\' || ch->unicode() == '"') {
res.append(*ch);
} else if (ch->unicode() == '\n') {
res.append('n');
} else if (ch->unicode() == '\r') {
res.append('r');
}
} else if (ch->unicode() < 0x0020) {
if (*ch == TextCommand) {
if (ch + 3 >= e || (ch + 1)->unicode() != TextCommandLangTag || (ch + 2)->unicode() > 0x007F || (ch + 2)->unicode() < 0x0020 || *(ch + 3) != TextCommand) {
throw Exception(QString("Bad value for key '%1'").arg(QLatin1String(key)));
} else {
if (instr) {
res.append('"');
instr = false;
}
res.append(' ').append('u').append('"');
res.append('\\').append('x').append(QString("%1").arg(ch->unicode(), 2, 16, QChar('0')));
res.append('\\').append('x').append(QString("%1").arg((ch + 1)->unicode(), 2, 16, QChar('0')));
res.append('\\').append('x').append(QString("%1").arg((ch + 2)->unicode(), 2, 16, QChar('0')));
res.append('\\').append('x').append(QString("%1").arg((ch + 3)->unicode(), 2, 16, QChar('0')));
res.append('"');
ch += 3;
}
} else {
throw Exception(QString("Bad value for key '%1'").arg(QLatin1String(key)));
}
} else {
if (!instr) {
res.append(' ').append('u').append('"');
instr = true;
}
res.append(*ch);
}
}
}
if (instr) res.append('"');
return "qsl(" + res.mid(1) + ")";
}
bool
SmartFilenameOrdering::operator()(QFileInfo const& lhs, QFileInfo const& rhs) const
{
// First compare directories.
if (int comp = lhs.absolutePath().compare(rhs.absolutePath())) {
return comp < 0;
}
QString const lhs_fname(lhs.fileName());
QString const rhs_fname(rhs.fileName());
QChar const* lhs_ptr = lhs_fname.constData();
QChar const* rhs_ptr = rhs_fname.constData();
while (!lhs_ptr->isNull() && !rhs_ptr->isNull()) {
bool const lhs_is_digit = lhs_ptr->isDigit();
bool const rhs_is_digit = rhs_ptr->isDigit();
if (lhs_is_digit != rhs_is_digit) {
// Digits have priority over non-digits.
return lhs_is_digit;
}
if (lhs_is_digit && rhs_is_digit) {
unsigned long lhs_number = 0;
do {
lhs_number = lhs_number * 10 + lhs_ptr->digitValue();
++lhs_ptr;
// Note: isDigit() implies !isNull()
} while (lhs_ptr->isDigit());
unsigned long rhs_number = 0;
do {
rhs_number = rhs_number * 10 + rhs_ptr->digitValue();
++rhs_ptr;
// Note: isDigit() implies !isNull()
} while (rhs_ptr->isDigit());
if (lhs_number != rhs_number) {
return lhs_number < rhs_number;
} else {
continue;
}
}
if (lhs_ptr->isNull() != rhs_ptr->isNull()) {
return *lhs_ptr < *rhs_ptr;
}
++lhs_ptr;
++rhs_ptr;
}
if (!lhs_ptr->isNull() || !rhs_ptr->isNull()) {
return lhs_ptr->isNull();
}
// OK, the smart comparison indicates the file names are equal.
// However, if they aren't symbol-to-symbol equal, we can't treat
// them as equal, so let's do a usual comparision now.
return lhs_fname < rhs_fname;
}
inline QString QUrlQueryPrivate::recodeFromUser(const QString &input) const
{
// note: duplicated in setQuery()
QString output;
if (qt_urlRecode(output, input.constData(), input.constData() + input.length(),
QUrl::DecodeReserved,
prettyDecodedActions))
return output;
return input;
}
ProFile::ProFile(const QString &fileName)
: ProBlock()
{
setBlockKind(ProBlock::ProFileKind);
m_fileName = fileName;
int nameOff = fileName.lastIndexOf(QLatin1Char('/'));
m_displayFileName = QString(fileName.constData() + nameOff + 1,
fileName.length() - nameOff - 1);
m_directoryName = QString(fileName.constData(), nameOff);
}
void tst_QFontMetrics::inFontUcs4()
{
int id = QFontDatabase::addApplicationFont(":/fonts/ucs4font.ttf");
QVERIFY(id >= 0);
QFont font("QtTestUcs4");
{
QFontMetrics fm(font);
QVERIFY(fm.inFontUcs4(0x1D7FF));
}
{
QFontMetricsF fm(font);
QVERIFY(fm.inFontUcs4(0x1D7FF));
}
{
QFontEngine *engine = QFontPrivate::get(font)->engineForScript(QChar::Script_Common);
QGlyphLayout glyphs;
glyphs.numGlyphs = 3;
uint buf[3];
glyphs.glyphs = buf;
QString string;
{
string.append(QChar::highSurrogate(0x1D7FF));
string.append(QChar::lowSurrogate(0x1D7FF));
glyphs.numGlyphs = 3;
glyphs.glyphs[0] = 0;
QVERIFY(engine->stringToCMap(string.constData(), string.size(),
&glyphs, &glyphs.numGlyphs,
QFontEngine::GlyphIndicesOnly));
QCOMPARE(glyphs.numGlyphs, 1);
QCOMPARE(glyphs.glyphs[0], uint(1));
}
{
string.clear();
string.append(QChar::ObjectReplacementCharacter);
glyphs.numGlyphs = 3;
glyphs.glyphs[0] = 0;
QVERIFY(engine->stringToCMap(string.constData(), string.size(),
&glyphs, &glyphs.numGlyphs,
QFontEngine::GlyphIndicesOnly));
QVERIFY(glyphs.glyphs[0] != 1);
}
}
QFontDatabase::removeApplicationFont(id);
}
void myMessageHandler(QtMsgType type, const char *msg)
{
QString txt;
QTime t=QTime::currentTime();
QString st=t.toString("hh:mm:ss");
switch (type) {
case QtDebugMsg:
txt = QString(" %1").arg(msg);
break;
case QtWarningMsg:
txt = QString(" Warning: %1").arg(msg);
break;
case QtCriticalMsg:
txt = QString(" Critical: %1").arg(msg);
break;
case QtFatalMsg:
txt = QString(" Fatal: %1").arg(msg);
abort();
}
txt=st+txt;
QFile outFile("C:\\mifmaster.txt");
outFile.open(QIODevice::WriteOnly | QIODevice::Append);
QTextStream ts(&outFile);
ts << txt << endl;
#ifdef Q_OS_SYMBIAN
TPtrC des (reinterpret_cast<const TText*>(txt.constData()),txt.length());
RDebug::Print(des);
#endif
}
QPair<QStringRef,QStringRef> QDeclarativeStyledTextPrivate::parseAttribute(const QChar *&ch, const QString &textIn)
{
skipSpace(ch);
int attrStart = ch - textIn.constData();
int attrLength = 0;
while (!ch->isNull()) {
if (*ch == greaterThan) {
break;
} else if (*ch == equals) {
++ch;
if (*ch != singleQuote && *ch != doubleQuote) {
while (*ch != greaterThan && !ch->isNull())
++ch;
break;
}
++ch;
if (!attrLength)
break;
QStringRef attr(&textIn, attrStart, attrLength);
QStringRef val = parseValue(ch, textIn);
if (!val.isEmpty())
return QPair<QStringRef,QStringRef>(attr,val);
break;
} else {
++attrLength;
}
++ch;
}
return QPair<QStringRef,QStringRef>();
}
bool QDeclarativeStyledTextPrivate::parseCloseTag(const QChar *&ch, const QString &textIn)
{
skipSpace(ch);
int tagStart = ch - textIn.constData();
int tagLength = 0;
while (!ch->isNull()) {
if (*ch == greaterThan) {
QStringRef tag(&textIn, tagStart, tagLength);
const QChar char0 = tag.at(0);
if (char0 == QLatin1Char('b')) {
if (tagLength == 1)
return true;
else if (tag.at(1) == QLatin1Char('r') && tagLength == 2)
return true;
} else if (char0 == QLatin1Char('i')) {
if (tagLength == 1)
return true;
} else if (tag == QLatin1String("font")) {
return true;
}
return false;
} else if (!ch->isSpace()){
tagLength++;
}
++ch;
}
return false;
}
// Konwertuje napisy z jednego kodowania na inne
bool QNapiAbstractEngine::ppChangeSubtitlesEncoding(const QString & from, const QString & to)
{
QFile f(subtitlesTmp);
if(!f.open(QIODevice::ReadOnly))
return false;
QByteArray fileContent = f.readAll();
QString contentStr = QTextCodec::codecForName(qPrintable(from))->toUnicode(fileContent);
f.close();
if(to.compare("UTF-8", Qt::CaseInsensitive) != 0)
{
fileContent = QTextCodec::codecForName(qPrintable(to))
->fromUnicode(contentStr.constData(), contentStr.size());
}
else
{
fileContent.clear();
fileContent.append(contentStr);
}
if(!f.open(QIODevice::WriteOnly))
return false;
f.write(fileContent);
f.close();
return true;
}
QScriptValue ScriptableSyntaxDefinition::STRING_(QScriptContext* context, QScriptEngine* engine)
{
checkNumberOfArguments(context, 1);
QString s = context->argument(0).toString();
NODE node = super(context)->STRING(s.constData());
return nodeToScriptValue(engine, node);
}
QString lowerISO88591(const QString & szSrc)
{
const QChar * pC = szSrc.constData();
if(!pC)
{
QString szRet;
return szRet;
}
QChar * pBuffer = (QChar *)KviMemory::allocate(sizeof(QChar) * szSrc.length());
QChar * pB = pBuffer;
unsigned short usX = pC->unicode();
while(usX)
{
if(usX < 256)
{
*pB = QChar((unsigned short)iso88591_toLower_map[usX]);
} else
*pB = *pC;
pC++;
pB++;
usX = pC->unicode();
}
QString szRet(pBuffer,szSrc.length());
KviMemory::free(pBuffer);
return szRet;
}
inline QString QUrlQueryPrivate::recodeFromUser(const QString &input) const
{
// note: duplicated in setQuery()
QString output;
ushort prettyDecodedActions[] = {
decode(pairDelimiter.unicode()),
decode(valueDelimiter.unicode()),
decode('#'),
0
};
if (qt_urlRecode(output, input.constData(), input.constData() + input.length(),
QUrl::DecodeReserved,
prettyDecodedActions))
return output;
return input;
}
bool
ColorParser::parseColor(const QString& name, int* r, int* g, int* b)
{
if (name.startsWith(QLatin1Char('#'))) {
if (getHexRGB(name.constData(), name.length(), r, g, b)) {
return true;
} else {
return false;
}
}
if (getNamedRGB(name.constData(), name.length(), r, g, b)) {
return true;
}
return false;
}
int LuaHighlighter::highlightLine(QString const& text, int initialState)
{
Scanner scanner(text.constData(),text.length());
scanner.setState(initialState);
FormatToken tk;
bool hasOnlyWhitespace = true;
while((tk = scanner.read()).format() != Format_EndOfBlock)
{
Format format = tk.format();
if(format == Format_Keyword) {
if(isImportKeyword(scanner.value(tk)) && hasOnlyWhitespace)
{
setFormat(tk.begin(), tk.length(), formatForCategory(format));
highlightImport(scanner);
break;
}
}
setFormat(tk.begin(), tk.length(), formatForCategory(format));
if(format != Format_Whitespace)
hasOnlyWhitespace = false;
}
return scanner.state();
}
bool HtmlFilter::colorValue(QString &value) const
{
int r = -1;
int g = -1;
int b = -1;
if (value.startsWith(LC('#')) && !HtmlFilterPrivate::get_hex_rgb(value.constData(), value.length(), &r, &g, &b))
return false;
if (value.startsWith(LS("rgb(")) ) {
const QStringList rgb = value.mid(4, value.size() - 5).remove(LC(' ')).split(LC(','));
if (rgb.size() == 3) {
r = rgb.at(0).toInt();
g = rgb.at(1).toInt();
b = rgb.at(2).toInt();
}
}
if (r == -1 && g == -1 && b == -1)
return false;
if (r > 210 && g > 210 && b > 210)
return false;
value.sprintf("#%02x%02x%02x", r, g, b);
return true;
}
void logMessageHandler(QtMsgType type, const QMessageLogContext& ctxt, const QString& msg)
{
// Silence qWarning spam due to bug in QTextBrowser (trying to open a file for base64 images)
if (ctxt.function == QString("virtual bool QFSFileEngine::open(QIODevice::OpenMode)")
&& msg == QString("QFSFileEngine::open: No file name specified"))
return;
QString LogMsg = QString("[%1] %2:%3 : ")
.arg(QTime::currentTime().toString("HH:mm:ss.zzz")).arg(ctxt.file).arg(ctxt.line);
switch (type)
{
case QtDebugMsg:
LogMsg += "Debug";
break;
case QtWarningMsg:
LogMsg += "Warning";
break;
case QtCriticalMsg:
LogMsg += "Critical";
break;
case QtFatalMsg:
LogMsg += "Fatal";
break;
default:
break;
}
LogMsg += ": " + msg + "\n";
QByteArray LogMsgBytes = LogMsg.toUtf8();
fwrite(LogMsgBytes.constData(), 1, LogMsgBytes.size(), stderr);
#ifdef LOG_TO_FILE
FILE * logFilePtr = logFileFile.load(); // atomically load the file pointer
if (!logFilePtr)
{
logBufferMutex->lock();
if (logBuffer)
logBuffer->append(LogMsgBytes);
logBufferMutex->unlock();
}
else
{
logBufferMutex->lock();
if (logBuffer)
{
// empty logBuffer to file
foreach (QByteArray msg, *logBuffer)
fwrite(msg.constData(), 1, msg.size(), logFilePtr);
delete logBuffer; // no longer needed
logBuffer = nullptr;
}
logBufferMutex->unlock();
fwrite(LogMsgBytes.constData(), 1, LogMsgBytes.size(), logFilePtr);
fflush(logFilePtr);
}
#endif
}
/*!
\since 4.7
Returns the resolved text direction.
If the block has no explicit direction set, it will resolve the
direction from the blocks content. Returns either Qt::LeftToRight
or Qt::RightToLeft.
\sa QTextFormat::layoutDirection(), QString::isRightToLeft(), Qt::LayoutDirection
*/
Qt::LayoutDirection QTextBlock::textDirection() const
{
Qt::LayoutDirection dir = blockFormat().layoutDirection();
if (dir != Qt::LayoutDirectionAuto)
return dir;
dir = p->defaultTextOption.textDirection();
if (dir != Qt::LayoutDirectionAuto)
return dir;
const QString buffer = p->buffer();
const int pos = position();
QTextDocumentPrivate::FragmentIterator it = p->find(pos);
QTextDocumentPrivate::FragmentIterator end = p->find(pos + length() - 1); // -1 to omit the block separator char
for (; it != end; ++it) {
const QTextFragmentData * const frag = it.value();
const QChar *p = buffer.constData() + frag->stringPosition;
const QChar * const end = p + frag->size_array[0];
while (p < end) {
switch(QChar::direction(p->unicode()))
{
case QChar::DirL:
return Qt::LeftToRight;
case QChar::DirR:
case QChar::DirAL:
return Qt::RightToLeft;
default:
break;
}
++p;
}
}
return Qt::LeftToRight;
}
bool SQLiteDatabase::prepare(const QString &sql)
{
if (m_db == nullptr) {
return false;
}
if (m_stmt != nullptr) {
finalize();
}
m_lastError.clear();
sqlite3_mutex_enter(sqlite3_db_mutex(m_db));
const void *pzTail = nullptr;
const int res = sqlite3_prepare16_v2(m_db, sql.constData(), (sql.size() + 1) * 2,
&m_stmt, &pzTail); // 2 = sizeof(QChar)
sqlite3_mutex_leave(sqlite3_db_mutex(m_db));
if (res != SQLITE_OK) {
// "Unable to execute statement"
updateLastError();
finalize();
return false;
} else if (pzTail && !QString(static_cast<const QChar *>(pzTail)).trimmed().isEmpty()) {
// Unable to execute multiple statements at a time
updateLastError();
finalize();
return false;
}
return true;
}
void addWord(QNFA *lexer, const QString& w, int action, bool cs)
{
if ( !lexer || !(lexer->type & CxtBeg) || !lexer->out.branch )
return;
// try using the fastest way if possible
QString pt;
if ( plain(w, &pt) && cs )
{
addWord(lexer->tree, pt, action, cs);
return;
}
// fallback on (fast) regexp-like NFA-based semi-compiled parsing
QNFA *nfa, *word, *end;
word = sequence(w.constData(), w.length(), &end, cs);
word->assertion |= WordStart;
nfa = new QNFA;
nfa->type = Match;
nfa->assertion = WordEnd;
nfa->actionid = action;
end->out.next = nfa;
//lexer->out.branch->append(word);
addNFA(lexer, word);
}
void QCopX11Client::sendChannelCommand( int cmd, const QString& ch )
{
int len = ch.length() * 2 + sizeof(QCopPacketHeader);
int writelen;
char *buf;
if ( len <= minPacketSize ) {
buf = outBuffer;
memset( buf + len, 0, minPacketSize - len );
writelen = minPacketSize;
} else {
buf = new char [len];
writelen = len;
}
QCopPacketHeader *header = (QCopPacketHeader *)buf;
header->command = cmd;
header->totalLength = len;
header->chLength = ch.length();
header->msgLength = 0;
header->forwardToLength = 0;
header->dataLength = 0;
char *ptr = buf + sizeof(QCopPacketHeader);
memcpy( ptr, ch.constData(), ch.length() * 2 );
write( buf, writelen );
if ( buf != outBuffer )
delete[] buf;
}
/*!
\overload
\a s contains the string being tested for encode-ability.
*/
bool QTextCodec::canEncode(const QString& s) const
{
ConverterState state;
state.flags = ConvertInvalidToNull;
convertFromUnicode(s.constData(), s.length(), &state);
return (state.invalidChars == 0);
}
bool NamespaceSupport::processName(const QString& qname, NameType type, QXmlName &name) const
{
int len = qname.size();
const QChar *data = qname.constData();
for (int pos = 0; pos < len; ++pos) {
if (data[pos] == QLatin1Char(':')) {
const QXmlName::PrefixCode prefixCode = m_namePool->allocatePrefix(qname.left(pos));
if (!m_ns.contains(prefixCode))
return false;
const QXmlName::NamespaceCode namespaceCode = uri(prefixCode);
const QXmlName::LocalNameCode localNameCode = m_namePool->allocateLocalName(qname.mid(pos + 1));
name = QXmlName(namespaceCode, localNameCode, prefixCode);
return true;
}
}
// there was no ':'
QXmlName::NamespaceCode namespaceCode = 0;
// attributes don't take default namespace
if (type == ElementName && !m_ns.isEmpty()) {
namespaceCode = m_ns.value(0); // get default namespace
}
const QXmlName::LocalNameCode localNameCode = m_namePool->allocateLocalName(qname);
name = QXmlName(namespaceCode, localNameCode, 0);
return true;
}
const AbstractMetaFunction *UiConverter::findFunction(AbstractMetaClass *javaClass,
const QString &signature,
SearchType type)
{
AbstractMetaFunctionList senderFunctions = javaClass->functions();
foreach (const AbstractMetaFunction *f, senderFunctions) {
if (type == SignalSearch && !f->isSignal())
continue;
QString fsig = f->minimalSignature();
int pos = 0;
while (pos < signature.length()
&& fsig.constData()[pos] == signature.constData()[pos]) ++pos;
if (pos == signature.length()
|| (type == SignalSearch
&& pos == signature.length() - 1
&& signature.constData()[pos] == QLatin1Char(')'))) {
return f;
}
}
return 0;
}
