Code::Blocks - User contributions [en]

https://wiki.codeblocks.org/api.php?action=feedcontributions&feedformat=atom&user=GravityWe11 Code::Blocks - User contributions [en] 2026-04-16T02:53:51Z User contributions MediaWiki 1.35.0 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7435 Pretty Printers 2012-10-29T02:59:42Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is enabled by default. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Save as <tt><span style="font-size: 10pt">/home/username/gdb_printers/printers.py</span></tt>.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version of Codeblocks may prevent entering anything in the Debugger Initialization Commands field. A work-around is to open a CBP project file via a file manager, which in turn launches Codeblocks and seems to resolve the issue.<br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7434 Pretty Printers 2012-10-29T02:59:22Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is enabled by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Save as <tt><span style="font-size: 10pt">/home/username/gdb_printers/printers.py</span></tt>.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version of Codeblocks may prevent entering anything in the Debugger Initialization Commands field. A work-around is to open a CBP project file via a file manager, which in turn launches Codeblocks and seems to resolve the issue.<br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7433 Pretty Printers 2012-10-28T15:16:25Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Save as <tt><span style="font-size: 10pt">/home/username/gdb_printers/printers.py</span></tt>.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version of Codeblocks may prevent entering anything in the Debugger Initialization Commands field. A work-around is to open a CBP project file via a file manager, which in turn launches Codeblocks and seems to resolve the issue.<br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7432 Pretty Printers 2012-10-27T01:49:31Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Save as <tt><span style="font-size: 10pt">/home/username/gdb_printers/printers.py</span></tt>.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version of Codeblocks may prevent entering anything in the Debugger Initialization Commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7431 Pretty Printers 2012-10-27T01:47:56Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Save as <tt><span style="font-size: 10pt">/home/username/gdb_printers/printers.py</span></tt>.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7430 Pretty Printers 2012-10-27T01:47:36Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in <tt><span style="font-size: 10pt">/home/username/gdb_printers/printers.py</span></tt>.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7429 Pretty Printers 2012-10-27T01:46:00Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in <tt><span style="font-size: 10pt">c:\mingw\bin\pp.gdb</span></tt> (windows) or <tt><span style="font-size: 10pt">/home/username/gdb_printers/pp.gdb</span></tt> (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7428 Pretty Printers 2012-10-27T01:43:25Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download printers.py (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7427 Pretty Printers 2012-10-27T01:42:17Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is included by default with GCC/GDB. For Windows, MinGW's GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7426 Pretty Printers 2012-10-26T22:51:20Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is working correctly, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7425 Pretty Printers 2012-10-26T22:49:59Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.x), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7424 Pretty Printers 2012-10-26T22:47:48Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like:<br/><span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7423 Pretty Printers 2012-10-26T22:47:31Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like<br/> <span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7422 Pretty Printers 2012-10-26T22:47:06Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span> and change the INIT_COMMANDS value to something like <span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7421 Pretty Printers 2012-10-26T22:45:57Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span><br /> NOTE: A bug in the Linux version may prevent entering anything in the Debugger initialization commands field. Until this is fixed, a workaround is to edit <span style="font-size: 10pt"><tt>./home/username/.codeblocks/default.conf</tt></span>to something like <span style="font-size: 10pt"><tt><![CDATA[source /home/user/gdb_pprinters/pp.gdb]]></tt></span><br /> </ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7420 Pretty Printers 2012-10-26T22:36:55Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> :Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6.<br /> :Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (windows) or /home/username/gdb_printers (linux). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py.<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7419 Pretty Printers 2012-10-26T22:14:40Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Download the python printer (if necessary)<br /> <ol><br /> Windows users with MinGW should already have this file in /MinGW/share/gcc-4.7.2/python/libstdcxx/v6. Linux users can download printers.py [http://gcc.gnu.org/viewcvs/trunk/libstdc%2B%2B-v3/python/libstdcxx/v6/ here]. Store in /home/username/gdb_printers.<br /> </ol><br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7418 Pretty Printers 2012-10-26T22:03:44Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test, launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span><br /> If python is enabled, the version will be printed (probably 2.7.1), otherwise, a message will indicate python scripting is not supported.<br /> </ol><br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7417 Pretty Printers 2012-10-26T22:02:23Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test:<br/><br /> Launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span></ol><br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7416 Pretty Printers 2012-10-26T22:01:59Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> <ol><br /> To test:<br /> Launch GDB from console:<br /> <span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span></ol><br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7415 Pretty Printers 2012-10-26T22:01:24Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> To test:<br /> Launch GDB from console:<br /> <ol><span style="font-size: 10pt"><pre><br /> (gdb) python print sys.version<br /> </pre></span></ol><br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7414 Pretty Printers 2012-10-26T22:01:02Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), it is installed by default with GDB. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> To test:<br /> <ol><span style="font-size: 10pt"><pre><br /> Launch GDB from console:<br /> (gdb) python print sys.version<br /> </pre></span></ol><br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7413 Pretty Printers 2012-10-26T21:36:00Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Ensure GDB is python-enabled. For Linux (tested with recent Ubuntu), this is automatic. For Windows, MinGW's default GDB is not python enabled. One option is to install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7412 Pretty Printers 2012-10-26T21:28:41Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command (substitute your path as necessary):<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7411 Pretty Printers 2012-10-26T21:27:51Z

