← Back to branch summary

~ubuntu-branches/ubuntu/dapper/fpc/dapper

« back to all changes in this revision

Viewing changes to rtl/objpas/typinfo.pp

  • Committer: Bazaar Package Importer
  • Author(s): Carlos Laviola
  • Date: 2005-05-30 11:59:10 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050530115910-x5pbzm4qqta4i94h
Tags: 2.0.0-2
http://bugs.debian.org/310907
debian/fp-compiler.postinst.in: forgot to reapply the patch that
correctly creates the slave link to pc(1).  (Closes: #310907)

Show diffs side-by-side

added added

removed removed

Lines of Context:
rtl/objpas/typinfo.pp
1
1
{
2
 
    $Id: typinfo.pp,v 1.25 2004/05/24 21:05:19 florian Exp $
 
2
    $Id: typinfo.pp,v 1.45 2005/04/16 09:24:29 michael Exp $
3
3
    This file is part of the Free Pascal run time library.
4
4
 
5
5
    Copyright (c) 1999-2000 by Florian Klaempfl
22
22
  interface
23
23
 
24
24
{$MODE objfpc}
 
25
{$h+}
25
26
 
26
27
  uses SysUtils;
27
28
 
42
43
                   tkClass,tkObject,tkWChar,tkBool,tkInt64,tkQWord,
43
44
                   tkDynArray,tkInterfaceRaw);
44
45
 
45
 
       TTOrdType  = (otSByte,otUByte,otSWord,otUWord,otSLong,otULong);
 
46
       TOrdType  = (otSByte,otUByte,otSWord,otUWord,otSLong,otULong);
46
47
 
47
48
       TFloatType = (ftSingle,ftDouble,ftExtended,ftComp,ftCurr);
48
49
       TMethodKind = (mkProcedure,mkFunction,mkConstructor,mkDestructor,
75
76
      PTypeInfo = ^TTypeInfo;
76
77
      PPTypeInfo = ^PTypeInfo;
77
78
 
 
79
{$PACKRECORDS C}
78
80
      PTypeData = ^TTypeData;
79
 
      TTypeData = packed record
 
81
      TTypeData =
 
82
{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
 
83
      packed
 
84
{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
 
85
      record
80
86
         case TTypeKind of
81
87
            tkUnKnown,tkLString,tkWString,tkAString,tkVariant:
82
88
              ();
83
89
            tkInteger,tkChar,tkEnumeration,tkWChar:
84
 
              (OrdType : TTOrdType;
 
90
              (OrdType : TOrdType;
85
91
               case TTypeKind of
86
92
                  tkInteger,tkChar,tkEnumeration,tkBool,tkWChar : (
87
93
                    MinValue,MaxValue : Longint;
133
139
      end;
134
140
 
135
141
      // unsed, just for completeness
136
 
      TPropData = packed record
 
142
      TPropData =
 
143
{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
 
144
      packed
 
145
{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
 
146
      record
137
147
        PropCount : Word;
138
 
        PropList : record end;
 
148
        PropList : record _alignmentdummy : ptrint; end;
139
149
      end;
 
150
{$PACKRECORDS 1}
140
151
 
141
152
      PPropInfo = ^TPropInfo;
142
153
      TPropInfo = packed record
180
191
Function FindPropInfo(Instance: TObject; const PropName: string): PPropInfo;
181
192
Function FindPropInfo(AClass:TClass;const PropName: string): PPropInfo;
182
193
Procedure GetPropInfos(TypeInfo : PTypeInfo;PropList : PPropList);
183
 
Function  GetPropList(TypeInfo : PTypeInfo;TypeKinds : TTypeKinds; PropList : PPropList) : Integer;
 
194
{$ifdef ver1_0}
 
195
Function  GetPropList(TypeInfo : PTypeInfo;TypeKinds : TTypeKinds; PropList : PPropList;Sorted : boolean):longint;
 
196
Function GetPropList(TypeInfo: PTypeInfo; var PropList: PPropList): SizeInt;
 
197
{$else}
 
198
Function  GetPropList(TypeInfo : PTypeInfo;TypeKinds : TTypeKinds; PropList : PPropList;Sorted : boolean = true):longint;
 
199
Function GetPropList(TypeInfo: PTypeInfo; out PropList: PPropList): SizeInt;
 
200
{$endif}
 
201
 
184
202
 
185
203
// Property information routines.
186
204
Function IsStoredProp(Instance: TObject;PropInfo : PPropInfo) : Boolean;
193
211
Function PropIsType(AClass: TClass; const PropName: string; TypeKind: TTypeKind): Boolean;
194
212
 
195
213
// subroutines to read/write properties
196
 
Function  GetOrdProp(Instance: TObject; PropInfo : PPropInfo) : Longint;
197
 
Function  GetOrdProp(Instance: TObject; const PropName: string): Longint;
198
 
Procedure SetOrdProp(Instance: TObject; PropInfo : PPropInfo;  Value : Longint);
199
 
Procedure SetOrdProp(Instance: TObject; const PropName: string; Value: Longint);
 
214
Function  GetOrdProp(Instance: TObject; PropInfo : PPropInfo) : Int64;
 
215
Function  GetOrdProp(Instance: TObject; const PropName: string): Int64;
 
216
Procedure SetOrdProp(Instance: TObject; PropInfo : PPropInfo;  Value : Int64);
 
217
Procedure SetOrdProp(Instance: TObject; const PropName: string; Value: Int64);
200
218
 
201
219
Function  GetEnumProp(Instance: TObject; const PropName: string): string;
202
220
Function  GetEnumProp(Instance: TObject; const PropInfo: PPropInfo): string;
226
244
Procedure SetFloatProp(Instance: TObject; const PropName: string; Value: Extended);
227
245
Procedure SetFloatProp(Instance: TObject; PropInfo : PPropInfo;  Value : Extended);
228
246
 
229
 
Function  GetVariantProp(Instance: TObject; PropInfo : PPropInfo): Variant;
230
 
Function  GetVariantProp(Instance: TObject; const PropName: string): Variant;
231
 
Procedure SetVariantProp(Instance: TObject; const PropName: string; const Value: Variant);
232
 
Procedure SetVariantProp(Instance: TObject; PropInfo : PPropInfo; const Value: Variant);
233
 
 
234
247
Function  GetObjectProp(Instance: TObject; const PropName: string): TObject;
235
248
Function  GetObjectProp(Instance: TObject; const PropName: string; MinClass: TClass): TObject;
236
249
Function  GetObjectProp(Instance: TObject; PropInfo: PPropInfo): TObject;
253
266
Function GetPropValue(Instance: TObject; const PropName: string): Variant;
254
267
Function GetPropValue(Instance: TObject; const PropName: string; PreferStrings: Boolean): Variant;
255
268
Procedure SetPropValue(Instance: TObject; const PropName: string; const Value: Variant);
 
269
Function  GetVariantProp(Instance: TObject; PropInfo : PPropInfo): Variant;
 
270
Function  GetVariantProp(Instance: TObject; const PropName: string): Variant;
 
271
Procedure SetVariantProp(Instance: TObject; const PropName: string; const Value: Variant);
 
272
Procedure SetVariantProp(Instance: TObject; PropInfo : PPropInfo; const Value: Variant);
 
273
 
256
274
 
257
275
// Auxiliary routines, which may be useful
258
276
Function GetEnumName(TypeInfo : PTypeInfo;Value : Integer) : string;
266
284
    DotSep: String = '.';
267
285
 
268
286
Type
269
 
  EPropertyError = Class(Exception);
270
 
 
 
287
  EPropertyError  = Class(Exception);
 
288
  TGetPropValue   = Function (Instance: TObject; const PropName: string; PreferStrings: Boolean) : Variant;
 
289
  TSetPropValue   = Procedure (Instance: TObject; const PropName: string; const Value: Variant);
 
290
  TGetVariantProp = Function (Instance: TObject; PropInfo : PPropInfo): Variant;  
 
291
  TSetVariantProp = Procedure (Instance: TObject; PropInfo : PPropInfo; const Value: Variant);
 
292
  
 
293
Const
 
294
  OnGetPropValue   : TGetPropValue = Nil;
 
295
  OnSetPropValue   : TSetPropValue = Nil;
 
296
  OnGetVariantprop : TGetVariantProp = Nil;
 
297
  OnSetVariantprop : TSetVariantProp = Nil;
 
298
 
271
299
Implementation
272
300
 
273
 
ResourceString
274
 
  SErrPropertyNotFound = 'Unknown property: "%s"';
275
 
  SErrUnknownEnumValue = 'Unknown enumeration value: "%s"';
276
 
 
 
301
uses rtlconsts;
 
302
  
277
303
type
278
304
  PMethod = ^TMethod;
279
305
 
281
307
  Auxiliary methods
282
308
  ---------------------------------------------------------------------}
283
309
 
 
310
function aligntoptr(p : pointer) : pointer;
 
311
  begin
 
312
{$ifdef FPC_REQUIRES_PROPER_ALIGNMENT}
 
313
    if (ptrint(p) mod sizeof(ptrint))<>0 then
 
314
      inc(ptrint(p),sizeof(ptrint)-ptrint(p) mod sizeof(ptrint));
 
315
{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
 
316
    result:=p;
 
317
  end;
 
318
 
 
319
 
284
320
Function GetEnumName(TypeInfo : PTypeInfo;Value : Integer) : string;
285
321
 
286
322
  Var PS : PShortString;
407
443
 
408
444
Function GetTypeData(TypeInfo : PTypeInfo) : PTypeData;
409
445
begin
410
 
  GetTypeData:=PTypeData(pointer(TypeInfo)+2+PByte(pointer(TypeInfo)+1)^);
 
446
  GetTypeData:=PTypeData(aligntoptr(PTypeData(pointer(TypeInfo)+2+PByte(pointer(TypeInfo)+1)^)));
411
447
end;
412
448
 
413
449
 
428
464
      // skip the name
429
465
      hp:=GetTypeData(Typeinfo);
430
466
      // the class info rtti the property rtti follows immediatly
431
 
      pd:=pointer(pointer(@hp^.UnitName)+Length(hp^.UnitName)+1);
 
467
      pd:=aligntoptr(pointer(pointer(@hp^.UnitName)+Length(hp^.UnitName)+1));
432
468
      Result:=@pd^.PropList;
433
469
      for i:=1 to pd^.PropCount do
434
470
        begin
436
472
          if Upcase(Result^.Name)=P then
437
473
            exit;
438
474
          // skip to next property
439
 
          Result:=PPropInfo(pointer(@Result^.Name)+byte(Result^.Name[0])+1);
 
475
          Result:=PPropInfo(aligntoptr(pointer(@Result^.Name)+byte(Result^.Name[0])+1));
440
476
        end;
441
477
      // parent class
442
478
      Typeinfo:=hp^.ParentInfo;
533
569
begin
534
570
  TD:=GetTypeData(TypeInfo);
535
571
  // Get this objects TOTAL published properties count
536
 
  TP:=(@TD^.UnitName+Length(TD^.UnitName)+1);
 
572
  TP:=aligntoptr(PPropInfo(aligntoptr((@TD^.UnitName+Length(TD^.UnitName)+1))));
537
573
  Count:=PWord(TP)^;
538
574
  // Now point TP to first propinfo record.
539
575
  Inc(Pointer(TP),SizeOF(Word));
 
576
  tp:=aligntoptr(tp);
540
577
  While Count>0 do
541
578
    begin
542
579
      PropList^[0]:=TP;
543
580
      Inc(Pointer(PropList),SizeOf(Pointer));
544
581
      // Point to TP next propinfo record.
545
582
      // Located at Name[Length(Name)+1] !
546
 
      TP:=PPropInfo(pointer(@TP^.Name)+PByte(@TP^.Name)^+1);
 
583
      TP:=aligntoptr(PPropInfo(pointer(@TP^.Name)+PByte(@TP^.Name)^+1));
547
584
      Dec(Count);
548
585
    end;
549
586
  // recursive call for parent info.
551
588
    GetPropInfos (TD^.ParentInfo,PropList);
552
589
end;
553
590
 
554
 
 
555
591
Procedure InsertProp (PL : PProplist;PI : PPropInfo; Count : longint);
556
592
Var
557
593
  I : Longint;
564
600
  PL^[I]:=PI;
565
601
end;
566
602
 
567
 
 
568
 
Function GetPropList(TypeInfo : PTypeInfo;TypeKinds : TTypeKinds; PropList : PPropList) : Integer;
 
603
Procedure InsertPropnosort (PL : PProplist;PI : PPropInfo; Count : longint);
 
604
begin
 
605
  PL^[Count]:=PI;
 
606
end;
 
607
 
 
608
Type TInsertProp = Procedure (PL : PProplist;PI : PPropInfo; Count : longint);
 
609
 
 
610
//Const InsertProps : array[false..boolean] of TInsertProp = (InsertPropNoSort,InsertProp);
 
611
 
 
612
{$ifdef ver1_0}
 
613
Function  GetPropList(TypeInfo : PTypeInfo;TypeKinds : TTypeKinds; PropList : PPropList;Sorted : boolean):longint;
 
614
{$else}
 
615
Function  GetPropList(TypeInfo : PTypeInfo;TypeKinds : TTypeKinds; PropList : PPropList;Sorted : boolean = true):longint;
 
616
{$endif}
 
617
 
569
618
{
570
619
  Store Pointers to property information OF A CERTAIN KIND in the list pointed
571
620
  to by proplist. PRopList must contain enough space to hold ALL
572
621
  properties.
573
622
}
 
623
 
574
624
Var
575
625
  TempList : PPropList;
576
626
  PropInfo : PPropinfo;
577
627
  I,Count : longint;
 
628
  DoInsertProp : TInsertProp;
578
629
begin
 
630
  if sorted then
 
631
    DoInsertProp:=@InsertProp
 
632
  else
 
633
    DoInsertProp:=@InsertPropnosort;
579
634
  Result:=0;
580
635
  Count:=GetTypeData(TypeInfo)^.Propcount;
581
636
  If Count>0 then
588
643
            PropInfo:=TempList^[i];
589
644
            If PropInfo^.PropType^.Kind in TypeKinds then
590
645
              begin
591
 
                InsertProp(PropList,PropInfo,Result);
 
646
                If (PropList<>Nil) then
 
647
                  DoInsertProp(PropList,PropInfo,Result);
592
648
                Inc(Result);
593
649
              end;
594
650
          end;
599
655
end;
600
656
 
601
657
 
 
658
{$ifdef ver1_0}
 
659
Function GetPropList(TypeInfo: PTypeInfo; var PropList: PPropList): SizeInt;
 
660
{$else}
 
661
Function GetPropList(TypeInfo: PTypeInfo; out PropList: PPropList): SizeInt;
 
662
{$endif}
 
663
  begin
 
664
    result:=GetTypeData(TypeInfo)^.Propcount;
 
665
    if result>0 then
 
666
      begin
 
667
        getmem(PropList,result*sizeof(pointer));
 
668
        GetPropInfos(TypeInfo,PropList);
 
669
      end;
 
670
  end;
 
671
 
 
672
 
602
673
{ ---------------------------------------------------------------------
603
674
  Property access functions
604
675
  ---------------------------------------------------------------------}
607
678
  Ordinal properties
608
679
  ---------------------------------------------------------------------}
609
680
 
610
 
Function GetOrdProp(Instance : TObject;PropInfo : PPropInfo) : Longint;
 
681
Function GetOrdProp(Instance : TObject;PropInfo : PPropInfo) : Int64;
611
682
type
 
683
  TGetInt64ProcIndex=function(index:longint):Int64 of object;
 
684
  TGetInt64Proc=function():Int64 of object;
612
685
  TGetIntegerProcIndex=function(index:longint):longint of object;
613
686
  TGetIntegerProc=function:longint of object;
 
687
  TGetWordProcIndex=function(index:longint):word of object;
 
688
  TGetWordProc=function:word of object;
 
689
  TGetByteProcIndex=function(index:longint):Byte of object;
 
690
  TGetByteProc=function:Byte of object;
614
691
var
615
692
  TypeInfo: PTypeInfo;
616
693
  AMethod : TMethod;
 
694
  DataSize: Integer;
 
695
  OrdType: TOrdType;
 
696
  Signed: Boolean;
617
697
begin
618
698
  Result:=0;
619
 
  case (PropInfo^.PropProcs) and 3 of
620
 
    ptfield:
621
 
      Result:=PLongint(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
622
 
    ptstatic,
623
 
    ptvirtual :
624
 
      begin
625
 
        if (PropInfo^.PropProcs and 3)=ptStatic then
626
 
          AMethod.Code:=PropInfo^.GetProc
627
 
        else
628
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.GetProc))^;
629
 
        AMethod.Data:=Instance;
630
 
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
631
 
          Result:=TGetIntegerProcIndex(AMethod)(PropInfo^.Index)
632
 
        else
633
 
          Result:=TGetIntegerProc(AMethod)();
634
 
      end;
635
 
  end;
636
 
  { cut off unnecessary stuff }
 
699
 
637
700
  TypeInfo := PropInfo^.PropType;
 
701
  Signed := false;
 
702
  DataSize := 4;
638
703
  case TypeInfo^.Kind of
639
704
    tkChar, tkBool:
640
 
      Result:=Result and $ff;
 
705
      DataSize:=1;
641
706
    tkWChar:
642
 
      Result:=Result and $ffff;
 
707
      DataSize:=2;
643
708
    tkEnumeration,
644
709
    tkInteger:
645
 
      case GetTypeData(TypeInfo)^.OrdType of
646
 
        otSWord,otUWord:
647
 
          Result:=Result and $ffff;
648
 
        otSByte,otUByte:
649
 
          Result:=Result and $ff;
 
710
      begin
 
711
        OrdType:=GetTypeData(TypeInfo)^.OrdType;
 
712
        case OrdType of
 
713
          otSByte,otUByte: DataSize := 1;
 
714
          otSWord,otUWord: DataSize := 2;
 
715
        end;
 
716
        Signed := OrdType in [otSByte,otSWord,otSLong];
 
717
      end;
 
718
    tkInt64 :
 
719
      begin
 
720
        DataSize:=8;
 
721
        Signed:=true;
 
722
      end;
 
723
    tkQword :
 
724
      begin
 
725
        DataSize:=8;
 
726
        Signed:=false;
 
727
      end;
 
728
  end;
 
729
 
 
730
  case (PropInfo^.PropProcs) and 3 of
 
731
    ptfield:
 
732
      if Signed then begin
 
733
        case DataSize of
 
734
          1: Result:=PShortInt(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
735
          2: Result:=PSmallInt(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
736
          4: Result:=PLongint(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
737
          8: Result:=PInt64(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
738
        end;
 
739
      end else begin
 
740
        case DataSize of
 
741
          1: Result:=PByte(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
742
          2: Result:=PWord(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
743
          4: Result:=PLongint(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
744
          8: Result:=PInt64(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
 
745
        end;
 
746
      end;
 
747
    ptstatic,
 
748
    ptvirtual :
 
749
      begin
 
750
        if (PropInfo^.PropProcs and 3)=ptStatic then
 
751
          AMethod.Code:=PropInfo^.GetProc
 
752
        else
 
753
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.GetProc))^;
 
754
        AMethod.Data:=Instance;
 
755
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then begin
 
756
          case DataSize of
 
757
            1: Result:=TGetByteProcIndex(AMethod)(PropInfo^.Index);
 
758
            2: Result:=TGetWordProcIndex(AMethod)(PropInfo^.Index);
 
759
            4: Result:=TGetIntegerProcIndex(AMethod)(PropInfo^.Index);
 
760
            8: result:=TGetInt64ProcIndex(AMethod)(PropInfo^.Index)
 
761
          end;
 
762
        end else begin
 
763
          case DataSize of
 
764
            1: Result:=TGetByteProc(AMethod)();
 
765
            2: Result:=TGetWordProc(AMethod)();
 
766
            4: Result:=TGetIntegerProc(AMethod)();
 
767
            8: result:=TGetInt64Proc(AMethod)();
 
768
          end;
 
769
        end;
 
770
        if Signed then begin
 
771
          case DataSize of
 
772
            1: Result:=ShortInt(Result);
 
773
            2: Result:=SmallInt(Result);
 
774
          end;
 
775
        end;
650
776
      end;
651
777
  end;
652
778
end;
653
779
 
654
 
 
655
 
Procedure SetOrdProp(Instance : TObject;PropInfo : PPropInfo;Value : Longint);
 
780
Procedure SetOrdProp(Instance : TObject;PropInfo : PPropInfo;Value : Int64);
656
781
type
 
782
  TSetInt64ProcIndex=procedure(index:longint;i:Int64) of object;
 
783
  TSetInt64Proc=procedure(i:Int64) of object;
657
784
  TSetIntegerProcIndex=procedure(index,i:longint) of object;
658
785
  TSetIntegerProc=procedure(i:longint) of object;
659
786
var
660
787
  DataSize: Integer;
661
788
  AMethod : TMethod;
662
789
begin
663
 
  DataSize := 4;
 
790
  if PropInfo^.PropType^.Kind in [tkInt64,tkQword] then
 
791
    DataSize := 8
 
792
  else
 
793
    DataSize := 4;
664
794
  if PropInfo^.PropType^.Kind <> tkClass then
665
795
    begin
666
796
      { cut off unnecessary stuff }
680
810
  case (PropInfo^.PropProcs shr 2) and 3 of
681
811
    ptfield:
682
812
      case DataSize of
683
 
        1: PByte(Pointer(Instance)+Longint(PropInfo^.SetProc))^:=Byte(Value);
684
 
        2: PWord(Pointer(Instance)+Longint(PropInfo^.SetProc))^:=Word(Value);
685
 
        4: PLongint(Pointer(Instance)+Longint(PropInfo^.SetProc))^:=Value;
 
813
        1: PByte(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Byte(Value);
 
814
        2: PWord(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Word(Value);
 
815
        4:PLongint(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Longint(Value);
 
816
        8: PInt64(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Value;
686
817
      end;
687
818
    ptstatic,
688
819
    ptvirtual :
690
821
        if ((PropInfo^.PropProcs shr 2) and 3)=ptStatic then
691
822
          AMethod.Code:=PropInfo^.SetProc
692
823
        else
693
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.SetProc))^;
 
824
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.SetProc))^;
694
825
        AMethod.Data:=Instance;
695
 
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
696
 
          TSetIntegerProcIndex(AMethod)(PropInfo^.Index,Value)
 
826
        if datasize=8 then
 
827
          begin
 
828
            if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
 
829
              TSetInt64ProcIndex(AMethod)(PropInfo^.Index,Value)
 
830
            else
 
831
              TSetInt64Proc(AMethod)(Value);
 
832
          end
697
833
        else
698
 
          TSetIntegerProc(AMethod)(Value);
 
834
          begin
 
835
            if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
 
836
              TSetIntegerProcIndex(AMethod)(PropInfo^.Index,Value)
 
837
            else
 
838
              TSetIntegerProc(AMethod)(Value);
 
839
          end;
699
840
      end;
700
841
  end;
701
842
end;
702
843
 
703
844
 
704
 
Function GetOrdProp(Instance: TObject; const PropName: string): Longint;
 
845
Function GetOrdProp(Instance: TObject; const PropName: string): Int64;
705
846
begin
706
847
  Result:=GetOrdProp(Instance,FindPropInfo(Instance,PropName));
707
848
end;
708
849
 
709
850
 
710
 
Procedure SetOrdProp(Instance: TObject; const PropName: string;  Value: Longint);
 
851
Procedure SetOrdProp(Instance: TObject; const PropName: string;  Value: Int64);
711
852
begin
712
853
  SetOrdProp(Instance,FindPropInfo(Instance,PropName),Value);
713
854
end;
746
887
 
747
888
 
748
889
{ ---------------------------------------------------------------------
 
890
  Int64 wrappers
 
891
  ---------------------------------------------------------------------}
 
892
 
 
893
Function GetInt64Prop(Instance: TObject; PropInfo: PPropInfo): Int64;
 
894
begin
 
895
  Result:=GetOrdProp(Instance,PropInfo);
 
896
end;
 
897
 
 
898
 
 
899
procedure SetInt64Prop(Instance: TObject; PropInfo: PPropInfo; const Value: Int64);
 
900
begin
 
901
  SetOrdProp(Instance,PropInfo,Value);
 
902
end;
 
903
 
 
904
 
 
905
Function GetInt64Prop(Instance: TObject; const PropName: string): Int64;
 
906
begin
 
907
  Result:=GetInt64Prop(Instance,FindPropInfo(Instance,PropName));
 
908
end;
 
909
 
 
910
 
 
911
Procedure SetInt64Prop(Instance: TObject; const PropName: string; const Value: Int64);
 
912
begin
 
913
  SetInt64Prop(Instance,FindPropInfo(Instance,PropName),Value);
 
914
end;
 
915
 
 
916
 
 
917
{ ---------------------------------------------------------------------
749
918
  Set properties
750
919
  ---------------------------------------------------------------------}
751
920
 
805
974
{$ifdef cpu64}
806
975
  Result:=TObject(GetInt64Prop(Instance,PropInfo));
807
976
{$else cpu64}
808
 
  Result:=TObject(GetOrdProp(Instance,PropInfo));
 
977
  Result:=TObject(PtrInt(GetOrdProp(Instance,PropInfo)));
809
978
{$endif cpu64}
810
979
  If (MinClass<>Nil) and (Result<>Nil) Then
811
980
    If Not Result.InheritsFrom(MinClass) then
865
1034
              if (PropInfo^.PropProcs and 3)=ptStatic then
866
1035
                AMethod.Code:=PropInfo^.GetProc
867
1036
              else
868
 
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.GetProc))^;
 
1037
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.GetProc))^;
869
1038
              AMethod.Data:=Instance;
870
1039
              if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
871
1040
                Result:=TGetShortStrProcIndex(AMethod)(PropInfo^.Index)
885
1054
              if (PropInfo^.PropProcs and 3)=ptStatic then
886
1055
                AMethod.Code:=PropInfo^.GetProc
887
1056
              else
888
 
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.GetProc))^;
 
1057
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.GetProc))^;
889
1058
              AMethod.Data:=Instance;
890
1059
              if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
891
1060
                Result:=TGetAnsiStrProcIndex(AMethod)(PropInfo^.Index)
923
1092
              if (PropInfo^.PropProcs and 3)=ptStatic then
924
1093
                AMethod.Code:=PropInfo^.SetProc
925
1094
              else
926
 
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.SetProc))^;
 
1095
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.SetProc))^;
927
1096
              AMethod.Data:=Instance;
928
1097
              if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
929
1098
                TSetShortStrProcIndex(AMethod)(PropInfo^.Index,Value)
943
1112
              if ((PropInfo^.PropProcs shr 2) and 3)=ptStatic then
944
1113
                AMethod.Code:=PropInfo^.SetProc
945
1114
              else
946
 
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.SetProc))^;
 
