Some people think it’s a Greatest Delphi article ever written:
https://forums.codegear.com/thread.jspa?threadID=15794

So I would trust it.

I’m not so sure about some though – the comments about try/finally adding overhead for example… I thought I’d read somewhere/somewhen else that try/finally or try/except *doesn’t* add any overhead unless an exception is actually thrown.

It’s also not entirely clear whether the author means that “absolute” affects parameters or local variables – he refers to variables but his example shows a parameter. I don’t think he can mean variables because afaik variables are *always* declared on the stack and if he means parameters then I’d be interested to do some further investigation. Perhaps my understanding of calling conventions is incomplete, but in respect of event handlers in particular I’m curious as to how one handler can be using a register for a parameter that another handler for the same event expects on the stack.

Generally I’d be careful about taking too much of that article as “gospel” without confirming any relevant observations in your own test harnesses – it was written almost 6 years ago after all.

Yes, it is:

A technique sometimes used to avoid typecasting is to “overlay” a variable with another of a different type by using the absolute keyword. However, this prevents the variable from becoming a “fast” register variable. It is better to type-cast and save the original variable into a new variable.

http://effovex.com/OptimalCode/general.htm

I remember doing it like this:

var StringLength: byte;
StringLength := MyString[0];

I think the compatible type char=byte meant no casting was necessary by the time BP7 arrived. Older Turbo Pascals were much stricter, hence the “absolute” technique, but it was an anachronism in BP7.

Unfortunately I work with a programmer who uses the for..in method, but calls the pointer p (and sometimes p1, p2 etc) – it’s amazing how hard a bad naming convention can make code to read!

In the case of
Str: string[32]:
StrLen: byte absolute Str;

that is ABSOLUTELY the way many of us did it in the day. Short strings were limited to 255 characters because the zero’th position of the string was a byte that contained its length. It was quicker to just access the 0th element of the string than call the Length function. IN those days, it mattered, particularilly when you did a LOT of string handling.

Yes, Delphi 2’s ANsiString caused a degree of migration pain for those of us who did this a lot. It wasn’t the correct way, and we payed for it when things changed. Fortunately, it was impossible to compile the old code in the new string style so you HAD to fix it (which was a relatively painless and predictable fix) before your code could run – made the outcome very predictable.

Interesting note, this use of the ABSOLUTE keyword is also not the intended use but rather actually allowed you to tell the compiler the absolute location in memory for a variable.

In the old DOS days, this was very VERY handy – the most common use I saw was to overlay a char array onto the video buffer (text and graphics).

Since Windows came along, it has been pretty much restricted to the stack thing.

In fact, I recall having done something similar to this to do endian conversion (way back when).