Nov 252017
 

You might have noticed that I haven’t blogged as much as usual and that there have been no recent updates to GExperts either. The reason of course was that I was busy doing other things. Some of them were programming related and one of these was writing a caching class wrapper for TStream descendants (e.g. TFileStream, but it should work with any other streams as well).

It is simple to use and totally transparent to the calling code because the cache itself descends from TStream:

procedure TestCache;
var
  fs: TFileStream;
  cache: TdzStreamCache;
  i: integer;
  by: byte;
begin
  cache := nil;
  fs := TFileStream.Create('C:\test.dat', fmOpenWrite);
  try
    cache := TdzStreamCache.Create(fs);
    // now, do any operation you usually do on the stream, but use the
    // cache instead
    // e.g. write 50 megabytes of random bytes
    randomize;
    for i := 0 to 50*1024*1024 do begin
      by := Random(256);
      cache.WriteBuffer(by, SizeOf(by));
    end;
    // Writing a single byte to a TFileStream will result in very
    // bad performance, which is why we usually copy the bytes to a
    // larger buffer instead and then write this buffer to the stream.
    // Using the TdzStreamCache you won't see much of a difference between
    // these two approaches.
  finally
    FreeAndNil(cache);
    FreeAndNil(fs);
  end;
end;

TdzStreamCache can also be used for read and read/write access to a stream. It supports linear and also random access. Performance is worst when reading a stream backwards a single byte at a time.

To get an idea how well it performs, I have benchmarked it against David Heffernan‘s excellent CachedFileStream and found that it compares very well. (I could not simply use David’s class because I needed caching for other types of streams, not just files.)

I have been using TdzStreamCache extensively in the last several weeks and I am pretty sure that I have weeded out most of the bugs. But of course, that does not mean that there aren’t any left, so there are no guarantees. If you use it, all problems are your own.

TdzStreamCache is released under the Mozilla Public License (MPL) 1.1 as part of my dzLib library, but the unit is pretty much stand alone. The only thing it requires is jedi.inc because Delphi 2007 declares NativeInt inconsistently to other Delphi versions. As with all my dzlib code, it is available from sourceforge as u_dzStreamCache.pas.

The code for the benchmarks I mentioned above is also available if you want to do the benchmarks yourself.

I would appreciate any feed back, especially if you find bugs or improve on it.

Nov 022017
 

There was a discussion about using the PE flag IMAGE_FILE_LARGE_ADDRESS_AWARE and whether this is equivalent to compiling a program to 64 bit Windows target (no it’s not) in the German Delphi Praxis forum. This prompted me to have a look at what kind of flags can be specified and how to do that for a Delphi program.

A quick Bing search for SETPEFLAGS and Delphi also found a blog post by Halvard Vassbotn from 2006 about the IMAGE_FILE_RELOCS_STRIPPED PE flag.

Since one of my programs has recently started to throw out of memory
exceptions (when displaying large(!) data files) and our executables tend to be rather large anyway, I decided to add these PE flags to it.

  • IMAGE_FILE_LARGE_ADDRESS_AWARE – App can handle >2gb addresses
  • IMAGE_FILE_RELOCS_STRIPPED – Relocation info stripped from file

With the flags it already used …

  • IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP – If Image is on removable media, copy and run from the swap file
  • IMAGE_FILE_NET_RUN_FROM_SWAP – If Image is on Net, copy and run from the swap file.

… this resulted in the following SETPEFLAGS compiler directive in the .dpr file:

{$SETPEFLAGS IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
          or IMAGE_FILE_NET_RUN_FROM_SWAP
          or IMAGE_FILE_LARGE_ADDRESS_AWARE
          or IMAGE_FILE_RELOCS_STRIPPED}

The result was as I hoped: No out of memory error any more when displaying a file that always caused one before. The executable size also shrank, but not as significantly as I had hoped: 9698 KB where before it was 9987 KB, but every little helps.

