Spinettaro's Blog

Monday, July 27, 2020

Delphi tips and tricks: Unknown custom attribute

Hacking, Cyber, Blackandwhite, Crime, Security

RTTI attributes are a Delphi language feature that allows you to add metadata information

to types and type members (comparable to C# attributes or Java annotations, to be clear).

By attributes, you can add metadata information in a declarative way. An attribute is depicted

by square brackets ([ ]) placed above the element it is used for, the attribute can be queried at runtime by using RTTI techniques and you take appropriate actions when you think they are required.

That is just a short introduction to Delphi RTTI Attributes and because it is not the central topic of this post, you can find more information about it here: http://docwiki.embarcadero.com/RADStudio/en/Attributes_(RTTI).

As for every Delphi construct you have to import it: put the unit in the uses section to use a specif class, interface, function and so on... This is not really true for Attributes!

Let's take a look at this code, a simple console application:

As you can see the [MyCustomAttribute] it's not declared anywhere ( and trust me it's not declared in the System.SysUtils unit).

So what happens if we try to build the project? Curious?

We are able to build it with success:

This because the compiler produces a warning and not an error around the situation just described (using Delphi 10.4):

[dcc32 Warning] Project1.dpr(15): W1074 Unknown custom attribute

In some cases, you might write an incorrect attribute name, or not import the unit

containing that attribute and this could have terrible consequences at run-time: at first you could think that the RTTI Attribute is not working, the framework is not working and so on... but the real fact is that we didn't include the right unit or wrote an incorrect name and probably we didn't have a look to warnings.

How can we be sure to have an error instead of a warning?

Up to Delphi 102, if you used a custom attribute that was not known to the compiler (because you typed it incorrectly or a unit was missing in the uses statement), you'd receive the warning:

Warning: W1025 Unsupported language feature: 'custom attribute'

The only way to turn it into an error was to set the Unsupported language feature to error. You had to go to Project | Options | Delphi Compiler | Hint and warnings | Unsupported Language Feature and set the value to error. From now on, every Unsupported language feature generates a compiler error. but that could have included also other unwanted scenarios.

Starting with 10.3, the same code will trigger a new specific warning as we have seen in the messages of the example project above:

Warning: W1074 Unknown custom attribute

Then now it is easier to turn this warning into an error by using the directive:

{$WARN UNKNOWN_CUSTOM_ATTRIBUTE ERROR}

If you add the above line in the previous project and try to build it again you will receive this error and the build will fail:

This is a really nice tip to know as it can save you a lot of time around troubleshooting, just because you didn't have a look to warnings after you write an incorrect attribute name, or not import the unit

containing that attribute. I saw so many times developers in forums and OS projects complaining about the behavior of a framework/feature when the real "mistake" was in a missed unit or misspelled name.

Deleaker: a great tool to find memory leaks

Hi folks,

In the past few weeks I had time to "play" and discover Deleaker: a memory leak detection - memory, GDI, and handles so far.

The creator and maintainer is Artem A. Razin (@deleaker) and this is the official website https://www.deleaker.com/ .

It is very simple to use and understand due to its simplicity and provided tutorials and documentation.

Deleaker integrates with all major IDEs: Visual Studio, Delphi, C++ Builder, and Qt Creator.

Hunting and fixing a memory leak could be a difficult task and you cannot approach it without the right tool!

It doesn't matter what type of leaks are occurring, Deleaker will find them all: memory leaks (produced by heap, virtual memory, or OLE allocators etc.), GDI leaks, leaks of Windows USER objects and handles.

I don't want to be repetitive or showing something that is already mentioned from official documentation and online resources, so here a list of useful links to start with Deleaker:

Official Website:

https://www.deleaker.com/

Documentation page:

https://www.deleaker.com/docs/

Installation:

https://www.deleaker.com/docs/deleaker/installation.html

Using Deleaker in Delphi:

https://www.deleaker.com/docs/deleaker/delphi_tutorial.html

Video tutorials:

Deleaker integration with RAD Studio. Find Leaks in Delphi and C++ Builder: https://www.youtube.com/watch?v=suyJfoSeRrQ
Using Deleaker in Rad Studio 10.4 Sydney: https://www.youtube.com/watch?v=-ZLhJAv8Ldc
Deleaker session at CodeRage: https://www.youtube.com/watch?v=rnq44Td9opQ

Here some screenshots:

Thursday, May 28, 2020

Delphi 10.4 Sydney is here!

Hi folks,

Delphi 10.4 Sydney has just released and this version comes with a lot of interesting features:

New Delphi CodeInsight based on LSP server
Custom Managed Records in the Delphi Language
New VCL Components, including TEdgeBrowser, and expanded High DPI support for VCL styled applications
Enhanced Delphi multi-device platform support integrating newer Apple APIs and supporting the latest Android
New LLDB-based debugger for Windows 64-bit for C++
Unified installer for online & offline installations
GetIt Package Manager Enhancements

I would like to spend few words around the features that impressed me:

Code Insight Technology in Delphi 10.4

From David Millington blog post:

In 10.4, Code insight features are implemented using a ‘LSP Server’. LSP refers to the Language Server Protocol, which is a standardized way to implement code insight-like features for many languages. An IDE talks to a ‘language server’, which is a small helper app that calculates and generates the information the IDE displays. It does so using a defined protocol, and that’s the language server protocol.

In other words, the IDE now talks to a helper app when you do something like open a project, or type a keystroke in your file.

What does it means?

Communication with another process is asynchronous
The work is done in another process

This means all the memory usage for calculating results is no longer in the IDE itself. The IDE has more memory, and the helper app can use its entire memory space dedicated solely to providing results

What you see onscreen is what the compiler sees.

If your code compiles, you won’t see any Error Insight errors; conversely, if you do see red squiggly underlines in your code or in the Structure view, your code will not compile.

You can get code completion while debugging.

If you want to know more about it have a look to David Millington post

Custom Managed Records

This is absolutely the top new language feature of Delphi 10.4!

Now in 10.4 the Delphi record type supports custom initialization and finalization:

From Marco Cantù blog post:

You can declare a record with custom initialization and finalization code regardless of the data type of its fields, and you can write such custom initialization and finalization code.
This is achieved by adding specific, new operators to the record type (you can have one without the other if you want).
Below is a simple code snippet:

type
  TMyRecord = record
    Value: Integer;
    class operator Initialize (out Dest: TMyRecord);
    class operator Finalize(var Dest: TMyRecord);
  end;

The huge difference between this construction mechanism and what was previously available for records is the automatic invocation. If you write something like the code below, you can invoke both the initializer and the finalizer, and end up with a try-finally block generated by the compiler for your managed record instance.

Marco Cantù post to know more.

GetIt Package Manager Enhancements

GetIt Package Manager Enhancements in Delphi 10.4:

the ability of sorting the list of entries by date, seeing the most recent ones on top
for each entry you have already installed, the indication that an updated version is available
the ability to list all installed entries that have an update available

Rad studio patches

A killer feature of the new GeIt is absolutely the ability to use GetIt to distribute patches, with a specific way to alert customers that a patch is available. There is a new section to the Welcome page to indicate when a patch is available and you have not installed it: