-
Notifications
You must be signed in to change notification settings - Fork 20
/
Copy pathQStrings.pas
23107 lines (21790 loc) · 639 KB
/
QStrings.pas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/////////////////////////////////////////////////////
// //
// QStrings 6.06.424 ( general release ) //
// //
// Quick string manipulation library //
// //
// Russian version //
// //
// Copyright (C) 2000, 2001 Andrew N. Driazgov //
// e-mail: [email protected] //
// //
// Portions (C) 2000, Sergey G. Shcherbakov //
// e-mail: [email protected], [email protected] //
// //
// Last updated: November 13, 2001 //
// //
/////////////////////////////////////////////////////
unit QStrings;
{
Список изменений:
13.11.2001 г. (v6.06) - исправлена ошибка в функции Q_Delete;
02.07.2001 г. (v6.05) - новые функции: Q_PosStrLimited и Q_PosTextLimited;
17.03.2001 г. (v6.04) - добавлены функции Q_GetWordN_1 для работы с данными
в формате CSV;
07.01.2001 г. (v6.03) - добавлена функция Q_CompMemS для сравнения блоков
памяти на больше-меньше (по содержимому), начиная
с байтов, расположенных по младшим адресам; усилен
алгоритм генерации ключа симметричного шифрования,
используемый в процедуре Q_DHGetCipherKey;
добавлены функции для преобразования строки в число;
эта версия QStrings совместима с Delphi 4;
19.11.2000 г. (v6.01) - новые функции для моделирования случайных величин
с равномерным и нормальным законами распределения
на базе генератора Mersenne Twister; добавлены
функции для быстрой сортировки массивов 4-байтных
или 2-байтных элементов и бинарного поиска в этих
массивах, для слияния таких массивов на основе
различных логических операций, функции, выполняющие
сканирование двойных слов и битовых строк в поисках
единичных или нулевых битов, устанавливающие и
сбрасывающие группы битов; добавлена функция
Q_StrTok1, которая не группирует идущие подряд
символы-разделители в исходной строке; добавлены
функции для удаления элементов с определенным
значением из массива (со сдвигом элементов) и
удаления повторяющихся элементов, функции для
сканирования массива в поисках значения, большего
или меньшего заданного; теперь для проверки на
пустую строку вместо Length(S)<>0 можно писать
S<>'' (исправлены функции Q_DelXXX и Q_TrimXXX);
07.10.2000 г. (v5.12) - добавлены функции Q_TestWildStr и Q_TestWildText
для сравнения строк по маске с учетом WildCard-
символов, функция Q_IsDecimal; еще раз изменен
алгоритм работы функций Q_MixHashXXX (!!!); убраны
процедуры Q_IncludeChar, Q_ExcludeChar (вместо них
надо вызывать стандартные Include, Exclude);
02.10.2000 г. (v5.11) - добавлены функции для проверки символьной записи
числа в строке и проверки того, что число в строке
принадлежит заданному диапазону; добавлены функции
Q_SwapMem, Q_SwapLongs, Q_NotByteArr, Q_IsEmptySet,
функции для работы с битовыми масками, для обмена
значений переменных типа Word и Byte;
23.09.2000 г. (v5.10) - изменен (!!!) алгоритм работы 320-битной hash-
функции (Q_MixHashXXX); исправлена реализация метода
RC4; удалены процедуры Q_RC4, Q_RC4(En/De)cryptCBC;
20.09.2000 г. (v5.09) - оптимизирован код некоторых функций (Q_GetCharSet,
Q_SameStr, Q_Delete, Q_CompareMem и других);
17.09.2000 г. (v5.08) - добавлены процедуры Q_MixHashXXX, для получения
320-битного значения односторонней hash-функции;
добавлена поддержка шифрования с открытым ключом
(метод Диффи-Хеллмана); исправлено несколько
процедур и функций (в том числе, метод CAST-256,
Q_RotateBitsLeft/Right, Q_RandRC6Update);
05.09.2000 г. (v5.07) - добавлена функция Q_PadInside (выравнивание текста
по обоим краям) и функция Q_ChangeBase (перевод
числа из одной системы счисления в другую);
23.08.2000 г. (v5.06) - переименованы функции, реализующие сжатие RLE;
19.08.2000 г. (v5.05) - добавлены функции Q_TabsToSpaces и Q_SpacesToTabs;
18.08.2000 г. (v5.04) - оптимизирован алгоритм работы процедур Q_FillLong,
Q_CopyLongs; добавлены новые процедуры: Q_OnesMem,
Q_CompareMem, Q_CompLongs, Q_ReverseBits; добавлено
сжатие строк и байтовых массивов методом RLE;
27.07.2000 г. (v5.03) - внесены изменения в работу безопасного генератора
псевдослучайных чисел;
24.07.2000 г. (v5.02) - исправлена ошибка в функциях Q_PadLeft, Q_PadRight,
Q_CenterStr; об ошибке сообщил Sergey G. Menylenko
e-mail: [email protected];
18.07.2000 г. (v4.12) - исправлена ошибка в следующих функциях: Q_StrMoveL,
Q_StrUpperMoveL, Q_StrLowerMoveL, возникающая при
передаче в них пустой строки в параметре Dest;
исправлен алгоритм работы датчика случайных чисел
Mersenne Twister; добавлены функции Q_SecureRandNext,
Q_SecureRandFill; функция Q_RandXOR заменена на
Q_SecureRandXOR; добавлены типы описателей TRC4ID,
TRC6ID, TCASTID, TSHAID, TMTID;
28.06.2000 г. (v4.11) - добавлены функции для сопоставления, подстановки
и вырезки фрагментов строк по маске: Q_TestByMask,
Q_ApplyMask(InPlace), Q_ExtractByMask(InPlace);
25.06.2000 г. (v4.10) - функции Q_SetBitCount и Q_FreeBitCount теперь
называются, соответственно, Q_CountOfSetBits и
Q_CountOfFreeBits; Q_ReplaceAllByOne переименована
в Q_ReplaceCharsByOneChar; добавлены функции
Q_DeleteStr и Q_DeleteText для удаления заданной
подстроки; исправлена ошибка в Q_PStrLen; добавлены
следующие функции: Q_PosLastStr, Q_PosLastText,
Q_ReplaceFirst/LastXXXX, Q_DeleteFirst/LastXXXX;
19.06.2000 г. (v4.09) - добавлена функция для быстрого вычисления длины
строки типа PChar (автором реализации является
Robert Lee), функции Q_SetBitCount и Q_FreeBitCount
для подсчета в байтовом массиве числа единичных и
нулевых битов соответственно;
31.05.2000 г. (v4.08) - функция Q_CharSet переименована в Q_GetCharStr;
Q_RemoveChars -> Q_DelChars; Q_ReplaceChars теперь
реализована как процедура; добавлена поддержка
символьных множеств (TCharSet); добавлены функции
для работы с байтовыми строками;
19.05.2000 г. (v4.07) - исправлена ошибка в функции Q_CenterStr; добавлена
поддержка динамических таблиц перекодировки;
16.05.2000 г. (v4.06) - добавлен третий параметр в функцию Q_StrRScan;
03.05.2000 г. (v4.05) - добавлены новые функции для работы с обычными
и бинарными строками; добавлены криптографические
функции; добавлена поддержка кодировки Base64 и
команды процессора RDTSC;
09.03.2000 г. (v3.05) - добавлено несколько функций для шифрования строк;
26.02.2000 г. (v3.03) - исправлено несколько ошибок; процедура Q_XORByKey
переименована в Q_XORByStr; добавлена процедура
Q_SetDelimiters; добавлены примечания;
21.02.2000 г. (v3.01) - добавлено много новых функций, некоторые функции
переименованы; добавлены функции для преобразования
десятичных чисел в шестнадцатеричные, восьмеричные,
двоичные, римские и наоборот; исправлено несколько
ошибок (в т.ч. Q_FillChar);
09.02.2000 г. (v2.10) - при записи денежных сумм первая буква делается
большой, изменены функции Q_CRC32 и Q_NextCRC32,
(!!!) чтобы соответствовать общепринятому алгоритму
вычисления CRC32, добавлены функции для работы с
датой, внесены исправления в комментарии;
07.02.2000 г. (v2.09) - добавлено несколько функций для работы с байтовыми
строками, функции для преобразования числа в строку
и для получения записи денежных сумм прописью;
25.01.2000 г. (v2.07) - исправлено несколько ошибок, добавлены функций для
работы с байтовыми массивами;
конец 1999 г. - первые версии QStrings.
ВНИМАНИЕ !!!
1. Если необходимо применить Q_FillChar, Q_NOTByteArr или другую подобную
функцию (в которую передается указатель и данные по указателю изменяются)
к строке S, то сначала надо вызвать стандартную процедуру UniqueString(S)
для фактического выделения памяти и исключения множественных ссылок и
ссылок на константную строку. Только после этого можно изменять строку
по указателю, например: Q_FillChar( Pointer(S), Length(S), '*' ).
2. Когда вы распределяете память под строку S с помощью SetString или
SetLength, а затем вызываете какие-либо функции или процедуры из этой
библиотеки, принимающие в качестве var-параметра (не const-) строку S,
то при выходе из этих функций или процедур размер памяти, выделенный
под строку S, может отличаться от исходного (т.е. в ходе выполнения
функции память под строку может быть перераспределена). Это замечание
не относится к процедурам Q_StrMoveL, Q_StrUpperMoveL, Q_StrLowerMoveL,
Q_IntToStrBuf, Q_UIntToStrBuf, Q_UIntToStrLBuf, Q_UIntToHexBuf,
Q_UIntToOctBuf, Q_UIntToBinBuf и процедурам, в которые строка передается
как указатель. В ходе выполнения перечисленных процедур память
не перераспределяется.
}
interface
{ Множество символов в языке Паскаль. }
type
TCharSet = set of Char;
{ Символы, по умолчанию используемые как разделители слов. }
const
Q_StdDelimsSet = [#0..#32,'!','"','(',')','*','+',',','-','.','/',':',
';','<','=','>','?','[','\',']','^','{','}','|'];
{ Названия месяцев и дней недели. }
Q_MonthsUp: array[1..12] of string =
('Январь','Февраль','Март','Апрель','Май','Июнь','Июль','Август',
'Сентябрь','Октябрь','Ноябрь','Декабрь');
Q_MonthsLo: array[1..12] of string =
('января','февраля','марта','апреля','мая','июня','июля','августа',
'сентября','октября','ноября','декабря');
Q_MonthsEng: array[1..12] of string =
('January','February','March','April','May','June','July','August',
'September','October','November','December');
Q_SMonthsUp: array[1..12] of string =
('Янв','Фев','Мар','Апр','Май','Июн','Июл','Авг','Сен','Окт','Ноя','Дек');
Q_SMonthsLo: array[1..12] of string =
('янв','фев','мар','апр','мая','июн','июл','авг','сен','окт','ноя','дек');
Q_SMonthsEng: array[1..12] of string =
('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
Q_WeekDays: array[1..7] of string =
('Воскресенье','Понедельник','Вторник','Среда','Четверг',
'Пятница','Суббота');
Q_WeekDaysEng: array[1..7] of string =
('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday');
Q_SWeekDays2: array[1..7] of string =
('Вс','Пн','Вт','Ср','Чт','Пт','Сб');
Q_SWeekDays3: array[1..7] of string =
('Вск','Пон','Втр','Срд','Чет','Пят','Суб');
Q_SWeekDaysEng: array[1..7] of string =
('Sun','Mon','Tue','Wed','Thu','Fri','Sat');
{ Функции для сравнения строк. }
{ Q_CompStr сравнивает две строки с учетом регистра. Возвращаемый результат
меньше нуля, если S1 < S2; больше нуля, если S1 > S2, и равен нулю, если
S1 = S2. Эта функция прекращает сравнение, когда обнаружено различие строк
или когда обнаружен символ с кодом 0. Если этот символ может встречаться в
середине строки, используйте вместо Q_CompStr функцию Q_CompStrL. Вторая
функция Q_PCompStr аналогична Q_CompStr для PChar и Pointer(String). Если
необходимо выяснить только, равны две строки или не равны, воспользуйтесь
вместо Q_CompStr функцией Q_SameStr. }
function Q_CompStr(const S1, S2: string): Integer;
function Q_PCompStr(P1, P2: PChar): Integer;
{ Q_CompStrL сравнивает две строки по MaxL первым символам с учетом регистра.
Возвращаемый результат меньше нуля, если Copy(S1,1,MaxL) < Copy(S2,1,MaxL);
результат больше нуля, если Copy(S1,1,MaxL) > Copy(S2,1,MaxL), иначе
результат равен нулю (если Copy(S1,1,MaxL) = Copy(S2,1,MaxL) ). Если Вам
надо выяснить только, равны две строки или не равны, воспользуйтесь
вместо Q_CompStrL функцией Q_SameStrL. }
function Q_CompStrL(const S1, S2: string; MaxL: Cardinal = MaxInt): Integer;
{ Q_CompText сравнивает две строки без учета регистра. Возвращаемый результат
меньше нуля, если S1 < S2; больше нуля, если S1 > S2, и равен нулю, если
S1 = S2. Эта функция прекращает сравнение, когда обнаружено различие строк
или когда обнаружен символ с кодом 0. Если этот символ может встречаться в
середине строки, используйте вместо Q_CompText функцию Q_CompTextL. Вторая
функция Q_PCompText аналогична Q_CompText для PChar и Pointer(String). Если
необходимо выяснить только, равны ли две строки или нет, воспользуйтесь
вместо Q_CompText функцией Q_SameText. }
function Q_CompText(const S1, S2: string): Integer;
function Q_PCompText(P1, P2: PChar): Integer;
{ Q_CompTextL сравнивает две строки по MaxL первым символам без учета регистра.
Если фрагмент первой строки больше (в алфавитном порядке), чем фрагмент
второй строки, возвращаемое значение больше нуля. Если фрагмент первой строки
меньше, чем фрагмент второй строки, возвращаемое значение меньше нуля, иначе
результат равен нулю. Если необходимо выяснить только, равны ли две строки
или не равны, используйте вместо Q_CompTextL функцию Q_SameTextL. }
function Q_CompTextL(const S1, S2: string; MaxL: Cardinal = MaxInt): Integer;
{ Q_SameStr сравнивает две строки с учетом регистра и возвращает True, если
строки равны, иначе возвращает False. Функция Q_PSameStr аналогична Q_SameStr
для Pointer(String). }
function Q_SameStr(const S1, S2: string): Boolean;
function Q_PSameStr(P1, P2: Pointer): Boolean;
{ Q_SameStrL сравнивает две строки по MaxL первым символам с учетом регистра.
Возвращает True, если строки равны, иначе возвращает False. }
function Q_SameStrL(const S1, S2: string; MaxL: Cardinal): Boolean;
{ Q_SameText сравнивает две строки без учета регистра и возвращает True, если
строки равны, иначе - False. Функция Q_PSameText аналогична Q_SameStr для
Pointer(String). }
function Q_SameText(const S1, S2: string): Boolean;
function Q_PSameText(P1, P2: Pointer): Boolean;
{ Q_SameTextL сравнивает две строки по MaxL первым символам без учета регистра.
Возвращает True, если строки равны, иначе возвращает False. }
function Q_SameTextL(const S1, S2: string; MaxL: Cardinal): Boolean;
{ Q_MatchStr проверяет, имеет ли место вхождение подстроки SubStr в строку S,
начиная с символа S[Pos]. При сравнении учитывается регистр символов. Если
вхождение имеет место, функция возвращает True, иначе - False. Эта функция
реализует собой быстрый вариант проверки Q_SameStr(X,Copy(S,Pos,Length(X))).
В отличие от других аналогичных функций, подстрока нулевой длины входит в
любую строку. Идея этой функции заимствована из модуля cStrings.pas, автором
которого является David Butler ([email protected]). }
function Q_MatchStr(const SubStr, S: string; Pos: Integer = 1): Boolean;
{ Q_MatchText проверяет, имеет ли место вхождение подстроки SubStr в строку S,
начиная с символа S[Pos]. При сравнении регистр символов не учитывается. Если
вхождение имеет место, функция возвращает True, иначе - False. Эта функция
реализует собой быстрый вариант проверки Q_SameText(X,Copy(S,Pos,Length(X))).
В отличие от других аналогичных функций, подстрока нулевой длины входит в
любую строку. Идея этой функции заимствована из модуля cStrings.pas, автором
которого является David Butler ([email protected]). }
function Q_MatchText(const SubStr, S: string; Pos: Integer = 1): Boolean;
{ Q_TestByMask проверяет, удовлетворяет ли строка S маске Mask, предполагая,
что символы MaskChar из строки Mask могут быть заменены в строке S любыми
другими символами. При сравнении регистр символов принимается во внимание.
Если строка S удовлетворяет маске, функция возвращает True, иначе False.
Например, Q_TestMask('ISBN 5-09-007017-2','ISBN ?-??-??????-?','?') вернет
значение True. }
function Q_TestByMask(const S, Mask: string; MaskChar: Char = 'X'): Boolean;
{ Q_TestWildStr проверяет, удовлетворяет ли строка S маске Mask, предполагая,
что символы MaskChar из строки Mask могут быть заменены в строке S любыми
другими символами, а символы WildCard могут быть заменены любым количеством
других символов. При сравнении большие и маленькие буквы различаются. Символ
WildCard должен быть отличен от #0. Если строка S удовлетворяет маске,
функция возвращает True, иначе False. Например, следующий вызов функции
вернет True: Q_TestWildStr('abc12345_infQ_XL.dat','abc*_???Q_*.d*at'). }
function Q_TestWildStr(const S, Mask: string; MaskChar: Char = '?';
WildCard: Char = '*'): Boolean;
{ Q_TestWildText аналогична функции Q_TestWildStr, но регистр символов
не принимается во внимание (большие и маленькие буквы не различаются). }
function Q_TestWildText(const S, Mask: string; MaskChar: Char = '?';
WildCard: Char = '*'): Boolean;
{ Функции для изменения регистра символов. }
{ Q_CharUpper переводит символ Ch в верхний регистр (в большую букву). }
function Q_CharUpper(Ch: Char): Char;
{ Q_CharLower переводит символ Ch в нижний регистр (в маленькую букву). }
function Q_CharLower(Ch: Char): Char;
{ Q_StrUpper переводит строку S в верхний регистр (в большие буквы). При
этом изменяется исходная строка. Функция Q_PStrUpper аналогична процедуре
Q_StrUpper для PChar и Pointer(String), за исключением того, что она
дополнительно возвращает указатель на начало строки. }
procedure Q_StrUpper(var S: string);
function Q_PStrUpper(P: PChar): PChar;
{ Q_StrLower переводит строку S в нижний регистр (в маленькие буквы). При
этом изменяется исходная строка. Функция Q_PStrLower аналогична процедуре
Q_StrLower для PChar и Pointer(String), за исключением того, что она
дополнительно возвращает указатель на начало строки. }
procedure Q_StrLower(var S: string);
function Q_PStrLower(P: PChar): PChar;
{ Q_StrUpperMoveL копирует содержимое строки Source в строку Dest. При этом
символы переводятся в верхний регистр. Максимальное число копируемых
символов равно MaxL. Длина строки Dest устанавливается равной числу
скопированных символов. Память для строки Dest должна быть распределена
заблаговременно вызовом функции SetString (или SetLength) (размером
не менее MaxL символов). }
procedure Q_StrUpperMoveL(const Source: string; var Dest: string; MaxL: Cardinal);
{ Q_StrLowerMoveL копирует содержимое строки Source в строку Dest. При этом
символы переводятся в нижний регистр. Максимальное число копируемых
символов равно MaxL. Длина строки Dest устанавливается равной числу
скопированных символов. Память для строки Dest должна быть распределена
предварительно вызовом функции SetString (или SetLength) (размером
не менее MaxL символов). }
procedure Q_StrLowerMoveL(const Source: string; var Dest: string; MaxL: Cardinal);
{ Q_UpperCase переводит строку S в верхний регистр (в большие буквы). Исходная
строка при этом не изменяется. Эта функция работает медленнее, чем Q_StrUpper
или Q_StrUpperMoveL. }
function Q_UpperCase(const S: string): string;
{ Q_LowerCase переводит строку S в нижний регистр (в маленькие буквы). Исходная
строка при этом не изменяется. Эта функция работает медленнее, чем Q_StrLower
или Q_StrLowerMoveL. }
function Q_LowerCase(const S: string): string;
{ Q_UpLowerInPlace преобразует первый символ строки к верхнему регистру, а все
остальные символы - к нижнему регистру. Исходная строка изменяется. }
procedure Q_UpLowerInPlace(var S: string);
{ Q_UpLowerStr преобразует первый символ строки к верхнему регистру, а все
остальные символы - к нижнему регистру. Исходная строка не изменяется.
Например: 'мЫРблКА bsDSFc' -> 'Мырблка bsdsfc'. }
function Q_UpLowerStr(const S: string): string;
{ Q_ProperCaseInPlace изменяет строку S таким образом, что каждое слово будет
начинаться с большой, а продолжаться маленькими буквами (первая буква каждого
слова преобразуется к верхнему регистру, а остальные буквы - к нижнему
регистру). Исходная строка S изменяется. В строке Delimiters передаются
символы, которые рассматриваются как разделители слов в строке S. Если
Delimiters равна пустой строке, используется список разделителей, которые
были заданы в ходе предыдущего вызова одной из следующих функций Q_StrTok,
Q_StrSpn, Q_StrCSpn, Q_ProperCase, Q_ProperCaseInPlace, Q_WordAtPos,
Q_GetWordN, Q_SetDelimiters, Q_CountOfWords. Если разделители передаются
в виде множества, они не запоминаются для последующих вызовов функций. }
procedure Q_ProperCaseInPlace(var S: string; const Delimiters: string); overload;
procedure Q_ProperCaseInPlace(var S: string;
const Delimiters: TCharSet = Q_StdDelimsSet); overload;
{ Q_ProperCase возвращает строку S, преобразованную таким образом, что каждое
слово начинается с большой буквы (первая буква каждого слова переводится в
верхний регистр, а остальные буквы - в нижний регистр). В строке Delimiters
передаются символы, которые рассматриваются как разделители слов в строке S.
Например, вызов функции Q_ProperCase('средства ИНТЕРНЕТА',' ') вернет строку
'Средства Интернета'. Если Delimiters равна пустой строке, используется
список разделителей, которые были заданы в ходе предыдущего вызова одной из
следующих функций: Q_ProperCaseInPlace, Q_ProperCase, Q_StrTok, Q_StrSpn,
Q_StrCSpn, Q_WordAtPos, Q_GetWordN, Q_SetDelimiters, Q_CountOfWords. Если
разделители передаются в виде множества, они не запоминаются для последующих
вызовов функций. }
function Q_ProperCase(const S, Delimiters: string): string; overload;
function Q_ProperCase(const S: string;
const Delimiters: TCharSet = Q_StdDelimsSet): string; overload;
{ Функции перекодировки строк: из DOS в Windows и наоборот. }
{ Q_StrToAnsi переводит строку S из кодировки DOS в кодировку Windows. При
этом изменяется исходная строка. Q_PStrToAnsi аналогична процедуре
Q_StrToAnsi для PChar и Pointer(String), за исключением того, что она
дополнительно возвращает указатель на начало строки. }
procedure Q_StrToAnsi(var S: string);
function Q_PStrToAnsi(P: PChar): PChar;
{ Q_StrToOem переводит строку S из кодировки Windows в кодировку DOS. При
этом изменяется исходная строка. Функция Q_PStrToOem аналогична процедуре
Q_StrToOem для PChar и Pointer(String), за исключением того, что она
дополнительно возвращает указатель на начало строки. }
procedure Q_StrToOem(var S: string);
function Q_PStrToOem(P: PChar): PChar;
{ Q_PStrToAnsiL переводит L первых символов строки, указываемой параметром P,
из кодировки DOS в кодировку Windows. При этом изменяется исходная строка.
Функция возвращает указатель на начало строки. }
function Q_PStrToAnsiL(P: PChar; L: Cardinal): PChar;
{ Q_PStrToOemL переводит L первых символов строки, указываемой параметром P,
из кодировки Windows в кодировку DOS. При этом изменяется исходная строка.
Функция возвращает указатель на начало строки. }
function Q_PStrToOemL(P: PChar; L: Cardinal): PChar;
{ Q_Str2ToAnsi переводит строку Source из кодировки DOS в кодировку Windows.
Результат сохраняется в строке Dest. Q_PStr2ToAnsi аналогична процедуре
Q_Str2ToAnsi для PChar и Pointer(String), за исключение того, что она
дополнительно возвращает указатель на начало строки-приемника Dest. }
procedure Q_Str2ToAnsi(const Source: string; var Dest: string);
function Q_PStr2ToAnsi(Source, Dest: PChar): PChar;
{ Q_Str2ToOem переводит строку Source из кодировки Windows в кодировку DOS.
Результат сохраняется в строке Dest. Q_PStr2ToOem аналогична процедуре
Q_Str2ToOem для PChar и Pointer(String), за исключение того, что она
дополнительно возвращает указатель на начало строки-приемника Dest. }
procedure Q_Str2ToOem(const Source: string; var Dest: string);
function Q_PStr2ToOem(Source, Dest: PChar): PChar;
{ Q_PStr2ToAnsiL переводит L первых символов строки Source из кодировки
DOS в кодировку Windows. Результат сохраняется в строке Dest. Функция
возвращает указатель на начало строки-приемника Dest. }
function Q_PStr2ToAnsiL(Source, Dest: PChar; L: Cardinal): PChar;
{ Q_PStr2ToOemL переводит L первых символов строки Source из кодировки Windows
в кодировку DOS. Результат сохраняется в строке Dest. Функция возвращает
указатель на начало строки-приемника Dest. }
function Q_PStr2ToOemL(Source, Dest: PChar; L: Cardinal): PChar;
{ Q_ToAnsi переводит строку OemStr из кодировки DOS в кодировку Windows. При
этом исходная строка не изменяется. Эта функция работает медленнее, чем
другие аналогичные функции и процедуры из этого модуля. }
function Q_ToAnsi(const OemStr: string): string;
{ Q_ToOem переводит строку AnsiStr из кодировки Windows в кодировку DOS. При
этом исходная строка не изменяется. Эта функция работает медленнее, чем
другие аналогичные функции и процедуры из этого модуля. }
function Q_ToOem(const AnsiStr: string): string;
{ Поиск, замена и удаление подстрок и отдельных символов. }
{ Q_PosStr находит первое входение подстроки FindString в строке SourceString,
начиная с позиции StartPos. Возвращается номер символа, с которого начинается
вхождение или 0, если подстрока FindString не найдена в строке SourceString.
Поиск подстроки производится с учетом регистра (большие и маленькие буквы
различаются). Автор алгоритма - Peter Morris (UK) (модуль FastStrings). }
function Q_PosStr(const FindString, SourceString: string;
StartPos: Integer = 1): Integer;
{ Q_PosText находит первое входение подстроки FindString в строке SourceString,
начиная с позиции StartPos. Возвращается номер символа, с которого начинается
вхождение или 0, если подстрока FindString не найдена в строке SourceString.
Поиск подстроки производится без учета регистра (большие и маленькие буквы
не различаются). Автор алгоритма - Peter Morris (UK) (модуль FastStrings). }
function Q_PosText(const FindString, SourceString: string;
StartPos: Integer = 1): Integer;
{ Q_PosStrLimited находит первое входение подстроки FindString в строке
SourceString, начиная с позиции StartPos и заканчивая позицией EndPos.
Возвращается номер символа, с которого начинается вхождение или 0, если
подстрока FindString не найдена в строке SourceString. Поиск подстроки
производится с учетом регистра (большие и маленькие буквы различаются). }
function Q_PosStrLimited(const FindString, SourceString: string;
StartPos: Integer = 1; EndPos: Integer = MaxInt): Integer;
{ Q_PosTextLimited находит первое входение подстроки FindString в строке
SourceString, начиная с позиции StartPos и заканчивая позицией EndPos.
Возвращается номер символа, с которого начинается вхождение или 0, если
подстрока FindString не найдена. Поиск подстроки производится без учета
регистра (большие и маленькие буквы не различаются). }
function Q_PosTextLimited(const FindString, SourceString: string;
StartPos: Integer = 1; EndPos: Integer = MaxInt): Integer;
{ Q_PosLastStr находит последнее входение подстроки FindString в строке
SourceString, полагая, что следующее вхождение было найдено в позиции
LastPos. Возвращается номер символа, с которого начинается искомая подстрока
или 0, если данная подстрока не найдена ранее (левее) указанной позиции.
Предполагается, что отдельные вхождения подстроки не перекрывают друг друга.
Поиск подстроки производится с учетом регистра (большие и маленькие буквы
различаются). Если LastPos превышает длину строки SourceString, то ищется
самое последнее вхождение подстроки FindString. }
function Q_PosLastStr(const FindString, SourceString: string;
LastPos: Integer = MaxInt): Integer;
{ Q_PosLastText находит последнее входение подстроки FindString в строке
SourceString, полагая, что следующее вхождение было найдено в позиции
LastPos. Возвращается номер символа, с которого начинается искомая подстрока
или 0, если данная подстрока не найдена ранее (левее) указанной позиции.
Предполагается, что отдельные вхождения подстроки не перекрывают друг друга.
Поиск подстроки производится без учета регистра (большие и маленькие буквы
не различаются). Если LastPos превышает длину строки SourceString, то
ищется самое последнее вхождение подстроки FindString. }
function Q_PosLastText(const FindString, SourceString: string;
LastPos: Integer = MaxInt): Integer;
{ Функции Q_TablePosXXX можно использовать для многократного поиска подстроки
в строке (одной или многих), когда подстрока состоит из нескольких символов.
Эти функции представляют собой одну из реализаций алгоритма поиска подстрок,
называемого "Boyer-Moore pattern searching algorithm". Сначала вызывается
процедура типа Q_InitTablePosXXX для задания искомой подстроки, а затем
соответствующая функция Q_TablePosXXX для фактического поиска подстроки в
строке. Эта вторая функция может вызываться многократно для поиска некоторого
фрагмента во многих строках или для поиска нескольких вхождений подстроки в
одну строку. Все функции и процедуры являются потокобезопасными, т.е.
Q_TablePosXXX работает только с подстрокой, которая была указана при вызове
Q_InitTablePosXXX в том же потоке. Одновременно поиск может проводиться
в другом потоке, что никак не повлияет на текущий поток. Следует отметить,
что Q_InitTablePosStr и Q_InitTablePosText используют одну и ту же область
памяти для хранения искомой подстроки. Таким образом, нельзя смешивать поиск
подстроки с учетом и без учета регистра. Скорость работы этих функций может
быть различной в зависимости от длины подстроки и набора входящих в нее
символов. Во многих случаях эти функции работают быстрее, чем Q_PosStr и
Q_PosText, но чаще бывает наоборот. }
{ Q_InitTablePosStr инициирует поиск подстроки в строке с учетом регистра
символов. Эта процедура должна быть вызвана для задания искомой подстроки
перед тем, как будет вызываться функция Q_TablePosStr. }
procedure Q_InitTablePosStr(const FindString: string);
{ Q_TablePosStr находит в строке SourceString подстроку, определенную при
вызове Q_InitTablePosStr. В параметре LastPos передается номер символа,
с которого начиналось предыдущее найденное вхождение этой подстроки в
строке SourceString. В этом же параметре возвращается позиция нового
очередного вхождения искомой подстроки. Первоначально, значение параметра
LastPos должно быть равно нулю. Если подстрока найдена, функция
Q_TablePosStr возвращает True, иначе - False. Если подстрока не найдена,
значение параметра LastPos не изменяется. }
function Q_TablePosStr(const SourceString: string; var LastPos: Integer): Boolean;
{ Q_InitTablePosText инициирует поиск подстроки в строке без учета
регистра символов. Эта процедура должна быть вызвана для задания искомой
подстроки перед тем, как будет вызываться функция Q_TablePosText. }
procedure Q_InitTablePosText(const FindString: string);
{ Q_TablePosText находит в строке SourceString подстроку, определенную при
вызове Q_InitTablePosText. В параметре LastPos передается номер символа,
с которого начиналось предыдущее найденное вхождение этой подстроки в
строке SourceString. В этом же параметре возвращается позиция нового
очередного вхождения искомой подстроки. Первоначально, значение параметра
LastPos должно быть равно нулю. Если подстрока найдена, функция
Q_TablePosText возвращает True, иначе - False. Если подстрока не найдена,
значение параметра LastPos не изменяется. }
function Q_TablePosText(const SourceString: string; var LastPos: Integer): Boolean;
{ Q_ReplaceStr заменяет все входения подстроки FindString в строке SourceString
подстрокой ReplaceString. Поиск подстроки производится с учетом регистра
(большие и маленькие буквы различаются). Функция возвращает строку-результат.
Если подстрока FindString отсутствует в строке SourceString, то возвращается
исходная строка SourceString. }
function Q_ReplaceStr(const SourceString, FindString, ReplaceString: string): string;
{ Q_ReplaceText заменяет все входения подстроки FindString в строке
SourceString подстрокой ReplaceString. Поиск подстроки производится без учета
регистра (большие и маленькие буквы не различаются). Функция возвращает
строку-результат. Если подстрока FindString отсутствует в строке SourceString,
то возвращается исходная строка SourceString. }
function Q_ReplaceText(const SourceString, FindString, ReplaceString: string): string;
{ Q_ReplaceFirstStr заменяет первое вхождение подстроки FindString в строке
SourceString подстрокой ReplaceString. Подстрока FindString ищется, начиная
с символа S[StartPos]. Номер символа, с которого начинается найденное вхож-
дение подстроки, возвращается как результат функции (или ноль, если подстрока
не найдена). Поиск подстроки FindString выполняется с учетом регистра
символов (большие и маленькие буквы различаются). }
function Q_ReplaceFirstStr(var S: string; const FindString, ReplaceString: string;
StartPos: Integer = 1): Integer;
{ Q_ReplaceFirstText заменяет первое вхождение подстроки FindString в строке
SourceString подстрокой ReplaceString. Подстрока FindString ищется, начиная
с символа S[StartPos]. Номер символа, с которого начинается найденное вхож-
дение подстроки, возвращается как результат функции (или ноль, если подстрока
не найдена). Поиск подстроки FindString выполняется без учета регистра
символов (большие и маленькие буквы не различаются). }
function Q_ReplaceFirstText(var S: string; const FindString, ReplaceString: string;
StartPos: Integer = 1): Integer;
{ Q_ReplaceLastStr заменяет последнее вхождение подстроки FindString в строке
SourceString подстрокой ReplaceString. Подстрока FindString ищется слева от
символа S[LastPos] (т.е. во фрагменте Copy(S, 1, LastPos-1)). Номер символа,
с которого начинается найденное вхождение, возвращается как результат функции
(или ноль, если подстрока не найдена). Поиск подстроки FindString выполняется
с учетом регистра символов (большие и маленькие буквы различаются). Если
LastPos превышает длину строки S, то заменяется самое последнее вхождение
искомой подстроки. }
function Q_ReplaceLastStr(var S: string; const FindString, ReplaceString: string;
LastPos: Integer = MaxInt): Integer;
{ Q_ReplaceLastText заменяет последнее вхождение подстроки FindString в строке
SourceString подстрокой ReplaceString. Подстрока FindString ищется слева от
символа S[LastPos] (т.е. во фрагменте Copy(S, 1, LastPos-1)). Номер символа,
с которого начинается найденное вхождение, возвращается как результат функции
(или ноль, если подстрока не найдена). Поиск подстроки FindString выполняется
без учета регистра символов (большие и маленькие буквы не различаются). Если
LastPos превышает длину строки S, то заменяется самое последнее вхождение
искомой подстроки. }
function Q_ReplaceLastText(var S: string; const FindString, ReplaceString: string;
LastPos: Integer = MaxInt): Integer;
{ Q_DeleteStr удаляет из строки S все вхождения подстроки SubStrToDel. Поиск
подстроки ведется с учетом регистра символов. Функция возвращает количество
найденных (и удаленных) фрагментов. }
function Q_DeleteStr(var S: string; const SubStrToDel: string): Integer;
{ Q_DeleteText удаляет из строки S все вхождения подстроки SubStrToDel. Поиск
подстроки ведется без учета регистра символов. Функция возвращает количество
найденных (и удаленных) фрагментов. }
function Q_DeleteText(var S: string; const SubStrToDel: string): Integer;
{ Q_DeleteFirstStr удаляет первое вхождение подстроки SubStrToDel из строки
SourceString. Подстрока SubStrToDel ищется, начиная с символа S[StartPos].
Номер символа, с которого начинается найденное вхождение подстроки, возвра-
щается как результат функции (или ноль, если подстрока не найдена). Поиск
подстроки SubStrToDel выполняется с учетом регистра символов (большие и
маленькие буквы различаются). }
function Q_DeleteFirstStr(var S: string; const SubStrToDel: string; StartPos:
Integer = 1): Integer;
{ Q_DeleteFirstText удаляет первое вхождение подстроки SubStrToDel из строки
SourceString. Подстрока SubStrToDel ищется, начиная с символа S[StartPos].
Номер символа, с которого начинается найденное вхождение подстроки, возвра-
щается как результат функции (или ноль, если подстрока не найдена). Поиск
подстроки SubStrToDel выполняется без учета регистра символов (большие и
маленькие буквы не различаются). }
function Q_DeleteFirstText(var S: string; const SubStrToDel: string; StartPos:
Integer = 1): Integer;
{ Q_DeleteLastStr удаляет последнее вхождение подстроки SubStrToDel в строке
SourceString. Подстрока SubStrToDel ищется слева от символа S[LastPos]
(во фрагменте Copy(S, 1, LastPos-1)). Номер символа, с которого начинается
найденное вхождение подстроки, возвращается как результат функции (или ноль,
если подстрока не найдена). Поиск подстроки SubStrToDel выполняется с учетом
регистра символов (большие и маленькие буквы различаются). }
function Q_DeleteLastStr(var S: string; const SubStrToDel: string; LastPos:
Integer = MaxInt): Integer;
{ Q_DeleteLastText удаляет последнее вхождение подстроки SubStrToDel в строке
SourceString. Подстрока SubStrToDel ищется слева от символа S[LastPos]
(во фрагменте Copy(S, 1, LastPos-1)). Номер символа, с которого начинается
найденное вхождение подстроки, возвращается как результат функции (или ноль,
если подстрока не найдена). Поиск подстроки SubStrToDel выполняется без
учета регистра символов (большие и маленькие буквы не различаются). }
function Q_DeleteLastText(var S: string; const SubStrToDel: string; LastPos:
Integer = MaxInt): Integer;
{ Q_ReplaceChar заменяет в строке S каждое вхождение символа ChOld на символ
ChNew. Результат функции равен количеству произведенных замен. Исходная
строка S изменяется. }
function Q_ReplaceChar(var S: string; ChOld, ChNew: Char): Integer;
{ Q_ReplaceChars заменяет в строке S все символы из строки StrChOld соответст-
вующими символами из строки StrChNew. Исходная строка S изменяется. Если
число символов в строке StrChOld не равно числу символов в строке StrChNew,
возникает исключительная ситуация типа Exception. }
procedure Q_ReplaceChars(var S: string; const StrChOld, StrChNew: string);
{ Q_ReplaceCharsByOneChar заменяет все подряд идущие вхождения символов из
множества ChOldSet в строке S одним символом ChNew. Исходная строка S при
этом изменяется. Если надо заменить несколько символов одним без удаления
повторений, воспользуйтесь процедурой Q_ReplaceChars. }
procedure Q_ReplaceCharsByOneChar(var S: string; const ChOldSet: TCharSet;
ChNew: Char);
{ Q_StrScan находит первое вхождение символа Ch в строку S, начиная с символа
номер StartPos. Возвращает номер найденного символа или ноль, если символ Ch
в строке S не найден. Функция Q_PStrScan аналогична Q_StrScan для
Pointer(String). }
function Q_StrScan(const S: string; Ch: Char; StartPos: Integer = 1): Integer;
function Q_PStrScan(P: Pointer; Ch: Char; StartPos: Integer = 1): Integer;
{ Q_StrRScan находит предыдущее вхождение символа Ch в строку S. В параметре
LastPos передается номер символа, соответствующий текущему вхождению Ch в
строку S. Поиск начинается с символа, предшествующего символу S[LastPos] или
с последнего символа строки, если LastPos превышает длину строки S. Функция
возвращает номер найденного символа или ноль, если символ Ch не найден в
строке S левее символа с номером LastPos. Функция Q_PStrRScan аналогична
Q_StrRScan для Pointer(String). }
function Q_StrRScan(const S: string; Ch: Char; LastPos: Integer = MaxInt): Integer;
function Q_PStrRScan(P: Pointer; Ch: Char; LastPos: Integer = MaxInt): Integer;
{ Q_StrSpn возвращает номер первого символа строки S, не входящего в строку
Delimiters, начиная с символа номер StartPos. Строка Delimiters задает
множество символов-разделителей, а функция находит первый символ,
не являющийся разделителем. Если обычные символы в строке S отсутствуют,
возвращается ноль. Если Delimiters равна пустой строке, используется список
разделителей, которые были заданы в ходе предыдущего вызова одной из
следующих функций: Q_StrTok, Q_StrSpn, Q_StrCSpn, Q_ProperCase, Q_WordAtPos,
Q_GetWordN, Q_ProperCaseInPlace, Q_SetDelimiters, Q_CountOfWords. Если
разделители передаются в виде множества типа TCharSet, они не запоминаются
для последующих вызовов функций. }
function Q_StrSpn(const S, Delimiters: string; StartPos: Cardinal = 1): Integer; overload;
function Q_StrSpn(const S: string; StartPos: Cardinal = 1;
const Delimiters: TCharSet = Q_StdDelimsSet): Integer; overload;
{ Q_StrCSpn возвращает номер первого символа строки S, входящего в строку
Delimiters, начиная с символа номер StartPos. Строка Delimiters задает
множество символов-разделителей, а функция находит первый символ-разделитель.
Если символы-разделители в строке S отсутствуют, возвращается ноль. Если
Delimiters равна пустой строке, используется список разделителей, которые
были заданы в ходе предыдущего вызова одной из следующих функций: Q_StrTok,
Q_StrSpn, Q_StrCSpn, Q_ProperCase, Q_ProperCaseInPlace, Q_WordAtPos,
Q_GetWordN, Q_SetDelimiters, Q_CountOfWords. Если разделители передаются
в виде множества, они не запоминаются для последующих вызовов функций. }
function Q_StrCSpn(const S, Delimiters: string; StartPos: Cardinal = 1): Integer; overload;
function Q_StrCSpn(const S: string; StartPos: Cardinal = 1;
const Delimiters: TCharSet = Q_StdDelimsSet): Integer; overload;
{ Q_DelCharInPlace удаляет все символы Ch из строки S. Исходная строка при
этом изменяется. }
procedure Q_DelCharInPlace(var S: string; Ch: Char = ' ');
{ Q_DelChar удаляет все символы Ch из строки, переданной параметром S. }
function Q_DelChar(const S: string; Ch: Char = ' '): string;
{ Q_Delete удаляет подстроку из строки S. При этом исходная строка изменяется.
Index - индекс первого удаляемого символа, Count - количество символов,
подлежащих удалению. Эта функция работает быстрее, чем стандартная Delete. }
procedure Q_Delete(var S: string; Index, Count: Integer);
{ Q_DelChars удаляет из строки S символы, которые присутствуют в строке
(или множестве) CharsToRemove. Исходная строка S изменяется. }
procedure Q_DelChars(var S: string; const CharsToRemove: string); overload;
procedure Q_DelChars(var S: string; const CharsToRemove: TCharSet); overload;
{ Q_KeepChars оставляет в строке S только те символы, которые присутствуют в
строке (или множестве) CharsToKeep, остальные символы удаляет. Исходная
строка S изменяется. }
procedure Q_KeepChars(var S: string; const CharsToKeep: string); overload;
procedure Q_KeepChars(var S: string; const CharsToKeep: TCharSet); overload;
{ Q_ApplyMask применяет маску Mask к строке SourceStr и возвращает полученную
строку как результат функции. Символ MaskChar используется в строке Mask для
указания позиций, в которых подставляются символы из строки SourceStr. Длина
SourceStr должна быть равна количеству символов MaskChar в маске. Пример:
Q_ApplyMask('(###) ##-##-##','075723293','#') вернет строку '(075) 72-32-93'.
Идея этой и следующих трех функций заимствована из модуля jbStr.Pas, автором
которого является Jaro Benes ([email protected]). }
function Q_ApplyMask(const Mask, SourceStr: string; MaskChar: Char = 'X'): string;
{ Q_ApplyMaskInPlace применяет маску Mask к строке SourceStr и сохраняет
полученную строку в переменной Mask. Символ MaskChar используется в строке
Mask для указания позиций, в которых подставляются символы из строки
SourceStr. Длина строки SourceStr должна соответствовать количеству символов
подстановки MaskChar в маске Mask. }
procedure Q_ApplyMaskInPlace(var Mask: string; const SourceStr: string;
MaskChar: Char = 'X');
{ Q_ExtractByMask удаляет из строки S все символы, являющиеся фиксированными
для данной маски Mask, оставляя только подставленные символы, т.е. символы,
которым в маске соответствует символ MaskChar. Полученная таким образом
строка возвращается как результат функции. Длина строк S и Mask должна быть
одинаковой. Пример: Q_ExtractByMask('7-35-01','X-XX-XX') вернет '73501'. }
function Q_ExtractByMask(const S, Mask: string; MaskChar: Char = 'X'): string;
{ Q_ExtractByMaskInPlace удаляет из строки S все символы, являющиеся
фиксированными для данной маски Mask, оставляя только подставленные символы,
т.е. символы, которым в маске соответствует символ MaskChar. Полученная
таким образом строка сохраняется в переменной, переданной параметром S.
Исходная длина строк S и Mask должна быть одинаковой. }
procedure Q_ExtractByMaskInPlace(var S: string; const Mask: string;
MaskChar: Char = 'X');
{ Форматирование строк, вырезка фрагментов строки. }
{ Q_TrimInPlace удаляет ведущие и концевые пробелы и управляющие символы из
строки S. При этом исходная строка изменяется. Эта процедура работает
быстрее, чем стандартная функция Trim. }
procedure Q_TrimInPlace(var S: string);
{ Q_TrimLeftInPlace удаляет ведущие пробелы и управляющие символы из строки S.
При этом исходная строка изменяется. Эта процедура работает быстрее, чем
стандартная функция TrimLeft. }
procedure Q_TrimLeftInPlace(var S: string);
{ Q_TrimRightInPlace удаляет концевые пробелы и управляющие символы из
строки S. При этом исходная строка изменяется. Эта процедура работает
быстрее, чем стандартная функция TrimRight. }
procedure Q_TrimRightInPlace(var S: string);
{ Q_TrimChar удаляет ведущие и концевые символы Ch из строки S. Исходная
строка S не изменяется. }
function Q_TrimChar(const S: string; Ch: Char = ' '): string;
{ Q_TrimCharLeft удаляет ведущие символы Ch из строки S. Исходная строка S
не изменяется.}
function Q_TrimCharLeft(const S: string; Ch: Char = ' '): string;
{ Q_TrimCharRight удаляет концевые символы Ch из строки S. Исходная строка S
не изменяется.}
function Q_TrimCharRight(const S: string; Ch: Char = ' '): string;
{ Q_KeepOneChar удаляет все подряд идущие символы Ch, кроме одного, из строки,
переданной параметром S. Исходная строка при этом не изменяется. Например,
Q_KeepOneChar('How do you do ',' ') вернет строку 'How do you do '. }
function Q_KeepOneChar(const S: string; Ch: Char = ' '): string;
{ Q_SpaceCompressInPlace удаляет из строки начальные и конечные пробелы и
управляющие символы (меньше пробела). Кроме того, все подряд идущие пробелы
и управляющие символы в середине строки заменяются одним пробелом. Исходная
строка изменяется. }
procedure Q_SpaceCompressInPlace(var S: string);
{ Q_SpaceCompress удаляет из строки начальные и конечные пробелы и управляющие
символы (меньше пробела). Кроме того, все подряд идущие пробелы и управляющие
символы в середине строки заменяются одним пробелом. Исходная строка при этом
не изменяется. Эта функция работает медленнее, чем Q_SpaceCompressInPlace. }
function Q_SpaceCompress(const S: string): string;
{ Q_PadLeft дополняет строку S символами PadCh слева до длины Length. Если
длина строки S больше Length, то, если параметр Cut = True, строка обрезается
справа до длины Length, иначе (Cut = False) возвращается исходная строка S. }
function Q_PadLeft(const S: string; Length: Integer; PadCh: Char = ' ';
Cut: Boolean = False): string;
{ Q_PadRight дополняет строку S символами PadCh справа до длины Length. Если
длина строки S больше Length, то, если параметр Cut = True, строка обрезается
справа до длины Length, иначе (Cut = False) возвращается исходная строка S. }
function Q_PadRight(const S: string; Length: Integer; PadCh: Char = ' ';
Cut: Boolean = False): string;
{ Q_CenterStr центрирует строку S символами PadCh относительно длины Length.
Если длина строки S больше Length, то, если параметр Cut = True, строка
обрезается справа до длины Length, иначе (Cut = False) возвращается исходная
строка S. }
function Q_CenterStr(const S: string; Length: Integer; PadCh: Char = ' ';
Cut: Boolean = False): string;
{ Q_PadInside добавляет (равномерно) символы PadCh в строку S в тех позициях,
где они уже присутствуют, до тех пор, пока длина строки не станет равной
Length. Другими словами, эта функция производит выравнивание текста по обоим
краям. Если длина строки превышает Length, то, если параметр Cut = True,
строка обрезается справа до длины Length, иначе (Cut = False) возвращается
исходная строка S. Никакие специальные символы не распознаются. }
function Q_PadInside(const S: string; Length: Integer; PadCh: Char = ' ';
Cut: Boolean = False): string;
{ Q_TabsToSpaces заменяет все символы табуляции (#9) в строке S пробелами.
Интервал табуляции задается параметром TabStop. }
function Q_TabsToSpaces(const S: string; TabStop: Integer = 8): string;
{ Q_SpacesToTabs заменяет последовательности пробелов в строке S символами
табуляции #9. Интервал табуляции задается параметром TabStop. Эта функция
работает, даже, если исходная строка уже содержит символы табуляции. }
function Q_SpacesToTabs(const S: string; TabStop: Integer = 8): string;
{ Q_StrTok возвращает очередной фрагмент строки S, одновременно удаляя его из
исходной строки. Q_StrTok рассматривает строку S как последовательность из
нуля или более текстовых фрагментов, отделенных друг от друга одним или более
символом-разделителем из строки Delimiters. В параметре Delimiters передается
строка, которая состоит из символов, которые рассматриваются как разделители
для строки S. Сами разделители не включаются во фрагмент, возвращаемый
функцией Q_StrTok. Если строка начинается с символов-разделителей, то все
они удаляются. Если Delimiters - пустая строке, используются разделители,
которые были заданы в ходе предыдущего вызова одной из следующих функций:
Q_StrTok, Q_StrSpn, Q_StrCSpn, Q_ProperCase, Q_WordAtPos, Q_SetDelimiters,
Q_GetWordN, Q_ProperCaseInPlace, Q_CountOfWords. Если разделители передаются
в виде множества, они не запоминаются для последующих вызовов функций. }
function Q_StrTok(var S: string; const Delimiters: string): string; overload;
function Q_StrTok(var S: string;
const Delimiters: TCharSet = Q_StdDelimsSet): string; overload;
{ Q_StrTok1 возвращает очередной фрагмент строки S, одновременно удаляя его
из исходной строки и удаляя следующий за ним символ-разделитель. Q_StrTok1
рассматривает строку S как последовательность из нуля или более текстовых
фрагментов, отделенных друг от друга единичным символом-разделителем из
строки Delimiters. Если в строке S подряд идет несколько разделителей, то
функция будет возвращать пустую строку для каждого такого символа, если
перед ним отсутствует текстовый фрагмент. В параметре Delimiters передается
строка, которая состоит из символов, которые рассматриваются как разделители
для строки S. Сами разделители не включаются во фрагмент, возвращаемый
функцией Q_StrTok1. Если Delimiters - пустая строке, используются символы,
которые были заданы в ходе предыдущего вызова одной из следующих функций:
Q_StrTok, Q_StrSpn, Q_StrCSpn, Q_ProperCase, Q_WordAtPos, Q_SetDelimiters,
Q_GetWordN, Q_ProperCaseInPlace, Q_CountOfWords. Если разделители передаются
в виде множества, они не запоминаются для последующих вызовов функций. }