{"id":26,"date":"2007-04-06T03:35:45","date_gmt":"2007-04-06T08:35:45","guid":{"rendered":"http:\/\/mariusbancila.ro\/blog\/?p=26"},"modified":"2011-07-15T22:40:29","modified_gmt":"2011-07-15T20:40:29","slug":"tweaking-autoexpdat-for-custom-types-in-vs2005","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2007\/04\/06\/tweaking-autoexpdat-for-custom-types-in-vs2005\/","title":{"rendered":"Customize autoexp.dat for own types in VS2005"},"content":{"rendered":"

Suppose you have a class foo like this:<\/p>\n

\r\nclass foo \r\n{\r\npublic:\r\n\tint X;\r\n\tint Y;\r\n\tint Z;\r\n\r\n\tfoo(int x = 0, int y = 0, int z = 0): X(x), Y(y), Z(z) {}\r\n};\r\n<\/pre>\n
<\/p>\n
And you have a variable f(1, 2, 3) what you watch in your Watch window. The window looks like this:<\/p>\n
\"Default<\/p>\n
The field Value shows a default expansion of the object, {X=1 Y=2 Z=3}. However, this can be changed by modifying a file called autpexp.dat, located in the Visual Studio installation folder, under Common7\\Packages\\Debugger. This file allows the control of several things in the debugger, such as the string displayed in the Value column, the functions the debugger skips when stepping, etc. One important limitation however, is that it does not support complex expression, for which it simply displays “???”. This file is loaded each time you start the debugger.<\/p>\n
The Autoexp.dat file consists in a set of rules, called AutoExpand rules, specified on a single line and having the format:<\/p>\n
\r\ntype=[text]<member[,format]>...\r\n<\/pre>\n
\nwhere<\/p>\n
\r\ntype      Name of the type (may be followed by <*> for template\r\n          types such as the ATL types listed below).\r\ntext      Any text.Usually the name of the member to display, \r\n          or a shorthand name for the member.\r\nmember    Name of a member to display.\r\nformat    Watch format specifier. One of the following:\r\n\r\nLetter  Description                 Sample         Display\r\n------  --------------------------  ------------   -------------\r\nd,i     Signed decimal integer      0xF000F065,d   -268373915\r\nu       Unsigned decimal integer    0x0065,u       101\r\no       Unsigned octal integer      0xF065,o       0170145\r\nx,X     Hexadecimal integer         61541,X        0X0000F065\r\nl,h     long or short prefix for    00406042,hx    0x0c22\r\n          d, i, u, o, x, X\r\nf       Signed floating-point       3.\/2.,f        1.500000\r\ne       Signed scientific-notation  3.\/2.,e        1.500000e+000\r\ng       Shorter of e and f          3.\/2.,g        1.5\r\nc       Single character            0x0065,c       'e'\r\ns       Zero-terminated string      pVar,s         \"Hello world\"\r\nsu      Unicode string              pVar,su        \"Hello world\"\r\n<\/pre>\n
<\/p>\n
The AutoExpand rules must be located under the [AutoExpand] section, because the file also contains rules for visualizing types when the object is expanded. These visualization rules are located under [Visualizer] and are a feature new in VS2005.<\/p>\n
Going back to our foo class, suppose you use this class heavily and you don’t like the default string shown in the Value column, and you would like it to be like this: {X=0x00000001, Y=0x00000002, Z=0x00000008}. That means using comma to separate the fields and display the values as hexadecimal numbers. What you would have to do is adding a AutoExpand rule like this:<\/p>\n
\r\nfoo =X=< X, X >, Y=< Y, X >, Z=< Z, X >\r\n<\/pre>\n
<\/p>\n
It says something like this: display X followed by = and the value of member X of foo in hexadicimal, followed by comma, space, Y and = followed by the value of member Y of foo in hexadecimal, and so on. Debugging now, will show a different string:<\/p>\n
\"Custom<\/p>\n
But now let’s imagine that our foo class was actually a template class, like this:<\/p>\n
\r\ntemplate < typename T >\r\nclass foo \r\n{\r\npublic:\r\n\tT X;\r\n\tT Y;\r\n\tT Z;\r\n\r\n\tfoo(T x, T y, T z): X(x), Y(y), Z(z) {}\r\n};\r\n<\/pre>\n
<\/p>\n
The rule above would not help for an object foo f(1, 2, 3) and the default format would be used. That is so because template types have a different form: we need to use <*>.<\/p>\n
\r\nfoo< * > =X=< X, X >, Y=< Y, X >, Z=< Z, X >\r\n<\/pre>\n
<\/p>\n
With this rule the string is the same as in the above image (the type though changes to foo).<\/p>\n
What is this good for? Well, I have shown you a simple example here, but suppose you have complex types, with a lot of members, and the default string shown by the debugger doesn’t help you. To see the info you actually need in the watch window or when you put the mouse over the variable you would have to expand the object and scroll down, perhaps expand aggregated objects, etc. to reach what you actually need on a regular basis. Creating a custom rule for the auto displayed value allows you to show exactly the information you need, in the form you want. For instance you may always want to see the numeric values of X,Y and Z from foo as hexadecimal, but you switched for decimal view in the debugger (from the context menu of the Watch window). That won’t affect the way you view your type, because of the custom rule.<\/p>\n
A second part of autoexp.dat file is dedicated to visualization rules. These are mappings from types to display form, shown when you expand the object. Unlike the simple AutoExpand rules, these are more complex and have a dedicated scripting language, which unfortunatelly is not documented.<\/p>\n
The basic form of a rule is:<\/p>\n
\r\ntypename[|typename...] {\r\n    preview (\r\n        preview-string-expression\r\n    )\r\n    stringview (\r\n        text-visualizer-expression\r\n    )\r\n    children (\r\n        expanded-contents-expression\r\n    )\r\n}\r\n<\/pre>\n
<\/p>\n
The three sections have the following purpose:<\/p>\n