Recorded merge of revisions 81029 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines

  Untabify C files. Will watch buildbots.
........

1 files changed, 117 insertions, 117 deletions

diff --git a/Parser/myreadline.c b/Parser/myreadline.c
index 0d8394b..ecb4701 100644
--- a/Parser/myreadline.c
+++ b/Parser/myreadline.c
@@ -35,64 +35,64 @@ int (*PyOS_InputHook)(void) = NULL;
 static int
 my_fgets(char *buf, int len, FILE *fp)
 {
-	char *p;
-	if (PyOS_InputHook != NULL)
-		(void)(PyOS_InputHook)();
-	errno = 0;
-	p = fgets(buf, len, fp);
-	if (p != NULL)
-		return 0; /* No error */
+    char *p;
+    if (PyOS_InputHook != NULL)
+        (void)(PyOS_InputHook)();
+    errno = 0;
+    p = fgets(buf, len, fp);
+    if (p != NULL)
+        return 0; /* No error */
 #ifdef MS_WINDOWS
-	/* In the case of a Ctrl+C or some other external event 
-	   interrupting the operation:
-	   Win2k/NT: ERROR_OPERATION_ABORTED is the most recent Win32 
-	   error code (and feof() returns TRUE).
-	   Win9x: Ctrl+C seems to have no effect on fgets() returning
-	   early - the signal handler is called, but the fgets()
-	   only returns "normally" (ie, when Enter hit or feof())
-	*/
-	if (GetLastError()==ERROR_OPERATION_ABORTED) {
-		/* Signals come asynchronously, so we sleep a brief 
-		   moment before checking if the handler has been 
-		   triggered (we cant just return 1 before the 
-		   signal handler has been called, as the later 
-		   signal may be treated as a separate interrupt).
-		*/
-		Sleep(1);
-		if (PyOS_InterruptOccurred()) {
-			return 1; /* Interrupt */
-		}
-		/* Either the sleep wasn't long enough (need a
-		   short loop retrying?) or not interrupted at all
-		   (in which case we should revisit the whole thing!)
-		   Logging some warning would be nice.  assert is not
-		   viable as under the debugger, the various dialogs
-		   mean the condition is not true.
-		*/
-	}
+    /* In the case of a Ctrl+C or some other external event
+       interrupting the operation:
+       Win2k/NT: ERROR_OPERATION_ABORTED is the most recent Win32
+       error code (and feof() returns TRUE).
+       Win9x: Ctrl+C seems to have no effect on fgets() returning
+       early - the signal handler is called, but the fgets()
+       only returns "normally" (ie, when Enter hit or feof())
+    */
+    if (GetLastError()==ERROR_OPERATION_ABORTED) {
+        /* Signals come asynchronously, so we sleep a brief
+           moment before checking if the handler has been
+           triggered (we cant just return 1 before the
+           signal handler has been called, as the later
+           signal may be treated as a separate interrupt).
+        */
+        Sleep(1);
+        if (PyOS_InterruptOccurred()) {
+            return 1; /* Interrupt */
+        }
+        /* Either the sleep wasn't long enough (need a
+           short loop retrying?) or not interrupted at all
+           (in which case we should revisit the whole thing!)
+           Logging some warning would be nice.  assert is not
+           viable as under the debugger, the various dialogs
+           mean the condition is not true.
+        */
+    }
 #endif /* MS_WINDOWS */
-	if (feof(fp)) {
-		return -1; /* EOF */
-	}
+    if (feof(fp)) {
+        return -1; /* EOF */
+    }
 #ifdef EINTR
-	if (errno == EINTR) {
-		int s;
+    if (errno == EINTR) {
+        int s;
 #ifdef WITH_THREAD
-		PyEval_RestoreThread(_PyOS_ReadlineTState);
+        PyEval_RestoreThread(_PyOS_ReadlineTState);
 #endif
-		s = PyErr_CheckSignals();
+        s = PyErr_CheckSignals();
 #ifdef WITH_THREAD
-		PyEval_SaveThread();
+        PyEval_SaveThread();
 #endif
-		if (s < 0) {
-			return 1;
-		}
-	}
+        if (s < 0) {
+            return 1;
+        }
+    }
 #endif
-	if (PyOS_InterruptOccurred()) {
-		return 1; /* Interrupt */
-	}
-	return -2; /* Error */
+    if (PyOS_InterruptOccurred()) {
+        return 1; /* Interrupt */
+    }
+    return -2; /* Error */
 }
 
 
