Solved

code that crashes compiler??!!

Posted on 2002-07-18
11
201 Views
Last Modified: 2010-04-04
Hi, got this WIERD error when compiling my code, it gives an acces voilation within dcc40.dll when i try to compile my code. dcc50 seems to be the compiler allright found that on the internet. I also tried to use another pc but it doesn't work. Also the commandline compiler crashes.

any ideas???

0
Comment
Question by:God_Ares
  • 9
  • 2
11 Comments
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
sorry dcc50.dll
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
i also have update pack 1 installed.
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
hey if you want to test it for your self drop your mail, and tell me if you had a problem, tested it on 4 machines now.
0
 
LVL 11

Expert Comment

by:robert_marquardt
Comment Utility
dcc50 is not the compiler but the IDE part handling the compiler and its output.
I checked the exported names of the DLL.
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
robert_marquardt would you be willing to test it.??
0
How to run any project with ease

Manage projects of all sizes how you want. Great for personal to-do lists, project milestones, team priorities and launch plans.
- Combine task lists, docs, spreadsheets, and chat in one
- View and edit from mobile/offline
- Cut down on emails

 
LVL 7

Author Comment

by:God_Ares
Comment Utility
Here Test it and tell me if it works out.
just start a new app and uses this unit.


unit Pas_Catalogue;


interface

uses Windows, SysUtils,Crc32,classes, contnrs;

Const   CHeadingDivider = ';';
        CHeadingString = 'The Nanny Reporter'; //do not change value
        CVersionIndicator = 'ver=';
        CVersion = '1.0';  //change only when nessesery
        CDescriptionIndicator = 'desc=';
        CHeaderTerminator = '$';
        CForbidenChars = [';','$'];
    TXT_Fout_Verboden_teken_komt_voor       = 'Er is een teken gebruikt in de omschrijving dat niet toegestaan is';
    TXT_Fout_Link_Bestaat_Al                = 'Deze link bestaat al voor deze tabel.';
    TXT_Fout_Link_Bestaat_Niet              = 'Deze link bestaat niet voor deze tabel.';
    TXT_Fout_Tabel_bestaat_Niet             = 'Tabel bestaat nog niet.';
    TXT_Fout_Table_bestaat_al               = 'De tabel bestaat al.';
    TXT_FOUT_HEADER_CORRUPT                 = 'De Header is corrupt, bestand wordt niet geladen.';
    TXT_FOUT_FINGERPRINT_ERROR              = 'Het bestand is gewijzigd.';
    TXT_FOUT_VELD_IS_AANWEZIG               = 'Het veld is al reeds toegevoegd.';