<p>GravityWe11: /* Add to Codeblocks */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7410 Pretty Printers 2012-10-26T21:25:20Z

<p>GravityWe11: /* Test with GDB */</p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import sys<br /> sys.path.insert(0, 'c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7409 Pretty Printers 2012-10-26T01:58:36Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks->debugger tab->command, or in GDB from the console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7408 Pretty Printers 2012-10-26T01:56:12Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the command file from GDB (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7407 Pretty Printers 2012-10-26T01:53:51Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL display nicely formatted variables in the hover pop-up and watch window, for all STL containers (vectors, maps, etc).<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7406 Pretty Printers 2012-10-26T00:48:04Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Disable Codeblocks handling of watch values:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Enable Watch Scripts = Unchecked</tt></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7405 Pretty Printers 2012-10-25T19:44:40Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python printer into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7404 Pretty Printers 2012-10-25T19:44:02Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the command file is correctly loading the python file into GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7403 Pretty Printers 2012-10-25T19:42:06Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run the GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7402 Pretty Printers 2012-10-25T19:41:23Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be loaded into GDB's python, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7401 Pretty Printers 2012-10-25T19:40:15Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path c:/MinGW/share... with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7400 Pretty Printers 2012-10-25T18:48:15Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.2/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7399 Pretty Printers 2012-10-25T18:47:32Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Below is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7398 Pretty Printers 2012-10-25T18:46:01Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files.html Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7397 Pretty Printers 2012-10-25T17:30:00Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7396 Pretty Printers 2012-10-25T17:28:42Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Codeblocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7395 Pretty Printers 2012-10-25T17:28:10Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7394 Pretty Printers 2012-10-25T17:27:44Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> <br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7393 Pretty Printers 2012-10-25T17:27:17Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> ===Other Info===<br /> Links:<br /> [http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html GDB Python API]<br /> [http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html GDB Pretty Printing]<br /> <br /> ===To Do===<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7392 Pretty Printers 2012-10-25T17:24:50Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png|border|Popup example]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7391 Pretty Printers 2012-10-25T17:24:13Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png|border|caption]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7390 Pretty Printers 2012-10-25T17:20:43Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png]]<br><br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7389 Pretty Printers 2012-10-25T17:20:29Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png]]<br><br /> UNDER CONSTRUCTION<br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler:</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <ol><span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span></ol><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7388 Pretty Printers 2012-10-25T17:19:11Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png]]<br><br /> UNDER CONSTRUCTION<br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command:<br/><span style="font-size: 10pt"><tt>Codeblocks->Settings->Debugger->Default->Debugger initialization commands</tt></span><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> <ol start="2"><br /> <li>Comment out the Codeblocks gdb handler</li><br /> </ol><br /> <ol>Edit the file (path to Codeblocks)\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7387 Pretty Printers 2012-10-25T17:14:38Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png]]<br><br /> UNDER CONSTRUCTION<br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <ol><span style="font-size: 10pt"><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></span></ol><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command<br/><tt>settings->debugger->default->debugger initialization commands</tt><br /> <ol><span style="font-size: 10pt"><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></span></ol><br /> #Comment out the Codeblocks gdb handler<br /> <ol>Edit pathto-Codeblocks\share\CodeBlocks\scripts\gdb_types.script</ol><br /> <ol>Add comments as follows:</ol><br /> <span style="font-size: 10pt"><pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre></span><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?</div>

