QString.cpp довольно большой, это примерно 8000 до 9000 строки коды, вводное описание этого является:

431 \ класс QString  
432 \ возвратный  
433
434 \ краток Класс QString содержит строку символов Unicode.  
435  
436 \ внутригрупповых инструментов  
437 \ ингруппы общей  
438 \ ингруппа строка обработки  
439
440 QString хранит строку 16-бит \ л {QChar} с, где каждый QChar  
441 соответствует один символ Unicode 4.0. (символы Unicode  
442 с кодовыми значениями выше 65535 сохраняются с помощью суррогатных пар,  
443 т.е. два последовательных \ л {QChar} с.)  
444
445 \ л {Unicode} является международным стандартом, который поддерживает большинство из  
446 системы письма, используемых сегодня. Он является надстройкой US-ASCII (ANSI  
447 X3.4-1986) и Latin-1 (ISO 8859-1), и все US-ASCII / Latin-1  
448 символов доступны на один и те же кодовых позиции.  
449
450 За кулисы, QString использует \ л {неявного обмен}  
451 (копирование при записи), чтобы уменьшить потребление памяти и, чтобы избежать ненужного  
452 копирования данных. Это также помогает уменьшить присущие накладные расходы  
453 хранения 16-битных символов вместо 8-битных символов.  
454
455 В дополнение к QString, Qt также предоставляет класс QByteArray к  
456 магазина сырых байт и традиционный 8-бит «\\ 0 'байтами.  
457 Для большинства целей, QString класс вы хотите использовать. это  
458 используется во API Qt, и поддержка Unicode гарантирует, что  
459 Ваши приложения будут легко перевести, если вы хотите расширить  
460 рынок вашего приложения в какой-то момент. Два основных случая, когда  
461 QByteArray подходит, когда вы должны хранить в двоичном формате  
462 данных, а также, когда критично сохранение памяти (например, с  
463 \ л {Qt для встраиваемых Linux}).

(Выше было также класс QCharRef, который может или не может использовать)

Таким образом, с подвигом точки зрения, это очень хорошая новость.

Unicode еще несколько экспериментальный / сложный и всегда в стадии разработки / расширения ........ файл / класс довольно большой ... так высоко вероятно капот некоторых оставшихся ошибок здесь и там ...

Теперь вопрос в том, где находятся ошибки и мы не повезти для .arg вещи?! = D

(Кроме того, связь / веб-ориентированный подход занимает минуту или около того, чтобы сделать это в HTML / ie9 так нужно немного терпения)

Вещи начинают становиться немного нечетким, так как я не знаю, какой именно вариант функции агда вызывается так, что это начинает казаться, что исполнение возможно в реальном мире / отслеживание может быть необходимо, чтобы знать наверняка.

Но если бы мне пришлось сделать ставку, я бы на месте свои ставки на наконец агд функции и процедуры, которые она вызывает.

Мне кажется, весьма вероятно, что существует, по крайней мере, какая-то ошибка в этих рутин, который вызывает% п будет отображаться вместо чего-то другого, как число или так:


