Entrian Solutions
 

Archive for the ‘Inline-Watch-ChangeLog’ Category

Entrian Inline Watch 0.9.11: Control the decimal places of floats and doubles

Thursday, January 28th, 2016 by Richie Hindle
I’ve just released Entrian Inline Watch 0.9.11, with these new features:
  • You can now globally control the displayed decimal places of floats and doubles:
  • In your Object Display rules, you can now individually control the displayed decimal places of floats and doubles, selectively overriding the global setting.  For example, ({x,.2f}, {y,.2f}) will round to two decimal places:  (1.23, 4.56) Thanks, Radek and Chris.

As always, this new release is available from the download page or the gallery.

 

Entrian Inline Watch 0.9.5: More powerful accessor display

Sunday, October 18th, 2015 by Richie Hindle
I’ve just released Entrian Inline Watch 0.9.5, with these fixes and features:
  • Accessor Method rules are now as powerful as Object Display rules, eg. Rect->Width() can be defined as {right-left} and display the calculated value (thanks, Martin).
  • Increased the default size limit of values, from 15 to 20 characters.
  • More compact default representation of single-value objects: {m_SomeMember=”Some string”} truncates to {“Some string”} rather than {m_SomeMe…string”}
  • Fixed an intermittent startup crash when the beta expiry date had passed.

As always, this new release is available from the download page or the gallery.

Update: 0.9.6 fixes a bug whereby the crash dialog could crash.  (Did I really just admit to that?)

 

Entrian Inline Watch 0.9.3: Template support; Optional raw pointers

Tuesday, October 13th, 2015 by Richie Hindle

I’m very pleased to announce Entrian Inline Watch 0.9.3, which introduces two new features:

  • You can now set Object Display rules for C++ template types, for instance for std::list you can set up a rule like this:

    std::list   \{size={_Mysize}\}

    to display the size of all std::list<whatever> objects like this: {size=10} (Thanks, Martin and Daniel)

  • The display of values for raw pointers in C/C++ is now optional – when there’s no Object Display rule configured for a type, and no sensible default value to display, you can choose whether to display the raw pointer value or nothing (thanks, Daniel).

Update: 0.9.4 adds C++ template support to Accessor Method rules as well as Object Display rules.

You can download the new release from the download page or the gallery.

Entrian Inline Watch 0.9.1: Less clutter, fewer bugs

Monday, October 5th, 2015 by Richie Hindle

(If you’re new to Entrian Inline Watch, check out the intro page!)

I’m pleased to announce Entrian Inline Watch 0.9.1, which fixes the following bugs:

  • Parameter values are now displayed properly for functions with a throw() signature (thanks, Martin).
  • Where there’s no Object Display rule for a class, and the debugger’s default value looks like {ClassName}, don’t clutter the code with it (thanks, Jan and Martin).
  • Commenting out a line in the Object Display settings no longer affects the layout of the columns.

You can download this new release from the download page or the gallery.

(Update: version 0.9.2 also updates the Beta expiry date. :-) )

 

Entrian Inline Watch 0.8.9: Hide values for given types; other fixes

Friday, September 18th, 2015 by Richie Hindle

I’ve just published Entrian Inline Watch 0.8.9, with these enhancements:

  • You can now suppress the display of values for a type, by entering a blank format for it in the Object Display settings.
  • When an accessor expression like p->get_x() doesn’t render a value, a value is now displayed for p (thanks, Martin).
  • Values are now correctly rendered for pointers to pointers (to pointers to pointers to pointers…) (thanks, Martin).
  • Fixed an intermittent crash that was due to Visual Studio firing debugger events re-entrantly (yeah, thanks, Visual Studio :-) )

You can download the new release from the download page or the gallery.

 

Entrian Inline Watch 0.8.8: Better object expressions

Saturday, September 12th, 2015 by Richie Hindle

I’m pleased to announce Entrian Inline Watch 0.8.8, with the following enhancements:

  • Object expressions can now follow references, eg. {m_x.y->z} (thanks, Martin).
  • If Inline Watch crashed, it could produce a crash report with no meaningful stack trace (thanks, Chris).
  • Object expressions can now special-case nullptr, eg. {p_str == nullptr ? "No!" : p_str} (thanks, Martin).
  • Fixed a bug whereby in a scope with lots of variables, the last few to be evaluated might not be displayed.
  • For pointers to objects, if there’s nothing meaningful to display for the object, display the pointer value rather than nothing (thanks, Martin).
  • Expressions of the form x.y - (z) now display the value of x.y properly (thanks, Martin).

You can download the new release from the download page or the gallery.

 

Entrian Inline Watch 0.8.6: More object formatting power!

Friday, August 14th, 2015 by Richie Hindle

I’ve just published Inline Watch 0.8.6, which includes this new feature:

  • You can now control the maximum length of the displayed values

and a bunch of features related to custom formatting of object instances:

  • Integer arithmetic in object formats, eg. {right-left} to display the width of a rectangle
  • Pointer arithmetic, eg. {m_str+4} where your string actually starts at an offset
  • Array indexing, eg. {m_arr[N]} where you want to display the N’th member of an array, where N can be a literal, {m_arr[4]} or another member, {m_arr[m_index]}
  • Specifying the length of a string (when your string is long, or not null-terminated), again with a literal, {m_str,8}, or another member {m_str,{m_len}}
  • Displaying braces now requires them to be backslash escaped – see the next example:
  • Force hex or decimal display in object formats, so if you always want your Point instances to be displayed in decimal like this: {50, 100} even if the Visual Studio debugger is set to hex display, you can say \{{m_x,d}, {m_y,d}\}. Use an x to get hex display.

Here’s an example that demonstrates some of these features.  (It’s based on a customer example – they have a C++ string class whose string buffer includes a leading reference count, and is not NUL-terminated but instead has a length member.)

struct Formatting
{
  const char *s;     // 4-byte refcount then an unterminated string.
  int len;           // Number of chars in the string, counting from s+4.
  const char *a[3];  // An array of three C-style strings.
  int current;       // Which of the three strings is the 'current' one?

  Formatting()
  {
    s = "\x1\x2\x3\x4TextGARBAGEGARBAGE...";
    len = 4;
    a[0] = "Zero";
    a[1] = "One";
    a[2] = "Two";
    current = 1; // "One" is the string to display.
  }
};

With an object formatting rule like this:

\{{s + 4,{len}}, {a[current]}\}

a Formatting instance displays like this: {“Text”, “One”}

You can download the new release from the download page or the gallery.

New: Entrian Inline Watch displays live variable values inline in your code as you debug

Saturday, August 8th, 2015 by Richie Hindle

I’m really excited to announce a new product from Entrian Solutions: Entrian Inline Watch.

It displays the values of variables inline in your source code, updated live as you step through your code:

Animation of Entrian Inline Watch in action

You can see the live values right there in the source, rather than having to hover over them with the mouse, or find them in the Watch windows.

As soon as you land in a function, or at a breakpoint, you can see the values of your function parameters and variables instantly.

It makes debugging almost pleasant.  You and your team need it.  :-)

Entrian Inline Watch works with Visual Studio 2010, 2012, 2013 or 2015; any edition except Express.

It works with both Managed and Native debugging; in C++, C#, and VB.

It’s free during the Beta period, with builds timing out after a few weeks.  Once it’s out of Beta it will cost $29 per developer, or $24 with a volume discount.

Download it from the download page, read the fine manual and the FAQ, and let me know what you think!  (And bear in mind it’s in Beta, and therefore does not carry a no-weirdness guarantee.)