1115
                AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.SetProc))^;
947
1116
              AMethod.Data:=Instance;
948
1117
              if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
949
1118
                TSetAnsiStrProcIndex(AMethod)(PropInfo^.Index,Value)
977
1146
 
978
1147
procedure SetWideStrProp(Instance: TObject; const PropName: string; const Value: WideString);
979
1148
begin
980
 
  SetStrProp(Instance,FindPropInfo(Instance,PropName),Value);
 
1149
  SetWideStrProp(Instance,FindPropInfo(Instance,PropName),Value);
981
1150
end;
982
1151
 
983
1152
 
1076
1245
    ptField:
1077
1246
      Case GetTypeData(PropInfo^.PropType)^.FloatType of
1078
1247
       ftSingle:
1079
 
         Result:=PSingle(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
 
1248
         Result:=PSingle(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
1080
1249
       ftDouble:
1081
 
         Result:=PDouble(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
 
1250
         Result:=PDouble(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
1082
1251
       ftExtended:
1083
 
         Result:=PExtended(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
 
1252
         Result:=PExtended(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
1084
1253
       ftcomp:
1085
 
         Result:=PComp(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
 
1254
         Result:=PComp(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
1086
1255
{$ifdef HASCURRENCY}
1087
1256
       ftcurr:
1088
 
         Result:=PCurrency(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
 
1257
         Result:=PCurrency(Pointer(Instance)+Ptrint(PropInfo^.GetProc))^;
1089
1258
{$endif HASCURRENCY}
1090
1259
       end;
1091
1260
    ptStatic,
1094
1263
        if (PropInfo^.PropProcs and 3)=ptStatic then
1095
1264
          AMethod.Code:=PropInfo^.GetProc
1096
1265
        else
1097
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.GetProc))^;
 
1266
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.GetProc))^;
1098
1267
        AMethod.Data:=Instance;
1099
1268
        Case GetTypeData(PropInfo^.PropType)^.FloatType of
1100
1269
          ftSingle:
1112
1281
              Result:=TGetExtendedProc(AMethod)()
1113
1282
            else
1114
1283
              Result:=TGetExtendedProcIndex(AMethod)(PropInfo^.Index);
 
1284
          {$ifdef HASCURRENCY}
 
1285
          ftCurr:
 
1286
            if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
 
1287
              Result:=TGetCurrencyProc(AMethod)()
 
1288
            else
 
1289
              Result:=TGetCurrencyProcIndex(AMethod)(PropInfo^.Index);
 
1290
          {$endif HASCURRENCY}
1115
1291
        end;
1116
1292
      end;
1117
1293
  end;
1137
1313
    ptfield:
1138
1314
      Case GetTypeData(PropInfo^.PropType)^.FloatType of
1139
1315
        ftSingle:
1140
 
          PSingle(Pointer(Instance)+Longint(PropInfo^.SetProc))^:=Value;
 
1316
          PSingle(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Value;
1141
1317
        ftDouble:
1142
 
          PDouble(Pointer(Instance)+Longint(PropInfo^.SetProc))^:=Value;
 
1318
          PDouble(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Value;
1143
1319
        ftExtended:
1144
 
          PExtended(Pointer(Instance)+Longint(PropInfo^.SetProc))^:=Value;
 
1320
          PExtended(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^:=Value;
1145
1321
{$ifdef FPC_COMP_IS_INT64}
1146
1322
        ftComp:
1147
1323
          PComp(Pointer(Instance)+PtrUInt(PropInfo^.SetProc))^:=trunc(Value);
1149
1325
        ftComp:
1150
1326
          PComp(Pointer(Instance)+PtrUInt(PropInfo^.SetProc))^:=Value;
1151
1327
{$endif FPC_COMP_IS_INT64}
 
1328
{$ifdef HASCURRENCY}
 
1329
        ftCurr:
 
1330
          PCurrency(Pointer(Instance)+PtrUInt(PropInfo^.SetProc))^:=Value;
 
1331
{$endif HASCURRENCY}
1152
1332
       end;
1153
1333
    ptStatic,
1154
1334
    ptVirtual:
1156
1336
        if ((PropInfo^.PropProcs shr 2) and 3)=ptStatic then
1157
1337
          AMethod.Code:=PropInfo^.SetProc
1158
1338
        else
1159
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.SetProc))^;
 
1339
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.SetProc))^;
1160
1340
        AMethod.Data:=Instance;
1161
1341
        Case GetTypeData(PropInfo^.PropType)^.FloatType of
1162
1342
          ftSingle:
1174
1354
              TSetExtendedProc(AMethod)(Value)
1175
1355
            else
1176
1356
              TSetExtendedProcIndex(AMethod)(PropInfo^.Index,Value);
 
1357
          {$ifdef HASCURRENCY}
 
1358
          ftCurr:
 
1359
            if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
 
1360
              TSetCurrencyProc(AMethod)(Value)
 
1361
            else
 
1362
              TSetCurrencyProcIndex(AMethod)(PropInfo^.Index,Value);
 
1363
          {$endif HASCURRENCY}
1177
1364
        end;
1178
1365
      end;
1179
1366
  end;
1193
1380
 
1194
1381
 
1195
1382
{ ---------------------------------------------------------------------
1196
 
  Variant properties
1197
 
  ---------------------------------------------------------------------}
1198
 
 
1199
 
Function GetVariantProp(Instance : TObject;PropInfo : PPropInfo): Variant;
1200
 
begin
1201
 
{$warning GetVariantProp not implemented}
1202
 
{$ifdef HASVARIANT}
1203
 
  Result:=Null;
1204
 
{$else}
1205
 
  Result:=nil;
1206
 
{$endif}
1207
 
end;
1208
 
 
1209
 
 
1210
 
Procedure SetVariantProp(Instance : TObject;PropInfo : PPropInfo; const Value: Variant);
1211
 
begin
1212
 
{$warning SetVariantProp not implemented}
1213
 
end;
1214
 
 
1215
 
 
1216
 
Function GetVariantProp(Instance: TObject; const PropName: string): Variant;
1217
 
begin
1218
 
  Result:=GetVariantProp(Instance,FindPropInfo(Instance,PropName));
1219
 
end;
1220
 
 
1221
 
 
1222
 
Procedure SetVariantProp(Instance: TObject; const PropName: string;  const Value: Variant);
1223
 
begin
1224
 
  SetVariantprop(instance,FindpropInfo(Instance,PropName),Value);
1225
 
end;
1226
 
 
1227
 
 
1228
 
{ ---------------------------------------------------------------------
1229
1383
  Method properties
1230
1384
  ---------------------------------------------------------------------}
1231
1385
 
1232
1386
 
1233
1387
Function GetMethodProp(Instance : TObject;PropInfo : PPropInfo) : TMethod;
1234
1388
type
1235
 
  TGetMethodProcIndex=function(index:longint):PMethod of object;
1236
 
  TGetMethodProc=function():PMethod of object;
 
1389
  TGetMethodProcIndex=function(Index: Longint): TMethod of object;
 
1390
  TGetMethodProc=function(): TMethod of object;
1237
1391
var
1238
1392
  value: PMethod;
1239
1393
  AMethod : TMethod;
1240
1394
begin
1241
 
  Value:=nil;
 
1395
  Result.Code:=nil;
 
1396
  Result.Data:=nil;
1242
1397
  case (PropInfo^.PropProcs) and 3 of
1243
1398
    ptfield:
1244
 
      Value:=PMethod(Pointer(Instance)+Longint(PropInfo^.GetProc));
 
1399
      begin
 
1400
        Value:=PMethod(Pointer(Instance)+Ptrint(PropInfo^.GetProc));
 
1401
        if Value<>nil then
 
1402
          Result:=Value^;
 
1403
      end;
1245
1404
    ptstatic,
1246
1405
    ptvirtual :
1247
1406
      begin
1248
1407
        if (PropInfo^.PropProcs and 3)=ptStatic then
1249
1408
          AMethod.Code:=PropInfo^.GetProc
1250
1409
        else
1251
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.GetProc))^;
 
1410
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.GetProc))^;
1252
1411
        AMethod.Data:=Instance;