GravityWe11 https://wiki.codeblocks.org/index.php?title=Pretty_Printers&diff=7386 Pretty Printers 2012-10-25T17:07:46Z

<p>GravityWe11: </p> <hr /> <div>GDB Pretty Printers for STL output nicely formatted variables, even for vectors and maps. This works in GDB, and if enabled, in the hover pop-up and watch window in Code::Blocks.<br /> ----<br /> [[File:Pprint1.png]]<br><br /> UNDER CONSTRUCTION<br /> ==Step 1 - Test with GDB==<br /> <br /> *Install a python-enabled GDB. For Windows, you can install [http://sourceforge.net/projects/mingwbuilds/ MinGW-Builds] over MinGW (consider backing up MinGW first). This updates GCC to 4.7.2 and includes a Python enabled GDB.<br /> *Create a GDB [http://sourceware.org/gdb/onlinedocs/gdb/Command-Files Command File] to enable the printer. Store in c:\mingw\bin\pp.gdb (or wherever you want). Here is a sample command file. Replace the path with your path to printers.py. NOTE: A Python STL printer.py is included with MinGW and MinGW-Builds, so there is no need to download one. It only needs to be turned on, which is the purpose of the command file<br /> <blockquote><span style="font-size: 10pt"><pre><br /> python<br /> import os, sys<br /> lib_path = os.path.abspath('c:/MinGW/share/gcc-4.7.0/python/libstdcxx/v6')<br /> sys.path.append(lib_path)<br /> #print 'path is [%s]' % ', '.join(map(str, sys.path))<br /> from printers import register_libstdcxx_printers<br /> register_libstdcxx_printers (None)<br /> end<br /> </pre></span></blockquote><br /> *Test<br /> #Set a breakpoint in a program and debug<br /> #Run GDB command file (can use Codeblocks debugger tab command, or GDB from console) (substitute your path if necessary)<br /> <ol><span style="font-size: 10pt"><pre>(gdb) source c:\MinGW\bin\pp.gdb</pre></span></ol><br /> <ol start="3"><br /> <li>Test the printer - example:</li><br /> </ol><br /> <blockquote><pre>(gdb) print words2<br /> $1 = std::vector of length 3, capacity 4 = {"one", "two", "three"}<br /> </pre></blockquote><br /> <br /> ==Step 2 - Add to Codeblocks==<br /> Once the printer works in GDB, there are two steps to activate in Codeblocks:<br /> #Set debugger initialization command<br/><tt>settings->debugger->default->debugger initialization commands</tt><br /> <ol><pre>source $(TARGET_COMPILER_DIR)bin\pp.gdb</pre></ol><br /> #Comment out the Codeblocks gdb handler<br /> **Edit pathto-Codeblocks\share\CodeBlocks\scripts\gdb_types.script<br /> **Add comments as follows:[/li][/list]<br /> <pre><br /> /* STL String<br /> driver.RegisterType(<br /> _T("STL String"),<br /> _T("[^[:alnum:]_]*string[^[:alnum:]_]*"),<br /> _T("Evaluate_StlString"),<br /> _T("Parse_StlString")<br /> );*/<br /> <br /> /* STL Vector<br /> driver.RegisterType(<br /> _T("STL Vector"),<br /> _T("[^[:alnum:]_]*vector<.*"),<br /> _T("Evaluate_StlVector"),<br /> _T("Parse_StlVector")<br /> ); */<br /> </pre><br /> [u]Other Info[/u]<br /> Links:<br /> http://sourceware.org/gdb/onlinedocs/gdb/Python-API.html<br /> http://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html<br /> <br /> [u]To Do[/u]<br /> The third column in the Codeblocks popup and watch window displays a long unformatted string. Codeblocks is calling the GDB whatis command. Can this command be Pretty-Printed?<br /> <br /> Mod: Please move if this is the wrong forum.</div>

GravityWe11