Type
  ECatalogueException = Class(Exception);

  TCatTableInfo =   Class
                    Private
                      FTableNumber: Integer;
                      FTableName  : String;
                      FTableAlias : String;
                      FGlobal     : Boolean;
                    Public
                      Property TableName : String read FTableName write FTableName;
                      Property TableAlias : String read FTableAlias write FTableAlias;
                      Property Global : Boolean read FGlobal Write FGlobal;

                      Function Compare(TableInfo : TCatTableInfo) : Boolean; {*}
                      Function CompareByName(TableName : String) : Boolean; {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream); {*}
                    End;

  TCatField     =   Class{4}
                    Private
                      FFieldName : String;
                      FHidden : Boolean;
                    Public
                      Property FieldName : String read FFieldName write FFieldName;
                      Property Hidden : Boolean read FHidden write FHidden;

                      Constructor Create(FieldName : String);overload; {*}
                      Constructor Create; overload; {*}
                      Destructor Destroy; override; {*}
                      Function CompareByName(FieldName : String) : Boolean; {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream);   {*}
                    End;

  TCatFields    =   Class(TObjectList){3}
                    Private
                      Function GetField(Index : Integer) : TCatField;
                    Public
                      property Items[Index: Integer]: TCatField read GetField; default;

                      Constructor Create;   {*}
                      Destructor  Destroy; override; {*}
                      function Add(AField: TCatField): Integer;  {*}
                      function Remove(AField: TCatField): Integer;  {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream);   {*}

                    End;

  TCatTableLinkField {8}
                =   Class
                    Private
                      FMasterFieldR: String;  //String Reference.
                      FDetailFieldR: String;  //String Reference.
                      FMasterField : TCatField;
                      FDetailField : TCatField;
                      FLinkMethod  : String;
                    Public
                      Property MasterField : TCatField Read FMasterField;
                      Property DetailField : TCatField Read FDetailField;
                      Property LinkMethod : String Read FLinkMethod;

                      Constructor Create;  {*}
                      Procedure Fill(MasterField , DetailField : TCatField; LinkMethod : ShortString = '='); {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream); {*}
                    End;

  TCatTableLinkFields
                =   Class(TObjectList){7}
                    Private
                      Function GetLinkedField(Index : Integer) : TCatTableLinkField; {*}
                    Public
                      property Items[Index: Integer]: TCatTableLinkField read GetLinkedField {write SetLinkedField};  default;

                      Constructor Create; {*}
                      Destructor  Destroy; override; {*}
                      function Add(ALinkField: TCatTableLinkField): Integer;  {*}
                      function Remove(ALinkField: TCatTableLinkField): Integer;  {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream); {*}
                    End;

  TCatTable     =   Class;

  TCatTableLink =   Class{6}
                    Private
                      FMasterTableR: Integer;  //reference to table;
                      FDetailR     : Integer;  //reference to table;
                      FMasterTable : TCatTable;
                      FDetail      : TCatTable;
                      FLinkFields  : TCatTableLinkFields;
                    Public
                      Property MasterTable : TCatTable read FMasterTable;
                      Property DetailTable : TCatTable read FDetail;
                      Property LinkFields : TCatTableLinkFields read FLinkFields write FLinkFields;

                      Constructor Create;  {*}
                      Destructor  Destroy; override; {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream); {*}
                    End;

  TCatTableLinks=   Class(TObjectList){5}
                    Private
                      Function GetLinkedField(Index : Integer) : TCatTableLinkField;
                    Public
                      property Items[Index: Integer]: TCatTableLinkField read GetLinkedField; default;

                      Constructor Create;
                      Destructor  Destroy; override;
                      function Add(AField: TCatTableLinkField): Integer;
                      function Remove(AField: TCatTableLinkField): Integer;
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream); {*}
                    End;

  TCatTable     =   Class{2}
                    Private
                      FTableInfo  : TCatTableInfo;
                      FLinks      : TCatTableLinks;
                      FFields     : TCatFields;
                    Public
                      Property TableInfo : TCatTableInfo Read FTableInfo Write FTableInfo;
                      Property Links : TCatTableLinks Read FLinks Write FLinks;
                      Property Fields : TCatFields Read FFields Write FFields;

                      Constructor Create;  {*}
                      Destructor  Destroy;override; {*}
                      Procedure LoadFromStream(Stream : TStream);  {*}
                      Procedure SaveToStream(Stream : TStream); {*}
                    End;

  TCatTables    =   Class(TObjectList){1}
                    Private
                      Function GetTable(Index : Integer) : TCatTable;
                    Public
                      property Items[Index: Integer]: TCatTable read GetTable; default;
                      Constructor Create;
                      Destructor  Destroy; override;
                      function Add(ATable: TCatTable): Integer;  {*}
                      function Remove(ATable: TCatTable): Integer;  {*}
                      procedure LoadFromStream(Stream: TStream); {*}
                      procedure SaveToStream(Stream: TStream);
                    End;

  TCatHeading   =   Class
                    Private
                      fFileOk   : Boolean;
                      fVersion  : ShortString;
                      fDescription : String;
                      fHeader   : String;
                    Public
                      Property FileOk   : Boolean Read fFileOk;
                      Property Version  : ShortString read fVersion;
                      Property Description : String read fDescription;
                      Property Header   : string read fHeader;
                      Procedure PrepageHeader(Description : String); {k}
                      Procedure LoadFromStream(Stream : TStream);    {k}
                      Procedure SaveToStream(Stream : TStream);      {k}
                    End;

  TCatBody      =   Class
                    Private
                      FCatTables : TCatTables;
                    Public
                      Constructor Create; {*}
                      Destructor Destroy; override; {*}
                      Procedure LoadFromStream(Stream : TStream); {*}
                      Procedure SaveToStream(Stream : TStream);   {*}
                    End;

  TCat          =   Class
                    Private
                      fHeading  : TCatHeading;
                      fBody     : TCatBody;
                    Public
                      Property Heading  : TCatHeading read fHeading write fHeading;
                      Property Body     : TCatBody read fBody write fBody;
                      Constructor Create;
                      Destructor Destroy; override;
                      Procedure LoadFromStream(Stream : TStream);
                      Procedure LoadFormFile(FileName : String);
                      Procedure SaveToStream(Stream : TStream);
                      Procedure SaveToFile(FileName : String);
                    End;

  //Non Class Related Functions
  Procedure SaveStringToStream(S : String; Stream : TStream);
  Function LoadStringFromStream(Stream : TStream) : String;