1253
1412
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
1254
 
          Value:=TGetMethodProcIndex(AMethod)(PropInfo^.Index)
 
1413
          Result:=TGetMethodProcIndex(AMethod)(PropInfo^.Index)
1255
1414
        else
1256
 
          Value:=TGetMethodProc(AMethod)();
 
1415
          Result:=TGetMethodProc(AMethod)();
1257
1416
      end;
1258
1417
  end;
1259
 
  if Value=nil then
1260
 
    begin
1261
 
      Result.Code:=nil;
1262
 
      Result.Data:=nil;
1263
 
    end
1264
 
  else
1265
 
    Result:=Value^;
1266
1418
end;
1267
1419
 
1268
1420
 
1275
1427
begin
1276
1428
  case (PropInfo^.PropProcs shr 2) and 3 of
1277
1429
    ptfield:
1278
 
      PMethod(Pointer(Instance)+Longint(PropInfo^.SetProc))^ := Value;
 
1430
      PMethod(Pointer(Instance)+Ptrint(PropInfo^.SetProc))^ := Value;
1279
1431
    ptstatic,
1280
1432
    ptvirtual :
1281
1433
      begin
1282
1434
        if ((PropInfo^.PropProcs shr 2) and 3)=ptStatic then
1283
1435
          AMethod.Code:=PropInfo^.SetProc
