DOC HOME SITE MAP MAN PAGES GNU INFO SEARCH PRINT BOOK
 
An Objection Class for Rudimentary Error Handling - Objection(C++)

Superseding an Objection

The approach taken by the client programmer in the last section has one drawback: MAXINT may actually be a valid element of the stack but will be skipped in the process of printing. Another solution to the overflow problem is to ask the library to appoint the following initial handler to handle Stack::overflow Objections:

      int dec_pnum(const char*) // won't use error message
      {
          extern int pnum;
          pnum--;
          return 1;
      }

This initial handler decrements pnum whenever an integer is push()'ed onto a full stack to offset the fact that it will be incremented upon return to silly_routine(). dec_pnum() returns a non- zero integer to ensure that the subsequent handler is bypassed and the recovery action takes place. silly_routine() now becomes:

      void silly_routine()
      {
          Stack::overflow.appoint(dec_pnum);  // added line
          int i;
          while( cin >> i ) {
              st.push(i);
              pnum++;
          }
          while(pnum > 0) {
              cout << st.pop() << "\ n";
              pnum--;
          }
      }

Now, the program will not abort; and MAXINT can be recognized as a valid element of the Stack.

On the other hand, let's assume that the client programmer feels that continuing the program is useless if the contents of the entire file have not been read in. The programmer really wants the program to abort on any error, but would like to save some information before it happens. One solution is to define an initial handler called cleanup(), which prints the current contents of the stack:

      int cleanup(const char* msg)
      {
          extern int pnum;
          extern Stack st;
          // error message from library
          cerr << msg << ": cleaning up\ n";
          while(pnum > 0) {
              cout << st.pop() << "\ n";
              pnum--;
          }
          return 0;
      }

and appoint it to handle overflow errors as follows:

      void silly_routine()
      {
          Stack::overflow.appoint(cleanup);   // added line
          int i;
          while( cin >> i ) {
              st.push(i);
              pnum++;
          }
          while(pnum > 0) {
              cout << st.pop() << "\ n";
              pnum--;
          }
      }

The cleanup() initial handler returns 0 so that the subsequent handler (the default action error(), which calls abort()) will take place upon return. It could also have chosen to exit or abort after printing the stack, so that neither the subsequent handler default action nor the recovery action would take place.


Next topic: Changing Actions Midstream
Previous topic: Ignoring an Objection

© 2005 The SCO Group, Inc. All rights reserved.
SCO OpenServer Release 6.0.0 -- 02 June 2005