コミット: 2fe2646c69cf31bcd03721ac35f7f56816712fdf - mingw-get (git)

The MinGW.org Installation Manager Tool

コミットメタ情報

• リビジョン: 2fe2646c69cf31bcd03721ac35f7f56816712fdf (tree)
• 日時: 2012-12-05 22:50:11
• 作者: Keith Marshall <keithmarshall@user...>
• コミッター: Keith Marshall

ログメッセージ

Implement PTY display emulation for GUI mode DMH.

変更サマリ

• modified: ChangeLog
• modified: src/dmh.cpp
• modified: src/dmhcore.h
• modified: src/guidmh.cpp

差分

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,26 @@
[phone]  Keith Marshall  <[e-mail]>
+
+	Implement PTY display emulation for GUI mode DMH.
+
+	* src/dmhcore.h (dmhTypeGeneric::set_console_hook): New public virtual
+	method; declare it, providing inline default do-nothing implementation.
+	(dmhTypeGeneric::severity_tag): New protected static method; declare it.
+	(dmhTypeGeneric::notification_format): New protected static property;
+	declare it.
+
+	* src/dmh.cpp (dmhTypeGeneric::severity_tag): Implement it.
+	(dmhTypeGeneric::notification_format): Define and initialise it.
+	(dmhTypeTTY::notify): Use them.
+	(dmh_setpty): New function; declare prototype and implement it.
+
+	* src/guidmh.cpp (dmhTypePTY): New locally implemented class.
+	(dmhTypeGUI::set_console_hook): New virtual method; declare and
+	implement it; it stores a dmhTypePTY reference pointer into...
+	(dmhTypeGUI::console_hook): ...this new private member variable.
+	(dmhTypeGUI::dmhTypeGUI): Initialise it.
+	(dmhTypeGUI::notify) [console_hook != NULL]: Delegate to it.
+	(dmhTypeGUI::printf) [console_hook != NULL]: Likewise.
+
 2012-12-03  Keith Marshall  <[e-mail]>
 
 	Implement generalised API for dialogue boxes with worker threads.

--- a/src/dmh.cpp
+++ b/src/dmh.cpp
@@ -34,6 +34,12 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+/* Prototype this at point of use, rather than in dmhcore.h,
+ * so that we don't need to arbitrarily include windows.h in
+ * any DMH client.
+ */
+EXTERN_C void dmh_setpty( HWND );
+
 /* Implementation of the dmh_exception class.
  */
 static const char *unspecified_error = "Unspecified error";
@@ -161,9 +167,9 @@ inline int dmhTypeTTY::emit_and_flush( int status )
   return status;
 }
 
-int dmhTypeTTY::notify( const dmh_severity code, const char *fmt, va_list argv )
+const char *dmhTypeGeneric::severity_tag( dmh_severity code )
 {
-  /* Message dispatcher for console class applications.
+  /* Helper function to assign labels to the known severity codes.
    */
   static const char *severity[] =
   {
@@ -174,13 +180,24 @@ int dmhTypeTTY::notify( const dmh_severity code, const char *fmt, va_list argv )
     "ERROR",		/* DMH_ERROR */
     "FATAL"		/* DMH_FATAL */
   };
+  return severity[code];
+}
+
+/* Establish the format to be used for the prefix string, which is
+ * attached to TTY and PTY notifications.
+ */
+const char *dmhTypeGeneric::notification_format = "%s: *** %s *** ";
 