1284
1436
        else
1285
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.SetProc))^;
 
1437
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Ptrint(PropInfo^.SetProc))^;
1286
1438
        AMethod.Data:=Instance;
1287
1439
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
1288
1440
          TSetMethodProcIndex(AMethod)(PropInfo^.Index,@Value)
1306
1458
 
1307
1459
 
1308
1460
{ ---------------------------------------------------------------------
1309
 
  Int64 properties
 
1461
  Variant properties
1310
1462
  ---------------------------------------------------------------------}
1311
1463
 
1312
 
Function GetInt64Prop(Instance: TObject; PropInfo: PPropInfo): Int64;
1313
 
type
1314
 
  TGetInt64ProcIndex=function(index:longint):Int64 of object;
1315
 
  TGetInt64Proc=function():Int64 of object;
1316
 
var
1317
 
  AMethod : TMethod;
1318
 
begin
1319
 
  Result:=0;
1320
 
  case (PropInfo^.PropProcs) and 3 of
1321
 
    ptfield:
1322
 
      Result:=PInt64(Pointer(Instance)+Longint(PropInfo^.GetProc))^;
1323
 
    ptstatic,
1324
 
    ptvirtual :
1325
 
      begin
1326
 
        if (PropInfo^.PropProcs and 3)=ptStatic then