But there is another side effect I found today: Setting IMAGE_FILE_NET_RUN_FROM_SWAP not only makes Windows load the executable into the swap file when executing it but apparently every time it accesses it. Simply selecting it in Windows Explorer resulted in the Explorer Window freezing for a short time (it feels like several seconds but probably is just about one), the same delay happens when opening the Properties dialog (e.g. to check the version info). That does not happen, when the flag isn’t set.

Oct 212017
 

Flattr have changed their terms an conditions. Since I haven’t received a single cent via Flattr, I really can’t be bothered what exactly they have changed and whether that’s good or bad for me personally. So I have closed that account for good. That leaves only PayPal, if you want to make a donation to GExperts. Sorry, if that’s an inconvenience. And please remember that I’d prefer you to contribute to GExperts in one of the other means described on that page than money.

Oct 142017
 

Jeroen has submitted two enhancements to GExperts:

Thanks!

I am still working on the refactoring for the IDE form enhancements, but progress is slow, so the next release will probably take a while.

Sep 302017
 

A new test release of my dzDebugVisualizers for Delphi 2005, 2006 and 2007 is available. Apart from fixing an Access Violation when unloading the package I have added support for TDateTime and unquoted (multiline) strings to the Evaluate / Modify window:

In addition I have added a “Modifiers” button to the dialog which allows to add any of the supported display format specifiers to the expression.

Download that test release and tell me, what you think. What other data types would you like me to add? Are there any bugs?

Sep 032017
 

I was made aware that dzPrepBuild no longer works with .dof files. Since I don’t use it with Delhi 6 or 7 any more, I didn’t realize that myself. The bugfix was easy, just pass the correct parameter.

The new version is available from SourceForge. Note that, for whatever reason, SoureForge still claims that the latest download is version 1.3.0. You’ll have to select version 1.3.2 yourself. I hope that it is just a matter of time for SourceForge to update that link.

Sep 022017
 

David Heffernan commented on Girish Patil’s post on G+

But you should never make instance methods on value types that mutate the value.

Otherwise you can call such a method on an instance passed to a function as a const parameter.

Where “value types” in this case is meant to be an advanced record in Delphi.

I must admit that I am guilty of doing this and have of course lived to regret it. Here is an example:

type
  TDistance = record
  private
    FMillimetres: Int64;
  public
    function InMillimetres: Int64;
    function InMetres: Double;
    function InKm: Double;
    procedure AssignMetres(_Value: Double); // don't do this!
  end;

In case it isn’t obvious: This is an advanced record for storing a distance with a fixed resolution on 1 mm. The idea is to prevent cases where you have got a variable containing a distance but it isn’t immediately clear what unit is it using.

There are functions that return the value converted to metres and kilometres. And then there is a procedure AssignMetres which violates the rule that David stated:

procedure TDistance.AssignMetres(_Value: double);
begin
  FMillimetres := Round(_Value * 1000);
end;

On first glance, there is nothing wrong with this method. It simply assigns a new value to the record.

But now, consider this procedure that takes a const TDistance parameter:

procedure doSomething(const _Dist: TDistance);
begin
  // ...
  Dist.AssignMetres(5);
  // ...
end;

// ...
var
  SomeDist: TDistance;
begin
  SomeDist.AssignMetres(3);
  doSomething(SomeDist);
  // ...

The compiler won’t complain because calling methods of value types passed as const is allowed. But since the method has a side effect, setting the value of _Dist, it will not just change the value of _Dist inside the procedure but also the value of the variable passed to doSomething. The caller of course relies on that value to remain unchanged, because this is a const parameter after all. But, after the call to doSomething, the value of SomeDist now is 5m rather than 3m as originally assigned.

That’s what David meant with this comment.

This was bad enough, but there is another trap which I fell for. Consider this class that has a property Length of the type TDistance:

 type
  TCar = class
  private
    FHasChanged: boolean;
    FLength: TDistance;
    procedure SetLength;
  public
    property Length: TDistance read GetLength write SetLength;
    property HasChanged: read FHasChanged;
  end;
