CShellCommandValue Class Reference

#include <ShellCommandValue.h>

Inheritance diagram for CShellCommandValue:

Collaboration diagram for CShellCommandValue:

Public Member Functions
	CShellCommandValue (CRegistryTree &rTree)
virtual	~CShellCommandValue ()
virtual BOOL	Match (const TCHAR *pchCommand)
virtual int	Execute (CConsole &rConsole, CArgumentParser &rArguments)
virtual const TCHAR *	GetHelpString ()
virtual const TCHAR *	GetHelpShortDescriptionString ()
Public Member Functions inherited from CShellCommand
	CShellCommand ()
virtual	~CShellCommand ()

Private Attributes
CRegistryTree &	m_rTree

Detailed Description

Definition at line 12 of file ShellCommandValue.h.

Constructor & Destructor Documentation

CShellCommandValue()

CShellCommandValue::CShellCommandValue

(

CRegistryTree &

rTree

)

Definition at line 40 of file ShellCommandValue.cpp.

                                                          :m_rTree(rTree)
{
}

~CShellCommandValue()

CShellCommandValue::~CShellCommandValue ( )

virtual

Definition at line 44 of file ShellCommandValue.cpp.

{
}

Member Function Documentation

Execute()

int CShellCommandValue::Execute ( CConsole &  rConsole, CArgumentParser &  rArguments  )

virtual

Implements CShellCommand.

Definition at line 61 of file ShellCommandValue.cpp.

