Profile cover photo
Profile photo
Honza Rameš

Post has attachment
Some time ago I wrote about an IDE plugin I made that modifies code completion behavior to be able to find even misspelled identifiers (like TComponent(o).comstate -> TComponent(o).ComponentState). I was asked a number of times to make the source public and I did just that (thanks for the interest btw).

There aren't many comments in the code but if you're used to developing and IDE expert I think there should be no problems getting around the code fast enough. The idea is really simple, just wrap some IDE interface implementation around and modify the behavior.

Although the completion works just fine most of the time, I noticed that the wrapper may interfere with class completion functionality (I never had time to fully investigate the issue - patches welcome ;-) ), I'm not fully sure if this is caused by the wrapper or maybe some other plugin(s) I have enabled in the IDE.

Post has attachment
I created a TWebBrowser inspector, should I make it public?
If you use TWebBrowser component in your app and you cannot "debug" the content in an ordinary web browser with a Dev console, you may find this useful. Drop me a line if you find it interesting and I'll post more info.

Post has attachment
I made the Code completion more forgiving. If you are as lazy as me and you do a lot of typos while coding you may like this IDE plugin I made. It replaces Pascal code completion matching algorithm with different implementation using Levenshtein distance to compute suggestions which is much more forgiving to misspelling.

It can replace things like:
TComponent(o).comstate -> TComponent(o).ComponentState
and even:
TComponent(o).Uatoon -> TComponent(o).UpdateAction

It completely disables suggestion filtering allowing you to see the whole list all the time and lets you see how suggestion changes as you type. This is an early alpha and a proof of concept example but I already found it helpful. Let me know if you run into any errors. It is tested mostly on XE7 and XE6!

Post has attachment
I just found a rather nasty bug in the compiler if optimization is enabled. AtomicIncrement (and possibly other atomic functions) may modify Increment (the second argument) in some cases depending on how the compiler will use the registers. If you think the Increment remain constant you may run into trouble when you use it later. It may not remain constant but contain the result of the operation instead. I found by accident so in case you use Atomic or TInterlocked functions and have optimization enabled I suggest you check your code for possible issues.

Post has attachment
LeakCheck library now supports DUnitX and stack traces:

Some time ago I posted about my LeakCheck library. Recently I've made some progress. Main new features include DUnitX support and allocation stack traces.

DUnitX support features object graph scanning and all DUnit supported features. My implementation does not suffer from the Status bug that made the DUnitX developers disable default FastMM monitor. I also added DUnitX pull request that if accepted will instantly allow enhanced leak reporting (all LeakCheck changes are forward compatible and already pushed).

Stack tracing generates fully formatted stack traces with symbols and line numbers and already offers several implementations (including Android one). If enabled test results get instant callstack preview.

Another feature I did not mention here before is ability to use Extended RTTI and create complex allocation graphs even in non-NextGen allowing you to visualize complete object structure of your application. The scanner is independent of the LeakChecker and may be used (with a visitor-like pattern) to operate on any object structure to perform any tasks in a generic way. Also several features like smarter leak ignores and object graph ignores can now be achieved.

Post has attachment
Which version of Delphi changed `TStringList` implementation from `array[0..MaxListSize] of TStringItem` to `array of TStringItem`? I know XE has the first version and XE6 (and later) the second one. I don't want to install all versions can you check for me please... Thanks
votes visible to Public

I created a parser that converts Polymer (0.5 supported, 0.8 as soon as it becomes stable) elements to GWT JSOs (support for JsType planned). It converts properties and methods (including comments, though more formatting is needed) and guesses most of the types (some manual corrections are required, but it is like 30 edits for all core and paper elements, from the specs it looks like this can be improved as soon as 0.8 is released). You can think of it as elemental for Polymer. Wide variety of GWT versions should be supported.

I cannot share the code right now (as its part of proprietary repo) but if anyone is interested, comment this post and I'll investigate how to release it (maybe only in binary form for the moment until I investigate other options).

Post has attachment
I've created a multi-platform leak checking library with DUnit integration and per test memory leak details (basically FastMM full debug report but per test) and instance cycle detection (analyzes managed fields of your object graph and tells you where your instances create cycles).

Post has shared content

Post has shared content
This makes sense ;)
Remember that time when everybody [citation needed] was freaking out about Firefox or Chrome version hitting double digits (10) and theorizing how version.substring(0, 1) conditions would affect various javascript blocks?
Wait while more posts are being loaded