bool TestCase::compareString() {
// RegularExpression re1("tình yêu", RegularExpression::RE_CASELESS && RegularExpression::RE_UTF8);
// string s;
// int n = re1.extract("tình yêu không lừa dối",s);// n == 1, s == "123"
// cout<<"n: "<<n<<"\ns: "<<s<<endl;
string str = ".*";
string str2 = "tình yêu";
string key = str + str2 + str;
RegularExpression re4(key, RegularExpression::RE_CASELESS && RegularExpression::RE_UTF8);
bool match = re4.match("ggg tình yêu không lừa dối", 0); // true
cout<<match;
}
QString niceType(QString type)
{
type.replace('*', '@');
for (int i = 0; i < 10; ++i) {
int start = type.indexOf("std::allocator<");
if (start == -1)
break;
// search for matching '>'
int pos;
int level = 0;
for (pos = start + 12; pos < type.size(); ++pos) {
int c = type.at(pos).unicode();
if (c == '<') {
++level;
} else if (c == '>') {
--level;
if (level == 0)
break;
}
}
QString alloc = type.mid(start, pos + 1 - start).trimmed();
QString inner = alloc.mid(15, alloc.size() - 16).trimmed();
//qDebug() << "MATCH: " << pos << alloc << inner;
if (inner == QLatin1String("char"))
// std::string
type.replace(QLatin1String("basic_string<char, std::char_traits<char>, "
"std::allocator<char> >"), QLatin1String("string"));
else if (inner == QLatin1String("wchar_t"))
// std::wstring
type.replace(QLatin1String("basic_string<wchar_t, std::char_traits<wchar_t>, "
"std::allocator<wchar_t> >"), QLatin1String("wstring"));
// std::vector, std::deque, std::list
QRegExp re1(QString("(vector|list|deque)<%1, %2\\s*>").arg(inner, alloc));
if (re1.indexIn(type) != -1)
type.replace(re1.cap(0), QString("%1<%2>").arg(re1.cap(1), inner));
// std::stack
QRegExp re6(QString("stack<%1, std::deque<%2> >").arg(inner, inner));
re6.setMinimal(true);
if (re6.indexIn(type) != -1)
type.replace(re6.cap(0), QString("stack<%1>").arg(inner));
// std::set
QRegExp re4(QString("set<%1, std::less<%2>, %3\\s*>").arg(inner, inner, alloc));
re4.setMinimal(true);
if (re4.indexIn(type) != -1)
type.replace(re4.cap(0), QString("set<%1>").arg(inner));
// std::map
if (inner.startsWith("std::pair<")) {
// search for outermost ','
int pos;
int level = 0;
for (pos = 10; pos < inner.size(); ++pos) {
int c = inner.at(pos).unicode();
if (c == '<')
++level;
else if (c == '>')
--level;
else if (c == ',' && level == 0)
break;
}
QString ckey = inner.mid(10, pos - 10);
QString key = chopConst(ckey);
QString value = inner.mid(pos + 2, inner.size() - 3 - pos);
QRegExp re5(QString("map<%1, %2, std::less<%3>, %4\\s*>")
.arg(key, value, key, alloc));
re5.setMinimal(true);
if (re5.indexIn(type) != -1)
type.replace(re5.cap(0), QString("map<%1, %2>").arg(key, value));
else {
QRegExp re7(QString("map<const %1, %2, std::less<const %3>, %4\\s*>")
.arg(key, value, key, alloc));
re7.setMinimal(true);
if (re7.indexIn(type) != -1)
type.replace(re7.cap(0), QString("map<const %1, %2>").arg(key, value));
}
}
}
type.replace('@', '*');
type.replace(QLatin1String(" >"), QString(QLatin1Char('>')));
return type;
}
static void parseClass(const QString& name, const QString& in)
{
Class cl;
cl.name = name;
QStringList sl = in.split("\n");
QStringList methodDescription;
QRegExp re("@P ([^\\s]+)\\s+([^\\s]+)(.*)");
// matches Q_INVOKABLE void mops(int a); // comment
QRegExp re1("Q_INVOKABLE +([^ ]+) +([^;]+); */*(.*)");
QRegExp re2("Q_INVOKABLE +([^ ]+) +([^\\{]+)\\{");
QRegExp re3("Q_INVOKABLE +([^ ]+) +(\\w+\\([^\\)]*\\))\\s+const\\s*([^\\{]*)\\{");
QRegExp reD("//@ (.*)");
QRegExp re4 ("class +(\\w+) *: *public +(\\w+) *\\{");
QRegExp re4b("class +(\\w+) *: *public +(\\w+), *public");
Q_ASSERT(re1.isValid() && re2.isValid() && re3.isValid());
bool parseClassDescription = true;
foreach(const QString& s, sl) {
if (re.indexIn(s, 0) != -1) { //@P
parseClassDescription = false;
Prop p;
p.name = re.cap(1);
p.type = re.cap(2);
p.description = re.cap(3);
cl.props.append(p);
}
else if (re2.indexIn(s, 0) != -1) {
parseClassDescription = false;
Proc p;
p.type = re2.cap(1);
p.name = re2.cap(2);
p.description = methodDescription;
methodDescription.clear();
cl.procs.append(p);
}
else if (re1.indexIn(s, 0) != -1) {
parseClassDescription = false;
Proc p;
p.type = re1.cap(1);
p.name = re1.cap(2);
p.description = methodDescription;
methodDescription.clear();
cl.procs.append(p);
}
else if (re3.indexIn(s, 0) != -1) {
parseClassDescription = false;
Proc p;
p.type = re3.cap(1);
p.name = re3.cap(2);
p.description = methodDescription;
methodDescription.clear();
cl.procs.append(p);
}
else if ((reD.indexIn(s, 0) != -1)) {
if (parseClassDescription)
cl.description.append(reD.cap(1));
else
methodDescription.append(reD.cap(1));
}
else if (s.startsWith("///")) {
QString ss = s.mid(3);
if (parseClassDescription)
cl.description.append(ss);
else
methodDescription.append(ss);
}
else if (re4.indexIn(s, 0) != -1) {
parseClassDescription = false;
QString parent = re4.cap(2).simplified();
if (name == re4.cap(1).simplified()) {
cl.parent = parent;
}
else {
printf("?<%s>!=<%s> derived from <%s>\n",
qPrintable(name), qPrintable(re4.cap(1).simplified()), qPrintable(parent));
}
}
else if (re4b.indexIn(s, 0) != -1) {
parseClassDescription = false;
QString parent = re4b.cap(2).simplified();
if (name == re4b.cap(1).simplified()) {
cl.parent = parent;
}
else {
printf("?<%s>!=<%s> derived from <%s>\n",
qPrintable(name), qPrintable(re4b.cap(1).simplified()), qPrintable(parent));
}
}
}
classes.append(cl);
}