1327
 
          AMethod.Code:=PropInfo^.GetProc
1328
 
        else
1329
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.GetProc))^;
1330
 
        AMethod.Data:=Instance;
1331
 
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
1332
 
          result:=TGetInt64ProcIndex(AMethod)(PropInfo^.Index)
1333
 
        else
1334
 
          result:=TGetInt64Proc(AMethod)();
1335
 
      end;
1336
 
  end;
1337
 
end;
1338
 
 
1339
 
 
1340
 
procedure SetInt64Prop(Instance: TObject; PropInfo: PPropInfo; const Value: Int64);
1341
 
type
1342
 
  TSetInt64ProcIndex=procedure(index:longint;i:Int64) of object;
1343
 
  TSetInt64Proc=procedure(i:Int64) of object;
1344
 
var
1345
 
  AMethod : TMethod;
1346
 
begin
1347
 
  case (PropInfo^.PropProcs shr 2) and 3 of
1348
 
    ptfield:
1349
 
      PInt64(Pointer(Instance)+Longint(PropInfo^.SetProc))^ := Value;
1350
 
    ptstatic,
1351
 
    ptvirtual :
1352
 
      begin
1353
 
        if ((PropInfo^.PropProcs shr 2) and 3)=ptStatic then
1354
 
          AMethod.Code:=PropInfo^.SetProc
