Recorded merge of revisions 81032 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/branches/py3k

................
  r81032 | antoine.pitrou | 2010-05-09 17:52:27 +0200 (dim., 09 mai 2010) | 9 lines

  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, 483 insertions, 483 deletions

diff --git a/Modules/main.c b/Modules/main.c
index 7736d99..eb44aa9 100644
--- a/Modules/main.c
+++ b/Modules/main.c
@@ -104,20 +104,20 @@ PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n\
 static FILE*
 _wfopen(const wchar_t *path, const wchar_t *mode)
 {
-	char cpath[PATH_MAX];
-	char cmode[10];
-	size_t r;
-	r = wcstombs(cpath, path, PATH_MAX);
-	if (r == (size_t)-1 || r >= PATH_MAX) {
-		errno = EINVAL;
-		return NULL;
-	}
-	r = wcstombs(cmode, mode, 10);
-	if (r == (size_t)-1 || r >= 10) {
-		errno = EINVAL;
-		return NULL;
-	}
-	return fopen(cpath, cmode);
+    char cpath[PATH_MAX];
+    char cmode[10];
+    size_t r;
+    r = wcstombs(cpath, path, PATH_MAX);
+    if (r == (size_t)-1 || r >= PATH_MAX) {
+        errno = EINVAL;
+        return NULL;
+    }
+    r = wcstombs(cmode, mode, 10);
+    if (r == (size_t)-1 || r >= 10) {
+        errno = EINVAL;
+        return NULL;
+    }
+    return fopen(cpath, cmode);
 }
 #endif
 