@@ -101,41 +101,41 @@ my_fgets(char *buf, int len, FILE *fp)
 char *
 PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 {
-	size_t n;
-	char *p;
-	n = 100;
-	if ((p = (char *)PyMem_MALLOC(n)) == NULL)
-		return NULL;
-	fflush(sys_stdout);
-	if (prompt)
-		fprintf(stderr, "%s", prompt);
-	fflush(stderr);
-	switch (my_fgets(p, (int)n, sys_stdin)) {
-	case 0: /* Normal case */
-		break;
-	case 1: /* Interrupt */
-		PyMem_FREE(p);
-		return NULL;
-	case -1: /* EOF */
-	case -2: /* Error */
-	default: /* Shouldn't happen */
-		*p = '\0';
-		break;
-	}
-	n = strlen(p);
-	while (n > 0 && p[n-1] != '\n') {
-		size_t incr = n+2;
-		p = (char *)PyMem_REALLOC(p, n + incr);
-		if (p == NULL)
-			return NULL;
-		if (incr > INT_MAX) {
-			PyErr_SetString(PyExc_OverflowError, "input line too long");
-		}
-		if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
-			break;
-		n += strlen(p+n);
-	}
-	return (char *)PyMem_REALLOC(p, n+1);
+    size_t n;
+    char *p;
+    n = 100;
+    if ((p = (char *)PyMem_MALLOC(n)) == NULL)
+        return NULL;
+    fflush(sys_stdout);
+    if (prompt)
+        fprintf(stderr, "%s", prompt);
+    fflush(stderr);
+    switch (my_fgets(p, (int)n, sys_stdin)) {
+    case 0: /* Normal case */
+        break;
+    case 1: /* Interrupt */
+        PyMem_FREE(p);
+        return NULL;
+    case -1: /* EOF */
+    case -2: /* Error */
+    default: /* Shouldn't happen */
+        *p = '\0';
+        break;
+    }
+    n = strlen(p);
+    while (n > 0 && p[n-1] != '\n') {
+        size_t incr = n+2;
+        p = (char *)PyMem_REALLOC(p, n + incr);
+        if (p == NULL)
+            return NULL;
+        if (incr > INT_MAX) {
+            PyErr_SetString(PyExc_OverflowError, "input line too long");
+        }
+        if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
+            break;
+        n += strlen(p+n);
+    }
+    return (char *)PyMem_REALLOC(p, n+1);
 }
 
 
@@ -152,52 +152,52 @@ char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
 char *
 PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 {
-	char *rv;
+    char *rv;
 
-	if (_PyOS_ReadlineTState == PyThreadState_GET()) {
-		PyErr_SetString(PyExc_RuntimeError,
-				"can't re-enter readline");
-		return NULL;
-	}
-	
+    if (_PyOS_ReadlineTState == PyThreadState_GET()) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "can't re-enter readline");
+        return NULL;
+    }
 
-	if (PyOS_ReadlineFunctionPointer == NULL) {
+
+    if (PyOS_ReadlineFunctionPointer == NULL) {
 #ifdef __VMS
-                PyOS_ReadlineFunctionPointer = vms__StdioReadline;
+        PyOS_ReadlineFunctionPointer = vms__StdioReadline;
 #else
-                PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
+        PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
 #endif
-	}
-	
+    }
+
 #ifdef WITH_THREAD
-	if (_PyOS_ReadlineLock == NULL) {
-		_PyOS_ReadlineLock = PyThread_allocate_lock();		
-	}
+    if (_PyOS_ReadlineLock == NULL) {
+        _PyOS_ReadlineLock = PyThread_allocate_lock();
+    }
 #endif
 
-	_PyOS_ReadlineTState = PyThreadState_GET();
-	Py_BEGIN_ALLOW_THREADS
+    _PyOS_ReadlineTState = PyThreadState_GET();
+    Py_BEGIN_ALLOW_THREADS
 #ifdef WITH_THREAD
-	PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
+    PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
 #endif
 
-        /* This is needed to handle the unlikely case that the
-         * interpreter is in interactive mode *and* stdin/out are not
-         * a tty.  This can happen, for example if python is run like
-         * this: python -i < test1.py
-         */
-        if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout)))
-                rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt);
-        else
-                rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout,
-                                                     prompt);
-	Py_END_ALLOW_THREADS
+    /* This is needed to handle the unlikely case that the
+     * interpreter is in interactive mode *and* stdin/out are not
+     * a tty.  This can happen, for example if python is run like
+     * this: python -i < test1.py
+     */
+    if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout)))
+        rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt);
+    else
+        rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout,
+                                             prompt);
+    Py_END_ALLOW_THREADS
 
 #ifdef WITH_THREAD
-	PyThread_release_lock(_PyOS_ReadlineLock);
+    PyThread_release_lock(_PyOS_ReadlineLock);
 #endif
 
-	_PyOS_ReadlineTState = NULL;
+    _PyOS_ReadlineTState = NULL;
 
-	return rv;
+    return rv;
 }