Mercurial > cpython-lru_cache-weakref

comparison Python/pythonrun.c @ 35742:1c4d192f1568 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge ast-branch to head This change implements a new bytecode compiler, based on a transformation of the parse tree to an abstract syntax defined in Parser/Python.asdl. The compiler implementation is not complete, but it is in stable enough shape to run the entire test suite excepting two disabled tests.
author Jeremy Hylton <jeremy@alum.mit.edu>
date Thu, 20 Oct 2005 19:59:25 +0000
parents b8e571e6de2e
children 72555a967d6a
comparison
equal deleted inserted replaced
35741:3716051830c2 35742:1c4d192f1568
1 1
2 /* Python interpreter top-level routines, including init/exit */ 2 /* Python interpreter top-level routines, including init/exit */
3 3
4 #include "Python.h" 4 #include "Python.h"
5 5
6 #include "Python-ast.h"
6 #include "grammar.h" 7 #include "grammar.h"
7 #include "node.h" 8 #include "node.h"
8 #include "token.h" 9 #include "token.h"
9 #include "parsetok.h" 10 #include "parsetok.h"
10 #include "errcode.h" 11 #include "errcode.h"
12 #include "code.h"
11 #include "compile.h" 13 #include "compile.h"
12 #include "symtable.h" 14 #include "symtable.h"
15 #include "ast.h"
13 #include "eval.h" 16 #include "eval.h"
14 #include "marshal.h" 17 #include "marshal.h"
15 18
16 #include <signal.h> 19 #include <signal.h>
17 20
30 extern grammar _PyParser_Grammar; /* From graminit.c */ 33 extern grammar _PyParser_Grammar; /* From graminit.c */
31 34
32 /* Forward */ 35 /* Forward */
33 static void initmain(void); 36 static void initmain(void);
34 static void initsite(void); 37 static void initsite(void);
35 static PyObject *run_err_node(node *, const char *, PyObject *, PyObject *, 38 static PyObject *run_err_mod(mod_ty, const char *, PyObject *, PyObject *,
36 PyCompilerFlags *); 39 PyCompilerFlags *);
37 static PyObject *run_node(node *, const char *, PyObject *, PyObject *, 40 static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *,
38 PyCompilerFlags *); 41 PyCompilerFlags *);
39 static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *, 42 static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,
40 PyCompilerFlags *); 43 PyCompilerFlags *);
41 static void err_input(perrdetail *); 44 static void err_input(perrdetail *);
42 static void initsigs(void); 45 static void initsigs(void);
632 } 635 }
633 636
634 /* Parse input from a file and execute it */ 637 /* Parse input from a file and execute it */
635 638
636 int 639 int
637 PyRun_AnyFile(FILE *fp, const char *filename) 640 PyRun_AnyFileExFlags(FILE *fp, char *filename, int closeit,
638 {
639 return PyRun_AnyFileExFlags(fp, filename, 0, NULL);
640 }
641
642 int
643 PyRun_AnyFileFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
644 {
645 return PyRun_AnyFileExFlags(fp, filename, 0, flags);
646 }
647
648 int
649 PyRun_AnyFileEx(FILE *fp, const char *filename, int closeit)
650 {
651 return PyRun_AnyFileExFlags(fp, filename, closeit, NULL);
652 }
653
654 int
655 PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
656 PyCompilerFlags *flags) 641 PyCompilerFlags *flags)
657 { 642 {
658 if (filename == NULL) 643 if (filename == NULL)
659 filename = "???"; 644 filename = "???";
660 if (Py_FdIsInteractive(fp, filename)) { 645 if (Py_FdIsInteractive(fp, filename)) {
666 else 651 else
667 return PyRun_SimpleFileExFlags(fp, filename, closeit, flags); 652 return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
668 } 653 }
669 654
670 int 655 int
671 PyRun_InteractiveLoop(FILE *fp, const char *filename)
672 {
673 return PyRun_InteractiveLoopFlags(fp, filename, NULL);
674 }
675
676 int
677 PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) 656 PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
678 { 657 {
679 PyObject *v; 658 PyObject *v;
680 int ret; 659 int ret;
681 PyCompilerFlags local_flags; 660 PyCompilerFlags local_flags;
706 return -1; 685 return -1;
707 */ 686 */
708 } 687 }
709 } 688 }
710 689
711 int
712 PyRun_InteractiveOne(FILE *fp, const char *filename)
713 {
714 return PyRun_InteractiveOneFlags(fp, filename, NULL);
715 }
716
717 /* compute parser flags based on compiler flags */ 690 /* compute parser flags based on compiler flags */
718 #define PARSER_FLAGS(flags) \ 691 #define PARSER_FLAGS(flags) \
719 (((flags) && (flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \ 692 (((flags) && (flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
720 PyPARSE_DONT_IMPLY_DEDENT : 0) 693 PyPARSE_DONT_IMPLY_DEDENT : 0)
721 694
722 int 695 int
723 PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) 696 PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
724 { 697 {
725 PyObject *m, *d, *v, *w; 698 PyObject *m, *d, *v, *w;
726 node *n; 699 mod_ty mod;
727 perrdetail err;
728 char *ps1 = "", *ps2 = ""; 700 char *ps1 = "", *ps2 = "";
701 int errcode = 0;
729 702
730 v = PySys_GetObject("ps1"); 703 v = PySys_GetObject("ps1");
731 if (v != NULL) { 704 if (v != NULL) {
732 v = PyObject_Str(v); 705 v = PyObject_Str(v);
733 if (v == NULL) 706 if (v == NULL)
741 if (w == NULL) 714 if (w == NULL)
742 PyErr_Clear(); 715 PyErr_Clear();
743 else if (PyString_Check(w)) 716 else if (PyString_Check(w))
744 ps2 = PyString_AsString(w); 717 ps2 = PyString_AsString(w);
745 } 718 }
746 n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar, 719 mod = PyParser_ASTFromFile(fp, filename,
747 Py_single_input, ps1, ps2, &err, 720 Py_single_input, ps1, ps2,
748 PARSER_FLAGS(flags)); 721 flags, &errcode);
749 Py_XDECREF(v); 722 Py_XDECREF(v);
750 Py_XDECREF(w); 723 Py_XDECREF(w);
751 if (n == NULL) { 724 if (mod == NULL) {
752 if (err.error == E_EOF) { 725 if (errcode == E_EOF) {
753 if (err.text) 726 PyErr_Clear();
754 PyMem_DEL(err.text);
755 return E_EOF; 727 return E_EOF;
756 } 728 }
757 err_input(&err);
758 PyErr_Print(); 729 PyErr_Print();
759 return err.error; 730 return -1;
760 } 731 }
761 m = PyImport_AddModule("__main__"); 732 m = PyImport_AddModule("__main__");
762 if (m == NULL) 733 if (m == NULL)
763 return -1; 734 return -1;
764 d = PyModule_GetDict(m); 735 d = PyModule_GetDict(m);
765 v = run_node(n, filename, d, d, flags); 736 v = run_mod(mod, filename, d, d, flags);
737 free_mod(mod);
766 if (v == NULL) { 738 if (v == NULL) {
767 PyErr_Print(); 739 PyErr_Print();
768 return -1; 740 return -1;
769 } 741 }
770 Py_DECREF(v); 742 Py_DECREF(v);
771 if (Py_FlushLine()) 743 if (Py_FlushLine())
772 PyErr_Clear(); 744 PyErr_Clear();
773 return 0; 745 return 0;
774 }
775
776 int
777 PyRun_SimpleFile(FILE *fp, const char *filename)
778 {
779 return PyRun_SimpleFileEx(fp, filename, 0);
780 } 746 }
781 747
782 /* Check whether a file maybe a pyc file: Look at the extension, 748 /* Check whether a file maybe a pyc file: Look at the extension,
783 the file type, and, if we may close it, at the first few bytes. */ 749 the file type, and, if we may close it, at the first few bytes. */
784 750
818 } 784 }
819 return 0; 785 return 0;
820 } 786 }
821 787
822 int 788 int
823 PyRun_SimpleFileEx(FILE *fp, const char *filename, int closeit)
824 {
825 return PyRun_SimpleFileExFlags(fp, filename, closeit, NULL);
826 }
827
828 int
829 PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, 789 PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
830 PyCompilerFlags *flags) 790 PyCompilerFlags *flags)
831 { 791 {
832 PyObject *m, *d, *v; 792 PyObject *m, *d, *v;
833 const char *ext; 793 const char *ext;
869 } 829 }
870 Py_DECREF(v); 830 Py_DECREF(v);
871 if (Py_FlushLine()) 831 if (Py_FlushLine())
872 PyErr_Clear(); 832 PyErr_Clear();
873 return 0; 833 return 0;
874 }
875
876 int
877 PyRun_SimpleString(const char *command)
878 {
879 return PyRun_SimpleStringFlags(command, NULL);
880 } 834 }
881 835
882 int 836 int
883 PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags) 837 PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
884 { 838 {
1052 1006
1053 if (PyErr_ExceptionMatches(PyExc_SystemExit)) { 1007 if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
1054 handle_system_exit(); 1008 handle_system_exit();
1055 } 1009 }
1056 PyErr_Fetch(&exception, &v, &tb); 1010 PyErr_Fetch(&exception, &v, &tb);
1011 if (exception == NULL)
1012 return;
1057 PyErr_NormalizeException(&exception, &v, &tb); 1013 PyErr_NormalizeException(&exception, &v, &tb);
1058 if (exception == NULL) 1014 if (exception == NULL)
1059 return; 1015 return;
1060 if (set_sys_last_vars) { 1016 if (set_sys_last_vars) {
1061 PySys_SetObject("last_type", exception); 1017 PySys_SetObject("last_type", exception);
1193 if (err != 0) 1149 if (err != 0)
1194 PyErr_Clear(); 1150 PyErr_Clear();
1195 } 1151 }
1196 1152
1197 PyObject * 1153 PyObject *
1198 PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals) 1154 PyRun_StringFlags(const char *str, int start, PyObject *globals,
1199 { 1155 PyObject *locals, PyCompilerFlags *flags)
1200 return run_err_node(PyParser_SimpleParseString(str, start), 1156 {
1201 "<string>", globals, locals, NULL); 1157 PyObject *ret;
1202 } 1158 mod_ty mod = PyParser_ASTFromString(str, "<string>", start, flags);
1203 1159 ret = run_err_mod(mod, "<string>", globals, locals, flags);
1204 PyObject * 1160 free_mod(mod);
1205 PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, 1161 return ret;
1206 PyObject *locals)
1207 {
1208 return PyRun_FileEx(fp, filename, start, globals, locals, 0);
1209 }
1210
1211 PyObject *
1212 PyRun_FileEx(FILE *fp, const char *filename, int start, PyObject *globals,
1213 PyObject *locals, int closeit)
1214 {
1215 node *n = PyParser_SimpleParseFile(fp, filename, start);
1216 if (closeit)
1217 fclose(fp);
1218 return run_err_node(n, filename, globals, locals, NULL);
1219 }
1220
1221 PyObject *
1222 PyRun_StringFlags(const char *str, int start, PyObject *globals, PyObject *locals,
1223 PyCompilerFlags *flags)
1224 {
1225 return run_err_node(PyParser_SimpleParseStringFlags(
1226 str, start, PARSER_FLAGS(flags)),
1227 "<string>", globals, locals, flags);
1228 }
1229
1230 PyObject *
1231 PyRun_FileFlags(FILE *fp, const char *filename, int start, PyObject *globals,
1232 PyObject *locals, PyCompilerFlags *flags)
1233 {
1234 return PyRun_FileExFlags(fp, filename, start, globals, locals, 0,
1235 flags);
1236 } 1162 }
1237 1163
1238 PyObject * 1164 PyObject *
1239 PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, 1165 PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
1240 PyObject *locals, int closeit, PyCompilerFlags *flags) 1166 PyObject *locals, int closeit, PyCompilerFlags *flags)
1241 { 1167 {
1242 node *n = PyParser_SimpleParseFileFlags(fp, filename, start, 1168 PyObject *ret;
1243 PARSER_FLAGS(flags)); 1169 mod_ty mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
1170 flags, NULL);
1171 if (mod == NULL)
1172 return NULL;
1244 if (closeit) 1173 if (closeit)
1245 fclose(fp); 1174 fclose(fp);
1246 return run_err_node(n, filename, globals, locals, flags); 1175 ret = run_err_mod(mod, filename, globals, locals, flags);
1176 free_mod(mod);
1177 return ret;
1247 } 1178 }
1248 1179
1249 static PyObject * 1180 static PyObject *
1250 run_err_node(node *n, const char *filename, PyObject *globals, PyObject *locals, 1181 run_err_mod(mod_ty mod, const char *filename, PyObject *globals,
1251 PyCompilerFlags *flags) 1182 PyObject *locals, PyCompilerFlags *flags)
1252 { 1183 {
1253 if (n == NULL) 1184 if (mod == NULL)
1254 return NULL; 1185 return NULL;
1255 return run_node(n, filename, globals, locals, flags); 1186 return run_mod(mod, filename, globals, locals, flags);
1256 } 1187 }
1257 1188
1258 static PyObject * 1189 static PyObject *
1259 run_node(node *n, const char *filename, PyObject *globals, PyObject *locals, 1190 run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
1260 PyCompilerFlags *flags) 1191 PyCompilerFlags *flags)
1261 { 1192 {
1262 PyCodeObject *co; 1193 PyCodeObject *co;
1263 PyObject *v; 1194 PyObject *v;
1264 co = PyNode_CompileFlags(n, filename, flags); 1195 co = PyAST_Compile(mod, filename, flags);
1265 PyNode_Free(n);
1266 if (co == NULL) 1196 if (co == NULL)
1267 return NULL; 1197 return NULL;
1268 v = PyEval_EvalCode(co, globals, locals); 1198 v = PyEval_EvalCode(co, globals, locals);
1269 Py_DECREF(co); 1199 Py_DECREF(co);
1270 return v; 1200 return v;
1271 } 1201 }
1272 1202
1273 static PyObject * 1203 static PyObject *
1274 run_pyc_file(FILE *fp, const char *filename, PyObject *globals, PyObject *locals, 1204 run_pyc_file(FILE *fp, const char *filename, PyObject *globals,
1275 PyCompilerFlags *flags) 1205 PyObject *locals, PyCompilerFlags *flags)
1276 { 1206 {
1277 PyCodeObject *co; 1207 PyCodeObject *co;
1278 PyObject *v; 1208 PyObject *v;
1279 long magic; 1209 long magic;
1280 long PyImport_GetMagicNumber(void); 1210 long PyImport_GetMagicNumber(void);
1301 Py_DECREF(co); 1231 Py_DECREF(co);
1302 return v; 1232 return v;
1303 } 1233 }
1304 1234
1305 PyObject * 1235 PyObject *
1306 Py_CompileString(const char *str, const char *filename, int start)
1307 {
1308 return Py_CompileStringFlags(str, filename, start, NULL);
1309 }
1310
1311 PyObject *
1312 Py_CompileStringFlags(const char *str, const char *filename, int start, 1236 Py_CompileStringFlags(const char *str, const char *filename, int start,
1313 PyCompilerFlags *flags) 1237 PyCompilerFlags *flags)
1314 { 1238 {
1315 node *n; 1239 mod_ty mod;
1316 PyCodeObject *co; 1240 PyCodeObject *co;
1317 1241 mod = PyParser_ASTFromString(str, filename, start, flags);
1318 n = PyParser_SimpleParseStringFlagsFilename(str, filename, start, 1242 if (mod == NULL)
1319 PARSER_FLAGS(flags));
1320 if (n == NULL)
1321 return NULL; 1243 return NULL;
1322 co = PyNode_CompileFlags(n, filename, flags); 1244 co = PyAST_Compile(mod, filename, flags);
1323 PyNode_Free(n); 1245 free_mod(mod);
1324 return (PyObject *)co; 1246 return (PyObject *)co;
1325 } 1247 }
1326 1248
1327 struct symtable * 1249 struct symtable *
1328 Py_SymtableString(const char *str, const char *filename, int start) 1250 Py_SymtableString(const char *str, const char *filename, int start)
1329 { 1251 {
1252 mod_ty mod;
1253 struct symtable *st;
1254
1255 mod = PyParser_ASTFromString(str, filename, start, NULL);
1256 if (mod == NULL)
1257 return NULL;
1258 st = PySymtable_Build(mod, filename, 0);
1259 free_mod(mod);
1260 return st;
1261 }
1262
1263 /* Preferred access to parser is through AST. */
1264 mod_ty
1265 PyParser_ASTFromString(const char *s, const char *filename, int start,
1266 PyCompilerFlags *flags)
1267 {
1330 node *n; 1268 node *n;
1331 struct symtable *st; 1269 mod_ty mod;
1332 n = PyParser_SimpleParseStringFlagsFilename(str, filename, 1270 perrdetail err;
1333 start, 0); 1271 n = PyParser_ParseStringFlagsFilename(s, filename, &_PyParser_Grammar,
1334 if (n == NULL) 1272 start, &err,
1273 PARSER_FLAGS(flags));
1274 if (n) {
1275 mod = PyAST_FromNode(n, flags, filename);
1276 PyNode_Free(n);
1277 return mod;
1278 }
1279 else {
1280 err_input(&err);
1335 return NULL; 1281 return NULL;
1336 st = PyNode_CompileSymtable(n, filename); 1282 }
1337 PyNode_Free(n); 1283 }
1338 return st; 1284
1285 mod_ty
1286 PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,
1287 char *ps2, PyCompilerFlags *flags, int *errcode)
1288 {
1289 node *n;
1290 mod_ty mod;
1291 perrdetail err;
1292 n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar, start,
1293 ps1, ps2, &err, PARSER_FLAGS(flags));
1294 if (n) {
1295 mod = PyAST_FromNode(n, flags, filename);
1296 PyNode_Free(n);
1297 return mod;
1298 }
1299 else {
1300 err_input(&err);
1301 if (errcode)
1302 *errcode = err.error;
1303 return NULL;
1304 }
1339 } 1305 }
1340 1306
1341 /* Simplified interface to parsefile -- return node or set exception */ 1307 /* Simplified interface to parsefile -- return node or set exception */
1342 1308
1343 node * 1309 node *
1347 perrdetail err; 1313 perrdetail err;
1348 n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar, start, 1314 n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar, start,
1349 (char *)0, (char *)0, &err, flags); 1315 (char *)0, (char *)0, &err, flags);
1350 if (n == NULL) 1316 if (n == NULL)
1351 err_input(&err); 1317 err_input(&err);
1318
1352 return n; 1319 return n;
1353 }
1354
1355 node *
1356 PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
1357 {
1358 return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
1359 } 1320 }
1360 1321
1361 /* Simplified interface to parsestring -- return node or set exception */ 1322 /* Simplified interface to parsestring -- return node or set exception */
1362 1323
1363 node * 1324 node *
1371 err_input(&err); 1332 err_input(&err);
1372 return n; 1333 return n;
1373 } 1334 }
1374 1335
1375 node * 1336 node *
1376 PyParser_SimpleParseString(const char *str, int start)
1377 {
1378 return PyParser_SimpleParseStringFlags(str, start, 0);
1379 }
1380
1381 node *
1382 PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename, 1337 PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename,
1383 int start, int flags) 1338 int start, int flags)
1384 { 1339 {
1385 node *n; 1340 node *n;
1386 perrdetail err; 1341 perrdetail err;
1416 { 1371 {
1417 PyObject *v, *w, *errtype; 1372 PyObject *v, *w, *errtype;
1418 PyObject* u = NULL; 1373 PyObject* u = NULL;
1419 char *msg = NULL; 1374 char *msg = NULL;
1420 errtype = PyExc_SyntaxError; 1375 errtype = PyExc_SyntaxError;
1421 v = Py_BuildValue("(ziiz)", err->filename,
1422 err->lineno, err->offset, err->text);
1423 if (err->text != NULL) {
1424 PyMem_DEL(err->text);
1425 err->text = NULL;
1426 }
1427 switch (err->error) { 1376 switch (err->error) {
1428 case E_SYNTAX: 1377 case E_SYNTAX:
1429 errtype = PyExc_IndentationError; 1378 errtype = PyExc_IndentationError;
1430 if (err->expected == INDENT) 1379 if (err->expected == INDENT)
1431 msg = "expected an indented block"; 1380 msg = "expected an indented block";
1448 msg = "EOL while scanning single-quoted string"; 1397 msg = "EOL while scanning single-quoted string";
1449 break; 1398 break;
1450 case E_INTR: 1399 case E_INTR:
1451 if (!PyErr_Occurred()) 1400 if (!PyErr_Occurred())
1452 PyErr_SetNone(PyExc_KeyboardInterrupt); 1401 PyErr_SetNone(PyExc_KeyboardInterrupt);
1453 Py_XDECREF(v);
1454 return; 1402 return;
1455 case E_NOMEM: 1403 case E_NOMEM:
1456 PyErr_NoMemory(); 1404 PyErr_NoMemory();
1457 Py_XDECREF(v);
1458 return; 1405 return;
1459 case E_EOF: 1406 case E_EOF:
1460 msg = "unexpected EOF while parsing"; 1407 msg = "unexpected EOF while parsing";
1461 break; 1408 break;
1462 case E_TABSPACE: 1409 case E_TABSPACE:
1496 default: 1443 default:
1497 fprintf(stderr, "error=%d\n", err->error); 1444 fprintf(stderr, "error=%d\n", err->error);
1498 msg = "unknown parsing error"; 1445 msg = "unknown parsing error";
1499 break; 1446 break;
1500 } 1447 }
1501 w = Py_BuildValue("(sO)", msg, v); 1448 v = Py_BuildValue("(ziiz)", err->filename,
1449 err->lineno, err->offset, err->text);
1450 if (err->text != NULL) {
1451 PyMem_DEL(err->text);
1452 err->text = NULL;
1453 }
1454 w = NULL;
1455 if (v != NULL)
1456 w = Py_BuildValue("(sO)", msg, v);
1502 Py_XDECREF(u); 1457 Py_XDECREF(u);
1503 Py_XDECREF(v); 1458 Py_XDECREF(v);
1504 PyErr_SetObject(errtype, w); 1459 PyErr_SetObject(errtype, w);
1505 Py_XDECREF(w); 1460 Py_XDECREF(w);
1506 } 1461 }
1685 siginterrupt(sig, 1); 1640 siginterrupt(sig, 1);
1686 #endif 1641 #endif
1687 return oldhandler; 1642 return oldhandler;
1688 #endif 1643 #endif
1689 } 1644 }
1645
1646 /* Deprecated C API functions still provided for binary compatiblity */
1647
1648 #undef PyParser_SimpleParseFile
1649 #undef PyParser_SimpleParseString
1650
1651 node *
1652 PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
1653 {
1654 return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
1655 }
1656
1657 node *
1658 PyParser_SimpleParseString(const char *str, int start)
1659 {
1660 return PyParser_SimpleParseStringFlags(str, start, 0);
1661 }