6374 Struct ArgEscapeData  
6375 {  
6376 INT min_escape; // низкий порядковый номер побег  
6377 INT вхождений; // количество вхождений с наименьшим номером последовательности побег  
6378 INT locale_occurrences; // количество вхождений наименьшим порядковым номером убегания, что  
6379 // содержит 'L'  
6380 INT escape_len; // общая длина управляющих последовательностей, которые будут заменены  
6381};  
6382  
6383 статическая ArgEscapeData findArgEscapes (Const QString &s)  
6384 {  
6385 Const QChar * uc_begin = s.unicode ();  
6386 Const QChar * uc_end = uc_begin + s.length ();  
6387  
6388 ArgEscapeData д;  
6389  
6390 d.min_escape = INT_MAX;  
6391 d.occurrences = 0;  
6392 d.escape_len = 0;  
6393 d.locale_occurrences = 0;  
6394  
6395 Const QChar * с = uc_begin;  
6396 в то время как (с! = Uc_end) {  
6397 в то время как (с! = Uc_end && c->юникода (!) = '%')  
6398 C ++;  
6399  
6400, если (с == uc_end)  
6401 перерыва;  
6402 Const QChar * escape_start = с;  
6403, если (C ++ == uc_end)  
6404 перерыва;  
6405  
6406 BOOL locale_arg = ложь;  
6407, если (c->Юникода () == 'L') {  
6408 locale_arg = TRUE;  
6409, если (C ++ == uc_end)  
6410 перерыва;  
6411}  
6412  
6413, если (c->digitValue () == -1)  
6414 продолжаются;  
6415  
6416 INT побег = c->digitValue ();  
6417 C ++;  
6418  
6419, если (с! = Uc_end && c->digitValue ()! = -1) {  
6420 побега = (10 * побег) + C->digitValue ();  
6421 C ++;  
6422}  
6423  
6424, если (побег > d.min_escape)  
6425 продолжаются;  
6426  
6427, если (побег < d.min_escape) {  
6428 d.min_escape = бежать;  
6429 d.occurrences = 0;  
6430 d.escape_len = 0;  
6431 d.locale_occurrences = 0;  
6432}  
6433  
6434 ++ d.occurrences;  
6435, если (locale_arg)  
6436 ++ d.locale_occurrences;  
6437 d.escape_len + = с - escape_start;  
6438}  
6439 возвращение д;  
6440}  
6441
6442 статического QString replaceArgEscapes (Const QString &s, Const ArgEscapeData &д, INT field_width,  
6443 Const QString &Арг, Const QString &круп, Const QChar &FillChar = QLatin1Char (»«))  
6444 {  
6445 Const QChar * uc_begin = s.unicode ();  
6446 Const QChar * uc_end = uc_begin + s.length ();  
6447  
6448 INT abs_field_width = Qabs (field_width);  
6449 INT result_len = s.length ()  
6450 - d.escape_len  
6451 + (d.occurrences - d.locale_occurrences)  
6452 * Qmax (abs_field_width, arg.length ())  
6453 + d.locale_occurrences  
6454 * Qmax (abs_field_width, larg.length ());  
6455  
6456 QString результат (result_len, Qt :: Неинициализированная);  
6457 QChar * result_buff = (QChar *) result.unicode ();  
6458  
6459 QChar * гс = result_buff;  
6460 Const QChar * с = uc_begin;  
6461 INT repl_cnt = 0;  
6462 в то время как (с! = Uc_end) {  
6463 / * Мы не должны проверить, если мы бежим от конца строки с с,  
6464, потому что до тех пор, как d.occurrences > 0 мы знаем, что есть действительный побег  
6465 последовательности. * /  
6466  
6467 Const QChar * text_start = с;  
6468  
6469 в то время как (C->юникода (!) = '%')  
6470 C ++;  
6471  
6472 Const QChar * escape_start = C ++;  
6473  
6474 BOOL locale_arg = ложь;  
6475, если (c->Юникода () == 'L') {  
6476 locale_arg = TRUE;  
6477 C ++;  
6478}  
6479  
6480 INT побег = c->digitValue ();  
6481, если (побег! = -1) {  
6482, если (с + 1! = Uc_end && (С + 1) ->digitValue ()! = -1) {  
6483 побег = (10 * побега) + (с + 1) ->digitValue ();  
6484 C ++;  
6485}  
6486}  
6487  
6488, если (побег! = D.min_escape) {  
6489 тетсру (гс, text_start, (с - text_start) * SizeOf (QChar));  
6490 гс + = с - text_start;  
6491}  
6492 еще {  
6493 C ++;  
6494  
6495 тетсру (гс, text_start, (escape_start - text_start) * SizeOf (QChar));  
6496 гс + = escape_start - text_start;  
6497
6498 UINT pad_chars;  
6499, если (locale_arg)  
6500 pad_chars = Qmax (abs_field_width, larg.length ()) - larg.length ();  
6501 еще  
6502 pad_chars = Qmax (abs_field_width, arg.length ()) - arg.length ();  
6503  
6504, если (field_width > 0) {// влево проложенный  
6505 для (UINT = 0; я < pad_chars; ++ я)  
6506 (гс ++) ->Юникода () = fillChar.unicode ();  
6507}  
6508  
6509, если (locale_arg) {  
6510 тетсру (гс, larg.unicode (), larg.length () * SizeOf (QChar));  
6511 гс + = larg.length ();  
6512}  
6513 еще {  
6514 тетсру (гс, arg.unicode (), arg.length () * SizeOf (QChar));  
6515 гс + = arg.length ();  
6516}  
6517  
6518, если (field_width < 0) {// Право проложенный  
6519 для (UINT = 0; я < pad_chars; ++ я)  
6520 (гс ++) ->Юникода () = fillChar.unicode ();  
6521}  
6522  
6523, если (++ repl_cnt == d.occurrences) {  
6524 тетсру (гс, с, (uc_end - с) * SizeOf (QChar));  
6525 гс + = uc_end - с;  
6526 Q_ASSERT (гс - result_buff == result_len);  
6527 с = uc_end;  
6528}  
6529}  
6530}  
6531 Q_ASSERT (гс == result_buff + result_len);  
6532  
6533 Возвращаемый результат;  
6534}  
6535  
6536 / *!  
6537 Возвращает копию этой строки с наименьшим порядковым номером места маркером  
6538 заменена строкой \ в а, то есть, \ с% 1, \ с% 2, ..., \ C% 99.  
6539  
6540 \ а fieldWidth определяет минимальный объем пространства, аргумент \ а  
6541 займем. Если \ A A требует меньше мест, чем \ а fieldWidth, это  
6542 дополняется до \ а fieldWidth с характером \ а FillChar. положительный  
6543 \ а fieldWidth производит выравнивание по правому краю текста. Отрицательная \ а fieldWidth  
6544 производит по левому краю текста.  
6545  
6546 В этом примере показано, как можно создать строку \ статус с для  
6547 отчетности прогресса при обработке списка файлов:  
6548  
6549 \ сниппет DOC / SRC / сниппеты / QString / main.cpp 11  
6550  
6551 Во-первых, \ с аг (я) заменяет \ с% 1. Тогда \ с Arg (всего) заменяет \ с  
6552% 2. Наконец, \ с Arg (Filename) заменяет \ C% 3.  
6553  
6554 Одним из преимуществ использования Arg () над Sprintf () является то, что порядок следования  
6555 пронумерованных маркеры место может измениться, если строки приложения являются  
6556 переведен на другие языки, но каждый аргумент () будет по-прежнему заменить  
6557 с наименьшим номером unreplaced маркер места, независимо от того, где это  
появляется 6558. Кроме того, если маркер места \ с% я больше одного раза в  
6559 строка, Arg () заменяет все из них.  
6560  
6561 Если нет unreplaced маркера места, оставшегося, предупреждающее сообщение  
6562 выводится и результат не определен. номера Место маркер должен быть  
6563 в диапазоне от 1 до 99.  
6564 * /  
6565 QString QString :: Arg (Const QString &а, ИНТ fieldWidth, константный QChar &FillChar) сопзЬ  
6566 {  
6567 ArgEscapeData г = findArgEscapes (* это);  
6568  
6569, если (d.occurrences == 0) {  
6570 qWarning ("QString :: агд: Аргумент отсутствует:% s,% s", toLocal8Bit (). (данные),  
. 6571 (a.toLocal8Bit) данных ());  
6572 возвращение * это;  
6573}  
6574 возврата replaceArgEscapes (* это, д, fieldWidth, а, а, FillChar);  
6575}


