[Patches] Readline replacement under QNX in myreadline.c

[David Vainapel]

                                Disclaimer
                    I confirm that, to the best of my knowledge and
belief, this
                     contribution is free of any claims of third parties
under
                     copyright, patent or other rights or interests
("claims").  To
                     the extent that I have any such claims, I hereby
grant to CNRI a
                     nonexclusive, irrevocable, royalty-free, worldwide
license to
                     reproduce, distribute, perform and/or display
publicly, prepare
                     derivative versions, and otherwise use this
contribution as part
                     of the Python software and its related
documentation, or any
                     derivative versions thereof, at no cost to CNRI or
its licensed
                     users, and to authorize others to do so.

                     I acknowledge that CNRI may, at its sole
discretion, decide
                     whether or not to incorporate this contribution in
the Python
                     software and its related documentation.  I further
grant CNRI
                     permission to use my name and other identifying
information
                     provided to CNRI by me for use in connection with
the Python
                     software and its related documentation.

This patch for Python 1.52 ,  /Parser/myreadline.c on QNX using Watcom
C++.
Readline does not work properly .
Using QNX input_line function instead of Linux readline.
 ------------------------------------------------------------
 30,38d29
<
< #ifdef __QNX__
<   p = input_line( fp, buf, len );
<   if( p ) {
<    int n = strlen(p);
<    p[n] = '\n';
<    p[n+1] = 0;
<   }
< #else
40d30
< #endif
-------------------------------------------------------------

Result file:

/* Readline interface for tokenizer.c and [raw_]input() in
bltinmodule.c.
   By default, or when stdin is not a tty device, we have a super
   simple my_readline function using fgets.
   Optionally, we can use the GNU readline library.
   my_readline() has a different return value from GNU readline():
   - NULL if an interrupt occurred or if an error occurred
   - a malloc'ed empty string if EOF was read
   - a malloc'ed string ending in \n normally
*/

#include "Python.h"

int (*PyOS_InputHook)() = NULL;

/* This function restarts a fgets() after an EINTR error occurred
   except if PyOS_InterruptOccurred() returns true. */

static int
my_fgets(buf, len, fp)
 char *buf;
 int len;
 FILE *fp;
{
 char *p;
 for (;;) {
  if (PyOS_InputHook != NULL)
   (void)(PyOS_InputHook)();
  errno = 0;

#ifdef __QNX__
  p = input_line( fp, buf, len );
  if( p ) {
   int n = strlen(p);
   p[n] = '\n';
   p[n+1] = 0;
  }
#else
  p = fgets(buf, len, fp);
#endif
  if (p != NULL)
   return 0; /* No error */
  if (feof(fp)) {
   return -1; /* EOF */
  }
#ifdef EINTR
  if (errno == EINTR) {
   if (PyOS_InterruptOccurred()) {
    return 1; /* Interrupt */
   }
   continue;
  }
#endif
  if (PyOS_InterruptOccurred()) {
   return 1; /* Interrupt */
  }
  return -2; /* Error */
 }
 /* NOTREACHED */
}


/* Readline implementation using fgets() */

char *
PyOS_StdioReadline(prompt)
 char *prompt;
{
 int n;
 char *p;
 n = 100;
 if ((p = malloc(n)) == NULL)
  return NULL;
 fflush(stdout);
 if (prompt)
  fprintf(stderr, "%s", prompt);
 fflush(stderr);
 switch (my_fgets(p, n, stdin)) {
 case 0: /* Normal case */
  break;
 case 1: /* Interrupt */
  free(p);
  return NULL;
 case -1: /* EOF */
 case -2: /* Error */
 default: /* Shouldn't happen */
  *p = '\0';
  break;
 }
#ifdef MPW
 /* Hack for MPW C where the prompt comes right back in the input */
 /* XXX (Actually this would be rather nice on most systems...) */
 n = strlen(prompt);
 if (strncmp(p, prompt, n) == 0)
  memmove(p, p + n, strlen(p) - n + 1);
#endif
 n = strlen(p);
 while (n > 0 && p[n-1] != '\n') {
  int incr = n+2;
  p = realloc(p, n + incr);
  if (p == NULL)
   return NULL;
  if (my_fgets(p+n, incr, stdin) != 0)
   break;
  n += strlen(p+n);
 }
 return realloc(p, n+1);
}


/* By initializing this function pointer, systems embedding Python can
   override the readline function. */

char *(*PyOS_ReadlineFunctionPointer) Py_PROTO((char *));


/* Interface used by tokenizer.c and bltinmodule.c */

char *
PyOS_Readline(prompt)
 char *prompt;
{
 char *rv;
 if (PyOS_ReadlineFunctionPointer == NULL) {
   PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
 }
 Py_BEGIN_ALLOW_THREADS
 rv = (*PyOS_ReadlineFunctionPointer)(prompt);
 Py_END_ALLOW_THREADS
 return rv;
}



D. Vainapel