+int dmhTypeTTY::notify( const dmh_severity code, const char *fmt, va_list argv )
+{
+  /* Message dispatcher for console class applications.
+   */
   /* Dispatch the message to standard error, terminate application
    * if DMH_FATAL, else continue, returning the message length.
    */
   return abort_if_fatal( code,
       emit_and_flush(
-	fprintf( stderr, "%s: *** %s *** ", progname, severity[code] )
+	fprintf( stderr, notification_format, progname, severity_tag( code ) )
 	+ vfprintf( stderr, fmt, argv )
 	)
       );
@@ -196,9 +213,21 @@ int dmhTypeTTY::printf( const char *fmt, va_list argv )
 
 EXTERN_C uint16_t dmh_control( const uint16_t request, const uint16_t mask )
 {
+  /* Public helper to access and manipulate the control channel for
+   * the diagnostic message handler.
+   */
   return dmh->control( request, mask );
 }
 
+EXTERN_C void dmh_setpty( HWND console )
+{
+  /* Public API for assignment of a GUI window as a pseudo-console
+   * for streaming of diagnostic message handler output; ("console"
+   * is assumed to refer to a Windows EDITTEXT control).
+   */
+  dmh->set_console_hook( (void *)(console) );
+}
+
 EXTERN_C int dmh_notify( const dmh_severity code, const char *fmt, ... )
 {
   /* Public entry point for diagnostic message dispatcher.

--- a/src/dmhcore.h
+++ b/src/dmhcore.h
@@ -36,12 +36,15 @@ class dmhTypeGeneric
    */
   public:
     dmhTypeGeneric( const char* );
+    virtual void set_console_hook( void * ){}
     virtual uint16_t control( const uint16_t, const uint16_t ) = 0;
     virtual int notify( const dmh_severity, const char*, va_list ) = 0;
     virtual int printf( const char*, va_list ) = 0;
 
   protected:
     const char *progname;
+    static const char *severity_tag( dmh_severity );
+    static const char *notification_format;
 };
 
 #endif /* DMHCORE_H: $RCSfile$: end of file */

--- a/src/guidmh.cpp
+++ b/src/guidmh.cpp
@@ -34,6 +34,217 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
+/* Establish limits on the buffer size for any EDITTEXT control which is
+ * used to emulate the VDU device of a pseudo-TTY diagnostic console.
+ */
+#define DMH_PTY_MIN_BUFSIZ   4096
+#define DMH_PTY_MAX_BUFSIZ  32768
+
+class dmhTypePTY
+{
+  /* An auxiliary class, which may be associated with a DMH controller,
+   * to control the emulated VDU device of a pseudo-TTY console.
+   */
+  public:
+    dmhTypePTY( HWND );
+    int printf( const char *, va_list );
+    ~dmhTypePTY();
+
+  private:
+    HWND console_hook;
+    static HFONT console_font;
+    char *console_buffer, *caret; size_t max;
+    int putchar( int );
+};
+
+/* When we assign an emulated PTY display to a DMH data stream, in a
+ * GUI context, we will wish to also assign a monospaced font object,
+ * (Lucida Console, for preference).  We will create this font object
+ * once, on making the first PTY assignment, and will maintain this
+ * static reference to locate it; we initialise the reference to NULL,
+ * indicating the requirement to create the font object.
+ */
+HFONT dmhTypePTY::console_font = NULL;
+
+static int CALLBACK dmhWordBreak( const char *buf, int cur, int max, int op )
+{
+  /* This trivial word-break call-back is assigned in place of the default
+   * handler for any EDITTEXT control used as a pseudo-TTY; it emulates the
+   * behaviour of a dumb VT-100 display, wrapping text at the right extent
+   * of the "screen", regardless of proximity to any natural word-break.
+   *
+   * Note that this call-back function must conform to the prototype which
+   * has been specified by Microsoft, even though it uses neither the "buf"
+   * nor the "max" arguments; we simply confirm, on request, that each and
+   * every character in "buf" may be considered as a word-break delimiter,
+   * and that the "cur" position in "buf" is a potential word-break point.
+   */
+  return (op == WB_ISDELIMITER) ? TRUE : cur;
+}
+
+dmhTypePTY::dmhTypePTY( HWND console ): console_hook( console )
+{
+  /* Construct a PTY controller and assign it to the EDITTEXT control which
+   * we assume, without checking, has been passed as "console".
+   */
+  if( console_font == NULL )
+  {
+    /* The font object for use with PTY diagnostic streams has yet to be
+     * created; create it now.
+     */
+    LOGFONT font_info;
+    console_font = (HFONT)(SendMessage( console, WM_GETFONT, 0, 0 ));
+    GetObject( console_font, sizeof( LOGFONT ), &font_info );
+    strcpy( (char *)(&(font_info.lfFaceName)), "Lucida Console" );
+    font_info.lfHeight = (font_info.lfHeight * 9) / 10;
+    font_info.lfWidth = (font_info.lfWidth * 9) / 10;
+    console_font = CreateFontIndirect( &font_info );
+  }
+  if( console_font != NULL )
+    /*
+     * When we have a valid font object, we instruct the EDITTEXT control
+     * to use it, within its device context.
+     */
+    SendMessage( console, WM_SETFONT, (WPARAM)(console_font), TRUE );
+
+  /* Override the default EDITTEXT word-wrapping behaviour, so that we
+   * more accurately emulate the display behaviour of a VT-100 device.
+   */
+  SendMessage( console, EM_SETWORDBREAKPROC, 0, (LPARAM)(dmhWordBreak) );
+
+  /* Finally, establish a working buffer for output to the PTY, and set
+   * the initial caret position for the output text stream.
+   */
+  caret = console_buffer = (char *)(malloc( max = DMH_PTY_MIN_BUFSIZ ));
+}
+
+int dmhTypePTY::printf( const char *fmt, va_list argv )
+{
+  /* Handler for printf() style output to a DMH pseudo-TTY stream.
+   *
+   * We begin by formatting the specified arguments, while saving
+   * the result into a local transfer buffer; (as a side effect,
+   * this also sets the output character count)...
+   */
+  char buf[1 + vsnprintf( NULL, 0, fmt, argv )];
+  int retval = vsnprintf( buf, sizeof( buf ), fmt, argv );
+  for( char *bufptr = buf; *bufptr; ++bufptr )
+  {
+    /* We transfer the content of the local buffer to the "device"
+     * buffer; (we do this character by character, because the DMH
+     * output stream encodes line breaks as God intended -- using
+     * '\n' only -- but the EDITTEXT control which emulates the PTY
+     * "device" requires Lucifer's "\r\n" encoding; thus '\r' and
+     * '\n' require special handling).
+     */
+    if( *bufptr == '\r' )
+    {
+      /* An explicit '\r' in the data stream should return the
+       * caret to the start of the current PHYSICAL line in the
+       * EDITTEXT display
+       *
+       * FIXME: must implement this; ignore, (and discount), it
+       * for now.
+       */
+      --retval;
+    }
+    else
+    { /* Any other character is transferred to the "device" buffer...
+       */
+      if( *bufptr == '\n' )
+      {
+	/* ...inserting, (and counting), an implied '\r' before each
+	 * '\n', to comply with Lucifer's encoding standard.
+	 */
+	putchar( '\r' );
+	++retval;
+      }
+      putchar( *bufptr );
+    }
+  }
+  /* When all output has been transferred to the "device" buffer, we
+   * terminate and flush it to the EDITTEXT control.
+   */
+  *caret = '\0';
+  SendMessage( console_hook, EM_SETSEL, 0, (LPARAM)(-1) );
+  SendMessage( console_hook, EM_REPLACESEL, FALSE, (LPARAM)(console_buffer) );
+
+  /* Finally, we repaint the display window, and return the output
+   * character count.
+   */
+  InvalidateRect( console_hook, NULL, FALSE );
+  UpdateWindow( console_hook );
+  return retval;
+}
+
+int dmhTypePTY::putchar( int charval )
+{
+  /* Helper method for appending a single character to the PTY "device"
+   * buffer; this will allocate an expanding buffer, (up to the maximum
+   * specified size limit), as may be required.
+   */
+  size_t offset;
+  if( (offset = caret - console_buffer) >= max )
+  {
+    /* The current "device" buffer is full; compute a new size, for
+     * possible buffer expansion.
+     */
+    size_t newsize;
+    if( (newsize = max + DMH_PTY_MIN_BUFSIZ) > DMH_PTY_MAX_BUFSIZ )
+      newsize = DMH_PTY_MAX_BUFSIZ;
+
+    if( newsize > max )
+    {
+      /* The buffer has not yet grown to its maximum allowed size;
+       * attempt to allocate additional memory, to expand it.
+       */
+      char *newbuf;
+      if( (newbuf = (char *)(realloc( console_buffer, newsize ))) != NULL )
+      {
+	/* Allocation was successful; complete assignment of the new
+	 * buffer, and adjust the caret to preserve its position, at
+	 * its original offset within the new buffer.
+	 */
+	max = newsize;
+	caret = (console_buffer = newbuf) + offset;
+      }
+    }
+    if( offset >= max )
+    {
+      /* The buffer has reached its maximum permitted size, (or there
+       * was insufficient free memory to expand it), and there still
+       * isn't room to accommodate another character; locate the start
+       * of the SECOND logical line within it...
+       */
+      char *mark = console_buffer, *endptr = caret;
+      while( *mark && (mark < caret) && (*mark++ != '\n') )
+	;
+      /* ...then copy it, and all following lines, to the start of the
+       * buffer, so deleting the FIRST logical line, and thus free up
+       * an equivalent amount of space at the end.
+       */
+      for( caret = console_buffer; mark < endptr; )
+	*caret++ = *mark++;
+    }
+  }
+  /* Finally, store the current character into the "device" buffer, and
+   * adjust the caret position in readiness for the next.
+   */
+  return *caret++ = charval;
+}
+
+dmhTypePTY::~dmhTypePTY()
+{
+  /* When closing a PTY controller handle, we may free the memory which
+   * we allocated for its "device" buffer.  (Note that we DO NOT delete
+   * the assocaiated font object, because the associated EDITTEXT control
+   * may outlive its controller, and will continue to need it; however,
+   * it does not need the buffer, because it maintains its own private
+   * copy of the content).
+   */
+  free( (void *)(console_buffer) );
+}
+
 class dmhTypeGUI: public dmhTypeGeneric
 {
   /* Diagnostic message handler for use in GUI applications.
@@ -43,11 +254,13 @@ class dmhTypeGUI: public dmhTypeGeneric
     virtual uint16_t control( const uint16_t, const uint16_t );
     virtual int notify( const dmh_severity, const char*, va_list );
     virtual int printf( const char*, va_list );
+    virtual void set_console_hook( void * );
 
   private:
     HWND owner; uint16_t mode;
     char *msgbuf; size_t msglen;
     int dispatch_message( int );
+    dmhTypePTY *console_hook;
 };
 
 EXTERN_C
@@ -67,9 +280,14 @@ dmhTypeGeneric *dmh_init_gui( const char *progname )
 dmhTypeGUI::dmhTypeGUI( const char* name ):dmhTypeGeneric( name ),
   /*
    * This handler also requires initialisation of the
-   * message box content collector.
+   * message box content collector...
+   */
+  owner( NULL ), mode( 0 ), msgbuf( NULL ), msglen( 0 ),
+  /*
+   * ...and must set the default state for pseudo-console
+   * association to "none".
    */
-  owner( NULL ), mode( 0 ), msgbuf( NULL ), msglen( 0 ){}
+  console_hook( NULL ){}
 
 uint16_t dmhTypeGUI::control( const uint16_t request, const uint16_t mask )
 {
@@ -84,11 +302,32 @@ uint16_t dmhTypeGUI::control( const uint16_t request, const uint16_t mask )
   return mode = request | (mode & mask);
 }
 
+void dmhTypeGUI::set_console_hook( void *console )
+{
+  /* Helper method to assign an emulated PTY "device" to the DMH stream;
+   * (note that any prior PTY assignment is first discarded).
+   */
+  delete console_hook;
+  console_hook = (console == NULL) ? NULL : new dmhTypePTY( (HWND)(console) );
+}
+
 int dmhTypeGUI::notify( const dmh_severity code, const char *fmt, va_list argv )
 {
   /* Message dispatcher for GUI applications; this formats messages
    * for display within a conventional MessageBox dialogue.
    */
+  if( console_hook != NULL )
+  {
+    /* When the DMH stream has an associated PTY, then we direct this
+     * notification to it, analogously to the CLI use of a TTY.
+     */
+    return dmh_printf( notification_format, progname, severity_tag( code ) )
+      + console_hook->printf( fmt, argv );
+  }
+
+  /* Conversely, when there is no associated PTY, then we lay out the
+   * notification for display in a windows message box.
+   */
   int newlen = 1 + vsnprintf( NULL, 0, fmt, argv );
   if( mode & DMH_COMPILE_DIGEST )
   {
@@ -200,11 +439,17 @@ int dmhTypeGUI::dispatch_message( int len )
 int dmhTypeGUI::printf( const char *fmt, va_list argv )
 {
   /* Display arbitrary text messages via the diagnostic message handler.
-   *
-   * FIXME: this is a stub; ideally, we would like to emulate
-   * console behaviour for displaying the message stream, but
-   * until a formal implementation can be provided, we simply
-   * emit each message in its own informational MessageBox.
+   */
+  if( console_hook != NULL )
+    /*
+     * When the DMH stream has an associated PTY, then we simply
+     * emit the message via that.
+     */
+    return console_hook->printf( fmt, argv );
+
+  /* Conversely, when there is no associated PTY, we redirect the
+   * message for display in a windows message box, in the guise of
+   * a DMH_INFO notification.
    */
   return notify( DMH_INFO, fmt, argv );
 }