implementation

//Non Class Related Functions
Procedure SaveStringToStream(S : String; Stream : TStream);
Var i:Integer;
Begin
  i := Length(S);
  Stream.Write(i,SizeOf(Integer)); //Write Length of string
  Stream.Write(s[1],i);            //Write String;
End;

Function LoadStringFromStream(Stream : TStream) : String;
Var I:Integer;
    r:String;
Begin
  Stream.read(i,SizeOf(Integer));  //read Length of String
  SetLength(r,i);
  Stream.Read(r[1],i);             //read String;
End;


{ TCatBody }

constructor TCatBody.Create;
begin
  FCatTables := TCatTables.Create;
end;

destructor TCatBody.Destroy;
begin
  FCatTables.free;
  inherited;
end;

procedure TCatBody.LoadFromStream(Stream: TStream);
begin
  FCatTables.LoadFromStream(Stream);
end;

procedure TCatBody.SaveToStream(Stream: TStream);
begin
  FCatTables.SaveToStream(Stream);
end;

{TCatHeading}

Procedure TCatHeading.PrepageHeader(Description:String);
{pre :Description does not hold any forbinden chars
 Post:The header is prepared.
}
Var i:Integer;
    b:Boolean;

Begin
  b := 1=0;
  For i:=1 to Length(Description) Do
    b := b or (Description[i] in CForbidenChars); //check if any forbidden chars exsist.
  If b then raise ECatalogueException.Create(TXT_Fout_Verboden_teken_komt_voor); //should be filterd beforehand.
  fHeader := '';
  fHeader := CHeadingString + CHeadingDivider
           + CVersionIndicator + CVersion + CHeadingDivider
           + CDescriptionIndicator + Description + CHeaderTerminator;
  fVersion := CVersion;
  fDescription := Description;
  fFileOk := 1=1;
End;

Procedure TCatHeading.LoadFromStream(Stream : TStream);
{pre :-
 post:header is loaded and the position of the stream starts at the body, or fileOk equals false. the

 we assume errors may occur in the heading, if there are none, the body should be correct.
}
var s:string;
    c:Char;
    TerminatorFound : Boolean;
Begin
  //Check File Intro header
  fFileOk := 1=0; //is not correct until proven otherwise.
  //the header is by definition incorect until a specific streang has been red.
  SetLength(s,length(CHeadingString)+1);
  Stream.Read(s[1],length(CHeadingString)+1); //get first couple of bytes and
  if s = (CHeadingString+CHeadingDivider) then  //compare them with the heading string.
  With Stream Do
  Begin
    //get rest of text until $ is reached.
    TerminatorFound := 1=0;
    s := '';
    while not (TerminatorFound or (Position = Size)) do
    Begin
      read(c,1);
      s := s + c;
      TerminatorFound := c = CHeaderTerminator;
    End;

    If TerminatorFound Then
    Begin
      //now read version info. should be on first position
      fHeader := CHeadingString+CHeadingDivider + s;
      If pos(CVersionIndicator,s) =1 Then
      Begin
        Delete(s,1,length(CVersionIndicator)); //remove ver=
        fVersion := Copy(s,1,pos(CHeadingDivider,s)-1); //store version number

        If fVersion = CVersion Then
        Begin
          Delete(s,1,pos(CHeadingDivider,s));
          If Pos(CDescriptionIndicator,s) =1 Then
          Begin
            Delete(s,1,Length(CDescriptionIndicator));
            fDescription := Copy(s,1,pos(CHeaderTerminator,s)-1); //store description
            fFileOk := 1=1; //file is ok.
          End;
        End;
      End;
    End;
  End;
End;

Procedure TCatHeading.SaveToStream(Stream : TStream);
{ Pre : -
  Post: Heading is saved to stream
}
Begin
  Stream.Write(fHeader[1],Length(fHeader));
End;

{ TCatTableInfo }

function TCatTableInfo.Compare(TableInfo: TCatTableInfo): Boolean;
begin
  Result := (tableInfo.TableName = TableName) And (tableInfo.TableAlias = TableAlias)