1355
 
        else
1356
 
          AMethod.Code:=PPointer(Pointer(Instance.ClassType)+Longint(PropInfo^.SetProc))^;
1357
 
        AMethod.Data:=Instance;
1358
 
        if ((PropInfo^.PropProcs shr 6) and 1)<>0 then
1359
 
          TSetInt64ProcIndex(AMethod)(PropInfo^.Index,Value)
1360
 
        else
1361
 
          TSetInt64Proc(AMethod)(Value);
1362
 
      end;
1363
 
  end;
1364
 
end;
1365
 
 
1366
 
 
1367
 
Function GetInt64Prop(Instance: TObject; const PropName: string): Int64;
1368
 
begin
1369
 
  Result:=GetInt64Prop(Instance,FindPropInfo(Instance,PropName));
1370
 
end;
1371
 
 
1372
 
 
1373
 
Procedure SetInt64Prop(Instance: TObject; const PropName: string; const Value: Int64);
1374
 
begin
1375
 
  SetInt64Prop(Instance,FindPropInfo(Instance,PropName),Value);
 
1464
Procedure CheckVariantEvent(P : Pointer);
 
1465
 
 
1466
begin
 
1467
  If (P=Nil) then
 
1468
    Raise Exception.Create(SErrNoVariantSupport);
 
