home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / LiterateA.h < prev    next >
C/C++ Source or Header  |  1998-08-21  |  6KB  |  192 lines
  1. // $Id: LiterateA.h,v 1.16 1998/08/21 10:21:50 zeller Exp $
  2. // Agent interface on a callback basis
  3.  
  4. // Copyright (C) 1995-1997 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _DDD_LiterateAgent_h
  30. #define _DDD_LiterateAgent_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36. /*
  37.     LiterateAgent(app_context, p) opens an asynchronous three-way communication
  38.     channel to the agent p (see Agent, AsyncAgent).
  39.  
  40.     Communication with the agent is achieved by writing data
  41.     to the agent (write()).
  42.  
  43.     Each LiterateAgent can be associated with handlers for the events
  44.     defined in Agent, plus:
  45.     LiterateAgent::Output -- data was written to the agent
  46.     LiterateAgent::Input  -- data was received from the agent
  47.     LiterateAgent::Error  -- data was received from the agent's stderr
  48.  
  49.     A handler takes the form
  50.     void handler(Agent *source, void *client_data, void *call_data)
  51.     where source is the agent causing the event,
  52.     DataLength *d = (DataLength *)call_data is the data sent or received,
  53.     and client_data is arbitrary data passed to addHandler() when
  54.     the handler was added.
  55.  
  56.     This class dispatches data to handlers as soon as it is available.
  57.     Use a more elaborate subclass to dispatch data in appropriate units.
  58. */
  59.  
  60. #include "assert.h"
  61. #include <stdio.h>
  62. #include <string.h>
  63. #include "strclass.h"
  64.  
  65. #include "AsyncAgent.h"
  66. #include "DataLength.h"
  67.  
  68.  
  69. // Event types
  70. const unsigned Ready  = AsyncAgent_NTypes; // Ready for output
  71. const unsigned Output = Ready + 1;         // Output written
  72. const unsigned Input  = Output + 1;        // Input read
  73. const unsigned Error  = Input + 1;       // Error read
  74.  
  75. const unsigned LiterateAgent_NTypes = Error + 1; // number of events
  76.  
  77.  
  78. class LiterateAgent: public AsyncAgent {
  79. public:
  80.     DECLARE_TYPE_INFO
  81.  
  82. private:
  83.     bool activeIO;        // Flag: I/O handlers active?
  84.     void _activateIO();         // activate I/O handlers
  85.     void _deactivateIO();       // deactivate I/O handlers
  86.  
  87.     virtual void activateIO()   
  88.     {
  89.     if (!activeIO) 
  90.     {
  91.         _activateIO();
  92.         activeIO = true; 
  93.     }
  94.     }
  95.     virtual void deactivateIO() 
  96.     {
  97.     if (activeIO) 
  98.     {
  99.         _deactivateIO();
  100.         activeIO = false; 
  101.     }
  102.     }
  103.  
  104.     int _read(char*& data, FILE *fp); // Simple read function
  105.     int _readNonBlocking(char* data, int size, FILE *fp); // Read what's there
  106.  
  107.     // Event Handlers
  108.     static void outputReady(AsyncAgent *c);
  109.     static void inputReady(AsyncAgent *c);
  110.     static void errorReady(AsyncAgent *c);
  111.  
  112.     // Flag: do we want TTYs to be read in blocking mode?
  113.     bool _block_tty_input;
  114.  
  115.     // Return default value for _block_tty_input
  116.     static bool default_block_tty_input();
  117.  
  118. public:
  119.     // Resources
  120.     bool block_tty_input() const     { return _block_tty_input; }
  121.     bool block_tty_input(bool state) { return _block_tty_input = state; }
  122.  
  123. protected:
  124.     // Input data handling
  125.     int readInput(char*& data);
  126.     virtual int _readInput(char *& data);
  127.     virtual void readAndDispatchInput(bool expectEOF = false);
  128.  
  129.     // Error data handling
  130.     int readError(char*& data);
  131.     virtual int _readError(char *& data);
  132.     virtual void readAndDispatchError(bool expectEOF = false);
  133.  
  134.     // Event management
  135.     virtual void dispatch(int type, char *data, int length); // dispatch data
  136.  
  137.     // Called when handlers were changed
  138.     void handlerChange();
  139.  
  140.     // Check if fp is a tty and wants blocking input
  141.     bool blocking_tty(FILE *fp) const
  142.     {
  143.     return block_tty_input() && isatty(fileno(fp));
  144.     }
  145.  
  146. public:
  147.     // Constructor for Agent users
  148.     LiterateAgent(XtAppContext app_context, const string& pth,
  149.           unsigned nTypes = LiterateAgent_NTypes):
  150.     AsyncAgent(app_context, pth, nTypes), activeIO(false),
  151.     _block_tty_input(default_block_tty_input())
  152.     {}
  153.  
  154.     // Constructor for Agent writers
  155.     LiterateAgent(XtAppContext app_context, FILE *in = stdin,
  156.           FILE *out = stdout, FILE *err = 0, 
  157.           unsigned nTypes = LiterateAgent_NTypes):
  158.     AsyncAgent(app_context, in, out, err, nTypes), activeIO(false),
  159.     // When reading from stdin, always block TTY input.
  160.     _block_tty_input(in == stdin || default_block_tty_input())
  161.     {}
  162.  
  163.     // "Dummy" Constructor without any communication
  164.     LiterateAgent(XtAppContext app_context, bool dummy,
  165.           unsigned nTypes = LiterateAgent_NTypes):
  166.     AsyncAgent(app_context, dummy, nTypes), activeIO(false),
  167.     _block_tty_input(default_block_tty_input())
  168.     {}
  169.  
  170.     // Duplicator
  171.     LiterateAgent(const LiterateAgent& lit)
  172.     : AsyncAgent(lit), activeIO(lit.activeIO),
  173.       _block_tty_input(lit.block_tty_input())
  174.     {}
  175.     virtual Agent *dup() const { return new LiterateAgent(*this); }
  176.  
  177.     // Output data handling
  178.     virtual int write(const char *data, int length);
  179.  
  180.     // Flush output
  181.     int flush();
  182.  
  183.     // Starter
  184.     virtual void start();
  185.     
  186.     // Terminator
  187.     virtual void abort();
  188. };
  189.  
  190. #endif // _DDD_LiterateAgent_h
  191. // DON'T ADD ANYTHING BEHIND THIS #endif
  192.