end;

function TCatTableInfo.CompareByName(TableName: String): Boolean;
begin
  Result := Self.TableName = TableName;
end;

procedure TCatTableInfo.LoadFromStream(Stream: TStream);
begin
  Stream.Read(FTableNumber,SizeOf(Integer));
  FTableName := LoadStringFromStream(Stream);
  FTableAlias:= LoadStringFromStream(Stream);
  Stream.Read(FGlobal,SizeOf(Boolean));
end;

procedure TCatTableInfo.SaveToStream(Stream: TStream);
begin
  Stream.Write(FTableNumber,SizeOf(Integer));
  SaveStringToStream(FTableName,Stream);
  SaveStringToStream(FTableAlias,Stream);
  Stream.Write(FGlobal,SizeOf(Boolean));
end;

{ TCatField }

function TCatField.CompareByName(FieldName: String): Boolean;
begin
  Result := Self.FieldName = FieldName;
end;

constructor TCatField.Create(FieldName: String);
begin
  Self.FieldName := FieldName;
end;

constructor TCatField.Create;
begin
 inherited;
end;

destructor TCatField.Destroy;
begin
  inherited;
end;

procedure TCatField.LoadFromStream(Stream: TStream);
begin
  FFieldName := LoadStringFromStream(Stream);
  Stream.Read(FHidden,SizeOf(Boolean));
end;

procedure TCatField.SaveToStream(Stream: TStream);
begin
  SaveStringToStream(FFieldName,Stream);
  Stream.Write(FHidden,SizeOf(Boolean));
end;

{ TCatFields }

function TCatFields.Add(AField: TCatField): Integer;
begin
  Result := inherited add(aField);
end;

constructor TCatFields.Create;
{ Pre :
  Post:
}
begin
  Inherited Create(True);
end;

destructor TCatFields.Destroy;
{ Pre :
  Post:
}
begin
  inherited;
end;

function TCatFields.GetField(Index: Integer): TCatField;
{ Pre :
  Post:
}
begin
  result := TCatField( Inherited Items[index]);
end;

procedure TCatFields.LoadFromStream(Stream: TStream);
Var i,t:Integer;
    new : TCatField;
begin
  Stream.Read(t,SizeOf(Integer));
  For i:=0 to t-1 Do
  Begin
    new := TCatField.Create;
    New.LoadFromStream(Stream);
    add(new);
  End;
end;

function TCatFields.Remove(AField: TCatField): Integer;
{ Pre :
  Post:
}
begin
  Result := inherited Remove(Afield);
end;

procedure TCatFields.SaveToStream(Stream: TStream);
begin

end;

{ TCatTables }

function TCatTables.Add(ATable: TCatTable): Integer;
{ Pre :
  Post:
}
begin
  Result := Inherited Add(ATable);
end;

constructor TCatTables.Create;
{ Pre :
  Post:
}
begin

end;

destructor TCatTables.Destroy;
{ Pre :
  Post:
}
begin

end;

function TCatTables.GetTable(Index: Integer): TCatTable;
begin
  Result := TCatTable(inherited Items[index]);
end;

function TCatTables.Remove(ATable: TCatTable): Integer;
begin
  Result := Inherited Remove(ATable);
end;

procedure TCatTables.LoadFromStream(Stream: TStream);
Var I,Cnt : Integer;
    New : TCatTable;
begin
  Stream.Read(Cnt,SizeOf(Integer));
  For I:=0 To Cnt-1 Do
  Begin
    new := TCatTable.Create;
    new.LoadFromStream(Stream);
    Add(New);
  End;
end;

procedure TCatTables.SaveToStream(Stream: TStream);
Var I : Integer;
begin
  Stream.Write(i,SizeOf(Integer));
  For i:=0 to count-1 Do
    Items[i].SaveToStream(Stream);
end;

{ TCatTableLinkFields }

function TCatTableLinkFields.Add(ALinkField: TCatTableLinkField): Integer;
begin
  Result := inherited Add(ALinkField);
end;

constructor TCatTableLinkFields.Create;
begin
  Inherited Create(True);
end;

destructor TCatTableLinkFields.Destroy;
begin
  inherited;
end;

function TCatTableLinkFields.GetLinkedField(
  Index: Integer): TCatTableLinkField;
