← Back to branch summary

~ubuntu-branches/ubuntu/feisty/fpc/feisty

« back to all changes in this revision

Viewing changes to rtl/objpas/classes/classes.inc

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-01-27 20:08:50 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070127200850-9mrptaqqjsx9nwa7
Tags: 2.0.4-5
* Fixed Build-Depends.
* Add myself to Uploaders in debian/control.
* Make sure that the sources are really patched before building them.
* Build unit 'libc' on powerpc too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
rtl/objpas/classes/classes.inc
1
1
{
2
 
    $Id: classes.inc,v 1.27 2005/04/28 09:15:44 florian Exp $
3
2
    This file is part of the Free Component Library (FCL)
4
3
    Copyright (c) 1999-2000 by Michael Van Canneyt and Florian Klaempfl
5
4
 
58
57
{ TStrings and TStringList implementations }
59
58
{$i stringl.inc}
60
59
 
61
 
{$ifndef VER1_0}
62
60
{ TThread implementation }
63
61
 
64
 
{ system dependend code }
65
 
{$i tthread.inc}
66
 
 
67
62
{ system independend threading code }
68
63
var
69
64
  { event that happens when gui thread is done executing the method}
79
74
  { caught exception in gui thread, to be raised in calling thread }
80
75
  SynchronizeException: Exception;
81
76
 
82
 
procedure TThread.Synchronize(Method: TThreadMethod);
 
77
 
 
78
function ThreadProc(ThreadObjPtr: Pointer): PtrInt;
 
79
  var
 
80
    FreeThread: Boolean;
 
81
    Thread: TThread absolute ThreadObjPtr;
 
82
  begin
 
83
    try
 
84
      Thread.Execute;
 
85
    except
 
86
      Thread.FFatalException := TObject(AcquireExceptionObject);
 
87
    end;
 
88
    FreeThread := Thread.FFreeOnTerminate;
 
89
    Result := Thread.FReturnValue;
 
90
    Thread.FFinished := True;
 
91
    Thread.DoTerminate;
 
92
    if FreeThread then
 
93
      Thread.Free;
 
94
    EndThread(Result);
 
95
  end;
 
96
 
 
97
{ system dependend code }
 
98
{$i tthread.inc}
 
99
 
 
100
class procedure TThread.Synchronize(AThread: TThread; AMethod: TThreadMethod);
83
101
  var
84
102
    LocalSyncException: Exception;
85
103
  begin
86
104
    { do we really need a synchronized call? }
87
105
    if GetCurrentThreadID=MainThreadID then
88
 
      Method()
 
106
      AMethod()
89
107
    else
90
108
      begin
91
 
        EnterCriticalSection(SynchronizeCritSect);
 
109
        System.EnterCriticalSection(SynchronizeCritSect);
92
110
        RtlEventStartWait(ExecuteEvent);
93
111
        SynchronizeException:=nil;
94
 
        SynchronizeMethod:=Method;
 
112
        SynchronizeMethod:=AMethod;
95
113
 
96
114
        { be careful, after this assignment Method could be already executed }
97
115
        DoSynchronizeMethod:=true;
99
117
        RtlEventSetEvent(SynchronizeTimeoutEvent);
100
118
 
101
119
        if assigned(WakeMainThread) then
102
 
          WakeMainThread(self);
 
120
          WakeMainThread(AThread);
103
121
 
104
122
        { wait infinitely }
105
123
        RtlEventWaitFor(ExecuteEvent);
106
124
        LocalSyncException:=SynchronizeException;
107
 
        LeaveCriticalSection(SynchronizeCritSect);
 
125
        System.LeaveCriticalSection(SynchronizeCritSect);
108
126
        if assigned(LocalSyncException) then
109
127
          raise LocalSyncException;
110
128
      end;
111
129
  end;
112
130
 
113
131
 
 
132
procedure TThread.Synchronize(AMethod: TThreadMethod);
 
133
  begin
 
134
    TThread.Synchronize(self,AMethod);
 
135
  end;
 
136
 
 
137
 
114
138
procedure CheckSynchronize(timeout : longint=0);
115
139
  { assumes being called from GUI thread }
116
140
  begin
117
 
    { sanity check }
118
 
    if GetCurrentThreadID<>MainThreadID then
 
141
    { first sanity check }
 
142
    if Not IsMultiThread then
 
143
      Exit
 
144
    { second sanity check }
 
145
    else if GetCurrentThreadID<>MainThreadID then
119
146
      raise EThread.CreateFmt(SCheckSynchronizeError,[GetCurrentThreadID])
120
147
    else
121
148
      begin
140
167
      end;
141
168
  end;
142
169
 
143
 
{$endif}
144
 
 
145
170
{ TPersistent implementation }
146
171
{$i persist.inc }
147
172
 
160
185
 
161
186
 
162
187
{ Interface related stuff }
163
 
{$ifdef HASINTF}
164
188
{$I intf.inc}
165
 
{$endif HASINTF}
166
189
 
167
190
{**********************************************************************
168
191
 *       Miscellaneous procedures and functions                       *
169
192
 **********************************************************************}
170
193
 
 
194
function ExtractStrings(Separators, WhiteSpace: TSysCharSet; Content: PChar; Strings: TStrings): Integer;
 
195
 
 
196
var
 
197
  Start,P: PChar;
 
198
  InQuote: Boolean;
 
199
  QC: Char;
 
200
  S : string;
 
201
 
 
202
begin
 
203
  Result:=0;
 
204
  if Not (Assigned(Content) and (Content^<>#0)) then
 
205
    Exit;
 
206
  P:=Content;
 
207
  InQuote:=False;
 
208
  QC:=#0;
 
209
  WhiteSpace:=WhiteSpace+[#10,#13];
 
210
  Separators:=Separators+[#0,#10,#13,'''','"'];
 
211
  if Assigned(Strings) then
 
212
    Strings.BeginUpdate;
 
213
  Try
 
214
    repeat
 
215
      while P^ in WhiteSpace do
 
216
        Inc(P); // Not MBCS safe
 
217
      Start:=P;
 
218
      while True do
 
219
        begin
 
220
        while (InQuote and not (P^ in [QC, #0])) or
 
221
              not (P^ in Separators) do
 
222
            Inc(P); // Not MBCS safe
 
223
        if P^ in ['''', '"'] then
 
224
          begin
 
225
          If (QC=#0) then
 
226
            QC:=P^
 
227
          else if (QC=P^) then
 
228
            QC:=#0;
 
229
          InQuote:=QC<>#0;
 
230
          Inc(P);
 
231
          end
 
232
        else
 
233
          Break;
 
234
        end;
 
235
      if (Start<>P) then
 
236
        begin
 
237
        if Assigned(Strings) then
 
238
          begin
 
239
            SetString(S,Start,P-Start);
 
240
            Strings.Add(S);
 
241
          end;
 
242
        Inc(Result);
 
243
        end;
 
244
      If (P^<>#0) then
 
245
        Inc(P);
 
246
    until (P^=#0);
 
247
  finally
 
248
    if Assigned(Strings) then
 
249
      Strings.EndUpdate;
 
250
  end;
 
251
end;
 
252
 
 
253
 
 
254
 
171
255
{ Point and rectangle constructors }
172
256
 
173
257
function Point(AX, AY: Integer): TPoint;
218
302
end;
219
303
 
220
304
 
221
 
 
 
305
function PointsEqual(const P1, P2: TPoint): Boolean; {$ifdef CLASSESINLINE}inline;{$endif CLASSESINLINE}
 
306
  begin
 
307
    { lazy, but should work }
 
308
    result:=QWord(P1)=QWord(P2);
 
309
  end;
 
310
 
 
311
 
 
312
function PointsEqual(const P1, P2: TSmallPoint): Boolean; {$ifdef CLASSESINLINE}inline;{$endif CLASSESINLINE}
 
313
  begin
 
314
    { lazy, but should work }
 
315
    result:=DWord(P1)=DWord(P2);
 
316
  end;
 
317
 
 
318
function InvalidPoint(X, Y: Integer): Boolean;
 
319
  begin
 
320
    result:=(X=-1) and (Y=-1);
 
321
  end;
 
322
 
 
323
 
 
324
function InvalidPoint(const At: TPoint): Boolean;
 
325
  begin
 
326
    result:=(At.x=-1) and (At.y=-1);
 
327
  end;
 
328
 
 
329
 
 
330
function InvalidPoint(const At: TSmallPoint): Boolean;
 
331
  begin
 
332
    result:=(At.x=-1) and (At.y=-1);
 
333
  end;
222
334
 
223
335
 
224
336
{ Object filing routines }
226
338
var
227
339
  IntConstList: TThreadList;
228
340
 
229
 
 
230
341
type
231
342
  TIntConst = class
232
343
    IntegerType: PTypeInfo;             // The integer type RTTI pointer
375
486
 
376
487
procedure RegisterFindGlobalComponentProc(AFindGlobalComponent: TFindGlobalComponent);
377
488
  begin
378
 
        if not(assigned(FindGlobalComponentList)) then
379
 
          FindGlobalComponentList:=TList.Create;
380
 
        if FindGlobalComponentList.IndexOf(Pointer(AFindGlobalComponent))<0 then
381
 
          FindGlobalComponentList.Add(Pointer(AFindGlobalComponent));
 
489
    if not(assigned(FindGlobalComponentList)) then
 
490
      FindGlobalComponentList:=TList.Create;
 
491
    if FindGlobalComponentList.IndexOf(Pointer(AFindGlobalComponent))<0 then
 
492
      FindGlobalComponentList.Add(Pointer(AFindGlobalComponent));
382
493
  end;
383
494
 
384
495
 
385
496
procedure UnregisterFindGlobalComponentProc(AFindGlobalComponent: TFindGlobalComponent);
386
497
  begin
387
 
        if assigned(FindGlobalComponentList) then
388
 
          FindGlobalComponentList.Remove(Pointer(AFindGlobalComponent));
 
498
    if assigned(FindGlobalComponentList) then
 
499
      FindGlobalComponentList.Remove(Pointer(AFindGlobalComponent));
389
500
  end;
390
501
 
391
502
 
393
504
  var
394
505
        i : sizeint;
395
506
  begin
396
 
        FindGlobalComponent:=nil;
397
 
        if assigned(FindGlobalComponentList) then
 
507
    FindGlobalComponent:=nil;
 
508
    if assigned(FindGlobalComponentList) then
398
509
      begin
399
510
        for i:=FindGlobalComponentList.Count-1 downto 0 do
400
511
          begin
407
518
 
408
519
 
409
520
procedure RegisterInitComponentHandler(ComponentClass: TComponentClass;   Handler: TInitComponentHandler);
410
 
 
411
521
Var
412
522
  I : Integer;
413
523
  H: TInitHandler;
414
 
 
415
524
begin
416
525
  If (InitHandlerList=Nil) then
417
526
    InitHandlerList:=TList.Create;
418
527
  H:=TInitHandler.Create;
419
528
  H.Aclass:=ComponentClass;
420
529
  H.AHandler:=Handler;
421
 
  With InitHandlerList do
 
530
  try
 
531
    With InitHandlerList do
 
532
      begin
 
533
        I:=0;
 
534
        While (I<Count) and not H.AClass.InheritsFrom(TInitHandler(Items[I]).AClass) do
 
535
          Inc(I);
 
536
        { override? }
 
537
        if (I<Count) and (TInitHandler(Items[I]).AClass=H.AClass) then
 
538
          begin
 
539
            TInitHandler(Items[I]).AHandler:=Handler;
 
540
            H.Free;
 
541
          end
 
542
        else
 
543
          InitHandlerList.Insert(I,H);
 
544
      end;
 
545
   except
 
546
     H.Free;
 
547
     raise;
 
548
  end;
 
549
end;
 
550
 
 
551
 
 
552
{ all targets should at least include the sysres.inc dummy in the system unit to compile this }
 
553
function CreateComponentfromRes(const res : string;Inst : THandle;var Component : TComponent) : Boolean;
 
554
  var
 
555
    ResStream : TResourceStream;
 
556
  begin
 
557
    result:=true;
 
558
 
 
559
    if Inst=0 then
 
560
      Inst:=HInstance;
 
561
 
 
562
    try
 
563
      ResStream:=TResourceStream.Create(Inst,res,RT_RCDATA);
 
564
      try
 
565
        Component:=ResStream.ReadComponent(Component);
 
566
      finally
 
567
        ResStream.Free;
 
568
      end;
 
569
    except
 
570
      on EResNotFound do
 
571
        result:=false;
 
572
    end;
 
573
  end;
 
574
 
 
575
 
 
576
function DefaultInitHandler(Instance: TComponent; RootAncestor: TClass): Boolean;
 
577
 
 
578
  function doinit(_class : TClass) : boolean;
422
579
    begin
423
 
    I:=0;
424
 
    While (I<Count) and not H.AClass.InheritsFrom(TInitHandler(Items[i]).AClass) do
425
 
      Inc(I);
426
 
    InitHandlerList.Insert(I,H);
427
 
    end;
428
 
end;
 
580
      result:=false;
 
581
      if (_class.ClassType=TComponent) or (_class.ClassType=RootAncestor) then
 
582
        exit;
 
583
      result:=doinit(_class.ClassParent);
 
584
      result:=CreateComponentfromRes(_class.ClassName,0,Instance) or result;
 
585
    end;
 
586
 
 
587
  begin
 
588
    GlobalNameSpace.BeginWrite;
 
589
    try
 
590
      result:=doinit(Instance.ClassType);
 
591
    finally
 
592
      GlobalNameSpace.EndWrite;
 
593
    end;
 
594
  end;
 
595
 
429
596
 
430
597
function InitInheritedComponent(Instance: TComponent; RootAncestor: TClass): Boolean;
431
 
 
432
598
Var
433
599
  I : Integer;
434
 
 
435
600
begin
436
601
  I:=0;
437
602
  if not Assigned(InitHandlerList) then begin
511
676
  Instance: TPersistent;
512
677
  Reference: Pointer;
513
678
begin
514
 
  {!!!: GlobalNameSpace.BeginWrite;
515
 
  try}
 
679
  GlobalNameSpace.BeginWrite;
 
680
  try
516
681
    GlobalList := GlobalFixupList.LockList;
517
682
    try
518
683
      if GlobalList.Count > 0 then
531
696
                if Assigned(Root) then
532
697
                begin
533
698
                  Reference := FindNestedComponent(Root, FName);
534
 
                  SetOrdProp(FInstance, FPropInfo, Longint(Reference));
 
699
                  SetOrdProp(FInstance, FPropInfo, PtrInt(Reference));
535
700
                end;
536
701
                // Move component to list of done components, if necessary
537
702
                if (DoneList.IndexOf(FInstance) < 0) and
564
729
    finally
565
730
      GlobalFixupList.UnlockList;
566
731
    end;
567
 
  {finally
 
732
  finally
568
733
    GlobalNameSpace.EndWrite;
569
 
  end;}
 
734
  end;
570
735
end;
571
736
 
572
737
 
733
898
  Result := Current;
734
899
end;
735
900
 
736
 
{!!!: Should be threadvar  -  doesn't work for all platforms yet!}
737
 
var
 
901
threadvar
738
902
  GlobalLoaded, GlobalLists: TList;
739
903
 
740
 
 
741
904
procedure BeginGlobalLoading;
742
905
 
743
906
begin
778
941
  CollectionsEqual:=false;
779
942
end;
780
943
 
 
944
function CollectionsEqual(C1, C2: TCollection; Owner1, Owner2: TComponent): Boolean;
 
945
 
 
946
  procedure stream_collection(s : tstream;c : tcollection;o : tcomponent);
 
947
    var
 
948
      w : twriter;
 
949
    begin
 
950
      w:=twriter.create(s,4096);
 
951
      try
 
952
        w.root:=o;
 
953
        w.flookuproot:=o;
 
954
        w.writecollection(c);
 
955
      finally
 
956
        w.free;
 
957
      end;
 
958
    end;
 
959
 
 
960
  var
 
961
    s1,s2 : tmemorystream;
 
962
  begin
 
963
    result:=false;
 
964
    if (c1.classtype<>c2.classtype) or
 
965
      (c1.count<>c2.count) then
 
966
      exit;
 
967
 
 
968
    s1:=tmemorystream.create;
 
969
    try
 
970
      s2:=tmemorystream.create;
 
971
      try
 
972
        stream_collection(s1,c1,owner1);
 
973
        stream_collection(s2,c2,owner2);
 
974
        result:=(s1.size=s2.size) and (CompareChar(s1.memory,s2.memory,s1.size)=0);
 
975
      finally
 
976
        s2.free;
 
977
      end;
 
978
    finally
 
979
      s1.free;
 
980
    end;
 
981
  end;
781
982
 
782
983
 
783
984
{ Object conversion routines }
791
992
  inc(pchar(P));
792
993
end;
793
994
 
794
 
{$ifdef HASWIDESTRING}
795
995
function WideCharToOrd(var P: Pointer): Cardinal;
796
996
begin
797
997
  result:= ord(pwidechar(P)^);
798
998
  inc(pwidechar(P));
799
999
end;
800
 
{$endif HASWIDESTRING}
801
1000
 
802
1001
function Utf8ToOrd(var P:Pointer): Cardinal;
803
1002
begin
843
1042
    w: Cardinal;
844
1043
    InString, NewInString: Boolean;
845
1044
  begin
 
1045
   if p = nil then begin
 
1046
    res:= '''''';
 
1047
   end
 
1048
   else begin
846
1049
    res := '';
847
1050
    InString := False;
848
1051
    while P < LastP do begin
867
1070
      res := res + NewStr;
868
1071
    end;
869
1072
    if InString then res := res + '''';
870
 
    OutStr(res);
 
1073
   end;
 
1074
   OutStr(res);
871
1075
  end;
872
1076
 
873
1077
  procedure OutString(s: String);
879
1083
  procedure OutWString(W: WideString);
880
1084
 
881
1085
  begin
882
 
{$ifdef HASWIDESTRING}
883
1086
    OutChars(Pointer(W),pwidechar(W)+Length(W),@WideCharToOrd);
884
 
{$endif HASWIDESTRING}
885
1087
  end;
886
1088
 
887
1089
  procedure OutUtf8Str(s: String);
925
1127
  var
926
1128
    len: DWord;
927
1129
  begin
928
 
{$ifdef HASWIDESTRING}
929
1130
    len := Input.ReadDWord;
930
1131
    SetLength(Result, len);
931
1132
    Input.Read(Pointer(@Result[1])^, len*2);
932
 
{$endif HASWIDESTRING}
933
1133
  end;
934
1134
 
935
1135
  procedure ReadPropList(indent: String);
1128
1328
      Output.Write(s[1], Length(s));
1129
1329
  end;
1130
1330
 
1131
 
{$ifdef HASWIDESTRING}
1132
1331
  procedure WriteWString(Const s: WideString);
1133
1332
  begin
1134
1333
    Output.WriteDWord(Length(s));
1135
1334
    if Length(s) > 0 then
1136
1335
      Output.Write(s[1], Length(s)*sizeof(widechar));
1137
1336
  end;
1138
 
{$endif HASWIDESTRING}
1139
1337
 
1140
1338
  procedure WriteInteger(value: LongInt);
1141
1339
  begin
1157
1355
  var
1158
1356
    flt: Extended;
1159
1357
    s: String;
1160
 
{$ifdef HASWIDESTRING}
1161
1358
    ws: WideString;
1162
 
{$else}
1163
 
    ws : Ansistring;
1164
 
{$endif HASWIDESTRING}
1165
1359
    stream: TMemoryStream;
1166
1360
    i: Integer;
1167
1361
    b: Boolean;
1181
1375
        end;
1182
1376
      toString:
1183
1377
        begin
1184
 
{$ifdef HASWIDESTRING}
1185
1378
          ws := parser.TokenWideString;
1186
1379
          while parser.NextToken = '+' do
1187
1380
          begin
1201
1394
            WriteWString(ws);
1202
1395
            end
1203
1396
          else
1204
 
{$else HASWIDESTRING}
1205
 
          ws := parser.TokenString;
1206
 
          while parser.NextToken = '+' do
1207
 
          begin
1208
 
            parser.NextToken;   // Get next string fragment
1209
 
            parser.CheckToken(toString);
1210
 
            ws := ws + parser.TokenString;
1211
 
          end;
1212
 
{$endif HASWIDESTRING}
1213
1397
            begin
1214
1398
            setlength(s,length(ws));
1215
1399
            for i:= 1 to length(s) do begin
1459
1643
 
1460
1644
procedure CommonInit;
1461
1645
begin
1462
 
{$ifndef ver1_0}
1463
1646
  InitCriticalSection(SynchronizeCritSect);
1464
1647
  ExecuteEvent:=RtlEventCreate;
1465
1648
  SynchronizeTimeoutEvent:=RtlEventCreate;
1466
1649
  DoSynchronizeMethod:=false;
1467
1650
  MainThreadID:=GetCurrentThreadID;
1468
 
{$endif ver1_0}
1469
1651
  InitHandlerList:=Nil;
1470
1652
  FindGlobalComponentList:=nil;
1471
1653
  IntConstList := TThreadList.Create;
1472
1654
  GlobalFixupList := TThreadList.Create;
1473
1655
  ClassList := TThreadList.Create;
1474
1656
  ClassAliasList := TStringList.Create;
 
1657
  { on unix this maps to a simple rw synchornizer }
 
1658
  GlobalNameSpace := TMultiReadExclusiveWriteSynchronizer.Create;
 
1659
  RegisterInitComponentHandler(TComponent,@DefaultInitHandler);
1475
1660
end;
1476
1661
 
1477
1662
procedure CommonCleanup;
1478
1663
var
1479
1664
  i: Integer;
1480
1665
begin
1481
 
  // !!!: GlobalNameSpace.BeginWrite;
 
1666
  GlobalNameSpace.BeginWrite;
1482
1667
  with IntConstList.LockList do
1483
1668
    try
1484
1669
      for i := 0 to Count - 1 do
1494
1679
  GlobalFixupList := nil;
1495
1680
  GlobalLists.Free;
1496
1681
  ComponentPages.Free;
1497
 
  {!!!: GlobalNameSpace.Free;
1498
 
  GlobalNameSpace := nil;}
 
1682
 
 
1683
  { GlobalNameSpace is an interface so this is enough }
 
1684
  GlobalNameSpace:=nil;
 
1685
 
1499
1686
  if (InitHandlerList<>Nil) then
1500
1687
    for i := 0 to InitHandlerList.Count - 1 do
1501
1688
      TInitHandler(InitHandlerList.Items[I]).Free;
1503
1690
  InitHandlerList:=Nil;
1504
1691
  FindGlobalComponentList.Free;
1505
1692
  FindGlobalComponentList:=nil;
1506
 
{$ifndef ver1_0}
1507
1693
  DoneCriticalSection(SynchronizeCritSect);
1508
1694
  RtlEventDestroy(ExecuteEvent);
1509
1695
  RtlEventDestroy(SynchronizeTimeoutEvent);
1510
 
{$endif}
1511
1696
end;
1512
1697
 
1513
1698
{ TFiler implementation }
1521
1706
{$i twriter.inc}
1522
1707
 
1523
1708
 
1524
 
{
1525
 
  $Log: classes.inc,v $
1526
 
  Revision 1.27  2005/04/28 09:15:44  florian
1527
 
    + variants: string -> float/int casts
1528
 
 
1529
 
  Revision 1.26  2005/04/13 16:16:43  peter
1530
 
  use createfmt instead of createresfmt
1531
 
 
1532
 
  Revision 1.25  2005/04/09 17:26:08  florian
1533
 
    + classes.mainthreadid is set now
1534
 
    + rtleventresetevent
1535
 
    + rtleventwairfor with timeout
1536
 
    + checksynchronize with timeout
1537
 
    * race condition in synchronize fixed
1538
 
 
1539
 
  Revision 1.24  2005/03/25 22:53:39  jonas
1540
 
    * fixed several warnings and notes about unused variables (mainly) or
1541
 
      uninitialised use of variables/function results (a few)
1542
 
 
1543
 
  Revision 1.23  2005/03/13 10:07:01  florian
1544
 
    * another utf-8 patch by C. Western
1545
 
 
1546
 
  Revision 1.22  2005/03/09 20:50:11  florian
1547
 
    * C. Western: utf-8 reading from resource files
1548
 
 
1549
 
  Revision 1.21  2005/03/07 19:55:13  florian
1550
 
    * C Western: component searching in FindGlobalComponent is now done backwards
1551
 
 
1552
 
  Revision 1.20  2005/03/07 17:57:25  peter
1553
 
    * renamed rtlconst to rtlconsts
1554
 
 
1555
 
  Revision 1.19  2005/03/07 16:35:19  peter
1556
 
    * Object text format of widestrings patch from Martin Schreiber
1557
 
 
1558
 
  Revision 1.18  2005/02/25 23:02:05  florian
1559
 
    + implemented D7 compliant FindGlobalComponents
1560
 
 
1561
 
  Revision 1.17  2005/02/25 22:10:27  florian
1562
 
    * final fix for linux (hopefully)
1563
 
 
1564
 
  Revision 1.16  2005/02/25 22:02:48  florian
1565
 
    * another "transfer to linux"-commit
1566
 
 
1567
 
  Revision 1.15  2005/02/25 21:52:07  florian
1568
 
    * "transfer to linux"-commit
1569
 
 
1570
 
  Revision 1.14  2005/02/25 21:41:09  florian
1571
 
    * generic tthread.synchronize
1572
 
    * delphi compatible wakemainthread
1573
 
 
1574
 
  Revision 1.13  2005/02/14 17:13:31  peter
1575
 
    * truncate log
1576
 
 
1577
 
  Revision 1.12  2005/02/14 16:47:37  peter
1578
 
    * support inline
1579
 
 
1580
 
  Revision 1.11  2005/02/06 11:20:52  peter
1581
 
    * threading in system unit
1582
 
    * removed systhrds unit
1583
 
 
1584
 
  Revision 1.10  2005/01/22 20:53:02  michael
1585
 
   + Patch from Colin Western to fix reading inherited forms
1586
 
 
1587
 
}