1469
end;
 
1470
 
 
1471
Function GetVariantProp(Instance : TObject;PropInfo : PPropInfo): Variant;
 
1472
begin
 
1473
  CheckVariantEvent(Pointer(OnGetVariantProp));
 
1474
  Result:=OnGetVariantProp(Instance,PropInfo);
 
1475
end;
 
1476
 
 
1477
 
 
1478
Procedure SetVariantProp(Instance : TObject;PropInfo : PPropInfo; const Value: Variant);
 
1479
begin
 
1480
   CheckVariantEvent(Pointer(OnSetVariantProp));
 
1481
   OnSetVariantProp(Instance,PropInfo,Value);
 
1482
end;
 
1483
 
 
1484
 
 
1485
Function GetVariantProp(Instance: TObject; const PropName: string): Variant;
 
1486
begin
 
1487
  Result:=GetVariantProp(Instance,FindPropInfo(Instance,PropName));
 
1488
end;
 
1489
 
 
1490
 
 
1491
Procedure SetVariantProp(Instance: TObject; const PropName: string;  const Value: Variant);
 
1492
begin
 
1493
  SetVariantprop(instance,FindpropInfo(Instance,PropName),Value);
1376
1494
end;
1377
1495
 
1378
1496
 
1387
1505
 
1388
1506
 