var o : TObject;
begin
  o := Inherited Items[index];
  Result :=  TCatTableLinkField(o);
end;

procedure TCatTableLinkFields.LoadFromStream(Stream: TStream);
Var I,Cnt:Integer;
    new : TCatTableLinkField;
begin
  Stream.Read(Cnt,SizeOf(Integer));
  For i:=0 to Cnt Do
  Begin
    new := TCatTableLinkField.Create;  //Create Objects
    new.LoadFromStream(Stream);        //Fill Objects.
    add(new);
  End;
end;

function TCatTableLinkFields.Remove(ALinkField: TCatTableLinkField): Integer;
begin
  Result := Inherited Remove(ALinkField);
end;

procedure TCatTableLinkFields.SaveToStream(Stream: TStream);
Var I:Integer;
begin
  Stream.Write(Count,SizeOf(Integer));
  For i:=0 to Count-1 Do
    Items[i].SaveToStream(Stream);  //save all objects.
end;

{ TCatTable }

constructor TCatTable.Create;
begin
  inherited;
  FTableInfo  := TCatTableInfo.Create;
  FLinks      := TCatTableLinks.Create;
  FFields     := TCatFields.Create;
end;

destructor TCatTable.Destroy;
begin
  FTableInfo.Free;
  FLinks.Free;
  FFields.Free;
  inherited;
end;

procedure TCatTable.LoadFromStream(Stream: TStream);
begin
  FTableInfo.LoadFromStream(Stream);
  FLinks.LoadFromStream(Stream);
  FFields.LoadFromStream(Stream);
end;

procedure TCatTable.SaveToStream(Stream: TStream);
begin
  FTableInfo.SaveToStream(Stream);
  FLinks.SaveToStream(Stream);
  FFields.SaveToStream(Stream);
end;

{ TCatTableLinkField }

constructor TCatTableLinkField.Create;
begin

end;

procedure TCatTableLinkField.Fill(MasterField, DetailField: TCatField;
  LinkMethod: ShortString);
begin
  Self.FMasterField := MasterField;
  Self.FDetailField := DetailField;
  Self.FLinkMethod := LinkMethod;
  FMasterFieldR := MasterField.FieldName;
  FDetailFieldR := DetailField.FieldName;
end;

procedure TCatTableLinkField.LoadFromStream(Stream: TStream);
begin
  SaveStringToStream(FMasterFieldR,Stream);
  SaveStringToStream(FDetailFieldR,Stream);
  SaveStringToStream(FLinkMethod,Stream);
end;

procedure TCatTableLinkField.SaveToStream(Stream: TStream);
begin
  FMasterFieldR := LoadStringFromStream(Stream);
  FDetailFieldR := LoadStringFromStream(Stream);
  FLinkMethod   := LoadStringFromStream(Stream);
end;

{ TCat }

constructor TCat.Create;
begin

end;

destructor TCat.Destroy;
begin
  inherited;

end;

procedure TCat.LoadFormFile(FileName: String);
begin

end;

procedure TCat.LoadFromStream(Stream: TStream);
Var FingerPrint, test : LongInt;
Begin
{$ifdef FingerPrintOn}
  stream.Read(FingerPrint,SizeOf(LongInt));

  test := GetCrc32ForStream(Stream,high(LongInt));
  stream.Position := SizeOf(LongInt);

  If test = FingerPrint then
{$endif}
  Begin
    fHeading.LoadFromStream(Stream);
    If fHeading.FileOk then
      fBody.LoadFromStream(Stream)
    else Raise ECatalogueException.Create(TXT_FOUT_HEADER_CORRUPT);
  end {$ifndef FingerPrintOn};
  {$Else} else Raise ECatalogueException.Create(TXT_FOUT_FINGERPRINT_ERROR); {$endif}
end;

procedure TCat.SaveToFile(FileName: String);
begin

end;

procedure TCat.SaveToStream(Stream: TStream);
Var FingerPrint : LongInt;
Begin
{$ifdef FingerPrintOn}
  FingerPrint := 0;
  Stream.Write(FingerPrint,SizeOf(LongInt)); //Write dummy finger print
{$endif}
  fHeading.SaveToStream(Stream); // Save heading to a stream
  fBody.SaveToStream(Stream);  //save body to stream
{$ifdef FingerPrintOn}
  Stream.Position :=SizeOf(LongInt);
  FingerPrint := GetCrc32ForStream(Stream,high(LongInt));
  Stream.Position :=0;
  Stream.Write(FingerPrint,SizeOf(LongInt)); //Write finger print
{$endif}
end;