{
    rArguments.ResetArgumentIteration();
    TCHAR *pchCommandItself = rArguments.GetNextArgument();

    TCHAR *pchParameter;
    TCHAR *pchValueFull = NULL;
    BOOL blnUnicodeDump = FALSE;
    BOOL blnBadParameter = FALSE;
    BOOL blnHelp = FALSE;
    LONG nError;
    DWORD dwValueSize;
    DWORD dwType = REG_NONE;
    BYTE *pDataBuffer = NULL;
    TCHAR *pchFilename = NULL;

    if ((_tcsnicmp(pchCommandItself,VALUE_CMD _T(".."),VALUE_CMD_LENGTH+2*sizeof(TCHAR)) == 0)||
        (_tcsnicmp(pchCommandItself,VALUE_CMD _T("\\"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0))
    {
        pchValueFull = pchCommandItself + VALUE_CMD_LENGTH;
    }
    else if (_tcsnicmp(pchCommandItself,VALUE_CMD _T("/"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0)
    {
        pchParameter = pchCommandItself + VALUE_CMD_LENGTH;
        goto CheckValueArgument;
    }

    while((pchParameter = rArguments.GetNextArgument()) != NULL)
    {
CheckValueArgument:
        blnBadParameter = FALSE;
        if ((_tcsicmp(pchParameter,_T("/?")) == 0)
            ||(_tcsicmp(pchParameter,_T("-?")) == 0))
        {
            blnHelp = TRUE;
            break;
        }
        else if (_tcsicmp(pchParameter,_T("/u")) == 0)
        {
            blnUnicodeDump = TRUE;
        }
        else if ((*pchParameter == _T('/'))&&(*(pchParameter+1) == _T('f')))
        {
            pchFilename = pchParameter+2;
        }
        else if (!pchValueFull)
        {
            pchValueFull = pchParameter;
        }
        else
        {
            blnBadParameter = TRUE;
        }
        if (blnBadParameter)
        {
            rConsole.Write(_T("Bad parameter: "));
            rConsole.Write(pchParameter);
            rConsole.Write(_T("\n"));
        }
    }

    CRegistryKey Key;
    TCHAR *pchValueName;
    const TCHAR *pszEmpty = _T("");
    const TCHAR *pszPath;

    if (blnHelp)
    {
        rConsole.Write(GetHelpString());

        if (pDataBuffer)
            delete pDataBuffer;

        return 0;
    }

    if (pchValueFull)
    {
        if (_tcscmp(pchValueFull,_T("\\")) == 0)
            goto ValueCommandNAonRoot;

        TCHAR *pchSep = _tcsrchr(pchValueFull,_T('\\'));
        pchValueName = pchSep?(pchSep+1):(pchValueFull);
        pszPath = pchSep?pchValueFull:_T(".");

        //if (_tcsrchr(pchValueName,_T('.')))
        //{
        //  pchValueName = _T("");
        //  pchPath = pchValueFull;
        //}
        //else
        if (pchSep)
            *pchSep = 0;
    }
    else
    {
        pchValueName = (TCHAR*)pszEmpty;
        pszPath = _T(".");
    }

  if (!m_rTree.GetKey(pszPath,KEY_READ,Key))
  {
    rConsole.Write(m_rTree.GetLastErrorDescription());
    goto SkipValueCommand;
  }

    if (Key.IsRoot())
    goto ValueCommandNAonRoot;

  {
    rConsole.Write(_T("Value name : \""));
    rConsole.Write(_T("\\"));
    rConsole.Write(Key.GetKeyName());
    size_t l = _tcslen(pchValueName);
    if (l&&
        (*pchValueName == _T('\"'))&&
        (pchValueName[l-1] == _T('\"')))
    {
      pchValueName[l-1] = 0;
      pchValueName++;
    }
    rConsole.Write(pchValueName);
    rConsole.Write(_T("\"\n"));

    nError = Key.GetValue(pchValueName,NULL,NULL,&dwValueSize);
    if (nError == ERROR_SUCCESS)
    {
      pDataBuffer = new BYTE [dwValueSize];
      Key.GetValue(pchValueName,&dwType,pDataBuffer,&dwValueSize);
      rConsole.Write(_T("Value type : "));
      rConsole.Write(CRegistryKey::GetValueTypeName(dwType));
      rConsole.Write(_T("\nValue data : "));
      switch(dwType)
      {
      case REG_DWORD_LITTLE_ENDIAN:
        {
          TCHAR Buffer[3];
          rConsole.Write(_T("0x"));
          for (unsigned int i = 0 ; i < dwValueSize ; i++)
          {
            _stprintf(Buffer,_T("%02X"),*(pDataBuffer+((dwValueSize-1)-i)));
            rConsole.Write(Buffer);
          }
        }
        rConsole.Write(_T("\n"));
        break;
      case REG_DWORD_BIG_ENDIAN:
        {
          TCHAR Buffer[3];
          rConsole.Write(_T("0x"));
          for (unsigned int i = 0 ; i < dwValueSize ; i++)
          {
            _stprintf(Buffer,_T("%02X"),*(pDataBuffer+i));
            rConsole.Write(Buffer);
          }
        }
        rConsole.Write(_T("\n"));
        break;
      case REG_LINK:
        break;
      case REG_MULTI_SZ:
        {
          TCHAR *pchCurrentString = (TCHAR *)pDataBuffer;
          rConsole.Write(_T("\n"));
          while(*pchCurrentString)
          {
            rConsole.Write(_T("\""));
            rConsole.Write(pchCurrentString);
            rConsole.Write(_T("\"\n"));
            pchCurrentString += _tcslen(pchCurrentString)+1;
          }
        }
        break;
      case REG_RESOURCE_LIST:
        break;
      case REG_SZ:
      case REG_EXPAND_SZ:
        rConsole.Write(_T("\""));
        rConsole.Write((TCHAR *)pDataBuffer);
        rConsole.Write(_T("\"\n"));
        break;
      case REG_BINARY:
      default:
        {
          TCHAR Buffer[256];
          DWORD i, j;
          for (i = 0 ; i < dwValueSize ; i++)
          {
            if (i%16 == 0)
            {   // ok this is begining of line
              rConsole.Write(_T("\n"));
              // print offset
              _stprintf(Buffer,_T("0x%08X  "),(unsigned int)i);
              rConsole.Write(Buffer);
            }
            else if (i%8 == 0)
            {   // this is the additional space between 7th and 8th byte in current line
              rConsole.Write(_T(" "));
            }

            // print current byte
            unsigned int n = *(pDataBuffer+i);
            _stprintf(Buffer,_T("%02X "),n);
            rConsole.Write(Buffer);

            if (i && (i%16 == 15))
            {   // if this is the last byte in line
              // Dump text representation
              for (j = i-15; j <= i; j += blnUnicodeDump?2:1)\
                  {
                    if ((j%8 == 0)&&(j%16 != 0))
                    {   // this is the additional space between 7th and 8th byte in current line
                      rConsole.Write(_T(" "));
                    }
                    ASSERT(i-j < 16);
                    // write current char representation
                    if (blnUnicodeDump)
                    {
                      ASSERT(j%2 == 0);
                      wchar_t ch = *(TCHAR *)(pDataBuffer+j);

                      _stprintf(Buffer,
#ifdef _UNICODE
                                _T("%c"),
#else
                                // g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
                                // %C in format string is a Microsoft extension.
                                _T("%C"),
#endif
                                iswprint(ch)?ch:L'.');
                    }
                    else
                    {
                      unsigned char ch = *(pDataBuffer+j);

                      _stprintf(Buffer,
#ifdef _UNICODE
                                // g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
                                // %C in format string is a Microsoft extension.
                                _T("%C"),
#else
                                _T("%c"),
#endif
                                isprint(ch)?ch:'.');
                    }
                    rConsole.Write(Buffer);
                  } // for
            }   // if
          } // for

          // print text representation of last line if it is not full (it have less than 16 bytes)
          // k is pseudo offset
          for (DWORD k = i; k%16 != 0; k++)
          {
            if (k%8 == 0)
            {   // this is the additional space between 7th and 8th byte in current line
              rConsole.Write(_T(" "));
            }
            _tcscpy(Buffer,_T("   "));  // the replacement of two digit of current byte + spacing
            rConsole.Write(Buffer);
            if (k && (k%16 == 15))
            {   // if this is the last byte in line
              ASSERT((k-15)%16 == 0);   // k-15 must point at begin of last line
              for (j = k-15; j < i; j += blnUnicodeDump?2:1)
              {
                if (blnUnicodeDump&&(j+1 >= i))
                {   // ok, buffer size is odd number, so we don't display last byte.
                  ASSERT(j+1 == i);
                  break;
                }
                if ((j%8 == 0)&&(j%16 != 0))
                {   // this is the additional space between 7th and 8th byte in current line
                  rConsole.Write(_T(" "));
                }

                // write current char representation
                if (blnUnicodeDump)
                {
                  ASSERT(j%2 == 0);
                  wchar_t ch = *(TCHAR *)(pDataBuffer+j);

                  _stprintf(Buffer,
#ifdef _UNICODE
                            _T("%c"),
#else
                            // g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
                            // %C in format string is a Microsoft extension.
                            _T("%C"),
#endif
                            iswprint(ch)?ch:L'.');
                }
                else
                {
                  unsigned char ch = *(pDataBuffer+j);

                  _stprintf(Buffer,
#ifdef _UNICODE
                            // g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
                            // %C in format string is a Microsoft extension.
                            _T("%C"),
#else
                            _T("%c"),
#endif
                            isprint(ch)?ch:'.');
                }
                rConsole.Write(Buffer);
              } // for
            } // if
          } // for
        } // default:
        rConsole.Write(_T("\n"));
      } // switch
      rConsole.Write(_T("\n"));

      if (pchFilename)
      {
        rConsole.Write(_T("Exporting value data to "));
        rConsole.Write(pchFilename);
        rConsole.Write(_T(" ...\n"));

        HANDLE hFile = CreateFile(pchFilename,GENERIC_WRITE,0,NULL,CREATE_NEW,FILE_ATTRIBUTE_NORMAL,NULL);
        if (hFile == INVALID_HANDLE_VALUE)
        {
          rConsole.Write(_T("Cannot create new file "));
          rConsole.Write(pchFilename);
          rConsole.Write(_T("\n"));
          goto SkipValueCommand;
        }

        DWORD dwBytesWritten;
        if (!WriteFile(hFile,pDataBuffer,dwValueSize,&dwBytesWritten,NULL))
        {
          rConsole.Write(_T("Error writting file.\n"));
          VERIFY(CloseHandle(hFile));
          goto SkipValueCommand;
        }

        ASSERT(dwBytesWritten == dwValueSize);
        VERIFY(CloseHandle(hFile));
      }
    }
    else
    {
      rConsole.Write(_T("Error "));
      TCHAR Buffer[256];
      rConsole.Write(_itoa(nError,Buffer,10));
      rConsole.Write(_T("\n"));
      if (nError == ERROR_FILE_NOT_FOUND)
      {
        rConsole.Write(_T("(System cannot find the value specified)\n"));
      }
    }
  }

SkipValueCommand:
    if (pDataBuffer)
        delete[] pDataBuffer;
    return 0;
ValueCommandNAonRoot:
    rConsole.Write(VALUE_CMD COMMAND_NA_ON_ROOT);
  return 0;
}

GetHelpShortDescriptionString()

const TCHAR * CShellCommandValue::GetHelpShortDescriptionString ( )

virtual

Implements CShellCommand.

Definition at line 436 of file ShellCommandValue.cpp.

{
    return VALUE_CMD_SHORT_DESC;
}

GetHelpString()

const TCHAR * CShellCommandValue::GetHelpString ( )

virtual

Implements CShellCommand.

Definition at line 424 of file ShellCommandValue.cpp.

{
    return VALUE_CMD_SHORT_DESC
            _T("Syntax: ") VALUE_CMD _T(" [<PATH>][<VALUE_NAME>] [/u] [/?]\n\n")
            _T("    <PATH>       - Optional relative path of key which value will be processed.\n")
            _T("    <VALUE_NAME> - Name of key's value. Default is key's default value.\n")
            _T("    /u           - On binary dump view as Unicode.\n")
            _T("    /fFILE       - Export value data to FILE.\n")
            _T("    /?           - This help.\n\n")
            _T("Without parameters, command displays default value of current key.\n");
}

Referenced by Execute().

Match()

BOOL CShellCommandValue::Match ( const TCHAR *  pchCommand )

virtual

Implements CShellCommand.

Definition at line 48 of file ShellCommandValue.cpp.

{
    if (_tcsicmp(pchCommand,VALUE_CMD) == 0)
        return TRUE;
    if (_tcsnicmp(pchCommand,VALUE_CMD _T(".."),VALUE_CMD_LENGTH+2*sizeof(TCHAR)) == 0)
        return TRUE;
    if (_tcsnicmp(pchCommand,VALUE_CMD _T("/"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0)
        return TRUE;
    if (_tcsnicmp(pchCommand,VALUE_CMD _T("\\"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0)
        return TRUE;
    return FALSE;
}

Member Data Documentation

m_rTree

CRegistryTree& CShellCommandValue::m_rTree

private

Definition at line 22 of file ShellCommandValue.h.

Referenced by Execute().

---

The documentation for this class was generated from the following files:

• modules/rosapps/applications/sysutils/regexpl/ShellCommandValue.h
• modules/rosapps/applications/sysutils/regexpl/ShellCommandValue.cpp