1389
1507
Function GetPropValue(Instance: TObject; const PropName: string; PreferStrings: Boolean): Variant;
 
1508
 
1390
1509
begin
 
1510
  CheckVariantEvent(Pointer(OnGetPropValue));
 
1511
  Result:=OnGetPropValue(Instance,PropName,PreferStrings)
1391
1512
end;
1392
1513
 
1393
 
 
1394
1514
Procedure SetPropValue(Instance: TObject; const PropName: string;  const Value: Variant);
 
1515
 
1395
1516
begin
 
1517
  CheckVariantEvent(Pointer(OnSetPropValue));
 
1518
  OnSetPropValue(Instance,PropName,Value);
1396
1519
end;
1397
1520
 
1398
1521
 
1438
1561
end.
1439
1562
{
1440
1563
  $Log: typinfo.pp,v $
1441
 
  Revision 1.25  2004/05/24 21:05:19  florian
1442
 
    * fixed comp property writing for cpus where comp=int64
1443
 
 
1444
 
  Revision 1.24  2004/05/23 19:00:40  florian
1445
 
    + added widestring routines
1446
 
 
1447
 
  Revision 1.23  2004/02/22 16:48:39  florian
1448
 
    * several 64 bit issues fixed
1449
 
 
1450
 
  Revision 1.22  2004/02/21 22:53:49  florian
1451
 
    * several 64 bit/x86-64 fixes
1452
 
 
1453
 
  Revision 1.21  2004/02/20 15:55:26  peter
1454
 
    * enable variant again
1455
 
 
1456
 
  Revision 1.20  2003/12/24 22:27:13  peter
1457
 
    * removed assembler
1458
 
    * cleanup
1459
 
 
1460
 
  Revision 1.19  2003/12/22 11:32:04  marco
1461
 
   * splitted up tintfflags into several components
1462
 
 
1463
 
  Revision 1.18  2003/10/24 08:37:20  marco
1464
 
   * Fix from Peter
1465
 
 
1466
 
  Revision 1.17  2003/10/17 20:58:27  olle
1467
 
    * Changed m68k to cpum68k, i386 to cpui386
1468
 
 
1469
 
  Revision 1.16  2003/04/24 11:46:25  florian
1470
 
    * fixed wrong newlines
1471
 
 
1472
 
  Revision 1.15  2003/03/29 16:55:56  michael
1473
 
  + Patch from Mattias Gaertner for single typeinfo
1474
 
 
1475
 
  Revision 1.14  2002/09/07 16:01:22  peter
1476
 
    * old logs removed and tabs fixed
1477
 
 
1478
 
  Revision 1.13  2002/04/04 18:32:59  peter
1479
 
    * merged getpropinfo fix
 
1564
  Revision 1.45  2005/04/16 09:24:29  michael
 
1565
  + Moved constants to rtlconsts and added callbacks for variant support
 
1566
 
 
1567
  Revision 1.44  2005/04/14 17:43:07  michael
 
1568
  + Added getPropValue by Uberto Barbini
 
1569
 
 
1570
  Revision 1.43  2005/04/05 06:44:25  marco
 
1571
   * Currency property patch from Dean Zobec
 
1572
 
 
1573
  Revision 1.42  2005/04/03 11:50:58  marco
 
1574
   * patch for 3854 added. There are probably more places that need explicit
 
1575
  currency handling.
 
1576
 
 
1577
  Revision 1.41  2005/03/14 21:15:52  florian
 
1578
    * fixed compilation on i386
 
1579
 
 
1580
  Revision 1.40  2005/03/14 19:16:06  peter
 
1581
    * getordprop supports int64
 
1582
 
 
1583
  Revision 1.39  2005/02/26 20:59:38  florian
 
1584
    * fixed 1.0.10 issue
 
1585
 
 
1586
  Revision 1.38  2005/02/26 11:37:01  florian
 
1587
    + overload of GetPropList added
 
1588
 
 
1589
  Revision 1.37  2005/02/22 12:14:56  marco
 
1590
   * getproplist sorted param added.
 
1591
 
 
1592
  Revision 1.36  2005/02/14 17:13:31  peter
 
1593
    * truncate log
 
1594
 
 
1595
  Revision 1.35  2005/02/08 16:10:29  florian
 
1596
    * TTOrdType -> TOrdType
 
1597
 
1480
1598
}