home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 545a.lha / PowerVisor_v1.0 / PowerVisor.readme.pp / PowerVisor.readme
Text File  |  1991-09-06  |  11KB  |  137 lines
  1. This is PowerVisor, a powerful machinelanguage level debugger                   
  2. for the serious Amiga programmer.                                               
  3. Below follows a list of features.                                               
  4. PowerVisor is shareware. Read the 'ReadThisFile' file in the                    
  5. root of the zoo file for more info.                                             
  6.                                                                                 
  7. Warning ! This is still a beta version. Although a very                         
  8. stable one I think.                                                             
  9.                                                                                 
  10.                                                                                 
  11. Some PowerVisor features :                                                      
  12.                                                                                 
  13. - Compatible with all Amiga models and all Motorola processors that             
  14.   you can put in your Amiga (68000,68010,68020,68030,68881,68882,               
  15.   68851). (The disassembler also supports the 68040).                           
  16. - Full screen debugger or commandline type debugger all in one.                 
  17. - Very configurable, you can redefine the keys (for example to                  
  18.   emulate the monam2 keys).                                                     
  19.   You can attach almost any command to almost any key.                          
  20. - Two versions : one for AmigaDOS 1.2-1.3 and one for AmigaDOS 2.0.             
  21. - The following singlestep commands are supported :                             
  22.     - simple trace                                                              
  23.     - trace over BSR/JSR (works even in ROM)                                    
  24.     - trace until register changes (done in singlestepmode)                     
  25.     - trace until branch (stops tracing before branch really                    
  26.       executes) (done in singlestepmode).                                       
  27.     - trace until operating system call used (JSR (a6) or JMP (a6))             
  28.       (done in singlestepmode).                                                 
  29.     - trace until address (with automatic breakpoint).                          
  30.     - trace until condition becomes true (with a powerful expression            
  31.       evaluator, you could for example trace until register d0 is               
  32.       equal to d1 and d2 is equal to d3) (done in singlestep mode).             
  33. - The following breakpoints are supported :                                     
  34.     - break                                                                     
  35.     - break and remove breakpoint                                               
  36.     - break after <n> times                                                     
  37.     - break if condition is true                                                
  38.     - profile breakpoint (counter)                                              
  39. - The number of breakpoints is unlimited (only limited by memory).              
  40. - When you are tracing a program you can continue typing commands.              
  41.   You can even singlestep more commands at the same time (multitasking          
  42.   debugging).                                                                   
  43. - SYMBOL hunks are supported.                                                   
  44. - You can interactivelly add or remove symbols so you can more easily           
  45.   remember routines to jump to.                                                 
  46. - You can debug crashed tasks, you can load a task, you can simply              
  47.   take a task from the task list to debug it or you can wait until              
  48.   the next task is started.                                                     
  49. - ARexx port. You can write your scripts in ARexx.                              
  50.   This ARexx scripts are asynchronious (multitasking) so you                    
  51.   can run an ARexx script in one logical window and type commands               
  52.   in the other one.                                                             
  53. - Simple scripts can also be written in the internal script                     
  54.   language.                                                                     
  55. - You can list several system lists : tasks, locks, files, libraries,           
  56.   devices, resources, interrupts, resident modules, dos devices,                
  57.   fonts, message ports, semaphores, execbase, graphicsbase,                     
  58.   intuitionbase, windows, screens, input handlers, memory lists,                
  59.   autoconfig devices, ...                                                       
  60. - You can ask more information about each element of a list. For                
  61.   example you can dump the task structure of an element in the                  
  62.   task list.                                                                    
  63. - You can of course view memory and disassemble instructions.                   
  64. - There is a very powerful 'view' command. You can define                       
  65.   regions of memory to be of a certain type. The 'view' command                 
  66.   will then automatically adapts its output to the type of the                  
  67.   memory. The following types are supported : ascii, byte,                      
  68.   word, long, code (disassembly) and structures. With the last                  
  69.   type you can define a region of memory to be a structure. For                 
  70.   example: with one command you can define all tasks in the system              
  71.   as 'STRUCTURE Task'. When the 'view' command accidently hits                  
  72.   the memory of one task, the output will automatically reflect                 
  73.   this.                                                                         
  74.   You can define your own structures to use in PowerVisor.                      
  75. - You can interactivelly test and use libraries and devices.                    
  76.   PowerVisor understands fd-files so that you can use the library               
  77.   functions in this library as if you type them from C (more                    
  78.   or less). This is very useful when you want to see how a certain              
  79.   library function works.                                                       
  80. - PowerVisor traps crashes and gurus (most of them anyway).                     
  81. - PowerVisor traps stack overflows.                                             
  82. - PowerVisor has 6 different logical windows (these are not                     
  83.   Intuition windows) for output. One is for the fullscreen debugger,            
  84.   one is for the automatic refresh and two are for normal output.               
  85.   The other two are for PortPrint output (see later) and for ARexx              
  86.   output.                                                                       
  87.   You can use a different font for any of the logical windows.                  
  88. - Powerful windowsystem. You can stack Intuitionwindows and                     
  89.   PowerVisor windows in any way you want.                                       
  90. - Integrated portprint facility (with library), all messages printed            
  91.   appear on the PowerVisor window.                                              
  92. - Support for interlace/non interlace.                                          
  93. - PowerVisor uses a 3D screen when started in AmigaDOS 2.0.                     
  94.   PowerVisor also uses overscan in AmigaDOS 2.0.                                
  95. - In AmigaDOS 2.0 the PowerVisor screen is a public screen.                     
  96.   You can make the screen of PowerVisor an autoscrolling                        
  97.   screen (like the 2.0 WorkBench).                                              
  98. - You can put the PowerVisor window on each screen available in                 
  99.   the system. This is of course dangerous but it can be useful                  
  100.   to debug some programs.                                                       
  101. - A logical window can be bigger than the visible size. This enables            
  102.   you to scroll this window to view the previous output.                        
  103. - A built-in snap facility.                                                     
  104. - A very powerful command parser and expression evaulator.                      
  105.   Some examples :                                                               
  106.     (5*4)<<2                 => 80                                              
  107.     *4                       => pointer to execbase                             
  108.     *4.b                     => byte at location 4                              
  109.     {a=5;v a*a}+1            => 26                                              
  110.     *(task:input.device+4)   => contents of task structure                      
  111.     if(a>=0,a,-a)            => abs(a)                                          
  112. - Online help.                                                                  
  113. - You can patch each library function in the system to see how                  
  114.   many times a function is used, by whom it is used, or what                    
  115.   parameters where given.                                                       
  116. - Commandline history.                                                          
  117. - 'Alias' command.                                                              
  118. - MMU commands, you can disassemble the mmu tree, you can reset                 
  119.   all U and M (used and modify) bits, you can display all 68020                 
  120.   68030 and the mmu registers.                                                  
  121. - 'kill' and 'freeze' commands to kill and freeze tasks.                        
  122. - You can remove a lot of things : tasks, input handlers, windows,              
  123.   screens, resident modules, ...                                                
  124. - You can read or write blocks using the trackdisk.device.                      
  125. - Variables allow you to remember values for later. Very useful                 
  126.   when debugging.                                                               
  127. - Except for the lists and the extra information for each element               
  128.   in the list, you can ask other information as well :                          
  129.     - all gadgets in a window (gadget structure is dumped)                      
  130.     - hunks for a process                                                       
  131. - Redirection of output to a file (log file).                                   
  132. - There are also commands to search, fill and copy memory.                      
  133. - You can also install a usage counter for each tasks, so that                  
  134.   you can determine how active a certain task is.                               
  135.                                                                                 
  136.           Jorrit Tyberghein                                                     
  137.