@@ -125,131 +125,131 @@ _wfopen(const wchar_t *path, const wchar_t *mode)
 static int
 usage(int exitcode, wchar_t* program)
 {
-	FILE *f = exitcode ? stderr : stdout;
-
-	fprintf(f, usage_line, program);
-	if (exitcode)
-		fprintf(f, "Try `python -h' for more information.\n");
-	else {
-		fputs(usage_1, f);
-		fputs(usage_2, f);
-		fputs(usage_3, f);
-		fprintf(f, usage_4, DELIM);
-		fprintf(f, usage_5, DELIM, PYTHONHOMEHELP);
-	}
+    FILE *f = exitcode ? stderr : stdout;
+
+    fprintf(f, usage_line, program);
+    if (exitcode)
+        fprintf(f, "Try `python -h' for more information.\n");
+    else {
+        fputs(usage_1, f);
+        fputs(usage_2, f);
+        fputs(usage_3, f);
+        fprintf(f, usage_4, DELIM);
+        fprintf(f, usage_5, DELIM, PYTHONHOMEHELP);
+    }
 #if defined(__VMS)
-	if (exitcode == 0) {
-		/* suppress 'error' message */
-		return 1;
-	}
-	else {
-		/* STS$M_INHIB_MSG + SS$_ABORT */
-		return 0x1000002c;
-	}
+    if (exitcode == 0) {
+        /* suppress 'error' message */
+        return 1;
+    }
+    else {
+        /* STS$M_INHIB_MSG + SS$_ABORT */
+        return 0x1000002c;
+    }
 #else
-	return exitcode;
+    return exitcode;
 #endif
-	/*NOTREACHED*/
+    /*NOTREACHED*/
 }
 
 static void RunStartupFile(PyCompilerFlags *cf)
 {
-	char *startup = Py_GETENV("PYTHONSTARTUP");
-	if (startup != NULL && startup[0] != '\0') {
-		FILE *fp = fopen(startup, "r");
-		if (fp != NULL) {
-			(void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
-			PyErr_Clear();
-			fclose(fp);
-		} else {
-			int save_errno;
-			
-			save_errno = errno;
-			PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
-			errno = save_errno;
-			PyErr_SetFromErrnoWithFilename(PyExc_IOError,
-					startup);
-			PyErr_Print();
-			PyErr_Clear();
-		}
-	}
+    char *startup = Py_GETENV("PYTHONSTARTUP");
+    if (startup != NULL && startup[0] != '\0') {
+        FILE *fp = fopen(startup, "r");
+        if (fp != NULL) {
+            (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
+            PyErr_Clear();
+            fclose(fp);
+        } else {
+            int save_errno;
+
+            save_errno = errno;
+            PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
+            errno = save_errno;
+            PyErr_SetFromErrnoWithFilename(PyExc_IOError,
+                            startup);
+            PyErr_Print();
+            PyErr_Clear();
+        }
+    }
 }
 
 
 static int RunModule(wchar_t *modname, int set_argv0)
 {
-	PyObject *module, *runpy, *runmodule, *runargs, *result;
-	runpy = PyImport_ImportModule("runpy");
-	if (runpy == NULL) {
-		fprintf(stderr, "Could not import runpy module\n");
-		return -1;
-	}
-	runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
-	if (runmodule == NULL) {
-		fprintf(stderr, "Could not access runpy._run_module_as_main\n");
-		Py_DECREF(runpy);
-		return -1;
-	}
-	module = PyUnicode_FromWideChar(modname, wcslen(modname));
-	if (module == NULL) {
-		fprintf(stderr, "Could not convert module name to unicode\n");
-		Py_DECREF(runpy);
-		Py_DECREF(runmodule);
-		return -1;
-	}
-	runargs = Py_BuildValue("(Oi)", module, set_argv0);
-	if (runargs == NULL) {
-		fprintf(stderr,
-			"Could not create arguments for runpy._run_module_as_main\n");
-		Py_DECREF(runpy);
-		Py_DECREF(runmodule);
-		Py_DECREF(module);
-		return -1;
-	}
-	result = PyObject_Call(runmodule, runargs, NULL);
-	if (result == NULL) {
-		PyErr_Print();
-	}
-	Py_DECREF(runpy);
-	Py_DECREF(runmodule);
-	Py_DECREF(module);
-	Py_DECREF(runargs);
-	if (result == NULL) {
-		return -1;
-	}
-	Py_DECREF(result);
-	return 0;
+    PyObject *module, *runpy, *runmodule, *runargs, *result;
+    runpy = PyImport_ImportModule("runpy");
+    if (runpy == NULL) {
+        fprintf(stderr, "Could not import runpy module\n");
+        return -1;
+    }
+    runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
+    if (runmodule == NULL) {
+        fprintf(stderr, "Could not access runpy._run_module_as_main\n");
+        Py_DECREF(runpy);
+        return -1;
+    }
+    module = PyUnicode_FromWideChar(modname, wcslen(modname));
+    if (module == NULL) {
+        fprintf(stderr, "Could not convert module name to unicode\n");
+        Py_DECREF(runpy);
+        Py_DECREF(runmodule);
+        return -1;
+    }
+    runargs = Py_BuildValue("(Oi)", module, set_argv0);
+    if (runargs == NULL) {
+        fprintf(stderr,
+            "Could not create arguments for runpy._run_module_as_main\n");
+        Py_DECREF(runpy);
+        Py_DECREF(runmodule);
+        Py_DECREF(module);
+        return -1;
+    }
+    result = PyObject_Call(runmodule, runargs, NULL);
+    if (result == NULL) {
+        PyErr_Print();
+    }
+    Py_DECREF(runpy);
+    Py_DECREF(runmodule);
+    Py_DECREF(module);
+    Py_DECREF(runargs);
+    if (result == NULL) {
+        return -1;
+    }
+    Py_DECREF(result);
+    return 0;
 }
 
 static int RunMainFromImporter(wchar_t *filename)
 {
-	PyObject *argv0 = NULL, *importer = NULL;
-
-	if ((argv0 = PyUnicode_FromWideChar(filename,wcslen(filename))) &&
-	    (importer = PyImport_GetImporter(argv0)) &&
-	    (importer->ob_type != &PyNullImporter_Type))
-	{
-		 /* argv0 is usable as an import source, so
-			put it in sys.path[0] and import __main__ */
-		PyObject *sys_path = NULL;
-		if ((sys_path = PySys_GetObject("path")) &&
-		    !PyList_SetItem(sys_path, 0, argv0))
-		{
-			Py_INCREF(argv0);
-			Py_DECREF(importer);
-			sys_path = NULL;
-			return RunModule(L"__main__", 0) != 0;
-		}
-	}
-	Py_XDECREF(argv0);
-	Py_XDECREF(importer);
-        if (PyErr_Occurred()) {
-		PyErr_Print();
-		return 1;
+    PyObject *argv0 = NULL, *importer = NULL;
+
+    if ((argv0 = PyUnicode_FromWideChar(filename,wcslen(filename))) &&
+        (importer = PyImport_GetImporter(argv0)) &&
+        (importer->ob_type != &PyNullImporter_Type))
+    {
+             /* argv0 is usable as an import source, so
+                    put it in sys.path[0] and import __main__ */
+        PyObject *sys_path = NULL;
+        if ((sys_path = PySys_GetObject("path")) &&
+            !PyList_SetItem(sys_path, 0, argv0))
+        {
+            Py_INCREF(argv0);
+            Py_DECREF(importer);
+            sys_path = NULL;
+            return RunModule(L"__main__", 0) != 0;
         }
-	else {
-		return -1;
-	}
+    }
+    Py_XDECREF(argv0);
+    Py_XDECREF(importer);
+    if (PyErr_Occurred()) {
+        PyErr_Print();
+        return 1;
+    }
+    else {
+        return -1;
+    }
 }
 
 
@@ -258,391 +258,391 @@ static int RunMainFromImporter(wchar_t *filename)
 int
 Py_Main(int argc, wchar_t **argv)
 {
-	int c;
-	int sts;
-	wchar_t *command = NULL;
-	wchar_t *filename = NULL;
-	wchar_t *module = NULL;
-	FILE *fp = stdin;
-	char *p;
-	int skipfirstline = 0;
-	int stdin_is_interactive = 0;
-	int help = 0;
-	int version = 0;
-	int saw_unbuffered_flag = 0;
-	PyCompilerFlags cf;
-
-	cf.cf_flags = 0;
-
-	orig_argc = argc;	/* For Py_GetArgcArgv() */
-	orig_argv = argv;
-
-	PySys_ResetWarnOptions();
-
-	while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
-		if (c == 'c') {
-			size_t len;
-			/* -c is the last option; following arguments
-			   that look like options are left for the
-			   command to interpret. */
-
-			len = wcslen(_PyOS_optarg) + 1 + 1;
-			command = (wchar_t *)malloc(sizeof(wchar_t) * len);
-			if (command == NULL)
-				Py_FatalError(
-				   "not enough memory to copy -c argument");
-			wcscpy(command, _PyOS_optarg);
-			command[len - 2] = '\n';
-			command[len - 1] = 0;
-			break;
-		}
-
-		if (c == 'm') {
-			/* -m is the last option; following arguments
-			   that look like options are left for the
-			   module to interpret. */
-			module = _PyOS_optarg;
-			break;
-		}
-
-		switch (c) {
-		case 'b':
-			Py_BytesWarningFlag++;
-			break;
-
-		case 'd':
-			Py_DebugFlag++;
-			break;
-
-		case 'i':
-			Py_InspectFlag++;
-			Py_InteractiveFlag++;
-			break;
-
-		/* case 'J': reserved for Jython */
-
-		case 'O':
-			Py_OptimizeFlag++;
-			break;
-
-		case 'B':
-			Py_DontWriteBytecodeFlag++;
-			break;
-
-		case 's':
-			Py_NoUserSiteDirectory++;
-			break;
-
-		case 'S':
-			Py_NoSiteFlag++;
-			break;
-
-		case 'E':
-			Py_IgnoreEnvironmentFlag++;
-			break;
-
-		case 't':
-			/* ignored for backwards compatibility */
-			break;
-
-		case 'u':
-			Py_UnbufferedStdioFlag = 1;
-			saw_unbuffered_flag = 1;
-			break;
-
-		case 'v':
-			Py_VerboseFlag++;
-			break;
-
-		case 'x':
-			skipfirstline = 1;
-			break;
-
-		/* case 'X': reserved for implementation-specific arguments */
-
-		case 'h':
-		case '?':
-			help++;
-			break;
-
-		case 'V':
-			version++;
-			break;
-
-		case 'W': 
-			PySys_AddWarnOption(_PyOS_optarg);
-			break;
-
-		/* This space reserved for other options */
-
-		default:
-			return usage(2, argv[0]);
-			/*NOTREACHED*/
-
-		}
-	}
-
-	if (help)
-		return usage(0, argv[0]);
-
-	if (version) {
-		fprintf(stderr, "Python %s\n", PY_VERSION);
-		return 0;
-	}
-
-	if (!Py_InspectFlag &&
-	    (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
-		Py_InspectFlag = 1;
-	if (!saw_unbuffered_flag &&
-	    (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
-		Py_UnbufferedStdioFlag = 1;
-
-	if (!Py_NoUserSiteDirectory &&
-	    (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0')
-		Py_NoUserSiteDirectory = 1;
-
-	if (command == NULL && module == NULL && _PyOS_optind < argc &&
-	    wcscmp(argv[_PyOS_optind], L"-") != 0)
-	{
+    int c;
+    int sts;
+    wchar_t *command = NULL;
+    wchar_t *filename = NULL;
+    wchar_t *module = NULL;
+    FILE *fp = stdin;
+    char *p;
+    int skipfirstline = 0;
+    int stdin_is_interactive = 0;
+    int help = 0;
+    int version = 0;
+    int saw_unbuffered_flag = 0;
+    PyCompilerFlags cf;
+
+    cf.cf_flags = 0;
+
+    orig_argc = argc;           /* For Py_GetArgcArgv() */
+    orig_argv = argv;
+
+    PySys_ResetWarnOptions();
+
+    while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
+        if (c == 'c') {
+            size_t len;
+            /* -c is the last option; following arguments
+               that look like options are left for the
+               command to interpret. */
+
+            len = wcslen(_PyOS_optarg) + 1 + 1;
+            command = (wchar_t *)malloc(sizeof(wchar_t) * len);
+            if (command == NULL)
+                Py_FatalError(
+                   "not enough memory to copy -c argument");
+            wcscpy(command, _PyOS_optarg);
+            command[len - 2] = '\n';
+            command[len - 1] = 0;
+            break;
+        }
+
+        if (c == 'm') {
+            /* -m is the last option; following arguments
+               that look like options are left for the
+               module to interpret. */
+            module = _PyOS_optarg;
+            break;
+        }
+
+        switch (c) {
+        case 'b':
+            Py_BytesWarningFlag++;
+            break;
+
+        case 'd':
+            Py_DebugFlag++;
+            break;
+
+        case 'i':
+            Py_InspectFlag++;
+            Py_InteractiveFlag++;
+            break;
+
+        /* case 'J': reserved for Jython */
+
+        case 'O':
+            Py_OptimizeFlag++;
+            break;
+
+        case 'B':
+            Py_DontWriteBytecodeFlag++;
+            break;
+
+        case 's':
+            Py_NoUserSiteDirectory++;
+            break;
+
+        case 'S':
+            Py_NoSiteFlag++;
+            break;
+
+        case 'E':
+            Py_IgnoreEnvironmentFlag++;
+            break;
+
+        case 't':
+            /* ignored for backwards compatibility */
+            break;
+
+        case 'u':
+            Py_UnbufferedStdioFlag = 1;
+            saw_unbuffered_flag = 1;
+            break;
+
+        case 'v':
+            Py_VerboseFlag++;
+            break;
+
+        case 'x':
+            skipfirstline = 1;
+            break;
+
+        /* case 'X': reserved for implementation-specific arguments */
+
+        case 'h':
+        case '?':
+            help++;
+            break;
+
+        case 'V':
+            version++;
+            break;
+
+        case 'W':
+            PySys_AddWarnOption(_PyOS_optarg);
+            break;
+
+        /* This space reserved for other options */
+
+        default:
+            return usage(2, argv[0]);
+            /*NOTREACHED*/
+
+        }
+    }
+
+    if (help)
+        return usage(0, argv[0]);
+
+    if (version) {
+        fprintf(stderr, "Python %s\n", PY_VERSION);
+        return 0;
+    }
+
+    if (!Py_InspectFlag &&
+        (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
+        Py_InspectFlag = 1;
+    if (!saw_unbuffered_flag &&
+        (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
+        Py_UnbufferedStdioFlag = 1;
+
+    if (!Py_NoUserSiteDirectory &&
+        (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0')
+        Py_NoUserSiteDirectory = 1;
+
+    if (command == NULL && module == NULL && _PyOS_optind < argc &&
+        wcscmp(argv[_PyOS_optind], L"-") != 0)
+    {
 #ifdef __VMS
-		filename = decc$translate_vms(argv[_PyOS_optind]);
-		if (filename == (char *)0 || filename == (char *)-1)
-			filename = argv[_PyOS_optind];
+        filename = decc$translate_vms(argv[_PyOS_optind]);
+        if (filename == (char *)0 || filename == (char *)-1)
+            filename = argv[_PyOS_optind];
 
 #else
-		filename = argv[_PyOS_optind];
+        filename = argv[_PyOS_optind];
 #endif
-	}
+    }
 
-	stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0);
+    stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0);
 
-	if (Py_UnbufferedStdioFlag) {
+    if (Py_UnbufferedStdioFlag) {
 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
-		_setmode(fileno(stdin), O_BINARY);
-		_setmode(fileno(stdout), O_BINARY);
+        _setmode(fileno(stdin), O_BINARY);
+        _setmode(fileno(stdout), O_BINARY);
 #endif
 #ifdef HAVE_SETVBUF
-		setvbuf(stdin,  (char *)NULL, _IONBF, BUFSIZ);
-		setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
-		setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
+        setvbuf(stdin,  (char *)NULL, _IONBF, BUFSIZ);
+        setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
+        setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
 #else /* !HAVE_SETVBUF */
-		setbuf(stdin,  (char *)NULL);
-		setbuf(stdout, (char *)NULL);
-		setbuf(stderr, (char *)NULL);
+        setbuf(stdin,  (char *)NULL);
+        setbuf(stdout, (char *)NULL);
+        setbuf(stderr, (char *)NULL);
 #endif /* !HAVE_SETVBUF */
-	}
-	else if (Py_InteractiveFlag) {
+    }
+    else if (Py_InteractiveFlag) {
 #ifdef MS_WINDOWS
-		/* Doesn't have to have line-buffered -- use unbuffered */
-		/* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
-		setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
+        /* Doesn't have to have line-buffered -- use unbuffered */
+        /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
+        setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 #else /* !MS_WINDOWS */
 #ifdef HAVE_SETVBUF
-		setvbuf(stdin,  (char *)NULL, _IOLBF, BUFSIZ);
-		setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
+        setvbuf(stdin,  (char *)NULL, _IOLBF, BUFSIZ);
+        setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
 #endif /* HAVE_SETVBUF */
 #endif /* !MS_WINDOWS */
-		/* Leave stderr alone - it should be unbuffered anyway. */
-  	}
+        /* Leave stderr alone - it should be unbuffered anyway. */
+    }
 #ifdef __VMS
-	else {
-		setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ);
-	}
+    else {
+        setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ);
+    }
 #endif /* __VMS */
 
 #ifdef __APPLE__
-	/* On MacOS X, when the Python interpreter is embedded in an
-	   application bundle, it gets executed by a bootstrapping script
-	   that does os.execve() with an argv[0] that's different from the
-	   actual Python executable. This is needed to keep the Finder happy,
-	   or rather, to work around Apple's overly strict requirements of
-	   the process name. However, we still need a usable sys.executable,
-	   so the actual executable path is passed in an environment variable.
-	   See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
-	   script. */
-	if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0') {
-		wchar_t* buffer;
-		size_t len = strlen(p);
-		size_t r;
-
-		buffer = malloc(len * sizeof(wchar_t));
-		if (buffer == NULL) {
-			Py_FatalError(
-			   "not enough memory to copy PYTHONEXECUTABLE");
-		}
-
-		r = mbstowcs(buffer, p, len);
-		Py_SetProgramName(buffer);
-		/* buffer is now handed off - do not free */
-	} else {
-		Py_SetProgramName(argv[0]);
-	}
+    /* On MacOS X, when the Python interpreter is embedded in an
+       application bundle, it gets executed by a bootstrapping script
+       that does os.execve() with an argv[0] that's different from the
+       actual Python executable. This is needed to keep the Finder happy,
+       or rather, to work around Apple's overly strict requirements of
+       the process name. However, we still need a usable sys.executable,
+       so the actual executable path is passed in an environment variable.
+       See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
+       script. */
+    if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0') {
+        wchar_t* buffer;
+        size_t len = strlen(p);
+        size_t r;
+
+        buffer = malloc(len * sizeof(wchar_t));
+        if (buffer == NULL) {
+            Py_FatalError(
+               "not enough memory to copy PYTHONEXECUTABLE");
+        }
+
+        r = mbstowcs(buffer, p, len);
+        Py_SetProgramName(buffer);
+        /* buffer is now handed off - do not free */
+    } else {
+        Py_SetProgramName(argv[0]);
+    }
 #else
-	Py_SetProgramName(argv[0]);
+    Py_SetProgramName(argv[0]);
 #endif
-	Py_Initialize();
-
-	if (Py_VerboseFlag ||
-	    (command == NULL && filename == NULL && module == NULL && stdin_is_interactive)) {
-		fprintf(stderr, "Python %s on %s\n",
-			Py_GetVersion(), Py_GetPlatform());
- 		if (!Py_NoSiteFlag)
- 			fprintf(stderr, "%s\n", COPYRIGHT);
-	}
-
-	if (command != NULL) {
-		/* Backup _PyOS_optind and force sys.argv[0] = '-c' */
-		_PyOS_optind--;
-		argv[_PyOS_optind] = L"-c";
-	}
-
-	if (module != NULL) {
-		/* Backup _PyOS_optind and force sys.argv[0] = '-c'
-		   so that PySys_SetArgv correctly sets sys.path[0] to ''*/
-		_PyOS_optind--;
-		argv[_PyOS_optind] = L"-c";
-	}
-
-	PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
-
-	if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
-	    isatty(fileno(stdin))) {
-		PyObject *v;
-		v = PyImport_ImportModule("readline");
-		if (v == NULL)
-			PyErr_Clear();
-		else
-			Py_DECREF(v);
-	}
-
-	if (command) {
-		PyObject *commandObj = PyUnicode_FromWideChar(
-		    command, wcslen(command));
-		free(command);
-		if (commandObj != NULL) {
-			sts = PyRun_SimpleStringFlags(
-				_PyUnicode_AsString(commandObj), &cf) != 0;
-		}
-		else {
-			PyErr_Print();
-			sts = 1;
-		}
-		Py_DECREF(commandObj);
-	} else if (module) {
-		sts = RunModule(module, 1);
-	}
-	else {
-
-		if (filename == NULL && stdin_is_interactive) {
-			Py_InspectFlag = 0; /* do exit on SystemExit */
-			RunStartupFile(&cf);
-		}
-		/* XXX */
-
-		sts = -1;	/* keep track of whether we've already run __main__ */
-
-		if (filename != NULL) {
-			sts = RunMainFromImporter(filename);
-		}
-
-		if (sts==-1 && filename!=NULL) {
-			if ((fp = _wfopen(filename, L"r")) == NULL) {
-				char cfilename[PATH_MAX];
-				size_t r = wcstombs(cfilename, filename, PATH_MAX);
-				if (r == PATH_MAX)
-					/* cfilename is not null-terminated;
-					 * forcefully null-terminating it
-					 * might break the shift state */
-					strcpy(cfilename, "<file name too long>");
-				if (r == ((size_t)-1))
-					strcpy(cfilename, "<unprintable file name>");
-				fprintf(stderr, "%ls: can't open file '%s': [Errno %d] %s\n",
-					argv[0], cfilename, errno, strerror(errno));
-
-				return 2;
-			}
-			else if (skipfirstline) {
-				int ch;
-				/* Push back first newline so line numbers
-				   remain the same */
-				while ((ch = getc(fp)) != EOF) {
-					if (ch == '\n') {
-						(void)ungetc(ch, fp);
-						break;
-					}
-				}
-			}
-			{
-				/* XXX: does this work on Win/Win64? (see posix_fstat) */
-				struct stat sb;
-				if (fstat(fileno(fp), &sb) == 0 &&
-				    S_ISDIR(sb.st_mode)) {
-					fprintf(stderr, "%ls: '%ls' is a directory, cannot continue\n", argv[0], filename);
-					fclose(fp);
-					return 1;
-				}
-			}
-		}
-
-		if (sts==-1) {
-			PyObject *filenameObj = NULL;
-			char *p_cfilename = "<stdin>";
-			if (filename) {
-				filenameObj = PyUnicode_FromWideChar(
-					filename, wcslen(filename));
-				if (filenameObj != NULL)
-					p_cfilename = _PyUnicode_AsString(filenameObj);
-				else
-					p_cfilename = "<decoding error>";
-			}
-			/* call pending calls like signal handlers (SIGINT) */
-			if (Py_MakePendingCalls() == -1) {
-				PyErr_Print();
-				sts = 1;
-			} else {
-				sts = PyRun_AnyFileExFlags(
-					fp,
-					p_cfilename,
-					filename != NULL, &cf) != 0;
-			}
-			Py_XDECREF(filenameObj);
-		}
-		
-	}
-
-	/* Check this environment variable at the end, to give programs the
-	 * opportunity to set it from Python.
-	 */
-	if (!Py_InspectFlag &&
-	    (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
-	{
-		Py_InspectFlag = 1;
-	}
-
-	if (Py_InspectFlag && stdin_is_interactive &&
-	    (filename != NULL || command != NULL || module != NULL)) {
-		Py_InspectFlag = 0;
-		/* XXX */
-		sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0;
-	}
-
-	Py_Finalize();
+    Py_Initialize();
+
+    if (Py_VerboseFlag ||
+        (command == NULL && filename == NULL && module == NULL && stdin_is_interactive)) {
+        fprintf(stderr, "Python %s on %s\n",
+            Py_GetVersion(), Py_GetPlatform());
+        if (!Py_NoSiteFlag)
+            fprintf(stderr, "%s\n", COPYRIGHT);
+    }
+
+    if (command != NULL) {
+        /* Backup _PyOS_optind and force sys.argv[0] = '-c' */
+        _PyOS_optind--;
+        argv[_PyOS_optind] = L"-c";
+    }
+
+    if (module != NULL) {
+        /* Backup _PyOS_optind and force sys.argv[0] = '-c'
+           so that PySys_SetArgv correctly sets sys.path[0] to ''*/
+        _PyOS_optind--;
+        argv[_PyOS_optind] = L"-c";
+    }
+
+    PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
+
+    if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
+        isatty(fileno(stdin))) {
+        PyObject *v;
+        v = PyImport_ImportModule("readline");
+        if (v == NULL)
+            PyErr_Clear();
+        else
+            Py_DECREF(v);
+    }
+
+    if (command) {
+        PyObject *commandObj = PyUnicode_FromWideChar(
+            command, wcslen(command));
+        free(command);
+        if (commandObj != NULL) {
+            sts = PyRun_SimpleStringFlags(
+                _PyUnicode_AsString(commandObj), &cf) != 0;
+        }
+        else {
+            PyErr_Print();
+            sts = 1;
+        }
+        Py_DECREF(commandObj);
+    } else if (module) {
+        sts = RunModule(module, 1);
+    }
+    else {
+
+        if (filename == NULL && stdin_is_interactive) {
+            Py_InspectFlag = 0; /* do exit on SystemExit */
+            RunStartupFile(&cf);
+        }
+        /* XXX */
+
+        sts = -1;               /* keep track of whether we've already run __main__ */
+
+        if (filename != NULL) {
+            sts = RunMainFromImporter(filename);
+        }
+
+        if (sts==-1 && filename!=NULL) {
+            if ((fp = _wfopen(filename, L"r")) == NULL) {
+                char cfilename[PATH_MAX];
+                size_t r = wcstombs(cfilename, filename, PATH_MAX);
+                if (r == PATH_MAX)
+                    /* cfilename is not null-terminated;
+                     * forcefully null-terminating it
+                     * might break the shift state */
+                    strcpy(cfilename, "<file name too long>");
+                if (r == ((size_t)-1))
+                    strcpy(cfilename, "<unprintable file name>");
+                fprintf(stderr, "%ls: can't open file '%s': [Errno %d] %s\n",
+                    argv[0], cfilename, errno, strerror(errno));
+
+                return 2;
+            }
+            else if (skipfirstline) {
+                int ch;
+                /* Push back first newline so line numbers
+                   remain the same */
+                while ((ch = getc(fp)) != EOF) {
+                    if (ch == '\n') {
+                        (void)ungetc(ch, fp);
+                        break;
+                    }
+                }
+            }
+            {
+                /* XXX: does this work on Win/Win64? (see posix_fstat) */
+                struct stat sb;
+                if (fstat(fileno(fp), &sb) == 0 &&
+                    S_ISDIR(sb.st_mode)) {
+                    fprintf(stderr, "%ls: '%ls' is a directory, cannot continue\n", argv[0], filename);
+                    fclose(fp);
+                    return 1;
+                }
+            }
+        }
+
+        if (sts==-1) {
+            PyObject *filenameObj = NULL;
+            char *p_cfilename = "<stdin>";
+            if (filename) {
+                filenameObj = PyUnicode_FromWideChar(
+                    filename, wcslen(filename));
+                if (filenameObj != NULL)
+                    p_cfilename = _PyUnicode_AsString(filenameObj);
+                else
+                    p_cfilename = "<decoding error>";
+            }
+            /* call pending calls like signal handlers (SIGINT) */
+            if (Py_MakePendingCalls() == -1) {
+                PyErr_Print();
+                sts = 1;
+            } else {
+                sts = PyRun_AnyFileExFlags(
+                    fp,
+                    p_cfilename,
+                    filename != NULL, &cf) != 0;
+            }
+            Py_XDECREF(filenameObj);
+        }
+
+    }
+
+    /* Check this environment variable at the end, to give programs the
+     * opportunity to set it from Python.
+     */
+    if (!Py_InspectFlag &&
+        (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
+    {
+        Py_InspectFlag = 1;
+    }
+
+    if (Py_InspectFlag && stdin_is_interactive &&
+        (filename != NULL || command != NULL || module != NULL)) {
+        Py_InspectFlag = 0;
+        /* XXX */
+        sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0;
+    }
+
+    Py_Finalize();
 
 #ifdef __INSURE__
-	/* Insure++ is a memory analysis tool that aids in discovering
-	 * memory leaks and other memory problems.  On Python exit, the
-	 * interned string dictionaries are flagged as being in use at exit
-	 * (which it is).  Under normal circumstances, this is fine because
-	 * the memory will be automatically reclaimed by the system.  Under
-	 * memory debugging, it's a huge source of useless noise, so we
-	 * trade off slower shutdown for less distraction in the memory
-	 * reports.  -baw
-	 */
-	_Py_ReleaseInternedStrings();
-	_Py_ReleaseInternedUnicodeStrings();
+    /* Insure++ is a memory analysis tool that aids in discovering
+     * memory leaks and other memory problems.  On Python exit, the
+     * interned string dictionaries are flagged as being in use at exit
+     * (which it is).  Under normal circumstances, this is fine because
+     * the memory will be automatically reclaimed by the system.  Under
+     * memory debugging, it's a huge source of useless noise, so we
+     * trade off slower shutdown for less distraction in the memory
+     * reports.  -baw
+     */
+    _Py_ReleaseInternedStrings();
+    _Py_ReleaseInternedUnicodeStrings();
 #endif /* __INSURE__ */
 
-	return sts;
+    return sts;
 }
 
 /* this is gonna seem *real weird*, but if you put some other code between
@@ -655,8 +655,8 @@ Py_Main(int argc, wchar_t **argv)
 void
 Py_GetArgcArgv(int *argc, wchar_t ***argv)
 {
-	*argc = orig_argc;
-	*argv = orig_argv;
+    *argc = orig_argc;
+    *argv = orig_argv;
 }
 
 #ifdef __cplusplus