Видя буфера на основе этих стеки или, возможно, кучи на основе переменного буфера, смелые высказывания в комментариях о "будучи уверенным," лол ... и memcopies, а также проверить некоторое здравомыслие Утверждает собираемся сделать некоторые эксплуатируют писатель / исследователь собираются водяные зубов

Код действительно выглядит довольно сложную поэтому высокая likelyness быть ошибкой, там

Было бы интересно узнать, если это действительно код, который выполняется.

Так что сейчас я думаю, что я собираюсь прекратить свое расследование, пока я или кто-то другой не может фактически выполнить весь Bitcoin + Qt код и посмотреть / подтвердить, если это действительно исполняемый код

Одна последняя возможность рассмотреть этот кусок кода в случае, если это мульти аргумент вызова:


6957 статические INT getEscape (Const QChar * ис, Int * поз, Int Len, Int MAXNUMBER = 999) 
6958 { 
6959 INT I = * позы; 
6960 ++ я; 
6961, если (я < Len && УНЦ == QLatin1Char ( 'L')) 
6962 ++ я; 
6963, если (я < длина) { 
6964 INT побег = ис.Юникода () - '0'; 
6965, если (UINT (побег) >= 10U) 
6966 возврата -1; 
6967 ++ я; 
6968 в то время как (я < длина) { 
6969 INT цифра = УНЦ.Юникода () - '0'; 
6970, если (UINT (цифра) >= 10U) 
6971 перерыва; 
6972 побег = (побег * 10) + цифры; 
6973 ++ я; 
6974} 
6975, если (побег <= MAXNUMBER) { 
6976 * поз = я; 
6977 возвращение побег; 
6978} 
6979} 
6980 возврата -1; 
6981} 
6982 
6983 QString QString :: multiArg (INT numArgs, Const QString ** арг) сопзЬ 
6984 { 
6985 QString результат; 
6986 QMap numbersUsed; 
6987 Const QChar * = ис (Const QChar *) d->данные; 
6988 Const INT Len = D->размер; 
6989 Const = INT конец Len - 1; 
6990 INT lastNumber = -1; 
6991 INT I = 0; 
6992
6993 // заполнить numbersUsed карту с% п это, что на самом деле происходит в строке 
6994 в то время как (я < конец) { 
6995, если (ЯК == QLatin1Char ( '%')) { 
6996 INT число = getEscape (ЯК, &я, длина); 
6997, если (число! = -1) { 
6998 numbersUsed.insert (число, -1); 
6999 продолжаются; 
7000} 
7001} 
7002 ++ я; 
7003} 
7004 
7005 // присвоить номер аргумента для каждого из% п х 
7006 QMap:: итератор J = numbersUsed.begin (); 
7007 QMap:: итератора jend = numbersUsed.end (); 
7008 INT Arg = 0; 
7009 в то время как (J! = Jend && Arg < numArgs) { 
7010 * J = Arg ++; 
7011 lastNumber = j.key (); 
7012 ++, J; 
7013} 
7014 
7015 // вменяемость 
7016 если (numArgs > Arg) { 
7017 qWarning ("QString :: Arg:% d аргумент (ы) отсутствует в% S"., NumArgs - Arg, toLocal8Bit () данных ()); 
7018 numArgs = Arg; 
7019} 
7020 
7021 = 0; 
7022 в то время как (я < длина) { 
7023, если (ЯК == QLatin1Char ( '%') && я! = конец) { 
7024 INT число = getEscape (ЯК, &я, длина, lastNumber); 
7025 INT Arg = numbersUsed [номер]; 
7026, если (число! = -1 && Arg! = -1) { 
7027 результат + = * арг [Arg]; 
7028 продолжаются; 
7029} 
7030} 
7031 результат + = UC [я ++]; 
7032} 
7033 Возвращаемый результат; 
7034}