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                         break;
 321
 322                 case 'Q':
 323                         if (strcmp(_PyOS_optarg, "old") == 0) {
 324                                 Py_DivisionWarningFlag = 0;
 325                                 break;
 326                         }
 327                         if (strcmp(_PyOS_optarg, "warn") == 0) {
 328                                 Py_DivisionWarningFlag = 1;
 329                                 break;
 330                         }
 331                         if (strcmp(_PyOS_optarg, "warnall") == 0) {
 332                                 Py_DivisionWarningFlag = 2;
 333                                 break;
 334                         }
 335                         if (strcmp(_PyOS_optarg, "new") == 0) {
 336                                 /* This only affects __main__ */
 337                                 cf.cf_flags |= CO_FUTURE_DIVISION;
 338                                 /* And this tells the eval loop to treat
 339                                    BINARY_DIVIDE as BINARY_TRUE_DIVIDE */
 340                                 _Py_QnewFlag = 1;
 341                                 break;
 342                         }
 343                         fprintf(stderr,
 344                                 "-Q option should be `-Qold', "
 345                                 "`-Qwarn', `-Qwarnall', or `-Qnew' only\n");
 346                         return usage(2, argv[0]);
 347                         /* NOTREACHED */
 348
 349                 case 'i':
 350                         Py_InspectFlag++;
 351                         Py_InteractiveFlag++;
 352                         break;
 353
 354                 /* case 'J': reserved for Jython */
 355
 356                 case 'O':
 357                         Py_OptimizeFlag++;
 358                         break;
 359
 360                 case 'B':
 361                         Py_DontWriteBytecodeFlag++;
 362                         break;
 363
 364                 case 's':
 365                         Py_NoUserSiteDirectory++;
 366                         break;
 367
 368                 case 'S':
 369                         Py_NoSiteFlag++;
 370                         break;
 371
 372                 case 'E':
 373                         Py_IgnoreEnvironmentFlag++;
 374                         break;
 375
 376                 case 't':
 377                         Py_TabcheckFlag++;
 378                         break;
 379
 380                 case 'u':
 381                         unbuffered++;
 382                         saw_unbuffered_flag = 1;
 383                         break;
 384
 385                 case 'v':
 386                         Py_VerboseFlag++;
 387                         break;
 388
 389 #ifdef RISCOS
 390                 case 'w':
 391                         Py_RISCOSWimpFlag = 1;
 392                         break;
 393 #endif
 394
 395                 case 'x':
 396                         skipfirstline = 1;
 397                         break;
 398
 399                 /* case 'X': reserved for implementation-specific arguments */
 400
 401                 case 'U':
 402                         Py_UnicodeFlag++;
 403                         break;
 404                 case 'h':
 405                 case '?':
 406                         help++;
 407                         break;
 408                 case 'V':
 409                         version++;
 410                         break;
 411
 412                 case 'W':
 413                         PySys_AddWarnOption(_PyOS_optarg);
 414                         break;
 415
 416                 /* This space reserved for other options */
 417
 418                 default:
 419                         return usage(2, argv[0]);
 420                         /*NOTREACHED*/
 421
 422                 }
 423         }
 424
 425         if (help)
 426                 return usage(0, argv[0]);
 427
 428         if (version) {
 429                 fprintf(stderr, "Python %s\n", PY_VERSION);
 430                 return 0;
 431         }
 432
 433         if (!Py_InspectFlag &&
 434             (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
 435                 Py_InspectFlag = 1;
 436         if (!saw_unbuffered_flag &&
 437             (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
 438                 unbuffered = 1;
 439
 440         if (!Py_NoUserSiteDirectory &&
 441             (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0')
 442                 Py_NoUserSiteDirectory = 1;
 443
 444         if (command == NULL && module == NULL && _PyOS_optind < argc &&
 445             strcmp(argv[_PyOS_optind], "-") != 0)
 446         {
 447 #ifdef __VMS
 448                 filename = decc$translate_vms(argv[_PyOS_optind]);
 449                 if (filename == (char *)0 || filename == (char *)-1)
 450                         filename = argv[_PyOS_optind];
 451
 452 #else
 453                 filename = argv[_PyOS_optind];
 454 #endif
 455         }
 456
 457         stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0);
 458
 459         if (unbuffered) {
 460 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
 461                 _setmode(fileno(stdin), O_BINARY);
 462                 _setmode(fileno(stdout), O_BINARY);
 463 #endif
 464 #ifdef HAVE_SETVBUF
 465                 setvbuf(stdin,  (char *)NULL, _IONBF, BUFSIZ);
 466                 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 467                 setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
 468 #else /* !HAVE_SETVBUF */
 469                 setbuf(stdin,  (char *)NULL);
 470                 setbuf(stdout, (char *)NULL);
 471                 setbuf(stderr, (char *)NULL);
 472 #endif /* !HAVE_SETVBUF */
 473         }
 474         else if (Py_InteractiveFlag) {
 475 #ifdef MS_WINDOWS
 476                 /* Doesn't have to have line-buffered -- use unbuffered */
 477                 /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
 478                 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 479 #else /* !MS_WINDOWS */
 480 #ifdef HAVE_SETVBUF
 481                 setvbuf(stdin,  (char *)NULL, _IOLBF, BUFSIZ);
 482                 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
 483 #endif /* HAVE_SETVBUF */
 484 #endif /* !MS_WINDOWS */
 485                 /* Leave stderr alone - it should be unbuffered anyway. */
 486         }
 487 #ifdef __VMS
 488         else {
 489                 setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ);
 490         }
 491 #endif /* __VMS */
 492
 493 #ifdef __APPLE__
 494         /* On MacOS X, when the Python interpreter is embedded in an
 495            application bundle, it gets executed by a bootstrapping script
 496            that does os.execve() with an argv[0] that's different from the
 497            actual Python executable. This is needed to keep the Finder happy,
 498            or rather, to work around Apple's overly strict requirements of
 499            the process name. However, we still need a usable sys.executable,
 500            so the actual executable path is passed in an environment variable.
 501            See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
 502            script. */
 503         if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0')
 504                 Py_SetProgramName(p);
 505         else
 506                 Py_SetProgramName(argv[0]);
 507 #else
 508         Py_SetProgramName(argv[0]);
 509 #endif
 510         Py_Initialize();
 511
 512         if (Py_VerboseFlag ||
 513             (command == NULL && filename == NULL && module == NULL && stdin_is_interactive)) {
 514                 fprintf(stderr, "Python %s on %s\n",
 515                         Py_GetVersion(), Py_GetPlatform());
 516                 if (!Py_NoSiteFlag)
 517                         fprintf(stderr, "%s\n", COPYRIGHT);
 518         }
 519
 520         if (command != NULL) {
 521                 /* Backup _PyOS_optind and force sys.argv[0] = '-c' */
 522                 _PyOS_optind--;
 523                 argv[_PyOS_optind] = "-c";
 524         }
 525
 526         if (module != NULL) {
 527                 /* Backup _PyOS_optind and force sys.argv[0] = '-c'
 528                    so that PySys_SetArgv correctly sets sys.path[0] to ''*/
 529                 _PyOS_optind--;
 530                 argv[_PyOS_optind] = "-c";
 531         }
 532
 533         PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
 534
 535         if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
 536             isatty(fileno(stdin))) {
 537                 PyObject *v;
 538                 v = PyImport_ImportModule("readline");
 539                 if (v == NULL)
 540                         PyErr_Clear();
 541                 else
 542                         Py_DECREF(v);
 543         }
 544
 545         if (command) {
 546                 sts = PyRun_SimpleStringFlags(command, &cf) != 0;
 547                 free(command);
 548         } else if (module) {
 549                 sts = RunModule(module, 1);
 550                 free(module);
 551         }
 552         else {
 553
 554                 if (filename == NULL && stdin_is_interactive) {
 555                         Py_InspectFlag = 0; /* do exit on SystemExit */
 556                         RunStartupFile(&cf);
 557                 }
 558                 /* XXX */
 559
 560                 sts = -1;       /* keep track of whether we've already run __main__ */
 561
 562                 if (filename != NULL) {
 563                         sts = RunMainFromImporter(filename);
 564                 }
 565
 566                 if (sts==-1 && filename!=NULL) {
 567                         if ((fp = fopen(filename, "r")) == NULL) {
 568                                 fprintf(stderr, "%s: can't open file '%s': [Errno %d] %s\n",
 569                                         argv[0], filename, errno, strerror(errno));
 570
 571                                 return 2;
 572                         }
 573                         else if (skipfirstline) {
 574                                 int ch;
 575                                 /* Push back first newline so line numbers
 576                                    remain the same */
 577                                 while ((ch = getc(fp)) != EOF) {
 578                                         if (ch == '\n') {
 579                                                 (void)ungetc(ch, fp);
 580                                                 break;
 581                                         }
 582                                 }
 583                         }
 584                         {
 585                                 /* XXX: does this work on Win/Win64? (see posix_fstat) */
 586                                 struct stat sb;
 587                                 if (fstat(fileno(fp), &sb) == 0 &&
 588                                     S_ISDIR(sb.st_mode)) {
 589                                         fprintf(stderr, "%s: '%s' is a directory, cannot continue\n", argv[0], filename);
 590                                         fclose(fp);
 591                                         return 1;
 592                                 }
 593                         }
 594                 }
 595
 596                 if (sts==-1) {
 597                         sts = PyRun_AnyFileExFlags(
 598                                 fp,
 599                                 filename == NULL ? "<stdin>" : filename,
 600                                 filename != NULL, &cf) != 0;
 601                 }
 602
 603         }
 604
 605         /* Check this environment variable at the end, to give programs the
 606          * opportunity to set it from Python.
 607          */
 608         if (!Py_InspectFlag &&
 609             (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
 610         {
 611                 Py_InspectFlag = 1;
 612         }
 613
 614         if (Py_InspectFlag && stdin_is_interactive &&
 615             (filename != NULL || command != NULL || module != NULL)) {
 616                 Py_InspectFlag = 0;
 617                 /* XXX */
 618                 sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0;
 619         }
 620
 621         WaitForThreadShutdown();
 622
 623         Py_Finalize();
 624 #ifdef RISCOS
 625         if (Py_RISCOSWimpFlag)
 626                 fprintf(stderr, "\x0cq\x0c"); /* make frontend quit */
 627 #endif
 628
 629 #ifdef __INSURE__
 630         /* Insure++ is a memory analysis tool that aids in discovering
 631          * memory leaks and other memory problems.  On Python exit, the
 632          * interned string dictionary is flagged as being in use at exit
 633          * (which it is).  Under normal circumstances, this is fine because
 634          * the memory will be automatically reclaimed by the system.  Under
 635          * memory debugging, it's a huge source of useless noise, so we
 636          * trade off slower shutdown for less distraction in the memory
 637          * reports.  -baw
 638          */
 639         _Py_ReleaseInternedStrings();
 640 #endif /* __INSURE__ */
 641
 642         return sts;
 643 }
 644
 645 /* this is gonna seem *real weird*, but if you put some other code between
 646    Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the
 647    while statement in Misc/gdbinit:ppystack */
 648
 649 /* Make the *original* argc/argv available to other modules.
 650    This is rare, but it is needed by the secureware extension. */
 651
 652 void
 653 Py_GetArgcArgv(int *argc, char ***argv)
 654 {
 655         *argc = orig_argc;
 656         *argv = orig_argv;
 657 }
 658
 659 #ifdef __cplusplus
 660 }
 661 #endif
 662