home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 40 / IOPROG_40.ISO / SOFT / NETFrameworkSDK.exe / comsdk.cab / samples1.exe / Debugger / shell.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  13.5 KB  |  539 lines
  1. /* ------------------------------------------------------------------------- *
  2.  * debug\shell.cpp: generic shell routines
  3.  * ------------------------------------------------------------------------- */
  4. #include "stdafx.h"
  5.  
  6. #include <Winbase.h>
  7.  
  8. #include "shell.h"
  9.  
  10. /* ------------------------------------------------------------------------- *
  11.  * ShellCommand routines
  12.  * ------------------------------------------------------------------------- */
  13.  
  14. ShellCommand::ShellCommand(const WCHAR *n, int min)
  15. {
  16.     m_pName = n; 
  17.  
  18.     if(min == 0)
  19.         m_minMatchLength = wcslen(n);
  20.     else
  21.         m_minMatchLength = min; 
  22. }
  23.  
  24. void ShellCommand::Help(Shell *shell)
  25. {
  26.     shell->Write(L"Usage: %s", m_pName);
  27. }
  28.  
  29. /* ------------------------------------------------------------------------- *
  30.  * ShellCommandTable routines
  31.  * ------------------------------------------------------------------------- */
  32.  
  33. struct ShellCommandEntry
  34. {
  35.     HASHENTRY entry;
  36.  
  37.     ShellCommand *command;
  38. };
  39.  
  40. class ShellCommandTable : CHashTableAndData<CNewData>
  41. {
  42. private:
  43.     BOOL Cmp(const BYTE *pc1, const HASHENTRY *pc2)
  44.     {
  45.         return((WCHAR)pc1) != ((ShellCommandEntry*)pc2)->command->GetName()[0];
  46.     };
  47.  
  48.     USHORT HASH(const WCHAR *name) 
  49.     {
  50.         // Try and keep them alphabetic
  51.         if(name[0] < L'a')
  52.             return(name[0] - L'a');
  53.         else
  54.             return(name[0] - L'A');
  55.     };
  56.  
  57.     BYTE *KEY(const WCHAR *name) 
  58.     {
  59.         return ((BYTE *) name[0]);
  60.     };
  61.  
  62.     bool Match(const WCHAR *string, size_t length, const WCHAR *match, size_t minMatchLength)
  63.     {
  64.         return(length >= minMatchLength && wcsncmp(string, match, length) == 0);
  65.     }
  66.  
  67.     ShellCommandEntry *Find(const WCHAR *name)
  68.     {
  69.         return((ShellCommandEntry *) CHashTableAndData<CNewData>::Find(HASH(name), KEY(name)));
  70.     }
  71.     
  72.     ShellCommandEntry *FindNext(ShellCommandEntry *cmdEntry)
  73.     {
  74.         USHORT index =
  75.             CHashTableAndData<CNewData>::FindNext(KEY(cmdEntry->command->GetName()),
  76.                                                   ItemIndex(&cmdEntry->entry));
  77.         
  78.         if(index == 0xffff)
  79.             return(NULL);
  80.         else
  81.             return((ShellCommandEntry *) EntryPtr(index));
  82.     }
  83.  
  84. public:
  85.  
  86.     ShellCommandTable() : CHashTableAndData<CNewData>(50) 
  87.     {
  88.         NewInit(50, sizeof(ShellCommandEntry), 500);
  89.     }
  90.  
  91.     bool AddCommand(ShellCommand *newCommand)
  92.     {
  93.         //
  94.         // Check for duplicate entry
  95.         //
  96.         for(ShellCommandEntry *entry = Find(newCommand->GetName());
  97.            entry != NULL;
  98.            entry = FindNext(entry))
  99.         {
  100.             ShellCommand *command = entry->command;
  101.  
  102.             // If we find a match, the command may not be entered
  103.             if(Match(newCommand->GetName(), newCommand->GetMinMatchLength(),
  104.                      command->GetName(), command->GetMinMatchLength()))
  105.                 return(false);
  106.         }
  107.  
  108.         //
  109.         // Add the new entry and fill out the data structure
  110.         //
  111.         ShellCommandEntry *newEntry = (ShellCommandEntry*) Add(HASH(newCommand->GetName()));
  112.         _ASSERTE(newEntry != NULL);
  113.         newEntry->command = newCommand;
  114.  
  115.         return(true);
  116.     }
  117.  
  118.     ShellCommand *GetCommand(const WCHAR *string, size_t length)
  119.     {
  120.         for(ShellCommandEntry *entry = Find(string);
  121.            entry != NULL;
  122.            entry = FindNext(entry))
  123.         {
  124.             ShellCommand *command = entry->command;
  125.  
  126.             if(Match(string, length, command->GetName(), command->GetMinMatchLength()))
  127.                 return(command);
  128.         }
  129.  
  130.         return(NULL);
  131.     }
  132.  
  133.     ShellCommand *GetFirstCommand(HASHFIND *info)
  134.     {
  135.         ShellCommandEntry *entry = (ShellCommandEntry *) FindFirstEntry(info);
  136.         
  137.         if(entry == NULL)
  138.             return(NULL);
  139.         else
  140.             return(entry->command);
  141.     }
  142.  
  143.     ShellCommand *GetNextCommand(HASHFIND *info)
  144.     {
  145.         ShellCommandEntry *entry = (ShellCommandEntry *) FindNextEntry(info);
  146.  
  147.         if(entry == NULL)
  148.             return(NULL);
  149.         else
  150.             return(entry->command);
  151.     }
  152. };
  153.  
  154. /* ------------------------------------------------------------------------- *
  155.  * Shell routines
  156.  * ------------------------------------------------------------------------- */
  157.  
  158. Shell::Shell()
  159. {
  160.     m_pPrompt = L"(shell)";
  161.     m_pCommands = new ShellCommandTable();
  162.     _ASSERTE(m_pCommands != NULL);
  163.     m_lastCommand[0] = L'\0';
  164. }
  165.  
  166. Shell::~Shell()
  167. {
  168.     HASHFIND info;
  169.  
  170.     for(ShellCommand *command = m_pCommands->GetFirstCommand(&info);
  171.        command != NULL;
  172.        command = m_pCommands->GetNextCommand(&info))
  173.     {
  174.         delete command;
  175.     }
  176.  
  177.     delete m_pCommands;
  178. }
  179.  
  180. void Shell::AddCommand(ShellCommand *command)
  181. {
  182.     m_pCommands->AddCommand(command); 
  183. }
  184.  
  185. void Shell::PutCommand(FILE *f)
  186. {
  187.     fwprintf(f, m_buffer);
  188.     fwprintf(f, L"\n");
  189. }
  190.  
  191. ShellCommand *Shell::GetCommand(const WCHAR *string, size_t length)
  192. {
  193.     return(m_pCommands->GetCommand(string, length));
  194. } 
  195.  
  196. void Shell::ReadCommand()
  197. {
  198.     Write(L"%s ", m_pPrompt);
  199.  
  200.     // !!! would be nice to handle some control characters - 
  201.     // we'll see what we get for free from stdio
  202.  
  203.     m_buffer[0] = L'\0';
  204.  
  205.     // @todo: ReadLine can fail if you hit ctrl-break while it in. It
  206.     // retuns a failure, but we don't really want to quit at that
  207.     // point. I'm leaving the old code for now just in case we find
  208.     // the need to switch back.
  209. #if 0
  210.     if(!ReadLine(m_buffer, BUFFER_SIZE))
  211.         wcscpy(m_buffer, L"quit");
  212.  
  213.     DoCommand(m_buffer);
  214. #else
  215.     if(ReadLine(m_buffer, BUFFER_SIZE))
  216.         DoCommand(m_buffer);
  217. #endif    
  218. }
  219.  
  220. void Shell::DoCommand(const WCHAR *string)
  221. {
  222.     const WCHAR     *args;
  223.     const WCHAR     *commandName;
  224.     ShellCommand    *command;
  225.  
  226.     if(*string == L'\0')
  227.         string = m_lastCommand;
  228.     else
  229.         wcscpy(m_lastCommand, string);
  230.  
  231.     args = string;
  232.  
  233.     if(GetStringArg(args, commandName))
  234.     {
  235.         command = m_pCommands->GetCommand(commandName, args - commandName);
  236.         if(command == NULL)
  237.         {
  238.             //
  239.             // I like to be able to hit return to clear some whitespace on the
  240.             // screen :)
  241.             //
  242.             if(wcslen(string) != 0)
  243.                 Error(L"Unknown command \"%.*s\"\n", args - commandName, commandName);
  244.         }
  245.         else
  246.         {
  247.             while(*args && iswspace(*args))
  248.                 args++;
  249.  
  250.             command->Do(this, args);
  251.         }
  252.     }
  253. }
  254.  
  255. #define MAX_SHELL_COMMANDS        256
  256.  
  257. void Shell::Help()
  258. {
  259.     HASHFIND        info;
  260.     ShellCommand *pCommand [MAX_SHELL_COMMANDS];
  261.     int iNumCommands = 0;
  262.  
  263.     Write(L"\nThe following commands are available:\n\n");
  264.  
  265.     pCommand [iNumCommands] = m_pCommands->GetFirstCommand(&info);
  266.     
  267.     while ((pCommand [iNumCommands] != NULL) && 
  268.             (iNumCommands < MAX_SHELL_COMMANDS))
  269.     {
  270.         iNumCommands++;
  271.         pCommand [iNumCommands] = m_pCommands->GetNextCommand(&info);
  272.     }
  273.  
  274.     // The commands that are returned are already sorted, it's just that 
  275.     // they don't start from "a". So, find the first entry starting with 
  276.     // "a" (there will be atleast one due to the "attach" command) and start
  277.     // printing from there. Then wrap around.
  278.  
  279.     int iStartIndex = 0;
  280.     bool fFound = false;
  281.  
  282.     while ((fFound == false) && (iStartIndex < iNumCommands))
  283.     {
  284.         WCHAR *strName = (WCHAR *)pCommand [iStartIndex] ->GetName();
  285.         if ((strName[0] == L'a') || (strName[0] == L'A'))
  286.             fFound = true;
  287.         else
  288.             iStartIndex++;
  289.     }
  290.  
  291.     // assert that there's always one command starting with "a".
  292.     _ASSERTE (iStartIndex < iNumCommands);
  293.  
  294.     // now print the commands starting from this one.
  295.     int iEndMarker = iStartIndex;
  296.     WCHAR buf[256];
  297.  
  298.     do
  299.     {
  300.         ShellCommand *command = pCommand [iStartIndex % iNumCommands];
  301.         iStartIndex++;
  302.  
  303.         if (command->GetMinMatchLength() == 0)
  304.             wcscpy(buf, command->GetName());
  305.         else
  306.         {
  307.             wcsncpy(buf, command->GetName(), command->GetMinMatchLength());
  308.             buf[command->GetMinMatchLength()] = L'\0';
  309.  
  310.             if (command->GetName()[command->GetMinMatchLength()] != 0)
  311.             {
  312.                 wcscat(buf, L"[");
  313.                 wcscat(buf, command->GetName() +
  314.                             command->GetMinMatchLength());
  315.                 wcscat(buf, L"]");
  316.             }
  317.         }
  318.  
  319.         Write(L"%-20s%s\n", buf, command->ShortHelp(this));
  320.         
  321.     } while ((iStartIndex % iNumCommands) != iEndMarker);
  322. }
  323.  
  324. void Shell::ReportError(long hr)
  325. {
  326.     WCHAR* wszBuffer;
  327.     WCHAR wsz[60];
  328.     
  329.     switch( hr )
  330.     {
  331.         case CORDBG_E_FUNCTION_NOT_IL:
  332.             wszBuffer = L"The function has no managed body!\n";
  333.             break;
  334.  
  335.         case CORDBG_E_UNRECOVERABLE_ERROR:
  336.             wszBuffer = L"Unrecoverable error!\n";
  337.             break;
  338.  
  339.         case CORDBG_E_PROCESS_TERMINATED:
  340.             wszBuffer = L"The debugee has terminated!\n";
  341.             break;
  342.         
  343.         default:
  344.         {
  345.             char *buffer;
  346.             
  347.             // Get the string error from the HR
  348.             DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM 
  349.                                        | FORMAT_MESSAGE_ALLOCATE_BUFFER
  350.                                        | FORMAT_MESSAGE_IGNORE_INSERTS, 
  351.                                        NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
  352.                                        (char *) &buffer, 0, NULL);
  353.  
  354.             if (!res)
  355.             {
  356.                 _ASSERTE( FAILED( HRESULT_FROM_WIN32(GetLastError()) ));
  357.                 wsprintf(wsz, L"Non-Windows Error:hr:0x%x\n", hr);
  358.                 wszBuffer = wsz;
  359.                 break;
  360.             }
  361.  
  362.             // Make the string Unicode and free the system-allocated string
  363.             MAKE_WIDEPTR_FROMUTF8(bufferW, buffer);
  364.             LocalFree(buffer);
  365.  
  366.             wszBuffer = bufferW;
  367.             break;
  368.         }
  369.     }
  370.     
  371.     Error(wszBuffer);
  372. }
  373.  
  374. void Shell::SystemError()
  375. {
  376.     ReportError(GetLastError());
  377. }
  378.  
  379. size_t Shell::GetArgArray(WCHAR *argString, const WCHAR **argArray, size_t argMax)
  380. {
  381.     const WCHAR **pArg = argArray, **pArgEnd = pArg, **pArgMax = pArg + argMax;
  382.  
  383.     while(pArgEnd < pArgMax)
  384.     {
  385.         // 
  386.         // Skip leading white space
  387.         //
  388.         while(*argString && iswspace(*argString))
  389.             argString++;
  390.  
  391.         if(*argString == 0)
  392.             break;
  393.  
  394.         *pArgEnd++ = argString;
  395.  
  396.         //
  397.         // Add some kind of quoting at some point
  398.         //
  399.  
  400.         while(*argString && !iswspace(*argString))
  401.             argString++;
  402.  
  403.         *argString++ = 0;
  404.     }
  405.  
  406.     return(pArgEnd - argArray);
  407. }
  408.  
  409. bool Shell::GetStringArg(const WCHAR *&string, const WCHAR *&result)
  410. {
  411.     while(*string && iswspace(*string))
  412.         string++;
  413.  
  414.     result = string;
  415.  
  416.     while(*string && !iswspace(*string))
  417.         string++;
  418.  
  419.     return(true);
  420. }
  421.  
  422. bool Shell::GetIntArg(const WCHAR *&string, int &result)
  423. {
  424.     while(*string && iswspace(*string))
  425.         string++;
  426.  
  427.     result = 0;
  428.  
  429.     if(string[0] == L'0' && towlower(string[1]) == L'x')
  430.     {
  431.         string += 2;
  432.  
  433.         while(iswxdigit(*string))
  434.         {
  435.             result <<= 4;
  436.             if(iswdigit(*string))
  437.                 result += *string - L'0';
  438.             else
  439.                 result += 10 + towlower(*string) - L'a';
  440.  
  441.             string++;
  442.         }
  443.  
  444.         return(true);
  445.     }
  446.     else if(iswdigit(*string))
  447.     {
  448.         while(iswdigit(*string))
  449.         {
  450.             result *= 10;
  451.             result += *string++ - L'0';
  452.         }
  453.  
  454.         return(true);
  455.     }
  456.     else
  457.         return(false);
  458. }
  459.  
  460. bool Shell::GetInt64Arg(const WCHAR *&string, unsigned __int64 &result)
  461. {
  462.     while(*string && iswspace(*string))
  463.         string++;
  464.  
  465.     result = 0;
  466.  
  467.     if(string[0] == L'0' && towlower(string[1]) == L'x')
  468.     {
  469.         string += 2;
  470.  
  471.         while(iswxdigit(*string))
  472.         {
  473.             result <<= 4;
  474.             if(iswdigit(*string))
  475.                 result += *string - L'0';
  476.             else
  477.                 result += 10 + towlower(*string) - L'a';
  478.  
  479.             string++;
  480.         }
  481.  
  482.         return(true);
  483.     }
  484.     else if(iswdigit(*string))
  485.     {
  486.         while(iswdigit(*string))
  487.         {
  488.             result *= 10;
  489.             result += *string++ - L'0';
  490.         }
  491.  
  492.         return(true);
  493.     }
  494.     else
  495.         return(false);
  496. }
  497.  
  498. /* ------------------------------------------------------------------------- *
  499.  * HelpShellCommand routines
  500.  * ------------------------------------------------------------------------- */
  501.  
  502. void HelpShellCommand::Do(Shell *shell, const WCHAR *args)
  503. {
  504.     if (*args == 0)
  505.         Help(shell);
  506.  
  507.     const WCHAR *commandName;
  508.  
  509.     while ((shell->GetStringArg(args, commandName)) &&
  510.            *commandName != 0)
  511.     {
  512.         ShellCommand *command = shell->GetCommand(commandName,
  513.                                                   args - commandName);
  514.  
  515.         if (command == NULL)
  516.             shell->Error(L"Unknown command \"%.*s\"\n",
  517.                          args - commandName, commandName);
  518.         else
  519.             command->Help(shell);
  520.  
  521.         shell->Write(L"\n");
  522.     }
  523. }
  524.  
  525. void HelpShellCommand::Help(Shell *shell)
  526. {
  527.     ShellCommand::Help(shell);
  528.     shell->Write(L" <command>*\n");
  529.     shell->Write(L"\tPrints help on the given commands.\n");
  530.     shell->Help();
  531. }
  532.  
  533. const WCHAR *HelpShellCommand::ShortHelp(Shell *shell)
  534. {
  535.     return L"Get help";
  536. }
  537.  
  538.  
  539.