home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tlx501.zip / SRC / BATCHAPP.CPP < prev    next >
C/C++ Source or Header  |  1996-07-08  |  7KB  |  208 lines
  1. /****************************************************************************
  2.     $Id: batchapp.cpp 501.0 1995/03/07 12:26:06 RON Exp $
  3.  
  4.     Copyright (c) 1991-95 Tarma Software Research. All rights reserved.
  5.  
  6.     Project:    Tarma Library for C++ V5.0
  7.     Author:    Ron van der Wal
  8.  
  9.     Implementation of class TLBatchApp.
  10.  
  11.     $Log: batchapp.cpp $
  12.     Revision 501.0  1995/03/07 12:26:06  RON
  13.     Updated for TLX 5.01
  14.     Revision 1.8  1995/01/31 16:30:02  RON
  15.     Update for release 012
  16.     Added partial support for SunPro C++ compiler
  17.     Revision 1.7  1995/01/06  15:57:23  ron
  18.     Corrected Revision keyword
  19.  
  20.     Revision 1.6  1994/11/16  15:35:57  ron
  21.     Added module info; rearranged #include directives
  22.  
  23.     Revision 1.5  1994/10/05  18:33:32  ron
  24.     Renamed TLx...() functions to tl...()
  25.  
  26.     Revision 1.4  1994/09/28  14:12:37  ron
  27.     Removed Macintosh-style #include references
  28.  
  29.     Revision 1.3  1994/09/27  20:21:56  ron
  30.     Changed path separator from / to \
  31.  
  32.     Revision 1.2  1994/09/26  15:38:36  ron
  33.     Changed include file references
  34.  
  35.     Revision 1.1  1994/08/16  18:12:52  ron
  36.     Initial revision
  37.  
  38. ****************************************************************************/
  39.  
  40. #include <tlx\501\_build.h>
  41.  
  42. TLX_MODULE_INFO("$Revision: 501.0 $");
  43.  
  44. //----- System headers
  45.  
  46. #ifdef _TLXDBG
  47. #include <iostream.h>
  48. #endif
  49.  
  50. //----- Project headers
  51.  
  52. #include <tlx\501\cmdapp.h>
  53.  
  54. /*-------------------------------------------------------------------------*/
  55.     TLBatchApp::TLBatchApp(int argc, char *argv[], const char *ver)
  56.  
  57. /*  Initializes the application from main()'s command line arguments.
  58. ---------------------------------------------------------------------------*/
  59. : mArgCnt(argc), mArgs(argv), mVersion(ver)
  60. {
  61.     mCurArg  = 1;        // Skip program name
  62.     mDone    =
  63.     mRetCode = 0;
  64. }
  65.  
  66. /*-------------------------------------------------------------------------*/
  67.     TLBatchApp::~TLBatchApp()
  68.  
  69. /*  Destructor. Declared virtual for derivation.
  70. ---------------------------------------------------------------------------*/
  71. {
  72. }
  73.  
  74. /*-------------------------------------------------------------------------*/
  75.     void TLBatchApp::Abort(int ret)
  76.  
  77. /*  Called when the application must exit prematurely and without
  78.     postprocessing.
  79. ---------------------------------------------------------------------------*/
  80. {
  81.     mDone = -1;        // Negative value indicates quick exit
  82.     mRetCode = ret;
  83. }
  84.  
  85. /*-------------------------------------------------------------------------*/
  86.     void TLBatchApp::DoFile(const char *fname)
  87.  
  88. /*  Called to handle the next file on the command line. The debugging
  89.     version of the default implementation simply prints the file name
  90.     on cout.
  91. ---------------------------------------------------------------------------*/
  92. {
  93. #ifdef NDEBUG
  94.     (void)fname;
  95. #else
  96.     cout << "\tFile\t= " << fname << "\n";
  97. #endif
  98. }
  99.  
  100. /*-------------------------------------------------------------------------*/
  101.     void TLBatchApp::DoOption(const char *opt)
  102.  
  103. /*  Called to handle the next option on the command line. The debugging
  104.     version of the default implementation simply prints the option on cout.
  105. ---------------------------------------------------------------------------*/
  106. {
  107. #ifdef NDEBUG
  108.     (void)opt;
  109. #else
  110.     cout << "\tOption\t= " << opt << "\n";
  111. #endif
  112. }
  113.  
  114. /*-------------------------------------------------------------------------*/
  115.     bool TLBatchApp::PostProcess()
  116.  
  117. /*  Optional postprocessing, should return nonzero on success.
  118. ---------------------------------------------------------------------------*/
  119. {
  120.     return true;
  121. }
  122.  
  123. /*-------------------------------------------------------------------------*/
  124.     bool TLBatchApp::PreProcess()
  125.  
  126. /*  Optional preprocessing, should return nonzero on success.
  127. ---------------------------------------------------------------------------*/
  128. {
  129.     return true;
  130. }
  131.  
  132. /*-------------------------------------------------------------------------*/
  133.     void TLBatchApp::PrintLogo()
  134.  
  135. /*  Called to print the log-on message for the application.
  136. ---------------------------------------------------------------------------*/
  137. {
  138. }
  139.  
  140. /*-------------------------------------------------------------------------*/
  141.     void TLBatchApp::PrintSyntax()
  142.  
  143. /*  Called to print a syntax summary for the command in case of an error.
  144. ---------------------------------------------------------------------------*/
  145. {
  146. }
  147.  
  148. /*-------------------------------------------------------------------------*/
  149.     int TLBatchApp::Run()
  150.  
  151. /*  The main routine. This function contains calls to preprocessing and
  152.     postprocessing functions and the main loop.
  153. ---------------------------------------------------------------------------*/
  154. {
  155.     PrintLogo();            // Make ourselves known
  156.  
  157.     if (!PreProcess()) return -1;    // Terminate early
  158.  
  159.     // Start the main loop, dealing with options and filenames as they
  160.     // come along. Note that there is no objection against other routines
  161.     // manipulating the '_args' sequence as well, in particular if they
  162.     // need to advance its internal iterator.
  163.  
  164.     mDone   = mRetCode = 0;
  165.     mCurArg = 1;
  166.  
  167.     while (!mDone && mArgs[mCurArg])
  168.     {
  169.     if (tlIsOption(mArgs[mCurArg]))
  170.         DoOption(mArgs[mCurArg]);
  171.     else
  172.         DoFile(mArgs[mCurArg]);
  173.  
  174.     ++mCurArg;            // Advance iterator
  175.     }
  176.  
  177.     // If the main loop finished because of premature termination through
  178.     // terminate(), mDone will be < 0 and we don't want any postprocessing.
  179.  
  180.     if (mDone >= 0) PostProcess();
  181.  
  182.     return mRetCode;
  183. }
  184.  
  185. /*-------------------------------------------------------------------------*/
  186.     void TLBatchApp::SetRetCode(int ret)
  187.  
  188. /*  Sets the return code for the application without terminating it in
  189.     any way.
  190. ---------------------------------------------------------------------------*/
  191. {
  192.     mRetCode = ret;
  193. }
  194.  
  195. /*-------------------------------------------------------------------------*/
  196.     void TLBatchApp::Terminate(int ret)
  197.  
  198. /*  Called when the application must exit prematurely, but in an orderly
  199.     fashion, i.e. with postprocessing. It is not normally necessary to
  200.     call this function, since the main loop will terminate when it has
  201.     exhausted the program's arguments.
  202. ---------------------------------------------------------------------------*/
  203. {
  204.     mDone = 1;        // Positive value indicates graceful exit
  205.     mRetCode = ret;
  206. }
  207.  
  208.