← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lazarus/saucy

« back to all changes in this revision

Viewing changes to components/lazutils/paswstring.pas

  • Committer: Package Import Robot
  • Author(s): Paul Gevers, Abou Al Montacir, Bart Martens, Paul Gevers
  • Date: 2013-06-08 14:12:17 UTC
  • mfrom: (1.1.9)
  • Revision ID: package-import@ubuntu.com-20130608141217-7k0cy9id8ifcnutc
Tags: 1.0.8+dfsg-1
http://bugs.debian.org/708695
[ Abou Al Montacir ]
* New upstream major release and multiple maintenace release offering many
  fixes and new features marking a new milestone for the Lazarus development
  and its stability level.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_fixes_branch
* LCL changes:
  - LCL is now a normal package.
      + Platform independent parts of the LCL are now in the package LCLBase
      + LCL is automatically recompiled when switching the target platform,
        unless pre-compiled binaries for this target are already installed.
      + No impact on existing projects.
      + Linker options needed by LCL are no more added to projects that do
        not use the LCL package.
  - Minor changes in LCL basic classes behaviour
      + TCustomForm.Create raises an exception if a form resource is not
        found.
      + TNotebook and TPage: a new implementation of these classes was added.
      + TDBNavigator: It is now possible to have focusable buttons by setting
        Options = [navFocusableButtons] and TabStop = True, useful for
        accessibility and for devices with neither mouse nor touch screen.
      + Names of TControlBorderSpacing.GetSideSpace and GetSpace were swapped
        and are now consistent. GetSideSpace = Around + GetSpace.
      + TForm.WindowState=wsFullscreen was added
      + TCanvas.TextFitInfo was added to calculate how many characters will
        fit into a specified Width. Useful for word-wrapping calculations.
      + TControl.GetColorResolvingParent and
        TControl.GetRGBColorResolvingParent were added, simplifying the work
        to obtain the final color of the control while resolving clDefault
        and the ParentColor.
      + LCLIntf.GetTextExtentExPoint now has a good default implementation
        which works in any platform not providing a specific implementation.
        However, Widgetset specific implementation is better, when available.
      + TTabControl was reorganized. Now it has the correct class hierarchy
        and inherits from TCustomTabControl as it should.
  - New unit in the LCL:
      + lazdialogs.pas: adds non-native versions of various native dialogs,
        for example TLazOpenDialog, TLazSaveDialog, TLazSelectDirectoryDialog.
        It is used by widgetsets which either do not have a native dialog, or
        do not wish to use it because it is limited. These dialogs can also be
        used by user applications directly.
      + lazdeviceapis.pas: offers an interface to more hardware devices such
        as the accelerometer, GPS, etc. See LazDeviceAPIs
      + lazcanvas.pas: provides a TFPImageCanvas descendent implementing
        drawing in a LCL-compatible way, but 100% in Pascal.
      + lazregions.pas. LazRegions is a wholly Pascal implementation of
        regions for canvas clipping, event clipping, finding in which control
        of a region tree one an event should reach, for drawing polygons, etc.
      + customdrawncontrols.pas, customdrawndrawers.pas,
        customdrawn_common.pas, customdrawn_android.pas and
        customdrawn_winxp.pas: are the Lazarus Custom Drawn Controls -controls
        which imitate the standard LCL ones, but with the difference that they
        are non-native and support skinning.
  - New APIs added to the LCL to improve support of accessibility software
    such as screen readers.
* IDE changes:
  - Many improvments.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/New_IDE_features_since#v1.0_.282012-08-29.29
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes#IDE_Changes
* Debugger / Editor changes:
  - Added pascal sources and breakpoints to the disassembler
  - Added threads dialog.