// ...
function TCar.GetLength: TDistance;
begin
  Result := FLength;
end;

procedure TCar.SetLength(const _Value: TDistance);
begin
  FHasChanged := True;
  FLength := _Value;
end;

Again, nothing seems to be wrong here. The SetLength property setter, in additon to setting the FLength field also sets the FHasChanged field to True which supposedly is read later on to determine whether any changes have to be saved somewhere. You could probably argue that the property getter for Length is not necessary, but who knows, it might become necessary later on.

It works fine too:

var
  MyCar: TCar;
  Dist: TDistance;
begin
  Dist.AssignMetres(4.5);
  MyCar := TCar.Create;
  try
    MyCar.Length := Dist;
    if MyCar.HasChanged then
      MyCar.SaveChanges;
  finally
    FreeAndNil(MyCar)
  end;

And then, probably years later, somebody thinks that the code above is unnecessarily complex and optimizes it like this:

var
  MyCar: TCar;
begin
  MyCar := TCar.Create;
  try
    MyCar.Length.AssignMetres(4.5);
    if MyCar.HasChanged then
      MyCar.SaveChanges;
  finally
    FreeAndNil(MyCar)
  end;

That’s a reasonable optimization. It looks much cleaner and gets rid of an unnecessary variable declaration. But it does not work!

Why? I’m glad you asked. Let’s have a look at what happens in this line:

MyCar.Length.AssignMetres(4.5);

It first calls the getter for the Length property, returning a copy of the FLenght field. Then it calls the AssignMetres method of that record, which changes the FMillimetres field of the record. Now, the question: What will be the value of the field MyCar.FLength? It will still be 0 (assuming the constructor of TMyCar does not initialize it otherwise), because we changed the value of the copy, not the value of the field. Also, MyCar.HasChanged will still be False, because the setter for Length has never been called.

So, advanced records should not have methods that change the record’s values. In the example, the solution would be something like this:

type
  TDistance = record
  private
    FMillimetres: Int64;
  public
    class function FromMetres(_Value: Double): TDistance; static;
    function InMillimetres: Int64;
    function InMetres: Double;
    function InKm: Double;
  end;

/// ...
class function TDistance.FromMetres(_Value: double): TDistance;
begin
  Result.FMillimetres := Round(_Value * 1000);
end;

So, a class function FromMetres would be used to return a new TDistance variable initialized to the given metres value.

And it would be used like this:

var
  MyCar: TCar;
begin
  MyCar := TCar.Create;
  try
    MyCar.Length := TDistance.FromMetres(4.5);
    if MyCar.HasChanged then
      MyCar.SaveChanges;
  finally
    FreeAndNil(MyCar)
  end;

The setter method for Length gets called does its thing. Everybody is happy. Until, of course, some smart ass like me thinks that an TDistance.AssignMetres would be a great idea …

Aug 202017
 

I have started to write some documentation on the internal workings of GExperts. For now, it covers only a very small part of the IDE form enhancements that GExperts provides. It is meant mostly for myself to get an overview of that part of the tool which has grown too large to understand at a single glance. But it might also help if somebody wants to contribute to that part.

Aug 122017
 

Donations for GExperts keep coming in. It’s more a trickle than a flood but hey, I’m not in it for the money. And please remember that I prefer other kinds of contributions over money.

I have used that money in turn for donations to

I would have liked to also donate to PuTTY and FileZilla but I found no way to do it.

(Yes, there is a donate link on the FileZilla SourceForge page but it doesn’t work.)

Jul 302017
 

The method of changing the order of the TabSheets in a PageControl in Delphi is not obvious. Apparently there is no drag and drop support (at least not in Delphi 2007). You have to change the PageIndex property. So, if you want to insert a new page, add it and then change its PageIndex to the insert position.

I smell an opportunity for a new GExperts Expert. Any takers?

EDIT: As Moreno Zenaro pointed out in a comment to my Google+ post, there is actually a GUI way of changing the order: Drag the TabSheet in the structure view.

%d bloggers like this: