1 // commands.h

     2 // 

     3 // Copyright (c) 2006 - 2010 Accenture. All rights reserved.

     4 // This component and the accompanying materials are made available

     5 // under the terms of the "Eclipse Public License v1.0"

     6 // which accompanies this distribution, and is available

     7 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 // 

     9 // Initial Contributors:

    10 // Accenture - Initial contribution

    11 //

    12 

    13 

    14 #ifndef __COMMANDS_H__

    15 #define __COMMANDS_H__

    16 

    17 #include <fshell/common.mmh>

    18 #include <fshell/consoleextensions.h>

    19 #include "parser.h"

    20 #include <hal.h>

    21 #include <fshell/ioutils.h>

    22 #include <fshell/memoryaccesscmd.h>

    23 

    24 using namespace IoUtils;

    25 

    26 

    27 class CCmdHelp : public CCommandBase

    28 	{

    29 public:

    30 	static CCommandBase* NewLC();

    31 	~CCmdHelp();

    32 private:

    33 	CCmdHelp();

    34 private: // From CCommandBase.

    35 	virtual const TDesC& Name() const;

    36 	virtual void DoRunL();

    37 	virtual void OptionsL(RCommandOptionList& aOptions);

    38 private:

    39 	IoUtils::CTextFormatter* iFormatter;

    40 	TBool iCount;

    41 	};

    42 

    43 

    44 // Note, this command should never execute as 'exit' has handled explicitly by CParser.

    45 // It exists so that 'exit' appears in fshell's help list and also to support 'exit --help'.

    46 class CCmdExit : public CCommandBase

    47 	{

    48 public:

    49 	static CCommandBase* NewLC();

    50 	~CCmdExit();

    51 private:

    52 	CCmdExit();

    53 private: // From CCommandBase.

    54 	virtual const TDesC& Name() const;

    55 	virtual void DoRunL();

    56 	};

    57 

    58 

    59 class MDirReaderObserver

    60 	{

    61 public:

    62 	virtual void DirReadComplete(TInt aError) = 0;

    63 	};

    64 

    65 

    66 class CCmdLs : public CCommandBase

    67 	{

    68 public:

    69 	static CCommandBase* NewLC();

    70 	~CCmdLs();

    71 private:

    72 	CCmdLs();

    73 	void ConstructL();

    74 	void PrintDirContentL(const CDir& aDir);

    75 	void PrintDirContentL(RDir& aDir);

    76 	void RecursiveScanDirL(const TDesC& aName);

    77 	void DoScanDirL();

    78 	void FormatEntryL(const TEntry& aEntry);

    79 private: // From CCommandBase.

    80 	virtual const TDesC& Name() const;

    81 	virtual void DoRunL();

    82 	virtual void OptionsL(RCommandOptionList& aOptions);

    83 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

    84 private:

    85 	TFileName2 iFileName;

    86 	TPtrC iBaseDir;

    87 	TBuf<256> iTempBuf;

    88 	CTextFormatter* iFormatter;

    89 	TBool iOptAll;

    90 	TBool iOptLong;

    91 	TBool iOptHuman;

    92 	TBool iOptOnePerLine;

    93 	TBool iOptRecurse;

    94 	};

    95 

    96 

    97 class CCmdCd : public CCommandBase

    98 	{

    99 public:

   100 	static CCommandBase* NewLC();

   101 	~CCmdCd();

   102 private:

   103 	CCmdCd();

   104 private: // From CCommandBase.

   105 	virtual const TDesC& Name() const;

   106 	virtual void DoRunL();

   107 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   108 private:

   109 	TFileName2 iDir;

   110 	};

   111 

   112 

   113 class CCmdClear : public CCommandBase

   114 	{

   115 public:

   116 	static CCommandBase* NewLC();

   117 	~CCmdClear();

   118 private:

   119 	CCmdClear();

   120 private: // From CCommandBase.

   121 	virtual const TDesC& Name() const;

   122 	virtual void DoRunL();

   123 	virtual void OptionsL(RCommandOptionList& aOptions);

   124 

   125 private:

   126 	TBool iFormFeed;

   127 	};

   128 

   129 

   130 class CForegroundAdjuster;

   131 

   132 class CCmdFg : public CCommandBase

   133 	{

   134 public:

   135 	static CCommandBase* NewLC();

   136 	~CCmdFg();

   137 private:

   138 	CCmdFg();

   139 private: // From CCommandBase.

   140 	virtual const TDesC& Name() const;

   141 	virtual void DoRunL();

   142 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   143 private:

   144 	HBufC* iJobSpec;

   145 	CForegroundAdjuster* iForegroundAdjuster;

   146 	};

   147 

   148 

   149 class CCmdBg : public CCommandBase

   150 	{

   151 public:

   152 	static CCommandBase* NewLC();

   153 	~CCmdBg();

   154 private:

   155 	CCmdBg();

   156 private: // From CCommandBase.

   157 	virtual const TDesC& Name() const;

   158 	virtual void DoRunL();

   159 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   160 private:

   161 	HBufC* iJobSpec;

   162 	CForegroundAdjuster* iForegroundAdjuster;

   163 	};

   164 

   165 

   166 class CCmdJobs : public CCommandBase

   167 	{

   168 public:

   169 	static CCommandBase* NewLC();

   170 	~CCmdJobs();

   171 private:

   172 	CCmdJobs();

   173 private: // From CCommandBase.

   174 	virtual const TDesC& Name() const;

   175 	virtual void DoRunL();

   176 private:

   177 	CTextFormatter* iFormatter;

   178 	};

   179 

   180 

   181 class CCmdRm : public CCommandBase

   182 	{

   183 public:

   184 	static CCommandBase* NewLC();

   185 	~CCmdRm();

   186 private:

   187 	CCmdRm();

   188 	TInt DoDelete(const TDesC& aFileName);

   189 private: // From CCommandBase.

   190 	virtual const TDesC& Name() const;

   191 	virtual void DoRunL();

   192 	virtual void OptionsL(RCommandOptionList& aOptions);

   193 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   194 private:

   195 	RArray<TFileName2> iFileNames;

   196 	CFileMan* iFileMan;

   197 	TBool iRecurse;

   198 	TBool iForce;

   199 	};

   200 

   201 

   202 class CCmdCp : public CCommandBase

   203 	{

   204 public:

   205 	static CCommandBase* NewLC();

   206 	~CCmdCp();

   207 private:

   208 	CCmdCp();

   209 private: // From CCommandBase.

   210 	virtual const TDesC& Name() const;

   211 	virtual void DoRunL();

   212 	virtual void OptionsL(RCommandOptionList& aOptions);

   213 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   214 private:

   215 	void ForciblyCopyFileL(const TDesC& aSourceFileName, const TDesC& aDestFileName);

   216 private:

   217 	TFileName2 iFrom;

   218 	TFileName2 iTo;

   219 	CFileMan* iFileMan;

   220 	TBool iRecurse;

   221 	TBool iForce;

   222 	TBool iOverwrite;

   223 	};

   224 

   225 

   226 class CCmdMv : public CCommandBase

   227 	{

   228 public:

   229 	static CCommandBase* NewLC();

   230 	~CCmdMv();

   231 private:

   232 	CCmdMv();

   233 private: // From CCommandBase.

   234 	virtual const TDesC& Name() const;

   235 	virtual void DoRunL();

   236 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   237 private:

   238 	TFileName2 iFrom;

   239 	TFileName2 iTo;

   240 	CFileMan* iFileMan;

   241 	};

   242 

   243 

   244 class CCmdMkDir : public CCommandBase

   245 	{

   246 public:

   247 	static CCommandBase* NewLC();

   248 	~CCmdMkDir();

   249 private:

   250 	CCmdMkDir();

   251 private: // From CCommandBase.

   252 	virtual const TDesC& Name() const;

   253 	virtual void DoRunL();

   254 	virtual void OptionsL(RCommandOptionList& aOptions);

   255 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   256 private:

   257 	TFileName2 iDir;

   258 	TBool iAllowExists;

   259 	};

   260 

   261 

   262 class CCmdRmDir : public CCommandBase

   263 	{

   264 public:

   265 	static CCommandBase* NewLC();

   266 	~CCmdRmDir();

   267 private:

   268 	CCmdRmDir();

   269 private: // From CCommandBase.

   270 	virtual const TDesC& Name() const;

   271 	virtual void DoRunL();

   272 	virtual void OptionsL(RCommandOptionList& aOptions);

   273 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   274 private:

   275 	RArray<TFileName2> iDirs;

   276 	CFileMan* iFileMan;

   277 	TBool iRecurse;

   278 	};

   279 

   280 

   281 class CCmdMatch : public CCommandBase

   282 	{

   283 public:

   284 	static CCommandBase* NewLC();

   285 	~CCmdMatch();

   286 private:

   287 	CCmdMatch();

   288 private: // From CCommandBase.

   289 	virtual const TDesC& Name() const;

   290 	virtual void DoRunL();

   291 	virtual void OptionsL(RCommandOptionList& aOptions);

   292 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   293 private:

   294 	HBufC* iToMatch;

   295 	TBool iIgnoreCase;

   296 	TBool iInvertMatch;

   297 	TBool iCount;

   298 	};

   299 

   300 

   301 class CCmdEcho : public CCommandBase

   302 	{

   303 public:

   304 	static CCommandBase* NewLC();

   305 	~CCmdEcho();

   306 private:

   307 	CCmdEcho();

   308 	void DoWriteL(const TDesC& aDes);

   309 private: // From CCommandBase.

   310 	virtual const TDesC& Name() const;

   311 	virtual void DoRunL();

   312 	virtual void OptionsL(RCommandOptionList& aOptions);

   313 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   314 private:

   315 	enum TAttr

   316 		{

   317 		EBold,

   318 		EUnderscore,

   319 		EBlink,

   320 		EInverse,

   321 		EConceal

   322 		};

   323 private:

   324 	HBufC* iToEcho;

   325 	TBool iToStderr;

   326 	TBool iWrap;

   327 	TUint iIndent;

   328 	RArray<TInt> iAttributes;

   329 	ConsoleAttributes::TColor iForegroundColor;

   330 	ConsoleAttributes::TColor iBackgroundColor;

   331 	TBool iBinaryMode;

   332 	TBool iNoNewline;

   333 	};

   334 

   335 

   336 class CCmdMore : public CCommandBase

   337 	{

   338 public:

   339 	static CCommandBase* NewLC();

   340 	~CCmdMore();

   341 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   342 private:

   343 	CCmdMore();

   344 private: // From CCommandBase.

   345 	virtual const TDesC& Name() const;

   346 	virtual void DoRunL();

   347 private:

   348 	TFileName2 iFile;

   349 	};

   350 

   351 

   352 class CCmdTrace : public CCommandBase

   353 	{

   354 public:

   355 	static CCommandBase* NewLC();

   356 	~CCmdTrace();

   357 private:

   358 	CCmdTrace();

   359 	void PrintConfig();

   360 	TInt SetFlag(const TDesC& aFlagName, TBool aSet);

   361 

   362 private: // From CCommandBase.

   363 	virtual const TDesC& Name() const;

   364 	virtual void DoRunL();

   365 	virtual void OptionsL(RCommandOptionList& aOptions);

   366 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   367 private:

   368 	TUint iMask;

   369 	TUint iIndex;

   370 	TBool iOptF32;

   371 	TBool iOptMultiThread;

   372 	TBool iOptLoader;

   373 	TBool iOptFat;

   374 	TBool iOptLffs;

   375 	TBool iOptIso9660;

   376 	TBool iOptNtfs;

   377 	TBool iOptRofs;

   378 	TBool iOptCompfs;

   379 	RPointerArray<HBufC> iEnable;

   380 	RPointerArray<HBufC> iDisable;

   381 	};

   382 

   383 

   384 class CCmdMemInfo : public CCommandBase

   385 	{

   386 public:

   387 	static CCommandBase* NewLC();

   388 	~CCmdMemInfo();

   389 private:

   390 	CCmdMemInfo();

   391 private: // From CCommandBase.

   392 	virtual const TDesC& Name() const;

   393 	virtual void DoRunL();

   394 	virtual void OptionsL(RCommandOptionList& aOptions);

   395 private:

   396 	void AppendLineL(CTextFormatter& aFormatter, const TDesC& aCaption, HALData::TAttribute aHalAttribute, TBool aNewLine);

   397 private:

   398 	TUint iUpdateRate;

   399 	TBool iHumanReadable;

   400 	TBool iOnlyFreeRam;

   401 	TBool iOnlyTotalRam;

   402 	TInt iLastTotalRamUsage;

   403 	};

   404 

   405 

   406 class CCmdDump : public CCommandBase

   407 	{

   408 public:

   409 	static CCommandBase* NewLC();

   410 	~CCmdDump();

   411 private:

   412 	CCmdDump();

   413 private: // From CCommandBase.

   414 	virtual const TDesC& Name() const;

   415 	virtual void DoRunL();

   416 	virtual void OptionsL(RCommandOptionList& aOptions);

   417 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   418 private:

   419 	RArray<TFileName2> iFileNames;

   420 	TBool iBinaryMode;

   421 	};

   422 

   423 

   424 class CCmdSleep : public CCommandBase

   425 	{

   426 public:

   427 	static CCommandBase* NewLC();

   428 	~CCmdSleep();

   429 private:

   430 	CCmdSleep();

   431 private: // From CCommandBase.

   432 	virtual const TDesC& Name() const;

   433 	virtual void DoRunL();

   434 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   435 private:

   436 	TUint iDuration;

   437 	};

   438 

   439 

   440 class CCmdEnv : public CCommandBase

   441 	{

   442 public:

   443 	static CCommandBase* NewLC();

   444 	~CCmdEnv();

   445 private:

   446 	CCmdEnv();

   447 private: // From CCommandBase.

   448 	virtual const TDesC& Name() const;

   449 	virtual void DoRunL();

   450 	};

   451 

   452 

   453 class CCmdExport : public CCommandBase

   454 	{

   455 public:

   456 	static CCommandBase* NewLC();

   457 	~CCmdExport();

   458 private:

   459 	CCmdExport();

   460 private: // From CCommandBase.

   461 	virtual const TDesC& Name() const;

   462 	virtual void DoRunL();

   463 	virtual void OptionsL(RCommandOptionList& aOptions);

   464 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   465 private:

   466 	HBufC* iKey;

   467 	HBufC* iVal;

   468 	TBool iStdin;

   469 	TBuf<512> iBuf;

   470 	};

   471 

   472 

   473 class CCmdSort : public CCommandBase

   474 	{

   475 public:

   476 	static CCommandBase* NewLC();

   477 	~CCmdSort();

   478 private:

   479 	CCmdSort();

   480 private: // From CCommandBase.

   481 	virtual const TDesC& Name() const;

   482 	virtual void DoRunL();

   483 	virtual void OptionsL(RCommandOptionList& aOptions);

   484 private:

   485 	TBool iReverse;

   486 	};

   487 

   488 

   489 class CCmdExists : public CCommandBase

   490 	{

   491 public:

   492 	static CCommandBase* NewLC();

   493 	~CCmdExists();

   494 private:

   495 	CCmdExists();

   496 private: // From CCommandBase.

   497 	virtual const TDesC& Name() const;

   498 	virtual void DoRunL();

   499 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   500 private:

   501 	TFileName2 iFileName;

   502 	};

   503 

   504 

   505 class CCmdInfoPrint : public CCommandBase

   506 	{

   507 public:

   508 	static CCommandBase* NewLC();

   509 	~CCmdInfoPrint();

   510 private:

   511 	CCmdInfoPrint();

   512 private: // From CCommandBase.

   513 	virtual const TDesC& Name() const;

   514 	virtual void DoRunL();

   515 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   516 private:

   517 	HBufC* iToPrint;

   518 	};

   519 

   520 

   521 class CCmdRDebug : public CCommandBase

   522 	{

   523 public:

   524 	static CCommandBase* NewLC();

   525 	~CCmdRDebug();

   526 private:

   527 	CCmdRDebug();

   528 private: // From CCommandBase.

   529 	virtual const TDesC& Name() const;

   530 	virtual void DoRunL();

   531 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   532 private:

   533 	HBufC* iToPrint;

   534 	};

   535 

   536 

   537 class CCmdDate : public CCommandBase

   538 	{

   539 public:

   540 	static CCommandBase* NewLC();

   541 	~CCmdDate();

   542 private:

   543 	CCmdDate();

   544 	void Display(const TTime& aTime);

   545 private: // From CCommandBase.

   546 	virtual const TDesC& Name() const;

   547 	virtual void DoRunL();

   548 	virtual void OptionsL(RCommandOptionList& aOptions);

   549 private:

   550 	TBool iUniversalTime;

   551 	HBufC* iDateToSet;

   552 	TInt iUtcOffset;

   553 	TBool iSecure;

   554 	TBool iRaw;

   555 	TBool iJustDisplay;

   556 	TInt64 iRawTimeToSet;

   557 	TBool iUseTimestampFormat;

   558 	};

   559 

   560 

   561 class CCmdFsck : public CCommandBase

   562 	{

   563 public:

   564 	static CCommandBase* NewLC();

   565 	~CCmdFsck();

   566 private:

   567 	CCmdFsck();

   568 private: // From CCommandBase.

   569 	virtual const TDesC& Name() const;

   570 	virtual void DoRunL();

   571 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   572 private:

   573 	HBufC* iDriveLetter;

   574 	};

   575 

   576 

   577 class CCmdDriver : public CCommandBase

   578 	{

   579 public:

   580 	static CCommandBase* NewLC();

   581 	~CCmdDriver();

   582 private:

   583 	enum TOperation

   584 		{

   585 		ELoad,

   586 		EFree,

   587 		EFind

   588 		};

   589 	enum TType

   590 		{

   591 		ELogical,

   592 		EPhysical

   593 		};

   594 private:

   595 	CCmdDriver();

   596 private: // From CCommandBase.

   597 	virtual const TDesC& Name() const;

   598 	virtual void DoRunL();

   599 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   600 private:

   601 	TOperation iOperation;

   602 	TType iType;

   603 	HBufC* iDriverName;

   604 	};

   605 

   606 

   607 class CCmdChunkInfo : public CMemoryAccessCommandBase

   608 	{

   609 public:

   610 	static CCommandBase* NewLC();

   611 	~CCmdChunkInfo();

   612 private:

   613 	CCmdChunkInfo();

   614 	void DoPrintL();

   615 	void ListChunksL();

   616 	void PrintChunkInfoL();

   617 	void PrintSizeL(const TDesC& aCaption, TInt aSize);

   618 private: // From CCommandBase.

   619 	virtual const TDesC& Name() const;

   620 	virtual void DoRunL();

   621 	virtual void OptionsL(RCommandOptionList& aOptions);

   622 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   623 private:

   624 	TUint iAddress;

   625 	TUint iUpdateRate;

   626 	TBool iHumanReadable;

   627 	TBool iIncludeSize;

   628 	HBufC* iOwningProcess;

   629 	TUint iControllingProcess;

   630 	TName iName;

   631 	TFullName iFullName;

   632 	CTextFormatter* iFormatter;

   633 	CTextBuffer* iBuf;

   634 	};

   635 

   636 

   637 class CCmdSvrInfo : public CMemoryAccessCommandBase

   638 	{

   639 public:

   640 	static CCommandBase* NewLC();

   641 	~CCmdSvrInfo();

   642 private:

   643 	CCmdSvrInfo();

   644 	void ListServersL();

   645 	void ListSessionsL();

   646 private: // From CCommandBase.

   647 	virtual const TDesC& Name() const;

   648 	virtual void DoRunL();

   649 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   650 private:

   651 	TUint iAddress;

   652 	TName iName;

   653 	TFullName iFullName;

   654 #ifdef FSHELL_MEMORY_ACCESS_SUPPORT

   655 	TServerKernelInfo iServerInfo;

   656 	TThreadKernelInfo iThreadInfo;

   657 	TProcessKernelInfo iProcessInfo;

   658 	TSessionKernelInfo iSessionInfo;

   659 #endif

   660 	CTextFormatter* iFormatter;

   661 	CTextBuffer* iBuf;

   662 	};

   663 

   664 

   665 class CCmdTickle : public CCommandBase

   666 	{

   667 public:

   668 	static CCommandBase* NewLC();

   669 	~CCmdTickle();

   670 private:

   671 	CCmdTickle();

   672 private: // From CCommandBase.

   673 	virtual const TDesC& Name() const;

   674 	virtual void DoRunL();

   675 	};

   676 

   677 

   678 class CCmdTicks : public CCommandBase

   679 	{

   680 public:

   681 	static CCommandBase* NewLC();

   682 	~CCmdTicks();

   683 private:

   684 	CCmdTicks();

   685 private: // From CCommandBase.

   686 	virtual const TDesC& Name() const;

   687 	virtual void DoRunL();

   688 	virtual void OptionsL(RCommandOptionList& aOptions);

   689 private:

   690 	TBool iVerbose;

   691 	};

   692 

   693 

   694 class CCmdUpTime : public CCommandBase

   695 	{

   696 public:

   697 	static CCommandBase* NewLC();

   698 	~CCmdUpTime();

   699 private:

   700 	CCmdUpTime();

   701 private: // From CCommandBase.

   702 	virtual const TDesC& Name() const;

   703 	virtual void DoRunL();

   704 	virtual void OptionsL(RCommandOptionList& aOptions);

   705 private:

   706 	TBool iHuman;

   707 	};

   708 

   709 

   710 class CCmdVar : public CCommandBase

   711 	{

   712 public:

   713 	static CCommandBase* NewLC();

   714 	~CCmdVar();

   715 private:

   716 	CCmdVar();

   717 private: // From CCommandBase.

   718 	virtual const TDesC& Name() const;

   719 	virtual void DoRunL();

   720 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   721 private:

   722 	enum

   723 		{

   724 		EDefined,

   725 		ENotDefined,

   726 		EEqual,

   727 		ENotEqual,

   728 		EAdd,

   729 		ESubtract,

   730 		} iOperation;

   731 	HBufC* iVar1;

   732 	HBufC* iArg;

   733 	};

   734 

   735 

   736 class CCmdSource : public CCommandBase, public MParserObserver

   737 	{

   738 public:

   739 	static CCommandBase* NewLC();

   740 	~CCmdSource();

   741 protected:

   742 	CCmdSource();

   743 private:

   744 	void BackupVarL(const TDesC& aKey, HBufC*& aBuf);

   745 	void RestoreVarL(const TDesC& aKey, const HBufC* aBuf);

   746 protected: // From CCommandBase.

   747 	virtual const TDesC& Name() const;

   748 	virtual void DoRunL();

   749 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   750 	virtual void OptionsL(RCommandOptionList& aOptions);

   751 private: // From MParserObserver.

   752 	virtual void HandleParserComplete(CParser& aParser, const TError& aError);

   753 protected:

   754 	TFileName2 iFileName;

   755 	HBufC* iArgs;

   756 	TBool iKeepGoing;

   757 	HBufC* iScriptData;

   758 	CParser* iParser;

   759 	};

   760 

   761 

   762 class CCmdStart : public CCommandBase

   763 	{

   764 public:

   765 	static CCommandBase* NewLC();

   766 	~CCmdStart();

   767 private:

   768 	CCmdStart();

   769 private: // From CCommandBase.

   770 	virtual const TDesC& Name() const;

   771 	virtual void DoRunL();

   772 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   773 	virtual void OptionsL(RCommandOptionList& aOptions);

   774 private:

   775 	TBool iRendezvous;

   776 	TBool iWait;

   777 	TInt iTimeout;

   778 	HBufC* iExe;

   779 	HBufC* iCommandLine;

   780 	TBool iMeasure;

   781 	};

   782 

   783 

   784 class CCmdCompare : public CCommandBase

   785 	{

   786 public:

   787 	static CCommandBase* NewLC();

   788 	~CCmdCompare();

   789 private:

   790 	CCmdCompare();

   791 private: // From CCommandBase.

   792 	virtual const TDesC& Name() const;

   793 	virtual void DoRunL();

   794 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   795 	virtual void OptionsL(RCommandOptionList& aOptions);

   796 private:

   797 	TFileName2 iFileName1;

   798 	TFileName2 iFileName2;

   799 	TBool iVerbose;

   800 	};

   801 

   802 

   803 class CCmdTime : public CCommandBase, public MParserObserver

   804 	{

   805 public:

   806 	static CCommandBase* NewLC();

   807 	~CCmdTime();

   808 private:

   809 	CCmdTime();

   810 	void NextIterationL();

   811 private: // From CCommandBase.

   812 	virtual const TDesC& Name() const;

   813 	virtual void DoRunL();

   814 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   815 	virtual void OptionsL(RCommandOptionList& aOptions);

   816 private: // From MParserObserver.

   817 	virtual void HandleParserComplete(CParser& aParser, const TError& aError);

   818 private:

   819 	HBufC* iCommandLine;

   820 	TUint32 iCountBefore;

   821 	CParser* iParser;

   822 	TBool iHuman;

   823 	TBool iFastCounter;

   824 	TInt iRepeatCount;

   825 	TInt iIteration;

   826 	TUint64 iTotalTime;

   827 	};

   828 

   829 

   830 class CCmdRepeat : public CCommandBase, public MParserObserver

   831 	{

   832 public:

   833 	static CCommandBase* NewLC();

   834 	~CCmdRepeat();

   835 private:

   836 	CCmdRepeat();

   837 	void CreateParserL();

   838 	void HandleParserCompleteL(const TError& aError);

   839 private: // From CCommandBase.

   840 	virtual const TDesC& Name() const;

   841 	virtual void DoRunL();

   842 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   843 	virtual void OptionsL(RCommandOptionList& aOptions);

   844 private: // From MParserObserver.

   845 	virtual void HandleParserComplete(CParser& aParser, const TError& aError);

   846 private:

   847 	HBufC* iCommandLine;

   848 	CParser* iParser;

   849 	TUint iCount;

   850 	TUint iNumRepeats;

   851 	TBool iKeepGoing;

   852 	TBool iForever;

   853 	TInt iWaitTime;

   854 	};

   855 

   856 

   857 class CCmdDebug : public CCommandBase, public MParserObserver

   858 	{

   859 public:

   860 	static CCommandBase* NewLC();

   861 	~CCmdDebug();

   862 private:

   863 	CCmdDebug();

   864 	void InteractL(const TDesC& aExpandedLine);

   865 private: // From CCommandBase.

   866 	virtual const TDesC& Name() const;

   867 	virtual void DoRunL();

   868 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   869 	virtual void OptionsL(RCommandOptionList& aOptions);

   870 private: // From MParserObserver.

   871 	virtual void HandleParserComplete(CParser& aParser, const TError& aError);

   872 	virtual void AboutToExecuteLine(const TDesC& aOrignalLine, const TDesC& aExpandedLine);

   873 	virtual void LineReturned(TInt aError);

   874 private:

   875 	TFileName2 iFileName;

   876 	HBufC* iArgs;

   877 	TBool iKeepGoing;

   878 	HBufC* iScriptData;

   879 	CParser* iParser;

   880 	};

   881 

   882 

   883 class CCmdReadMem : public CMemoryAccessCommandBase

   884 	{

   885 public:

   886 	static CCommandBase* NewLC();

   887 	~CCmdReadMem();

   888 private:

   889 	CCmdReadMem();

   890 private: // From CCommandBase.

   891 	virtual const TDesC& Name() const;

   892 	virtual void DoRunL();

   893 	virtual void OptionsL(RCommandOptionList& aOptions);

   894 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   895 private:

   896 	TUint iAddress;

   897 	TUint iSize;

   898 	TFileName2 iFileName;

   899 	TInt iThreadId;

   900 	RFile iFile;

   901 	};

   902 

   903 

   904 class CCmdE32Header : public CCommandBase

   905 	{

   906 public:

   907 	static CCommandBase* NewLC();

   908 	~CCmdE32Header();

   909 private:

   910 	CCmdE32Header();

   911 private: // From CCommandBase.

   912 	virtual const TDesC& Name() const;

   913 	virtual void DoRunL();

   914 	virtual void OptionsL(RCommandOptionList& aOptions);

   915 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   916 private:

   917 	TFileName2 iFileName;

   918 	TBool iXip;

   919 	TBool iNotXip;

   920 	CTextFormatter* iFormatter;

   921 	};

   922 

   923 

   924 class CCmdObjInfo : public CMemoryAccessCommandBase

   925 	{

   926 public:

   927 	static CCommandBase* NewLC();

   928 	~CCmdObjInfo();

   929 private:

   930 	CCmdObjInfo();

   931 	void PrintObjectDetailsL(TUint aObjectAddress);

   932 	void PrintObjectReferencersL(TUint aObjectAddress);

   933 	void PrintReferencedObjectDetailsL(TOwnerType aOwnerType, TUint aId);

   934 private: // From CCommandBase.

   935 	virtual const TDesC& Name() const;

   936 	virtual void DoRunL();

   937 	virtual void OptionsL(RCommandOptionList& aOptions);

   938 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   939 private:

   940 	TUint iObjectAddress;

   941 	TBool iReferencers;

   942 	TUint iProcessId;

   943 	TUint iThreadId;

   944 	TBool iAll;

   945 	};

   946 

   947 class CCmdTouch : public CCommandBase

   948 	{

   949 public:

   950 	static CCommandBase* NewLC();

   951 	~CCmdTouch();

   952 private:

   953 	CCmdTouch();

   954 private: // From CCommandBase.

   955 	virtual const TDesC& Name() const;

   956 	virtual void DoRunL();

   957 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   958 private:

   959 	TFileName2 iFileName;

   960 	};

   961 

   962 class CCmdDialog : public CCommandBase

   963 	{

   964 public:

   965 	static CCommandBase* NewLC();

   966 	~CCmdDialog();

   967 private:

   968 	enum TMode

   969 		{

   970 		EModeNotifier,

   971 		EModeConsole,

   972 		EModeNull

   973 		};

   974 private:

   975 	CCmdDialog();

   976 	TMode ModeL() const;

   977 	void ClearLineL(RIoConsoleWriteHandle& aWriteHandle);

   978 private: // From CCommandBase.

   979 	virtual const TDesC& Name() const;

   980 	virtual void DoRunL();

   981 	virtual void OptionsL(RCommandOptionList& aOptions);

   982 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

   983 private:

   984 	HBufC* iTitle;

   985 	HBufC* iBody;

   986 	HBufC* iButton1;

   987 	HBufC* iButton2;

   988 	};

   989 

   990 #ifdef __WINS__

   991 

   992 class CCmdJit : public CCommandBase

   993 	{

   994 public:

   995 	static CCommandBase* NewLC();

   996 	~CCmdJit();

   997 private:

   998 	CCmdJit();

   999 private: // From CCommandBase.

  1000 	virtual const TDesC& Name() const;

  1001 	virtual void DoRunL();

  1002 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

  1003 private:

  1004 	enum

  1005 		{

  1006 		EStatus,

  1007 		EOn,

  1008 		EOff

  1009 		} iOperation;

  1010 	};

  1011 

  1012 #endif // __WINS__

  1013 

  1014 class CCmdConsole : public CCommandBase

  1015 	{

  1016 public:

  1017 	static CCommandBase* NewLC();

  1018 	~CCmdConsole();

  1019 private:

  1020 	CCmdConsole();

  1021 private: // From CCommandBase.

  1022 	virtual const TDesC& Name() const;

  1023 	virtual void DoRunL();

  1024 	virtual void OptionsL(RCommandOptionList& aOptions);

  1025 private:

  1026 	TBool iVerbose;

  1027 	TBool iIsRemote;

  1028 	TBool iIsNull;

  1029 	};

  1030 	

  1031 class CCmdPcons : public CCommandBase

  1032 	{

  1033 public:

  1034 	static CCommandBase* NewLC();

  1035 	~CCmdPcons();

  1036 private:

  1037 	CCmdPcons();

  1038 private: // From CCommandBase.

  1039 	virtual const TDesC& Name() const;

  1040 	virtual void DoRunL();

  1041 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

  1042 	virtual void OptionsL(RCommandOptionList& aOptions);

  1043 	

  1044 	void CreateL(RIoPersistentConsole& aPcons);

  1045 	void AttachL(RIoPersistentConsole& aPcons, const TDesC& aNewOrExisting, TBool aForce);

  1046 	TInt DoAttach(RIoPersistentConsole& aPcons, RIoConsole& aNew, RIoPersistentConsole::TCloseBehaviour aOnClose);

  1047 private:

  1048 	enum

  1049 		{

  1050 		EList,

  1051 		ENew,

  1052 		EConnect,

  1053 		EStart,

  1054 		EDisconnect,

  1055 		} iOperation;

  1056 	HBufC* iName;

  1057 	HBufC* iCommand;

  1058 	HBufC* iCommandArgs;

  1059 	TBool iVerbose;

  1060 	};

  1061 

  1062 class CCmdIoInfo : public CCommandBase

  1063 	{

  1064 public:

  1065 	static CCommandBase* NewLC();

  1066 	~CCmdIoInfo();

  1067 private:

  1068 	CCmdIoInfo();

  1069 private: // From CCommandBase.

  1070 	virtual const TDesC& Name() const;

  1071 	virtual void DoRunL();

  1072 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

  1073 	virtual void OptionsL(RCommandOptionList& aOptions);

  1074 private:

  1075 	RIoHandle::TType iObjectType;

  1076 	HBufC* iMatchString;

  1077 	};

  1078 

  1079 class CCmdReattach : public CCommandBase

  1080 	{

  1081 public:

  1082 	static CCommandBase* NewLC();

  1083 	~CCmdReattach();

  1084 private:

  1085 	CCmdReattach();

  1086 	void OpenEndPointLC(RIoEndPoint& aEndPoint, const TDesC& aName);

  1087 private: // From CCommandBase.

  1088 	virtual const TDesC& Name() const;

  1089 	virtual void DoRunL();

  1090 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

  1091 private:

  1092 	HBufC* iJobSpec;

  1093 	HBufC* iStdinEndPointName;

  1094 	HBufC* iStdoutEndPointName;

  1095 	HBufC* iStderrEndPointName;

  1096 	};

  1097 

  1098 class CCmdDisown : public CCommandBase

  1099 	{

  1100 public:

  1101 	static CCommandBase* NewLC();

  1102 	~CCmdDisown();

  1103 private:

  1104 	CCmdDisown();

  1105 private: // From CCommandBase.

  1106 	virtual const TDesC& Name() const;

  1107 	virtual void DoRunL();

  1108 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

  1109 private:

  1110 	HBufC* iJobSpec;

  1111 	};

  1112 

  1113 class CCmdDebugPort : public CMemoryAccessCommandBase

  1114 	{

  1115 public:

  1116 	static CCommandBase* NewLC();

  1117 	~CCmdDebugPort();

  1118 private:

  1119 	CCmdDebugPort();

  1120 private: // From CCommandBase.

  1121 	virtual const TDesC& Name() const;

  1122 	virtual void DoRunL();

  1123 	virtual void ArgumentsL(RCommandArgumentList& aArguments);

  1124 	virtual void OptionsL(RCommandOptionList& aOptions);

  1125 private:

  1126 	TInt iPort;

  1127 	TBool iForce;

  1128 	};

  1129 

  1130 class CCmdRom : public CCommandBase

  1131 	{

  1132 public:

  1133 	static CCommandBase* NewLC();

  1134 	~CCmdRom();