{ TCatTableLinks }

function TCatTableLinks.Add(AField: TCatTableLinkField): Integer;
begin
  Result := Inherited add(AField);
end;

constructor TCatTableLinks.Create;
begin
  inherited Create;
end;

destructor TCatTableLinks.Destroy;
begin

end;

function TCatTableLinks.GetLinkedField(Index: Integer): TCatTableLinkField;
begin

end;

procedure TCatTableLinks.LoadFromStream(Stream: TStream);
Var i,t:Integer;
begin
  Stream.Read(t,SizeOf(Integer));
  For i:=0 to t-1 Do
  Begin
    inherited Items[i] := TCatTableLink.Create;
    Items[i].LoadFromStream(Stream);
  End;
end;

function TCatTableLinks.Remove(AField: TCatTableLinkField): Integer;
begin

end;

procedure TCatTableLinks.SaveToStream(Stream: TStream);
var i:Integer;
begin
  Stream.Write(Count,SizeOf(Integer));
  For i:=0 to Count-1 Do
    Items[i].SaveToStream(Stream)
end;

{ TCatTableLink }

constructor TCatTableLink.Create;
begin
  inherited;
  FLinkFields := TCatTableLinkFields.Create;
end;

destructor TCatTableLink.Destroy;
begin
  FLinkFields.free;
  inherited;
end;

procedure TCatTableLink.LoadFromStream(Stream: TStream);
begin
  Stream.Read(FMasterTableR,SizeOf(Integer));
  Stream.Read(FDetailR,SizeOf(Integer));
  FLinkFields.LoadFromStream(Stream);
end;

procedure TCatTableLink.SaveToStream(Stream: TStream);
begin
  Stream.Write(FMasterTableR,SizeOf(Integer));
  Stream.Write(FDetailR,SizeOf(Integer));
  FLinkFields.SaveToStream(Stream);
end;

end.
0
 
LVL 11

Accepted Solution

by:
robert_marquardt earned 25 total points
Comment Utility
Crashes also.
I removed crc32 from uses and changed the unit name to match my file name. The bug still occurs.
This is obviously a real IDE bug you found.
Report it to Borland.
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
how?
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
This is how:

BUG SUBMISSION FOR NON-SUPPORT CUSTOMERS

There is a new Bug Submission capability for customers without support
agreements, the client from the QualityCentral public field test
(<http://wwwapp1.borland.com/qc/>) home page. The system is now in a
pre-release state, and updates will be made regularly. The "QualityCentral
About" box has a link where you can always download the latest client.
Additional products will be added over time, as well as a web-based client.
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
the problem is:

The issue is real in D5 with
**********
unit Pas_Catalogue;

interface

type
  TSomeClass = class
    procedure p(AParam: ShortString = '=');
  end;

implementation

procedure TSomeClass.p(AParam: ShortString = '=');
begin
  //
end;

end.
**********
but cannot be reproduced in D6.
0
 
LVL 7

Author Comment

by:God_Ares
Comment Utility
He made me realise that it wasnt MY problem. Thanx for the help, i was going INSANE
0

Featured Post

Highfive + Dolby Voice = No More Audio Complaints!

Poor audio quality is one of the top reasons people don’t use video conferencing. Get the crispest, clearest audio powered by Dolby Voice in every meeting. Highfive and Dolby Voice deliver the best video conferencing and audio experience for every meeting and every room.

Join & Write a Comment

In this tutorial I will show you how to use the Windows Speech API in Delphi. I will only cover basic functions such as text to speech and controlling the speed of the speech. SAPI Installation First you need to install the SAPI type library, th…
In my programming career I have only very rarely run into situations where operator overloading would be of any use in my work.  Normally those situations involved math with either overly large numbers (hundreds of thousands of digits or accuracy re…
Illustrator's Shape Builder tool will let you combine shapes visually and interactively. This video shows the Mac version, but the tool works the same way in Windows. To follow along with this video, you can draw your own shapes or download the file…
This video demonstrates how to create an example email signature rule for a department in a company using CodeTwo Exchange Rules. The signature will be inserted beneath users' latest emails in conversations and will be displayed in users' Sent Items…

744 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

11 Experts available now in Live!

Get 1:1 Help Now