Modules/main.c

   1 /* Python interpreter main program */
   2
   3 #include "Python.h"
   4 #include "osdefs.h"
   5 #include "code.h" /* For CO_FUTURE_DIVISION */
   6 #include "import.h"
   7
   8 #ifdef __VMS
   9 #include <unixlib.h>
  10 #endif
  11
  12 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
  13 #ifdef HAVE_FCNTL_H
  14 #include <fcntl.h>
  15 #endif
  16 #endif
  17
  18 #if (defined(PYOS_OS2) && !defined(PYCC_GCC)) || defined(MS_WINDOWS)
  19 #define PYTHONHOMEHELP "<prefix>\\lib"
  20 #else
  21 #if defined(PYOS_OS2) && defined(PYCC_GCC)
  22 #define PYTHONHOMEHELP "<prefix>/Lib"
  23 #else
  24 #define PYTHONHOMEHELP "<prefix>/pythonX.X"
  25 #endif
  26 #endif
  27
  28 #include "pygetopt.h"
  29
  30 #define COPYRIGHT \
  31     "Type \"help\", \"copyright\", \"credits\" or \"license\" " \
  32     "for more information."
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 /* For Py_GetArgcArgv(); set by main() */
  39 static char **orig_argv;
  40 static int  orig_argc;
  41
  42 /* command line options */
  43 #define BASE_OPTS "3bBc:dEhiJm:OQ:sStuUvVW:xX?"
  44
  45 #ifndef RISCOS
  46 #define PROGRAM_OPTS BASE_OPTS
  47 #else /*RISCOS*/
  48 /* extra option saying that we are running under a special task window
  49    frontend; especially my_readline will behave different */
  50 #define PROGRAM_OPTS BASE_OPTS "w"
  51 /* corresponding flag */
  52 extern int Py_RISCOSWimpFlag;
  53 #endif /*RISCOS*/
  54
  55 /* Short usage message (with %s for argv0) */
  56 static char *usage_line =
  57 "usage: %s [option] ... [-c cmd | -m mod | file | -] [arg] ...\n";
  58
  59 /* Long usage message, split into parts < 512 bytes */
  60 static char *usage_1 = "\
  61 Options and arguments (and corresponding environment variables):\n\
  62 -B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
  63 -c cmd : program passed in as string (terminates option list)\n\
  64 -d     : debug output from parser; also PYTHONDEBUG=x\n\
  65 -E     : ignore PYTHON* environment variables (such as PYTHONPATH)\n\
  66 -h     : print this help message and exit (also --help)\n\
  67 -i     : inspect interactively after running script; forces a prompt even\n\
  68 ";
  69 static char *usage_2 = "\
  70          if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
  71 -m mod : run library module as a script (terminates option list)\n\
  72 -O     : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\
  73 -OO    : remove doc-strings in addition to the -O optimizations\n\
  74 -Q arg : division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew\n\
  75 -s     : don't add user site directory to sys.path; also PYTHONNOUSERSITE\n\
  76 -S     : don't imply 'import site' on initialization\n\
  77 -t     : issue warnings about inconsistent tab usage (-tt: issue errors)\n\
  78 ";
  79 static char *usage_3 = "\
  80 -u     : unbuffered binary stdout and stderr; also PYTHONUNBUFFERED=x\n\
  81          see man page for details on internal buffering relating to '-u'\n\
  82 -v     : verbose (trace import statements); also PYTHONVERBOSE=x\n\
  83          can be supplied multiple times to increase verbosity\n\
  84 -V     : print the Python version number and exit (also --version)\n\
  85 -W arg : warning control; arg is action:message:category:module:lineno\n\
  86 -x     : skip first line of source, allowing use of non-Unix forms of #!cmd\n\
  87 ";
  88 static char *usage_4 = "\
  89 -3     : warn about Python 3.x incompatibilities that 2to3 cannot trivially fix\n\
  90 file   : program read from script file\n\
  91 -      : program read from stdin (default; interactive mode if a tty)\n\
  92 arg ...: arguments passed to program in sys.argv[1:]\n\n\
  93 Other environment variables:\n\
  94 PYTHONSTARTUP: file executed on interactive startup (no default)\n\
  95 PYTHONPATH   : '%c'-separated list of directories prefixed to the\n\
  96                default module search path.  The result is sys.path.\n\
  97 ";
  98 static char *usage_5 = "\
  99 PYTHONHOME   : alternate <prefix> directory (or <prefix>%c<exec_prefix>).\n\
 100                The default module search path uses %s.\n\
 101 PYTHONCASEOK : ignore case in 'import' statements (Windows).\n\
 102 PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n\
 103 ";
 104
 105
 106 static int
 107 usage(int exitcode, char* program)
 108 {
 109         FILE *f = exitcode ? stderr : stdout;
 110
 111         fprintf(f, usage_line, program);
 112         if (exitcode)
 113                 fprintf(f, "Try `python -h' for more information.\n");
 114         else {
 115                 fprintf(f, usage_1);
 116                 fprintf(f, usage_2);
 117                 fprintf(f, usage_3);
 118                 fprintf(f, usage_4, DELIM);
 119                 fprintf(f, usage_5, DELIM, PYTHONHOMEHELP);
 120         }
 121 #if defined(__VMS)
 122         if (exitcode == 0) {
 123                 /* suppress 'error' message */
 124                 return 1;
 125         }
 126         else {
 127                 /* STS$M_INHIB_MSG + SS$_ABORT */
 128                 return 0x1000002c;
 129         }
 130 #else
 131         return exitcode;
 132 #endif
 133         /*NOTREACHED*/
 134 }
 135
 136 static void RunStartupFile(PyCompilerFlags *cf)
 137 {
 138         char *startup = Py_GETENV("PYTHONSTARTUP");
 139         if (startup != NULL && startup[0] != '\0') {
 140                 FILE *fp = fopen(startup, "r");
 141                 if (fp != NULL) {
 142                         (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
 143                         PyErr_Clear();
 144                         fclose(fp);
 145                } else {
 146                         int save_errno;
 147                         save_errno = errno;
 148                         PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
 149                         errno = save_errno;
 150                         PyErr_SetFromErrnoWithFilename(PyExc_IOError,
 151                                                        startup);
 152                         PyErr_Print();
 153                         PyErr_Clear();
 154                 }
 155         }
 156 }
 157
 158
 159 static int RunModule(char *module, int set_argv0)
 160 {
 161         PyObject *runpy, *runmodule, *runargs, *result;
 162         runpy = PyImport_ImportModule("runpy");
 163         if (runpy == NULL) {
 164                 fprintf(stderr, "Could not import runpy module\n");
 165                 return -1;
 166         }
 167         runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
 168         if (runmodule == NULL) {
 169                 fprintf(stderr, "Could not access runpy._run_module_as_main\n");
 170                 Py_DECREF(runpy);
 171                 return -1;
 172         }
 173         runargs = Py_BuildValue("(si)", module, set_argv0);
 174         if (runargs == NULL) {
 175                 fprintf(stderr,
 176                         "Could not create arguments for runpy._run_module_as_main\n");
 177                 Py_DECREF(runpy);
 178                 Py_DECREF(runmodule);
 179                 return -1;
 180         }
 181         result = PyObject_Call(runmodule, runargs, NULL);
 182         if (result == NULL) {
 183                 PyErr_Print();
 184         }
 185         Py_DECREF(runpy);
 186         Py_DECREF(runmodule);
 187         Py_DECREF(runargs);
 188         if (result == NULL) {
 189                 return -1;
 190         }
 191         Py_DECREF(result);
 192         return 0;
 193 }
 194
 195 static int RunMainFromImporter(char *filename)
 196 {
 197         PyObject *argv0 = NULL, *importer = NULL;
 198
 199         if ((argv0 = PyString_FromString(filename)) &&
 200             (importer = PyImport_GetImporter(argv0)) &&
 201             (importer->ob_type != &PyNullImporter_Type))
 202         {
 203                  /* argv0 is usable as an import source, so
 204                         put it in sys.path[0] and import __main__ */
 205                 PyObject *sys_path = NULL;
 206                 if ((sys_path = PySys_GetObject("path")) &&
 207                     !PyList_SetItem(sys_path, 0, argv0))
 208                 {
 209                         Py_INCREF(argv0);
 210                         Py_DECREF(importer);
 211                         sys_path = NULL;
 212                         return RunModule("__main__", 0) != 0;
 213                 }
 214         }
 215         Py_XDECREF(argv0);
 216         Py_XDECREF(importer);
 217         if (PyErr_Occurred()) {
 218                 PyErr_Print();
 219                 return 1;
 220         }
 221         return -1;
 222 }
 223
 224
 225 /* Wait until threading._shutdown completes, provided
 226    the threading module was imported in the first place.
 227    The shutdown routine will wait until all non-daemon
 228    "threading" threads have completed. */
 229 #include "abstract.h"
 230 static void
 231 WaitForThreadShutdown(void)
 232 {
 233 #ifdef WITH_THREAD
 234         PyObject *result;
 235         PyThreadState *tstate = PyThreadState_GET();
 236         PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
 237                                                       "threading");
 238         if (threading == NULL) {
 239                 /* threading not imported */
 240                 PyErr_Clear();
 241                 return;
 242         }
 243         result = PyObject_CallMethod(threading, "_shutdown", "");
 244         if (result == NULL)
 245                 PyErr_WriteUnraisable(threading);
 246         else
 247                 Py_DECREF(result);
 248         Py_DECREF(threading);
 249 #endif
 250 }
 251
 252 /* Main program */
 253
 254 int
 255 Py_Main(int argc, char **argv)
 256 {
 257         int c;
 258         int sts;
 259         char *command = NULL;
 260         char *filename = NULL;
 261         char *module = NULL;
 262         FILE *fp = stdin;
 263         char *p;
 264         int unbuffered = 0;
 265         int skipfirstline = 0;
 266         int stdin_is_interactive = 0;
 267         int help = 0;
 268         int version = 0;
 269         int saw_unbuffered_flag = 0;
 270         PyCompilerFlags cf;
 271
 272         cf.cf_flags = 0;
 273
 274         orig_argc = argc;       /* For Py_GetArgcArgv() */
 275         orig_argv = argv;
 276
 277 #ifdef RISCOS
 278         Py_RISCOSWimpFlag = 0;
 279 #endif
 280
 281         PySys_ResetWarnOptions();
 282
 283         while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
 284                 if (c == 'c') {
 285                         /* -c is the last option; following arguments
 286                            that look like options are left for the
 287                            command to interpret. */
 288                         command = (char *)malloc(strlen(_PyOS_optarg) + 2);
 289                         if (command == NULL)
 290                                 Py_FatalError(
 291                                    "not enough memory to copy -c argument");
 292                         strcpy(command, _PyOS_optarg);
 293                         strcat(command, "\n");
 294                         break;
 295                 }
 296
 297                 if (c == 'm') {
 298                         /* -m is the last option; following arguments
 299                            that look like options are left for the
 300                            module to interpret. */
 301                         module = (char *)malloc(strlen(_PyOS_optarg) + 2);
 302                         if (module == NULL)
 303                                 Py_FatalError(
 304                                    "not enough memory to copy -m argument");
 305                         strcpy(module, _PyOS_optarg);
 306                         break;
 307                 }
 308
 309                 switch (c) {
 310                 case 'b':
 311                         Py_BytesWarningFlag++;
 312                         break;
 313
 314                 case 'd':
 315                         Py_DebugFlag++;
 316                         break;
 317
 318                 case '3':
 319                         Py_Py3kWarningFlag++;
 320                         if (!Py_DivisionWarningFlag)
 321                                 Py_DivisionWarningFlag = 1;
 322                         break;
 323
 324                 case 'Q':
 325                         if (strcmp(_PyOS_optarg, "old") == 0) {
 326                                 Py_DivisionWarningFlag = 0;
 327                                 break;
 328                         }
 329                         if (strcmp(_PyOS_optarg, "warn") == 0) {
 330                                 Py_DivisionWarningFlag = 1;
 331                                 break;
 332                         }
 333                         if (strcmp(_PyOS_optarg, "warnall") == 0) {
 334                                 Py_DivisionWarningFlag = 2;
 335                                 break;
 336                         }
 337                         if (strcmp(_PyOS_optarg, "new") == 0) {
 338                                 /* This only affects __main__ */
 339                                 cf.cf_flags |= CO_FUTURE_DIVISION;
 340                                 /* And this tells the eval loop to treat
 341                                    BINARY_DIVIDE as BINARY_TRUE_DIVIDE */
 342                                 _Py_QnewFlag = 1;
 343                                 break;
 344                         }
 345                         fprintf(stderr,
 346                                 "-Q option should be `-Qold', "
 347                                 "`-Qwarn', `-Qwarnall', or `-Qnew' only\n");
 348                         return usage(2, argv[0]);
 349                         /* NOTREACHED */
 350
 351                 case 'i':
 352                         Py_InspectFlag++;
 353                         Py_InteractiveFlag++;
 354                         break;
 355
 356                 /* case 'J': reserved for Jython */
 357
 358                 case 'O':
 359                         Py_OptimizeFlag++;
 360                         break;
 361
 362                 case 'B':
 363                         Py_DontWriteBytecodeFlag++;
 364                         break;
 365
 366                 case 's':
 367                         Py_NoUserSiteDirectory++;
 368                         break;
 369
 370                 case 'S':
 371                         Py_NoSiteFlag++;
 372                         break;
 373
 374                 case 'E':
 375                         Py_IgnoreEnvironmentFlag++;
 376                         break;
 377
 378                 case 't':
 379                         Py_TabcheckFlag++;
 380                         break;
 381
 382                 case 'u':
 383                         unbuffered++;
 384                         saw_unbuffered_flag = 1;
 385                         break;
 386
 387                 case 'v':
 388                         Py_VerboseFlag++;
 389                         break;
 390
 391 #ifdef RISCOS
 392                 case 'w':
 393                         Py_RISCOSWimpFlag = 1;
 394                         break;
 395 #endif
 396
 397                 case 'x':
 398                         skipfirstline = 1;
 399                         break;
 400
 401                 /* case 'X': reserved for implementation-specific arguments */
 402
 403                 case 'U':
 404                         Py_UnicodeFlag++;
 405                         break;
 406                 case 'h':
 407                 case '?':
 408                         help++;
 409                         break;
 410                 case 'V':
 411                         version++;
 412                         break;
 413
 414                 case 'W':
 415                         PySys_AddWarnOption(_PyOS_optarg);
 416                         break;
 417
 418                 /* This space reserved for other options */
 419
 420                 default:
 421                         return usage(2, argv[0]);
 422                         /*NOTREACHED*/
 423
 424                 }
 425         }
 426
 427         if (help)
 428                 return usage(0, argv[0]);
 429
 430         if (version) {
 431                 fprintf(stderr, "Python %s\n", PY_VERSION);
 432                 return 0;
 433         }
 434
 435         if (!Py_InspectFlag &&
 436             (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
 437                 Py_InspectFlag = 1;
 438         if (!saw_unbuffered_flag &&
 439             (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
 440                 unbuffered = 1;
 441
 442         if (!Py_NoUserSiteDirectory &&
 443             (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0')
 444                 Py_NoUserSiteDirectory = 1;
 445
 446         if (command == NULL && module == NULL && _PyOS_optind < argc &&
 447             strcmp(argv[_PyOS_optind], "-") != 0)
 448         {
 449 #ifdef __VMS
 450                 filename = decc$translate_vms(argv[_PyOS_optind]);
 451                 if (filename == (char *)0 || filename == (char *)-1)
 452                         filename = argv[_PyOS_optind];
 453
 454 #else
 455                 filename = argv[_PyOS_optind];
 456 #endif
 457         }
 458
 459         stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0);
 460
 461         if (unbuffered) {
 462 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
 463                 _setmode(fileno(stdin), O_BINARY);
 464                 _setmode(fileno(stdout), O_BINARY);
 465 #endif
 466 #ifdef HAVE_SETVBUF
 467                 setvbuf(stdin,  (char *)NULL, _IONBF, BUFSIZ);
 468                 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 469                 setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
 470 #else /* !HAVE_SETVBUF */
 471                 setbuf(stdin,  (char *)NULL);
 472                 setbuf(stdout, (char *)NULL);
 473                 setbuf(stderr, (char *)NULL);
 474 #endif /* !HAVE_SETVBUF */
 475         }
 476         else if (Py_InteractiveFlag) {
 477 #ifdef MS_WINDOWS
 478                 /* Doesn't have to have line-buffered -- use unbuffered */
 479                 /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
 480                 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 481 #else /* !MS_WINDOWS */
 482 #ifdef HAVE_SETVBUF
 483                 setvbuf(stdin,  (char *)NULL, _IOLBF, BUFSIZ);
 484                 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
 485 #endif /* HAVE_SETVBUF */
 486 #endif /* !MS_WINDOWS */
 487                 /* Leave stderr alone - it should be unbuffered anyway. */
 488         }
 489 #ifdef __VMS
 490         else {
 491                 setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ);
 492         }
 493 #endif /* __VMS */
 494
 495 #ifdef __APPLE__
 496         /* On MacOS X, when the Python interpreter is embedded in an
 497            application bundle, it gets executed by a bootstrapping script
 498            that does os.execve() with an argv[0] that's different from the
 499            actual Python executable. This is needed to keep the Finder happy,
 500            or rather, to work around Apple's overly strict requirements of
 501            the process name. However, we still need a usable sys.executable,
 502            so the actual executable path is passed in an environment variable.
 503            See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
 504            script. */
 505         if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0')
 506                 Py_SetProgramName(p);
 507         else
 508                 Py_SetProgramName(argv[0]);
 509 #else
 510         Py_SetProgramName(argv[0]);
 511 #endif
 512         Py_Initialize();
 513
 514         if (Py_VerboseFlag ||
 515             (command == NULL && filename == NULL && module == NULL && stdin_is_interactive)) {
 516                 fprintf(stderr, "Python %s on %s\n",
 517                         Py_GetVersion(), Py_GetPlatform());
 518                 if (!Py_NoSiteFlag)
 519                         fprintf(stderr, "%s\n", COPYRIGHT);
 520         }
 521
 522         if (command != NULL) {
 523                 /* Backup _PyOS_optind and force sys.argv[0] = '-c' */
 524                 _PyOS_optind--;
 525                 argv[_PyOS_optind] = "-c";
 526         }
 527
 528         if (module != NULL) {
 529                 /* Backup _PyOS_optind and force sys.argv[0] = '-c'
 530                    so that PySys_SetArgv correctly sets sys.path[0] to ''*/
 531                 _PyOS_optind--;
 532                 argv[_PyOS_optind] = "-c";
 533         }
 534
 535         PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
 536
 537         if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
 538             isatty(fileno(stdin))) {
 539                 PyObject *v;
 540                 v = PyImport_ImportModule("readline");
 541                 if (v == NULL)
 542                         PyErr_Clear();
 543                 else
 544                         Py_DECREF(v);
 545         }
 546
 547         if (command) {
 548                 sts = PyRun_SimpleStringFlags(command, &cf) != 0;
 549                 free(command);
 550         } else if (module) {
 551                 sts = RunModule(module, 1);
 552                 free(module);
 553         }
 554         else {
 555
 556                 if (filename == NULL && stdin_is_interactive) {
 557                         Py_InspectFlag = 0; /* do exit on SystemExit */
 558                         RunStartupFile(&cf);
 559                 }
 560                 /* XXX */
 561
 562                 sts = -1;       /* keep track of whether we've already run __main__ */
 563
 564                 if (filename != NULL) {
 565                         sts = RunMainFromImporter(filename);
 566                 }
 567
 568                 if (sts==-1 && filename!=NULL) {
 569                         if ((fp = fopen(filename, "r")) == NULL) {
 570                                 fprintf(stderr, "%s: can't open file '%s': [Errno %d] %s\n",
 571                                         argv[0], filename, errno, strerror(errno));
 572
 573                                 return 2;
 574                         }
 575                         else if (skipfirstline) {
 576                                 int ch;
 577                                 /* Push back first newline so line numbers
 578                                    remain the same */
 579                                 while ((ch = getc(fp)) != EOF) {
 580                                         if (ch == '\n') {
 581                                                 (void)ungetc(ch, fp);
 582                                                 break;
 583                                         }
 584                                 }
 585                         }
 586                         {
 587                                 /* XXX: does this work on Win/Win64? (see posix_fstat) */
 588                                 struct stat sb;
 589                                 if (fstat(fileno(fp), &sb) == 0 &&
 590                                     S_ISDIR(sb.st_mode)) {
 591                                         fprintf(stderr, "%s: '%s' is a directory, cannot continue\n", argv[0], filename);
 592                                         fclose(fp);
 593                                         return 1;
 594                                 }
 595                         }
 596                 }
 597
 598                 if (sts==-1) {
 599                         sts = PyRun_AnyFileExFlags(
 600                                 fp,
 601                                 filename == NULL ? "<stdin>" : filename,
 602                                 filename != NULL, &cf) != 0;
 603                 }
 604
 605         }
 606
 607         /* Check this environment variable at the end, to give programs the
 608          * opportunity to set it from Python.
 609          */
 610         if (!Py_InspectFlag &&
 611             (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
 612         {
 613                 Py_InspectFlag = 1;
 614         }
 615
 616         if (Py_InspectFlag && stdin_is_interactive &&
 617             (filename != NULL || command != NULL || module != NULL)) {
 618                 Py_InspectFlag = 0;
 619                 /* XXX */
 620                 sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0;
 621         }
 622
 623         WaitForThreadShutdown();
 624
 625         Py_Finalize();
 626 #ifdef RISCOS
 627         if (Py_RISCOSWimpFlag)
 628                 fprintf(stderr, "\x0cq\x0c"); /* make frontend quit */
 629 #endif
 630
 631 #ifdef __INSURE__
 632         /* Insure++ is a memory analysis tool that aids in discovering
 633          * memory leaks and other memory problems.  On Python exit, the
 634          * interned string dictionary is flagged as being in use at exit
 635          * (which it is).  Under normal circumstances, this is fine because
 636          * the memory will be automatically reclaimed by the system.  Under
 637          * memory debugging, it's a huge source of useless noise, so we
 638          * trade off slower shutdown for less distraction in the memory
 639          * reports.  -baw
 640          */
 641         _Py_ReleaseInternedStrings();
 642 #endif /* __INSURE__ */
 643
 644         return sts;
 645 }
 646
 647 /* this is gonna seem *real weird*, but if you put some other code between
 648    Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the
 649    while statement in Misc/gdbinit:ppystack */
 650
 651 /* Make the *original* argc/argv available to other modules.
 652    This is rare, but it is needed by the secureware extension. */
 653
 654 void
 655 Py_GetArgcArgv(int *argc, char ***argv)
 656 {
 657         *argc = orig_argc;
 658         *argv = orig_argv;
 659 }
 660
 661 #ifdef __cplusplus
 662 }
 663 #endif
 664