* Components changes:
  - TAChart: many fixes and new features
  - CodeTool: support Delphi style generics and new syntax extensions.
  - AggPas: removed to honor free licencing. (Closes: Bug#708695)
[Bart Martens]
* New debian/watch file fixing issues with upstream RC release.
[Abou Al Montacir]
* Avoid changing files in .pc hidden directory, these are used by quilt for
  internal purpose and could lead to surprises during build.
[Paul Gevers]
* Updated get-orig-source target and it compinion script orig-tar.sh so that they
  repack the source file, allowing bug 708695 to be fixed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
components/lazutils/paswstring.pas
 
1
{
 
2
 *****************************************************************************
 
3
 *                                                                           *
 
4
 *  This file is part of the LazUtils package                                *
 
5
 *                                                                           *
 
6
 *  See the file COPYING.modifiedLGPL.txt, included in this distribution,    *
 
7
 *  for details about the copyright.                                         *
 
8
 *                                                                           *
 
9
 *  This program is distributed in the hope that it will be useful,          *
 
10
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 
11
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                     *
 
12
 *                                                                           *
 
13
 *****************************************************************************
 
14
}
 
15
unit paswstring;
 
16
 
 
17
{$mode objfpc}
 
18
{$inline on}
 
19
//{$define PASWSTRING_VERBOSE}
 
20
//{.$define PASWSTRING_SUPPORT_NONUTF8_ANSISTRING} disabled by default because
 
21
// non utf-8 ansistring is rare in UNIXes and lconvencoding makes the executable big
 
22
 
 
23
interface
 
24
 
 
25
uses
 
26
  SysUtils, lazutf8
 
27
  {$ifdef PASWSTRING_SUPPORT_NONUTF8_ANSISTRING}, lconvencoding{$endif}
 
28
  ;
 
29
 
 
30
{$IFNDEF VER2_7}
 
31
procedure SetPasWidestringManager;
 
32
{$ENDIF}
 
33
 
 
34
implementation
 
35
 
 
36
{$IFNDEF VER2_7}
 
37
procedure fpc_rangeerror; [external name 'FPC_RANGEERROR'];
 
38
 
 
39
// len comes in widechars, not bytes
 
40
procedure Wide2AnsiMove(source:pwidechar;var dest:ansistring;len:SizeInt);
 
41
var
 
42
  widestr: widestring;
 
43
begin
 
44
  {$ifdef PASWSTRING_VERBOSE}WriteLn('Wide2AnsiMove START');{$endif}
 
45
  // Copy the originating string taking into account the specified length
 
46
  SetLength(widestr, len);
 
47
  System.Move(source^, widestr[1], len * SizeOf(WideChar));
 
48
 
 
49
  // Now convert it, using UTF-16 -> UTF-8
 
50
  dest := UTF16ToUTF8(widestr);
 
51
  {$ifdef PASWSTRING_SUPPORT_NONUTF8_ANSISTRING}
 
52
  // And correct to the real Ansi encoding
 
53
  dest := ConvertEncoding(dest, EncodingUTF8, GetDefaultTextEncoding());
 
54
  {$endif}
 
55
end;
 
56
 
 
57
procedure Ansi2WideMove(source:pchar;var dest:widestring;len:SizeInt);
 
58
var
 
59
  ansistr: ansistring;
 
60
begin
 
61
  {$ifdef PASWSTRING_VERBOSE}WriteLn('Ansi2WideMove START');{$endif}
 
62
  // Copy the originating string taking into account the specified length
 
63
  SetLength(ansistr, len);
 
64
  System.Move(source^, ansistr[1], len);
 
65
 
 
66
  {$ifdef PASWSTRING_SUPPORT_NONUTF8_ANSISTRING}
 
67
  // Convert to UTF-8
 
68
  ansistr := ConvertEncoding(ansistr, GetDefaultTextEncoding(), EncodingUTF8);
 
69
  {$endif}
 
70
  // Now convert it, using UTF-8 -> UTF-16
 
71
  dest := UTF8ToUTF16(ansistr);
 
72
end;
 
73
 
 
74
function LowerWideString(const s : WideString) : WideString;
 
75
var
 
76
  str: utf8string;
 
77
begin
 
78
  {$ifdef PASWSTRING_VERBOSE}WriteLn('LowerWideString START');{$endif}
 
79
  str := UTF16ToUTF8(s);
 
80
  str := UTF8LowerCase(str);
 
81
  Result := UTF8ToUTF16(str);
 
82
end;
 
83
 
 
84
function UpperWideString(const s : WideString) : WideString;
 
85
var
 
86
  str: utf8string;
 
87
begin
 
88
  {$ifdef PASWSTRING_VERBOSE}WriteLn('UpperWideString START');{$endif}
 
89
  str := UTF16ToUTF8(s);
 
90
  str := UTF8UpperCase(str);
 
91
  Result := UTF8ToUTF16(str);
 
92
end;
 
93
 
 
94
procedure EnsureAnsiLen(var S: AnsiString; const len: SizeInt); inline;
 
95
begin
 
96
  {$ifdef PASWSTRING_VERBOSE}WriteLn('EnsureAnsiLen START');{$endif}
 
97
  if (len>length(s)) then
 
98
    if (length(s) < 10*256) then
 
99
      setlength(s,length(s)+10)
 
100
    else
 
101
      setlength(s,length(s)+length(s) shr 8);
 
102
end;
 
103
 
 
104
 
 
105
procedure ConcatCharToAnsiStr(const c: char; var S: AnsiString; var index: SizeInt);
 
106
begin
 
107
  {$ifdef PASWSTRING_VERBOSE}WriteLn('ConcatCharToAnsiStr START');{$endif}
 
108
  EnsureAnsiLen(s,index);
 
109
  pchar(@s[index])^:=c;
 
110
  inc(index);
 
111
end;
 
112
 
 
113
function LowerAnsiString(const s : AnsiString) : AnsiString;
 
114
var
 
115
  Str: utf8string;
 
116
begin
 
117
  {$ifdef PASWSTRING_VERBOSE}WriteLn('LowerAnsiString START');{$endif}
 
118
  Str := SysToUTF8(s);
 
119
  Str := UTF8LowerCase(Str);
 
120
  Result := UTF8ToSys(Str);
 
121
end;
 
122
 
 
123
function UpperAnsiString(const s : AnsiString) : AnsiString;
 
124
var
 
125
  Str: utf8string;
 
126
begin
 
127
  {$ifdef PASWSTRING_VERBOSE}WriteLn('UpperAnsiString START');{$endif}
 
128
  Str := SysToUTF8(s);
 
129
  Str := UTF8UpperCase(Str);
 
130
  Result := UTF8ToSys(Str);
 
131
end;
 
132
 
 
133
// Just do a simple byte comparison
 
134
// A more complex analysis would require normalization
 
135
function WideCompareStr(const s1, s2 : WideString) : PtrInt;
 
136
var
 
137
  count, count1, count2: integer;
 
138
begin
 
139
  {$ifdef PASWSTRING_VERBOSE}WriteLn('WideCompareStr START');{$endif}
 
140
  result := 0;
 
141
  Count1 := Length(S1);
 
142
  Count2 := Length(S2);
 
143
  if Count1>Count2 then
 
144
    Count:=Count2
 
145
  else
 
146
    Count:=Count1;
 
147
  result := SysUtils.CompareMemRange(Pointer(S1),Pointer(S2), Count*2);
 
148
  if result=0 then
 
149
    result:=Count1-Count2;
 
150
end;
 
151
 
 
152
function WideCompareText(const s1, s2 : WideString): PtrInt;
 
153
var
 
154
  a, b: WideString;
 
155
begin
 
156
  {$ifdef PASWSTRING_VERBOSE}WriteLn('WideCompareText START');{$endif}
 
157
  a:=LowerWidestring(s1);
 
158
  b:=LowerWidestring(s2);
 
159
  result := WideCompareStr(a,b);
 
160
end;
 
161
 
 
162
function CharLengthPChar(const Str: PChar): PtrInt;
 
163
begin
 
164
  {$ifdef PASWSTRING_VERBOSE}WriteLn('CharLengthPChar START');{$endif}
 
165
  Result := UTF8CharacterLength(Str);
 
166
end;
 
167
 
 
168
function AnsiCompareStr(const s1, s2: ansistring): PtrInt;
 
169
begin
 
170
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiCompareStr START');{$endif}
 
171
  Result := SysUtils.CompareStr(s1, s2);
 
172
end;
 
173
 
 
174
// Similar to AnsiCompareStr, but with PChar
 
175
function StrCompAnsi(s1,s2 : PChar): PtrInt;
 
176
var
 
177
  ansi1, ansi2: ansistring;
 
178
begin
 
179
  {$ifdef PASWSTRING_VERBOSE}WriteLn('StrCompAnsi START');{$endif}
 
180
  ansi1 := StrPas(S1);
 
181
  ansi2 := StrPas(S2);
 
182
  Result := SysUtils.CompareStr(ansi1, ansi2);
 
183
end;
 
184
 
 
185
 
 
186
function AnsiCompareText(const S1, S2: ansistring): PtrInt;
 
187
var
 
188
  str1, str2: utf8string;
 
189
begin
 
190
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiCompareText START');{$endif}
 
191
  str1 := SysToUTF8(S1);
 
192
  str2 := SysToUTF8(S2);
 
193
  Result := UTF8CompareText(str1, str2);
 
194
end;
 
195
 
 
196
 
 
197
function AnsiStrIComp(S1, S2: PChar): PtrInt;
 
198
begin
 
199
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiStrIComp START');{$endif}
 
200
  Result := AnsiCompareText(StrPas(s1),StrPas(s2));
 
201
end;
 
202
 
 
203
 
 
204
function AnsiStrLComp(S1, S2: PChar; MaxLen: PtrUInt): PtrInt;
 
205
  var
 
206
    a, b: pchar;
 
207
begin
 
208
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiStrLComp START');{$endif}
 
209
  Result := 0;
 
210
  if (maxlen=0) then
 
211
    exit(0);
 
212
  if (s1[maxlen]<>#0) then
 
213
    begin
 
214
      getmem(a,maxlen+1);
 
215
      move(s1^,a^,maxlen);
 
216
      a[maxlen]:=#0;
 
217
    end
 
218
  else
 
219
    a:=s1;
 
220
  if (s2[maxlen]<>#0) then
 
221
    begin
 
222
      getmem(b,maxlen+1);
 
223
      move(s2^,b^,maxlen);
 
224
      b[maxlen]:=#0;
 
225
    end
 
226
  else
 
227
    b:=s2;
 
228
  result:=StrCompAnsi(a,b);
 
229
  if (a<>s1) then
 
230
    freemem(a);
 
231
  if (b<>s2) then
 
232
    freemem(b);
 
233
end;
 
234
 
 
235
 
 
236
function AnsiStrLIComp(S1, S2: PChar; MaxLen: PtrUInt): PtrInt;
 
237
  var
 
238
    a, b: ansistring;
 
239
begin
 
240
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiStrLIComp START');{$endif}
 
241
  if (maxlen=0) then
 
242
    exit(0);
 
243
  setlength(a,maxlen);
 
244
  move(s1^,a[1],maxlen);
 
245
  setlength(b,maxlen);
 
246
  move(s2^,b[1],maxlen);
 
247
  result:=AnsiCompareText(a,b);
 
248
end;
 
249
 
 
250
 
 
251
procedure ansi2pchar(const s: ansistring; const orgp: pchar; out p: pchar);
 
252
var
 
253
  newlen: sizeint;
 
254
begin
 
255
  {$ifdef PASWSTRING_VERBOSE}WriteLn('ansi2pchar START');{$endif}
 
256
  newlen:=length(s);
 
257
  if newlen>strlen(orgp) then
 
258
    fpc_rangeerror;
 
259
  p:=orgp;
 
260
  if (newlen>0) then
 
261
    move(s[1],p[0],newlen);
 
262
  p[newlen]:=#0;
 
263
end;
 
264
 
 
265
 
 
266
function AnsiStrLower(Str: PChar): PChar;
 
267
var
 
268
  temp: ansistring;
 
269
begin
 
270
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiStrLower START');{$endif}
 
271
  temp:=loweransistring(str);
 
272
  ansi2pchar(temp,str,result);
 
273
end;
 
274
 
 
275
 
 
276
function AnsiStrUpper(Str: PChar): PChar;
 
277
var
 
278
  temp: ansistring;
 
279
begin
 
280
  {$ifdef PASWSTRING_VERBOSE}WriteLn('AnsiStrUpper START');{$endif}
 
281
  temp:=upperansistring(str);
 
282
  ansi2pchar(temp,str,result);
 
283
end;
 
284
 
 
285
 
 
286
procedure InitThread;
 
287
begin
 
288
end;
 
289
 
 
290
 
 
291
procedure FiniThread;
 
292
begin
 
293
end;
 
294
 
 
295
{ Unicode }
 
296
 
 
297
procedure Unicode2AnsiMove(source:pwidechar;var dest:ansistring;len:SizeInt);
 
298
var
 
299
  widestr: unicodestring;
 
300
begin
 
301
  {$ifdef PASWSTRING_VERBOSE}WriteLn('Unicode2AnsiMove START');{$endif}
 
302
  // Copy the originating string taking into account the specified length
 
303
  SetLength(widestr, len);
 
304
  System.Move(source^, widestr[1], len*2);
 
305
 
 
306
  // Now convert it, using UTF-16 -> UTF-8
 
307
  dest := UTF16ToUTF8(widestr);
 
308
  {$ifdef PASWSTRING_SUPPORT_NONUTF8_ANSISTRING}
 
309
  // And correct to the real Ansi encoding
 
310
  dest := ConvertEncoding(dest, EncodingUTF8, GetDefaultTextEncoding());
 
311
  {$endif}
 
312
end;
 
313
 
 
314
procedure Ansi2UnicodeMove(source:pchar;var dest:UnicodeString;len:SizeInt);
 
315
var
 
316
  ansistr: ansistring;
 
317
begin
 
318
  {$ifdef PASWSTRING_VERBOSE}WriteLn('Ansi2UnicodeMove START');{$endif}
 
319
  // Copy the originating string taking into account the specified length
 
320
  SetLength(ansistr, len);
 
321
  System.Move(source^, ansistr[1], len);
 
322
 
 
323
  {$ifdef PASWSTRING_SUPPORT_NONUTF8_ANSISTRING}
 
324
  // Convert to UTF-8
 
325
  ansistr := ConvertEncoding(ansistr, GetDefaultTextEncoding(), EncodingUTF8);
 
326
  {$endif}
 
327
  // Now convert it, using UTF-8 -> UTF-16
 
328
  dest := UTF8ToUTF16(ansistr);
 
329
end;
 
330
 
 
331
function UpperUnicodeString(const s : UnicodeString) : UnicodeString;
 
332
var
 
333
  str: utf8string;
 
334
begin
 
335
  {$ifdef PASWSTRING_VERBOSE}WriteLn('UpperUnicodeString START');{$endif}
 
336
  str := UTF16ToUTF8(s);
 
337
  str := UTF8UpperCase(str);
 
338
  Result := UTF8ToUTF16(str);
 
339
end;
 
340
 
 
341
function LowerUnicodeString(const s : UnicodeString) : UnicodeString;
 
342
var
 
343
  str: utf8string;
 
344
begin
 
345
  {$ifdef PASWSTRING_VERBOSE}WriteLn('LowerUnicodeString START');{$endif}
 
346
  str := UTF16ToUTF8(s);
 
347
  str := UTF8LowerCase(str);
 
348
  Result := UTF8ToUTF16(str);
 
349
end;
 
350
 
 
351
// Just do a simple byte comparison
 
352
// A more complex analysis would require normalization
 
353
function PasUnicodeCompareStr(const s1, s2 : unicodestring) : PtrInt;
 
354
var
 
355
  count, count1, count2: integer;
 
356
begin
 
357
  {$ifdef PASWSTRING_VERBOSE}WriteLn('PasUnicodeCompareStr START');{$endif}
 
358
  result := 0;
 
359
  Count1 := Length(S1);
 
360
  Count2 := Length(S2);
 
361
  if Count1>Count2 then
 
362
    Count:=Count2
 
363
  else
 
364
    Count:=Count1;
 
365
  result := SysUtils.CompareMemRange(Pointer(S1),Pointer(S2), Count*2);
 
366
  if result=0 then
 
367
    result:=Count1-Count2;
 
368
end;
 
369
 
 
370
function PasUnicodeCompareText(const s1, s2 : unicodestring): PtrInt;
 
371
var
 
372
  a, b: unicodestring;
 
373
begin
 
374
  {$ifdef PASWSTRING_VERBOSE}WriteLn('PasUnicodeCompareText START');{$endif}
 
375
  a:=LowerWidestring(s1);
 
376
  b:=LowerWidestring(s2);
 
377
  result := WideCompareStr(a,b);
 
378
end;
 
379
 
 
380
Procedure SetPasWideStringManager;
 
381
Var
 
382
  PasWideStringManager : TUnicodeStringManager;
 
383
begin
 
384
  PasWideStringManager:=widestringmanager;
 
385
  PasWideStringManager.Wide2AnsiMoveProc:=@Wide2AnsiMove;
 
386
  PasWideStringManager.Ansi2WideMoveProc:=@Ansi2WideMove;
 
387
 
 
388
  //    UpperUTF8 : procedure(p:PUTF8String);
 
389
  PasWideStringManager.UpperWideStringProc:=@UpperWideString;
 
390
  //    UpperUCS4 : procedure(p:PUCS4Char);
 
391
  //    LowerUTF8 : procedure(p:PUTF8String);
 
392
  PasWideStringManager.LowerWideStringProc:=@LowerWideString;
 
393
  //    LowerUCS4 : procedure(p:PUCS4Char);
 
394
 
 
395
  {
 
396
    CompUTF8 : function(p1,p2:PUTF8String) : shortint;
 
397
    CompUCS2 : function(p1,p2:PUCS2Char) : shortint;
 
398
    CompUCS4 : function(p1,p2:PUC42Char) : shortint;
 
399
  }
 
400
  PasWideStringManager.CompareWideStringProc:=@WideCompareStr;
 
401
  PasWideStringManager.CompareTextWideStringProc:=@WideCompareText;
 
402
 
 
403
  { return value: number of code points in the string. Whenever an invalid
 
404
    code point is encountered, all characters part of this invalid code point
 
405
    are considered to form one "character" and the next character is
 
406
    considered to be the start of a new (possibly also invalid) code point }
 
407
  PasWideStringManager.CharLengthPCharProc:=@CharLengthPChar;
 
408
 
 
409
  { Ansi }
 
410
  PasWideStringManager.UpperAnsiStringProc:=@UpperAnsiString;
 
411
  PasWideStringManager.LowerAnsiStringProc:=@LowerAnsiString;
 
412
  PasWideStringManager.CompareStrAnsiStringProc:=@AnsiCompareStr;
 
413
  PasWideStringManager.CompareTextAnsiStringProc:=@AnsiCompareText;
 
414
  PasWideStringManager.StrCompAnsiStringProc:=@StrCompAnsi;
 
415
  PasWideStringManager.StrICompAnsiStringProc:=@AnsiStrIComp;
 
416
  PasWideStringManager.StrLCompAnsiStringProc:=@AnsiStrLComp;
 
417
  PasWideStringManager.StrLICompAnsiStringProc:=@AnsiStrLIComp;
 
418
  PasWideStringManager.StrLowerAnsiStringProc:=@AnsiStrLower;
 
419
  PasWideStringManager.StrUpperAnsiStringProc:=@AnsiStrUpper;
 
420
  PasWideStringManager.ThreadInitProc:=@InitThread;
 
421
  PasWideStringManager.ThreadFiniProc:=@FiniThread;
 
422
 
 
423
  { Unicode }
 
424
  PasWideStringManager.Unicode2AnsiMoveProc:=@Unicode2AnsiMove;
 
425
  PasWideStringManager.Ansi2UnicodeMoveProc:=@Ansi2UnicodeMove;
 
426
  PasWideStringManager.UpperUnicodeStringProc:=@UpperUnicodeString;
 
427
  PasWideStringManager.LowerUnicodeStringProc:=@LowerUnicodeString;
 
428
  PasWideStringManager.CompareUnicodeStringProc:=@PasUnicodeCompareStr;
 
429
  PasWideStringManager.CompareTextUnicodeStringProc:=@PasUnicodeCompareText;
 
430
 
 
431
  SetUnicodeStringManager(PasWideStringManager);
 
432
end;
 
433
 
 
434
 
 
435
initialization
 
436
  SetPasWideStringManager;
 
437
{$ENDIF}
 
438
end.