+++ /dev/null
-/*\r
- * This file includes functions to transform a concrete syntax tree (CST) to\r
- * an abstract syntax tree (AST). The main function is PyAST_FromNode().\r
- *\r
- */\r
-#include "Python.h"\r
-#include "Python-ast.h"\r
-#include "grammar.h"\r
-#include "node.h"\r
-#include "pyarena.h"\r
-#include "ast.h"\r
-#include "token.h"\r
-#include "parsetok.h"\r
-#include "graminit.h"\r
-\r
-#include <assert.h>\r
-\r
-/* Data structure used internally */\r
-struct compiling {\r
- char *c_encoding; /* source encoding */\r
- int c_future_unicode; /* __future__ unicode literals flag */\r
- PyArena *c_arena; /* arena for allocating memeory */\r
- const char *c_filename; /* filename */\r
-};\r
-\r
-static asdl_seq *seq_for_testlist(struct compiling *, const node *);\r
-static expr_ty ast_for_expr(struct compiling *, const node *);\r
-static stmt_ty ast_for_stmt(struct compiling *, const node *);\r
-static asdl_seq *ast_for_suite(struct compiling *, const node *);\r
-static asdl_seq *ast_for_exprlist(struct compiling *, const node *,\r
- expr_context_ty);\r
-static expr_ty ast_for_testlist(struct compiling *, const node *);\r
-static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *);\r
-static expr_ty ast_for_testlist_comp(struct compiling *, const node *);\r
-\r
-/* Note different signature for ast_for_call */\r
-static expr_ty ast_for_call(struct compiling *, const node *, expr_ty);\r
-\r
-static PyObject *parsenumber(struct compiling *, const char *);\r
-static PyObject *parsestr(struct compiling *, const node *n, const char *);\r
-static PyObject *parsestrplus(struct compiling *, const node *n);\r
-\r
-#ifndef LINENO\r
-#define LINENO(n) ((n)->n_lineno)\r
-#endif\r
-\r
-#define COMP_GENEXP 0\r
-#define COMP_SETCOMP 1\r
-\r
-static identifier\r
-new_identifier(const char* n, PyArena *arena) {\r
- PyObject* id = PyString_InternFromString(n);\r
- if (id != NULL)\r
- PyArena_AddPyObject(arena, id);\r
- return id;\r
-}\r
-\r
-#define NEW_IDENTIFIER(n) new_identifier(STR(n), c->c_arena)\r
-\r
-/* This routine provides an invalid object for the syntax error.\r
- The outermost routine must unpack this error and create the\r
- proper object. We do this so that we don't have to pass\r
- the filename to everything function.\r
-\r
- XXX Maybe we should just pass the filename...\r
-*/\r
-\r
-static int\r
-ast_error(const node *n, const char *errstr)\r
-{\r
- PyObject *u = Py_BuildValue("zi", errstr, LINENO(n));\r
- if (!u)\r
- return 0;\r
- PyErr_SetObject(PyExc_SyntaxError, u);\r
- Py_DECREF(u);\r
- return 0;\r
-}\r
-\r
-static void\r
-ast_error_finish(const char *filename)\r
-{\r
- PyObject *type, *value, *tback, *errstr, *loc, *tmp;\r
- long lineno;\r
-\r
- assert(PyErr_Occurred());\r
- if (!PyErr_ExceptionMatches(PyExc_SyntaxError))\r
- return;\r
-\r
- PyErr_Fetch(&type, &value, &tback);\r
- errstr = PyTuple_GetItem(value, 0);\r
- if (!errstr)\r
- return;\r
- Py_INCREF(errstr);\r
- lineno = PyInt_AsLong(PyTuple_GetItem(value, 1));\r
- if (lineno == -1) {\r
- Py_DECREF(errstr);\r
- return;\r
- }\r
- Py_DECREF(value);\r
-\r
- loc = PyErr_ProgramText(filename, lineno);\r
- if (!loc) {\r
- Py_INCREF(Py_None);\r
- loc = Py_None;\r
- }\r
- tmp = Py_BuildValue("(zlOO)", filename, lineno, Py_None, loc);\r
- Py_DECREF(loc);\r
- if (!tmp) {\r
- Py_DECREF(errstr);\r
- return;\r
- }\r
- value = PyTuple_Pack(2, errstr, tmp);\r
- Py_DECREF(errstr);\r
- Py_DECREF(tmp);\r
- if (!value)\r
- return;\r
- PyErr_Restore(type, value, tback);\r
-}\r
-\r
-static int\r
-ast_warn(struct compiling *c, const node *n, char *msg)\r
-{\r
- if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename, LINENO(n),\r
- NULL, NULL) < 0) {\r
- /* if -Werr, change it to a SyntaxError */\r
- if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxWarning))\r
- ast_error(n, msg);\r
- return 0;\r
- }\r
- return 1;\r
-}\r
-\r
-static int\r
-forbidden_check(struct compiling *c, const node *n, const char *x)\r
-{\r
- if (!strcmp(x, "None"))\r
- return ast_error(n, "cannot assign to None");\r
- if (!strcmp(x, "__debug__"))\r
- return ast_error(n, "cannot assign to __debug__");\r
- if (Py_Py3kWarningFlag) {\r
- if (!(strcmp(x, "True") && strcmp(x, "False")) &&\r
- !ast_warn(c, n, "assignment to True or False is forbidden in 3.x"))\r
- return 0;\r
- if (!strcmp(x, "nonlocal") &&\r
- !ast_warn(c, n, "nonlocal is a keyword in 3.x"))\r
- return 0;\r
- }\r
- return 1;\r
-}\r
-\r
-/* num_stmts() returns number of contained statements.\r
-\r
- Use this routine to determine how big a sequence is needed for\r
- the statements in a parse tree. Its raison d'etre is this bit of\r
- grammar:\r
-\r
- stmt: simple_stmt | compound_stmt\r
- simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE\r
-\r
- A simple_stmt can contain multiple small_stmt elements joined\r
- by semicolons. If the arg is a simple_stmt, the number of\r
- small_stmt elements is returned.\r
-*/\r
-\r
-static int\r
-num_stmts(const node *n)\r
-{\r
- int i, l;\r
- node *ch;\r
-\r
- switch (TYPE(n)) {\r
- case single_input:\r
- if (TYPE(CHILD(n, 0)) == NEWLINE)\r
- return 0;\r
- else\r
- return num_stmts(CHILD(n, 0));\r
- case file_input:\r
- l = 0;\r
- for (i = 0; i < NCH(n); i++) {\r
- ch = CHILD(n, i);\r
- if (TYPE(ch) == stmt)\r
- l += num_stmts(ch);\r
- }\r
- return l;\r
- case stmt:\r
- return num_stmts(CHILD(n, 0));\r
- case compound_stmt:\r
- return 1;\r
- case simple_stmt:\r
- return NCH(n) / 2; /* Divide by 2 to remove count of semi-colons */\r
- case suite:\r
- if (NCH(n) == 1)\r
- return num_stmts(CHILD(n, 0));\r
- else {\r
- l = 0;\r
- for (i = 2; i < (NCH(n) - 1); i++)\r
- l += num_stmts(CHILD(n, i));\r
- return l;\r
- }\r
- default: {\r
- char buf[128];\r
-\r
- sprintf(buf, "Non-statement found: %d %d",\r
- TYPE(n), NCH(n));\r
- Py_FatalError(buf);\r
- }\r
- }\r
- assert(0);\r
- return 0;\r
-}\r
-\r
-/* Transform the CST rooted at node * to the appropriate AST\r
-*/\r
-\r
-mod_ty\r
-PyAST_FromNode(const node *n, PyCompilerFlags *flags, const char *filename,\r
- PyArena *arena)\r
-{\r
- int i, j, k, num;\r
- asdl_seq *stmts = NULL;\r
- stmt_ty s;\r
- node *ch;\r
- struct compiling c;\r
-\r
- if (flags && flags->cf_flags & PyCF_SOURCE_IS_UTF8) {\r
- c.c_encoding = "utf-8";\r
- if (TYPE(n) == encoding_decl) {\r
- ast_error(n, "encoding declaration in Unicode string");\r
- goto error;\r
- }\r
- } else if (TYPE(n) == encoding_decl) {\r
- c.c_encoding = STR(n);\r
- n = CHILD(n, 0);\r
- } else {\r
- c.c_encoding = NULL;\r
- }\r
- c.c_future_unicode = flags && flags->cf_flags & CO_FUTURE_UNICODE_LITERALS;\r
- c.c_arena = arena;\r
- c.c_filename = filename;\r
-\r
- k = 0;\r
- switch (TYPE(n)) {\r
- case file_input:\r
- stmts = asdl_seq_new(num_stmts(n), arena);\r
- if (!stmts)\r
- return NULL;\r
- for (i = 0; i < NCH(n) - 1; i++) {\r
- ch = CHILD(n, i);\r
- if (TYPE(ch) == NEWLINE)\r
- continue;\r
- REQ(ch, stmt);\r
- num = num_stmts(ch);\r
- if (num == 1) {\r
- s = ast_for_stmt(&c, ch);\r
- if (!s)\r
- goto error;\r
- asdl_seq_SET(stmts, k++, s);\r
- }\r
- else {\r
- ch = CHILD(ch, 0);\r
- REQ(ch, simple_stmt);\r
- for (j = 0; j < num; j++) {\r
- s = ast_for_stmt(&c, CHILD(ch, j * 2));\r
- if (!s)\r
- goto error;\r
- asdl_seq_SET(stmts, k++, s);\r
- }\r
- }\r
- }\r
- return Module(stmts, arena);\r
- case eval_input: {\r
- expr_ty testlist_ast;\r
-\r
- /* XXX Why not comp_for here? */\r
- testlist_ast = ast_for_testlist(&c, CHILD(n, 0));\r
- if (!testlist_ast)\r
- goto error;\r
- return Expression(testlist_ast, arena);\r
- }\r
- case single_input:\r
- if (TYPE(CHILD(n, 0)) == NEWLINE) {\r
- stmts = asdl_seq_new(1, arena);\r
- if (!stmts)\r
- goto error;\r
- asdl_seq_SET(stmts, 0, Pass(n->n_lineno, n->n_col_offset,\r
- arena));\r
- if (!asdl_seq_GET(stmts, 0))\r
- goto error;\r
- return Interactive(stmts, arena);\r
- }\r
- else {\r
- n = CHILD(n, 0);\r
- num = num_stmts(n);\r
- stmts = asdl_seq_new(num, arena);\r
- if (!stmts)\r
- goto error;\r
- if (num == 1) {\r
- s = ast_for_stmt(&c, n);\r
- if (!s)\r
- goto error;\r
- asdl_seq_SET(stmts, 0, s);\r
- }\r
- else {\r
- /* Only a simple_stmt can contain multiple statements. */\r
- REQ(n, simple_stmt);\r
- for (i = 0; i < NCH(n); i += 2) {\r
- if (TYPE(CHILD(n, i)) == NEWLINE)\r
- break;\r
- s = ast_for_stmt(&c, CHILD(n, i));\r
- if (!s)\r
- goto error;\r
- asdl_seq_SET(stmts, i / 2, s);\r
- }\r
- }\r
-\r
- return Interactive(stmts, arena);\r
- }\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "invalid node %d for PyAST_FromNode", TYPE(n));\r
- goto error;\r
- }\r
- error:\r
- ast_error_finish(filename);\r
- return NULL;\r
-}\r
-\r
-/* Return the AST repr. of the operator represented as syntax (|, ^, etc.)\r
-*/\r
-\r
-static operator_ty\r
-get_operator(const node *n)\r
-{\r
- switch (TYPE(n)) {\r
- case VBAR:\r
- return BitOr;\r
- case CIRCUMFLEX:\r
- return BitXor;\r
- case AMPER:\r
- return BitAnd;\r
- case LEFTSHIFT:\r
- return LShift;\r
- case RIGHTSHIFT:\r
- return RShift;\r
- case PLUS:\r
- return Add;\r
- case MINUS:\r
- return Sub;\r
- case STAR:\r
- return Mult;\r
- case SLASH:\r
- return Div;\r
- case DOUBLESLASH:\r
- return FloorDiv;\r
- case PERCENT:\r
- return Mod;\r
- default:\r
- return (operator_ty)0;\r
- }\r
-}\r
-\r
-/* Set the context ctx for expr_ty e, recursively traversing e.\r
-\r
- Only sets context for expr kinds that "can appear in assignment context"\r
- (according to ../Parser/Python.asdl). For other expr kinds, it sets\r
- an appropriate syntax error and returns false.\r
-*/\r
-\r
-static int\r
-set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n)\r
-{\r
- asdl_seq *s = NULL;\r
- /* If a particular expression type can't be used for assign / delete,\r
- set expr_name to its name and an error message will be generated.\r
- */\r
- const char* expr_name = NULL;\r
-\r
- /* The ast defines augmented store and load contexts, but the\r
- implementation here doesn't actually use them. The code may be\r
- a little more complex than necessary as a result. It also means\r
- that expressions in an augmented assignment have a Store context.\r
- Consider restructuring so that augmented assignment uses\r
- set_context(), too.\r
- */\r
- assert(ctx != AugStore && ctx != AugLoad);\r
-\r
- switch (e->kind) {\r
- case Attribute_kind:\r
- if (ctx == Store && !forbidden_check(c, n,\r
- PyBytes_AS_STRING(e->v.Attribute.attr)))\r
- return 0;\r
- e->v.Attribute.ctx = ctx;\r
- break;\r
- case Subscript_kind:\r
- e->v.Subscript.ctx = ctx;\r
- break;\r
- case Name_kind:\r
- if (ctx == Store && !forbidden_check(c, n,\r
- PyBytes_AS_STRING(e->v.Name.id)))\r
- return 0;\r
- e->v.Name.ctx = ctx;\r
- break;\r
- case List_kind:\r
- e->v.List.ctx = ctx;\r
- s = e->v.List.elts;\r
- break;\r
- case Tuple_kind:\r
- if (asdl_seq_LEN(e->v.Tuple.elts)) {\r
- e->v.Tuple.ctx = ctx;\r
- s = e->v.Tuple.elts;\r
- }\r
- else {\r
- expr_name = "()";\r
- }\r
- break;\r
- case Lambda_kind:\r
- expr_name = "lambda";\r
- break;\r
- case Call_kind:\r
- expr_name = "function call";\r
- break;\r
- case BoolOp_kind:\r
- case BinOp_kind:\r
- case UnaryOp_kind:\r
- expr_name = "operator";\r
- break;\r
- case GeneratorExp_kind:\r
- expr_name = "generator expression";\r
- break;\r
- case Yield_kind:\r
- expr_name = "yield expression";\r
- break;\r
- case ListComp_kind:\r
- expr_name = "list comprehension";\r
- break;\r
- case SetComp_kind:\r
- expr_name = "set comprehension";\r
- break;\r
- case DictComp_kind:\r
- expr_name = "dict comprehension";\r
- break;\r
- case Dict_kind:\r
- case Set_kind:\r
- case Num_kind:\r
- case Str_kind:\r
- expr_name = "literal";\r
- break;\r
- case Compare_kind:\r
- expr_name = "comparison";\r
- break;\r
- case Repr_kind:\r
- expr_name = "repr";\r
- break;\r
- case IfExp_kind:\r
- expr_name = "conditional expression";\r
- break;\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "unexpected expression in assignment %d (line %d)",\r
- e->kind, e->lineno);\r
- return 0;\r
- }\r
- /* Check for error string set by switch */\r
- if (expr_name) {\r
- char buf[300];\r
- PyOS_snprintf(buf, sizeof(buf),\r
- "can't %s %s",\r
- ctx == Store ? "assign to" : "delete",\r
- expr_name);\r
- return ast_error(n, buf);\r
- }\r
-\r
- /* If the LHS is a list or tuple, we need to set the assignment\r
- context for all the contained elements.\r
- */\r
- if (s) {\r
- int i;\r
-\r
- for (i = 0; i < asdl_seq_LEN(s); i++) {\r
- if (!set_context(c, (expr_ty)asdl_seq_GET(s, i), ctx, n))\r
- return 0;\r
- }\r
- }\r
- return 1;\r
-}\r
-\r
-static operator_ty\r
-ast_for_augassign(struct compiling *c, const node *n)\r
-{\r
- REQ(n, augassign);\r
- n = CHILD(n, 0);\r
- switch (STR(n)[0]) {\r
- case '+':\r
- return Add;\r
- case '-':\r
- return Sub;\r
- case '/':\r
- if (STR(n)[1] == '/')\r
- return FloorDiv;\r
- else\r
- return Div;\r
- case '%':\r
- return Mod;\r
- case '<':\r
- return LShift;\r
- case '>':\r
- return RShift;\r
- case '&':\r
- return BitAnd;\r
- case '^':\r
- return BitXor;\r
- case '|':\r
- return BitOr;\r
- case '*':\r
- if (STR(n)[1] == '*')\r
- return Pow;\r
- else\r
- return Mult;\r
- default:\r
- PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n));\r
- return (operator_ty)0;\r
- }\r
-}\r
-\r
-static cmpop_ty\r
-ast_for_comp_op(struct compiling *c, const node *n)\r
-{\r
- /* comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'\r
- |'is' 'not'\r
- */\r
- REQ(n, comp_op);\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- switch (TYPE(n)) {\r
- case LESS:\r
- return Lt;\r
- case GREATER:\r
- return Gt;\r
- case EQEQUAL: /* == */\r
- return Eq;\r
- case LESSEQUAL:\r
- return LtE;\r
- case GREATEREQUAL:\r
- return GtE;\r
- case NOTEQUAL:\r
- return NotEq;\r
- case NAME:\r
- if (strcmp(STR(n), "in") == 0)\r
- return In;\r
- if (strcmp(STR(n), "is") == 0)\r
- return Is;\r
- default:\r
- PyErr_Format(PyExc_SystemError, "invalid comp_op: %s",\r
- STR(n));\r
- return (cmpop_ty)0;\r
- }\r
- }\r
- else if (NCH(n) == 2) {\r
- /* handle "not in" and "is not" */\r
- switch (TYPE(CHILD(n, 0))) {\r
- case NAME:\r
- if (strcmp(STR(CHILD(n, 1)), "in") == 0)\r
- return NotIn;\r
- if (strcmp(STR(CHILD(n, 0)), "is") == 0)\r
- return IsNot;\r
- default:\r
- PyErr_Format(PyExc_SystemError, "invalid comp_op: %s %s",\r
- STR(CHILD(n, 0)), STR(CHILD(n, 1)));\r
- return (cmpop_ty)0;\r
- }\r
- }\r
- PyErr_Format(PyExc_SystemError, "invalid comp_op: has %d children",\r
- NCH(n));\r
- return (cmpop_ty)0;\r
-}\r
-\r
-static asdl_seq *\r
-seq_for_testlist(struct compiling *c, const node *n)\r
-{\r
- /* testlist: test (',' test)* [','] */\r
- asdl_seq *seq;\r
- expr_ty expression;\r
- int i;\r
- assert(TYPE(n) == testlist ||\r
- TYPE(n) == listmaker ||\r
- TYPE(n) == testlist_comp ||\r
- TYPE(n) == testlist_safe ||\r
- TYPE(n) == testlist1);\r
-\r
- seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);\r
- if (!seq)\r
- return NULL;\r
-\r
- for (i = 0; i < NCH(n); i += 2) {\r
- assert(TYPE(CHILD(n, i)) == test || TYPE(CHILD(n, i)) == old_test);\r
-\r
- expression = ast_for_expr(c, CHILD(n, i));\r
- if (!expression)\r
- return NULL;\r
-\r
- assert(i / 2 < seq->size);\r
- asdl_seq_SET(seq, i / 2, expression);\r
- }\r
- return seq;\r
-}\r
-\r
-static expr_ty\r
-compiler_complex_args(struct compiling *c, const node *n)\r
-{\r
- int i, len = (NCH(n) + 1) / 2;\r
- expr_ty result;\r
- asdl_seq *args = asdl_seq_new(len, c->c_arena);\r
- if (!args)\r
- return NULL;\r
-\r
- /* fpdef: NAME | '(' fplist ')'\r
- fplist: fpdef (',' fpdef)* [',']\r
- */\r
- REQ(n, fplist);\r
- for (i = 0; i < len; i++) {\r
- PyObject *arg_id;\r
- const node *fpdef_node = CHILD(n, 2*i);\r
- const node *child;\r
- expr_ty arg;\r
-set_name:\r
- /* fpdef_node is either a NAME or an fplist */\r
- child = CHILD(fpdef_node, 0);\r
- if (TYPE(child) == NAME) {\r
- if (!forbidden_check(c, n, STR(child)))\r
- return NULL;\r
- arg_id = NEW_IDENTIFIER(child);\r
- if (!arg_id)\r
- return NULL;\r
- arg = Name(arg_id, Store, LINENO(child), child->n_col_offset,\r
- c->c_arena);\r
- }\r
- else {\r
- assert(TYPE(fpdef_node) == fpdef);\r
- /* fpdef_node[0] is not a name, so it must be '(', get CHILD[1] */\r
- child = CHILD(fpdef_node, 1);\r
- assert(TYPE(child) == fplist);\r
- /* NCH == 1 means we have (x), we need to elide the extra parens */\r
- if (NCH(child) == 1) {\r
- fpdef_node = CHILD(child, 0);\r
- assert(TYPE(fpdef_node) == fpdef);\r
- goto set_name;\r
- }\r
- arg = compiler_complex_args(c, child);\r
- }\r
- asdl_seq_SET(args, i, arg);\r
- }\r
-\r
- result = Tuple(args, Store, LINENO(n), n->n_col_offset, c->c_arena);\r
- if (!set_context(c, result, Store, n))\r
- return NULL;\r
- return result;\r
-}\r
-\r
-\r
-/* Create AST for argument list. */\r
-\r
-static arguments_ty\r
-ast_for_arguments(struct compiling *c, const node *n)\r
-{\r
- /* parameters: '(' [varargslist] ')'\r
- varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME]\r
- | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']\r
- */\r
- int i, j, k, n_args = 0, n_defaults = 0, found_default = 0;\r
- asdl_seq *args, *defaults;\r
- identifier vararg = NULL, kwarg = NULL;\r
- node *ch;\r
-\r
- if (TYPE(n) == parameters) {\r
- if (NCH(n) == 2) /* () as argument list */\r
- return arguments(NULL, NULL, NULL, NULL, c->c_arena);\r
- n = CHILD(n, 1);\r
- }\r
- REQ(n, varargslist);\r
-\r
- /* first count the number of normal args & defaults */\r
- for (i = 0; i < NCH(n); i++) {\r
- ch = CHILD(n, i);\r
- if (TYPE(ch) == fpdef)\r
- n_args++;\r
- if (TYPE(ch) == EQUAL)\r
- n_defaults++;\r
- }\r
- args = (n_args ? asdl_seq_new(n_args, c->c_arena) : NULL);\r
- if (!args && n_args)\r
- return NULL;\r
- defaults = (n_defaults ? asdl_seq_new(n_defaults, c->c_arena) : NULL);\r
- if (!defaults && n_defaults)\r
- return NULL;\r
-\r
- /* fpdef: NAME | '(' fplist ')'\r
- fplist: fpdef (',' fpdef)* [',']\r
- */\r
- i = 0;\r
- j = 0; /* index for defaults */\r
- k = 0; /* index for args */\r
- while (i < NCH(n)) {\r
- ch = CHILD(n, i);\r
- switch (TYPE(ch)) {\r
- case fpdef: {\r
- int complex_args = 0, parenthesized = 0;\r
- handle_fpdef:\r
- /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is\r
- anything other than EQUAL or a comma? */\r
- /* XXX Should NCH(n) check be made a separate check? */\r
- if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) {\r
- expr_ty expression = ast_for_expr(c, CHILD(n, i + 2));\r
- if (!expression)\r
- return NULL;\r
- assert(defaults != NULL);\r
- asdl_seq_SET(defaults, j++, expression);\r
- i += 2;\r
- found_default = 1;\r
- }\r
- else if (found_default) {\r
- /* def f((x)=4): pass should raise an error.\r
- def f((x, (y))): pass will just incur the tuple unpacking warning. */\r
- if (parenthesized && !complex_args) {\r
- ast_error(n, "parenthesized arg with default");\r
- return NULL;\r
- }\r
- ast_error(n,\r
- "non-default argument follows default argument");\r
- return NULL;\r
- }\r
- if (NCH(ch) == 3) {\r
- ch = CHILD(ch, 1);\r
- /* def foo((x)): is not complex, special case. */\r
- if (NCH(ch) != 1) {\r
- /* We have complex arguments, setup for unpacking. */\r
- if (Py_Py3kWarningFlag && !ast_warn(c, ch,\r
- "tuple parameter unpacking has been removed in 3.x"))\r
- return NULL;\r
- complex_args = 1;\r
- asdl_seq_SET(args, k++, compiler_complex_args(c, ch));\r
- if (!asdl_seq_GET(args, k-1))\r
- return NULL;\r
- } else {\r
- /* def foo((x)): setup for checking NAME below. */\r
- /* Loop because there can be many parens and tuple\r
- unpacking mixed in. */\r
- parenthesized = 1;\r
- ch = CHILD(ch, 0);\r
- assert(TYPE(ch) == fpdef);\r
- goto handle_fpdef;\r
- }\r
- }\r
- if (TYPE(CHILD(ch, 0)) == NAME) {\r
- PyObject *id;\r
- expr_ty name;\r
- if (!forbidden_check(c, n, STR(CHILD(ch, 0))))\r
- return NULL;\r
- id = NEW_IDENTIFIER(CHILD(ch, 0));\r
- if (!id)\r
- return NULL;\r
- name = Name(id, Param, LINENO(ch), ch->n_col_offset,\r
- c->c_arena);\r
- if (!name)\r
- return NULL;\r
- asdl_seq_SET(args, k++, name);\r
-\r
- }\r
- i += 2; /* the name and the comma */\r
- if (parenthesized && Py_Py3kWarningFlag &&\r
- !ast_warn(c, ch, "parenthesized argument names "\r
- "are invalid in 3.x"))\r
- return NULL;\r
-\r
- break;\r
- }\r
- case STAR:\r
- if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))\r
- return NULL;\r
- vararg = NEW_IDENTIFIER(CHILD(n, i+1));\r
- if (!vararg)\r
- return NULL;\r
- i += 3;\r
- break;\r
- case DOUBLESTAR:\r
- if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))\r
- return NULL;\r
- kwarg = NEW_IDENTIFIER(CHILD(n, i+1));\r
- if (!kwarg)\r
- return NULL;\r
- i += 3;\r
- break;\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "unexpected node in varargslist: %d @ %d",\r
- TYPE(ch), i);\r
- return NULL;\r
- }\r
- }\r
-\r
- return arguments(args, vararg, kwarg, defaults, c->c_arena);\r
-}\r
-\r
-static expr_ty\r
-ast_for_dotted_name(struct compiling *c, const node *n)\r
-{\r
- expr_ty e;\r
- identifier id;\r
- int lineno, col_offset;\r
- int i;\r
-\r
- REQ(n, dotted_name);\r
-\r
- lineno = LINENO(n);\r
- col_offset = n->n_col_offset;\r
-\r
- id = NEW_IDENTIFIER(CHILD(n, 0));\r
- if (!id)\r
- return NULL;\r
- e = Name(id, Load, lineno, col_offset, c->c_arena);\r
- if (!e)\r
- return NULL;\r
-\r
- for (i = 2; i < NCH(n); i+=2) {\r
- id = NEW_IDENTIFIER(CHILD(n, i));\r
- if (!id)\r
- return NULL;\r
- e = Attribute(e, id, Load, lineno, col_offset, c->c_arena);\r
- if (!e)\r
- return NULL;\r
- }\r
-\r
- return e;\r
-}\r
-\r
-static expr_ty\r
-ast_for_decorator(struct compiling *c, const node *n)\r
-{\r
- /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */\r
- expr_ty d = NULL;\r
- expr_ty name_expr;\r
-\r
- REQ(n, decorator);\r
- REQ(CHILD(n, 0), AT);\r
- REQ(RCHILD(n, -1), NEWLINE);\r
-\r
- name_expr = ast_for_dotted_name(c, CHILD(n, 1));\r
- if (!name_expr)\r
- return NULL;\r
-\r
- if (NCH(n) == 3) { /* No arguments */\r
- d = name_expr;\r
- name_expr = NULL;\r
- }\r
- else if (NCH(n) == 5) { /* Call with no arguments */\r
- d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- if (!d)\r
- return NULL;\r
- name_expr = NULL;\r
- }\r
- else {\r
- d = ast_for_call(c, CHILD(n, 3), name_expr);\r
- if (!d)\r
- return NULL;\r
- name_expr = NULL;\r
- }\r
-\r
- return d;\r
-}\r
-\r
-static asdl_seq*\r
-ast_for_decorators(struct compiling *c, const node *n)\r
-{\r
- asdl_seq* decorator_seq;\r
- expr_ty d;\r
- int i;\r
-\r
- REQ(n, decorators);\r
- decorator_seq = asdl_seq_new(NCH(n), c->c_arena);\r
- if (!decorator_seq)\r
- return NULL;\r
-\r
- for (i = 0; i < NCH(n); i++) {\r
- d = ast_for_decorator(c, CHILD(n, i));\r
- if (!d)\r
- return NULL;\r
- asdl_seq_SET(decorator_seq, i, d);\r
- }\r
- return decorator_seq;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)\r
-{\r
- /* funcdef: 'def' NAME parameters ':' suite */\r
- identifier name;\r
- arguments_ty args;\r
- asdl_seq *body;\r
- int name_i = 1;\r
-\r
- REQ(n, funcdef);\r
-\r
- name = NEW_IDENTIFIER(CHILD(n, name_i));\r
- if (!name)\r
- return NULL;\r
- else if (!forbidden_check(c, CHILD(n, name_i), STR(CHILD(n, name_i))))\r
- return NULL;\r
- args = ast_for_arguments(c, CHILD(n, name_i + 1));\r
- if (!args)\r
- return NULL;\r
- body = ast_for_suite(c, CHILD(n, name_i + 3));\r
- if (!body)\r
- return NULL;\r
-\r
- return FunctionDef(name, args, body, decorator_seq, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static stmt_ty\r
-ast_for_decorated(struct compiling *c, const node *n)\r
-{\r
- /* decorated: decorators (classdef | funcdef) */\r
- stmt_ty thing = NULL;\r
- asdl_seq *decorator_seq = NULL;\r
-\r
- REQ(n, decorated);\r
-\r
- decorator_seq = ast_for_decorators(c, CHILD(n, 0));\r
- if (!decorator_seq)\r
- return NULL;\r
-\r
- assert(TYPE(CHILD(n, 1)) == funcdef ||\r
- TYPE(CHILD(n, 1)) == classdef);\r
-\r
- if (TYPE(CHILD(n, 1)) == funcdef) {\r
- thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq);\r
- } else if (TYPE(CHILD(n, 1)) == classdef) {\r
- thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq);\r
- }\r
- /* we count the decorators in when talking about the class' or\r
- function's line number */\r
- if (thing) {\r
- thing->lineno = LINENO(n);\r
- thing->col_offset = n->n_col_offset;\r
- }\r
- return thing;\r
-}\r
-\r
-static expr_ty\r
-ast_for_lambdef(struct compiling *c, const node *n)\r
-{\r
- /* lambdef: 'lambda' [varargslist] ':' test */\r
- arguments_ty args;\r
- expr_ty expression;\r
-\r
- if (NCH(n) == 3) {\r
- args = arguments(NULL, NULL, NULL, NULL, c->c_arena);\r
- if (!args)\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(n, 2));\r
- if (!expression)\r
- return NULL;\r
- }\r
- else {\r
- args = ast_for_arguments(c, CHILD(n, 1));\r
- if (!args)\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(n, 3));\r
- if (!expression)\r
- return NULL;\r
- }\r
-\r
- return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static expr_ty\r
-ast_for_ifexpr(struct compiling *c, const node *n)\r
-{\r
- /* test: or_test 'if' or_test 'else' test */\r
- expr_ty expression, body, orelse;\r
-\r
- assert(NCH(n) == 5);\r
- body = ast_for_expr(c, CHILD(n, 0));\r
- if (!body)\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(n, 2));\r
- if (!expression)\r
- return NULL;\r
- orelse = ast_for_expr(c, CHILD(n, 4));\r
- if (!orelse)\r
- return NULL;\r
- return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
-}\r
-\r
-/* XXX(nnorwitz): the listcomp and genexpr code should be refactored\r
- so there is only a single version. Possibly for loops can also re-use\r
- the code.\r
-*/\r
-\r
-/* Count the number of 'for' loop in a list comprehension.\r
-\r
- Helper for ast_for_listcomp().\r
-*/\r
-\r
-static int\r
-count_list_fors(struct compiling *c, const node *n)\r
-{\r
- int n_fors = 0;\r
- node *ch = CHILD(n, 1);\r
-\r
- count_list_for:\r
- n_fors++;\r
- REQ(ch, list_for);\r
- if (NCH(ch) == 5)\r
- ch = CHILD(ch, 4);\r
- else\r
- return n_fors;\r
- count_list_iter:\r
- REQ(ch, list_iter);\r
- ch = CHILD(ch, 0);\r
- if (TYPE(ch) == list_for)\r
- goto count_list_for;\r
- else if (TYPE(ch) == list_if) {\r
- if (NCH(ch) == 3) {\r
- ch = CHILD(ch, 2);\r
- goto count_list_iter;\r
- }\r
- else\r
- return n_fors;\r
- }\r
-\r
- /* Should never be reached */\r
- PyErr_SetString(PyExc_SystemError, "logic error in count_list_fors");\r
- return -1;\r
-}\r
-\r
-/* Count the number of 'if' statements in a list comprehension.\r
-\r
- Helper for ast_for_listcomp().\r
-*/\r
-\r
-static int\r
-count_list_ifs(struct compiling *c, const node *n)\r
-{\r
- int n_ifs = 0;\r
-\r
- count_list_iter:\r
- REQ(n, list_iter);\r
- if (TYPE(CHILD(n, 0)) == list_for)\r
- return n_ifs;\r
- n = CHILD(n, 0);\r
- REQ(n, list_if);\r
- n_ifs++;\r
- if (NCH(n) == 2)\r
- return n_ifs;\r
- n = CHILD(n, 2);\r
- goto count_list_iter;\r
-}\r
-\r
-static expr_ty\r
-ast_for_listcomp(struct compiling *c, const node *n)\r
-{\r
- /* listmaker: test ( list_for | (',' test)* [','] )\r
- list_for: 'for' exprlist 'in' testlist_safe [list_iter]\r
- list_iter: list_for | list_if\r
- list_if: 'if' test [list_iter]\r
- testlist_safe: test [(',' test)+ [',']]\r
- */\r
- expr_ty elt, first;\r
- asdl_seq *listcomps;\r
- int i, n_fors;\r
- node *ch;\r
-\r
- REQ(n, listmaker);\r
- assert(NCH(n) > 1);\r
-\r
- elt = ast_for_expr(c, CHILD(n, 0));\r
- if (!elt)\r
- return NULL;\r
-\r
- n_fors = count_list_fors(c, n);\r
- if (n_fors == -1)\r
- return NULL;\r
-\r
- listcomps = asdl_seq_new(n_fors, c->c_arena);\r
- if (!listcomps)\r
- return NULL;\r
-\r
- ch = CHILD(n, 1);\r
- for (i = 0; i < n_fors; i++) {\r
- comprehension_ty lc;\r
- asdl_seq *t;\r
- expr_ty expression;\r
- node *for_ch;\r
-\r
- REQ(ch, list_for);\r
-\r
- for_ch = CHILD(ch, 1);\r
- t = ast_for_exprlist(c, for_ch, Store);\r
- if (!t)\r
- return NULL;\r
- expression = ast_for_testlist(c, CHILD(ch, 3));\r
- if (!expression)\r
- return NULL;\r
-\r
- /* Check the # of children rather than the length of t, since\r
- [x for x, in ... ] has 1 element in t, but still requires a Tuple.\r
- */\r
- first = (expr_ty)asdl_seq_GET(t, 0);\r
- if (NCH(for_ch) == 1)\r
- lc = comprehension(first, expression, NULL, c->c_arena);\r
- else\r
- lc = comprehension(Tuple(t, Store, first->lineno, first->col_offset,\r
- c->c_arena),\r
- expression, NULL, c->c_arena);\r
- if (!lc)\r
- return NULL;\r
-\r
- if (NCH(ch) == 5) {\r
- int j, n_ifs;\r
- asdl_seq *ifs;\r
- expr_ty list_for_expr;\r
-\r
- ch = CHILD(ch, 4);\r
- n_ifs = count_list_ifs(c, ch);\r
- if (n_ifs == -1)\r
- return NULL;\r
-\r
- ifs = asdl_seq_new(n_ifs, c->c_arena);\r
- if (!ifs)\r
- return NULL;\r
-\r
- for (j = 0; j < n_ifs; j++) {\r
- REQ(ch, list_iter);\r
- ch = CHILD(ch, 0);\r
- REQ(ch, list_if);\r
-\r
- list_for_expr = ast_for_expr(c, CHILD(ch, 1));\r
- if (!list_for_expr)\r
- return NULL;\r
-\r
- asdl_seq_SET(ifs, j, list_for_expr);\r
- if (NCH(ch) == 3)\r
- ch = CHILD(ch, 2);\r
- }\r
- /* on exit, must guarantee that ch is a list_for */\r
- if (TYPE(ch) == list_iter)\r
- ch = CHILD(ch, 0);\r
- lc->ifs = ifs;\r
- }\r
- asdl_seq_SET(listcomps, i, lc);\r
- }\r
-\r
- return ListComp(elt, listcomps, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-/*\r
- Count the number of 'for' loops in a comprehension.\r
-\r
- Helper for ast_for_comprehension().\r
-*/\r
-\r
-static int\r
-count_comp_fors(struct compiling *c, const node *n)\r
-{\r
- int n_fors = 0;\r
-\r
- count_comp_for:\r
- n_fors++;\r
- REQ(n, comp_for);\r
- if (NCH(n) == 5)\r
- n = CHILD(n, 4);\r
- else\r
- return n_fors;\r
- count_comp_iter:\r
- REQ(n, comp_iter);\r
- n = CHILD(n, 0);\r
- if (TYPE(n) == comp_for)\r
- goto count_comp_for;\r
- else if (TYPE(n) == comp_if) {\r
- if (NCH(n) == 3) {\r
- n = CHILD(n, 2);\r
- goto count_comp_iter;\r
- }\r
- else\r
- return n_fors;\r
- }\r
-\r
- /* Should never be reached */\r
- PyErr_SetString(PyExc_SystemError,\r
- "logic error in count_comp_fors");\r
- return -1;\r
-}\r
-\r
-/* Count the number of 'if' statements in a comprehension.\r
-\r
- Helper for ast_for_comprehension().\r
-*/\r
-\r
-static int\r
-count_comp_ifs(struct compiling *c, const node *n)\r
-{\r
- int n_ifs = 0;\r
-\r
- while (1) {\r
- REQ(n, comp_iter);\r
- if (TYPE(CHILD(n, 0)) == comp_for)\r
- return n_ifs;\r
- n = CHILD(n, 0);\r
- REQ(n, comp_if);\r
- n_ifs++;\r
- if (NCH(n) == 2)\r
- return n_ifs;\r
- n = CHILD(n, 2);\r
- }\r
-}\r
-\r
-static asdl_seq *\r
-ast_for_comprehension(struct compiling *c, const node *n)\r
-{\r
- int i, n_fors;\r
- asdl_seq *comps;\r
-\r
- n_fors = count_comp_fors(c, n);\r
- if (n_fors == -1)\r
- return NULL;\r
-\r
- comps = asdl_seq_new(n_fors, c->c_arena);\r
- if (!comps)\r
- return NULL;\r
-\r
- for (i = 0; i < n_fors; i++) {\r
- comprehension_ty comp;\r
- asdl_seq *t;\r
- expr_ty expression, first;\r
- node *for_ch;\r
-\r
- REQ(n, comp_for);\r
-\r
- for_ch = CHILD(n, 1);\r
- t = ast_for_exprlist(c, for_ch, Store);\r
- if (!t)\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(n, 3));\r
- if (!expression)\r
- return NULL;\r
-\r
- /* Check the # of children rather than the length of t, since\r
- (x for x, in ...) has 1 element in t, but still requires a Tuple. */\r
- first = (expr_ty)asdl_seq_GET(t, 0);\r
- if (NCH(for_ch) == 1)\r
- comp = comprehension(first, expression, NULL, c->c_arena);\r
- else\r
- comp = comprehension(Tuple(t, Store, first->lineno, first->col_offset,\r
- c->c_arena),\r
- expression, NULL, c->c_arena);\r
- if (!comp)\r
- return NULL;\r
-\r
- if (NCH(n) == 5) {\r
- int j, n_ifs;\r
- asdl_seq *ifs;\r
-\r
- n = CHILD(n, 4);\r
- n_ifs = count_comp_ifs(c, n);\r
- if (n_ifs == -1)\r
- return NULL;\r
-\r
- ifs = asdl_seq_new(n_ifs, c->c_arena);\r
- if (!ifs)\r
- return NULL;\r
-\r
- for (j = 0; j < n_ifs; j++) {\r
- REQ(n, comp_iter);\r
- n = CHILD(n, 0);\r
- REQ(n, comp_if);\r
-\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- asdl_seq_SET(ifs, j, expression);\r
- if (NCH(n) == 3)\r
- n = CHILD(n, 2);\r
- }\r
- /* on exit, must guarantee that n is a comp_for */\r
- if (TYPE(n) == comp_iter)\r
- n = CHILD(n, 0);\r
- comp->ifs = ifs;\r
- }\r
- asdl_seq_SET(comps, i, comp);\r
- }\r
- return comps;\r
-}\r
-\r
-static expr_ty\r
-ast_for_itercomp(struct compiling *c, const node *n, int type)\r
-{\r
- expr_ty elt;\r
- asdl_seq *comps;\r
-\r
- assert(NCH(n) > 1);\r
-\r
- elt = ast_for_expr(c, CHILD(n, 0));\r
- if (!elt)\r
- return NULL;\r
-\r
- comps = ast_for_comprehension(c, CHILD(n, 1));\r
- if (!comps)\r
- return NULL;\r
-\r
- if (type == COMP_GENEXP)\r
- return GeneratorExp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena);\r
- else if (type == COMP_SETCOMP)\r
- return SetComp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena);\r
- else\r
- /* Should never happen */\r
- return NULL;\r
-}\r
-\r
-static expr_ty\r
-ast_for_dictcomp(struct compiling *c, const node *n)\r
-{\r
- expr_ty key, value;\r
- asdl_seq *comps;\r
-\r
- assert(NCH(n) > 3);\r
- REQ(CHILD(n, 1), COLON);\r
-\r
- key = ast_for_expr(c, CHILD(n, 0));\r
- if (!key)\r
- return NULL;\r
-\r
- value = ast_for_expr(c, CHILD(n, 2));\r
- if (!value)\r
- return NULL;\r
-\r
- comps = ast_for_comprehension(c, CHILD(n, 3));\r
- if (!comps)\r
- return NULL;\r
-\r
- return DictComp(key, value, comps, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static expr_ty\r
-ast_for_genexp(struct compiling *c, const node *n)\r
-{\r
- assert(TYPE(n) == (testlist_comp) || TYPE(n) == (argument));\r
- return ast_for_itercomp(c, n, COMP_GENEXP);\r
-}\r
-\r
-static expr_ty\r
-ast_for_setcomp(struct compiling *c, const node *n)\r
-{\r
- assert(TYPE(n) == (dictorsetmaker));\r
- return ast_for_itercomp(c, n, COMP_SETCOMP);\r
-}\r
-\r
-static expr_ty\r
-ast_for_atom(struct compiling *c, const node *n)\r
-{\r
- /* atom: '(' [yield_expr|testlist_comp] ')' | '[' [listmaker] ']'\r
- | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+\r
- */\r
- node *ch = CHILD(n, 0);\r
-\r
- switch (TYPE(ch)) {\r
- case NAME: {\r
- /* All names start in Load context, but may later be\r
- changed. */\r
- PyObject *name = NEW_IDENTIFIER(ch);\r
- if (!name)\r
- return NULL;\r
- return Name(name, Load, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- case STRING: {\r
- PyObject *str = parsestrplus(c, n);\r
- if (!str) {\r
-#ifdef Py_USING_UNICODE\r
- if (PyErr_ExceptionMatches(PyExc_UnicodeError)){\r
- PyObject *type, *value, *tback, *errstr;\r
- PyErr_Fetch(&type, &value, &tback);\r
- errstr = PyObject_Str(value);\r
- if (errstr) {\r
- char *s = "";\r
- char buf[128];\r
- s = PyString_AsString(errstr);\r
- PyOS_snprintf(buf, sizeof(buf), "(unicode error) %s", s);\r
- ast_error(n, buf);\r
- Py_DECREF(errstr);\r
- } else {\r
- ast_error(n, "(unicode error) unknown error");\r
- }\r
- Py_DECREF(type);\r
- Py_DECREF(value);\r
- Py_XDECREF(tback);\r
- }\r
-#endif\r
- return NULL;\r
- }\r
- PyArena_AddPyObject(c->c_arena, str);\r
- return Str(str, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- case NUMBER: {\r
- PyObject *pynum = parsenumber(c, STR(ch));\r
- if (!pynum)\r
- return NULL;\r
-\r
- PyArena_AddPyObject(c->c_arena, pynum);\r
- return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- case LPAR: /* some parenthesized expressions */\r
- ch = CHILD(n, 1);\r
-\r
- if (TYPE(ch) == RPAR)\r
- return Tuple(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);\r
-\r
- if (TYPE(ch) == yield_expr)\r
- return ast_for_expr(c, ch);\r
-\r
- return ast_for_testlist_comp(c, ch);\r
- case LSQB: /* list (or list comprehension) */\r
- ch = CHILD(n, 1);\r
-\r
- if (TYPE(ch) == RSQB)\r
- return List(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);\r
-\r
- REQ(ch, listmaker);\r
- if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) {\r
- asdl_seq *elts = seq_for_testlist(c, ch);\r
- if (!elts)\r
- return NULL;\r
-\r
- return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- else\r
- return ast_for_listcomp(c, ch);\r
- case LBRACE: {\r
- /* dictorsetmaker:\r
- * (test ':' test (comp_for | (',' test ':' test)* [','])) |\r
- * (test (comp_for | (',' test)* [',']))\r
- */\r
- int i, size;\r
- asdl_seq *keys, *values;\r
-\r
- ch = CHILD(n, 1);\r
- if (TYPE(ch) == RBRACE) {\r
- /* it's an empty dict */\r
- return Dict(NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena);\r
- } else if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) {\r
- /* it's a simple set */\r
- asdl_seq *elts;\r
- size = (NCH(ch) + 1) / 2; /* +1 in case no trailing comma */\r
- elts = asdl_seq_new(size, c->c_arena);\r
- if (!elts)\r
- return NULL;\r
- for (i = 0; i < NCH(ch); i += 2) {\r
- expr_ty expression;\r
- expression = ast_for_expr(c, CHILD(ch, i));\r
- if (!expression)\r
- return NULL;\r
- asdl_seq_SET(elts, i / 2, expression);\r
- }\r
- return Set(elts, LINENO(n), n->n_col_offset, c->c_arena);\r
- } else if (TYPE(CHILD(ch, 1)) == comp_for) {\r
- /* it's a set comprehension */\r
- return ast_for_setcomp(c, ch);\r
- } else if (NCH(ch) > 3 && TYPE(CHILD(ch, 3)) == comp_for) {\r
- return ast_for_dictcomp(c, ch);\r
- } else {\r
- /* it's a dict */\r
- size = (NCH(ch) + 1) / 4; /* +1 in case no trailing comma */\r
- keys = asdl_seq_new(size, c->c_arena);\r
- if (!keys)\r
- return NULL;\r
-\r
- values = asdl_seq_new(size, c->c_arena);\r
- if (!values)\r
- return NULL;\r
-\r
- for (i = 0; i < NCH(ch); i += 4) {\r
- expr_ty expression;\r
-\r
- expression = ast_for_expr(c, CHILD(ch, i));\r
- if (!expression)\r
- return NULL;\r
-\r
- asdl_seq_SET(keys, i / 4, expression);\r
-\r
- expression = ast_for_expr(c, CHILD(ch, i + 2));\r
- if (!expression)\r
- return NULL;\r
-\r
- asdl_seq_SET(values, i / 4, expression);\r
- }\r
- return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- }\r
- case BACKQUOTE: { /* repr */\r
- expr_ty expression;\r
- if (Py_Py3kWarningFlag &&\r
- !ast_warn(c, n, "backquote not supported in 3.x; use repr()"))\r
- return NULL;\r
- expression = ast_for_testlist(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
-\r
- return Repr(expression, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- default:\r
- PyErr_Format(PyExc_SystemError, "unhandled atom %d", TYPE(ch));\r
- return NULL;\r
- }\r
-}\r
-\r
-static slice_ty\r
-ast_for_slice(struct compiling *c, const node *n)\r
-{\r
- node *ch;\r
- expr_ty lower = NULL, upper = NULL, step = NULL;\r
-\r
- REQ(n, subscript);\r
-\r
- /*\r
- subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]\r
- sliceop: ':' [test]\r
- */\r
- ch = CHILD(n, 0);\r
- if (TYPE(ch) == DOT)\r
- return Ellipsis(c->c_arena);\r
-\r
- if (NCH(n) == 1 && TYPE(ch) == test) {\r
- /* 'step' variable hold no significance in terms of being used over\r
- other vars */\r
- step = ast_for_expr(c, ch);\r
- if (!step)\r
- return NULL;\r
-\r
- return Index(step, c->c_arena);\r
- }\r
-\r
- if (TYPE(ch) == test) {\r
- lower = ast_for_expr(c, ch);\r
- if (!lower)\r
- return NULL;\r
- }\r
-\r
- /* If there's an upper bound it's in the second or third position. */\r
- if (TYPE(ch) == COLON) {\r
- if (NCH(n) > 1) {\r
- node *n2 = CHILD(n, 1);\r
-\r
- if (TYPE(n2) == test) {\r
- upper = ast_for_expr(c, n2);\r
- if (!upper)\r
- return NULL;\r
- }\r
- }\r
- } else if (NCH(n) > 2) {\r
- node *n2 = CHILD(n, 2);\r
-\r
- if (TYPE(n2) == test) {\r
- upper = ast_for_expr(c, n2);\r
- if (!upper)\r
- return NULL;\r
- }\r
- }\r
-\r
- ch = CHILD(n, NCH(n) - 1);\r
- if (TYPE(ch) == sliceop) {\r
- if (NCH(ch) == 1) {\r
- /*\r
- This is an extended slice (ie "x[::]") with no expression in the\r
- step field. We set this literally to "None" in order to\r
- disambiguate it from x[:]. (The interpreter might have to call\r
- __getslice__ for x[:], but it must call __getitem__ for x[::].)\r
- */\r
- identifier none = new_identifier("None", c->c_arena);\r
- if (!none)\r
- return NULL;\r
- ch = CHILD(ch, 0);\r
- step = Name(none, Load, LINENO(ch), ch->n_col_offset, c->c_arena);\r
- if (!step)\r
- return NULL;\r
- } else {\r
- ch = CHILD(ch, 1);\r
- if (TYPE(ch) == test) {\r
- step = ast_for_expr(c, ch);\r
- if (!step)\r
- return NULL;\r
- }\r
- }\r
- }\r
-\r
- return Slice(lower, upper, step, c->c_arena);\r
-}\r
-\r
-static expr_ty\r
-ast_for_binop(struct compiling *c, const node *n)\r
-{\r
- /* Must account for a sequence of expressions.\r
- How should A op B op C by represented?\r
- BinOp(BinOp(A, op, B), op, C).\r
- */\r
-\r
- int i, nops;\r
- expr_ty expr1, expr2, result;\r
- operator_ty newoperator;\r
-\r
- expr1 = ast_for_expr(c, CHILD(n, 0));\r
- if (!expr1)\r
- return NULL;\r
-\r
- expr2 = ast_for_expr(c, CHILD(n, 2));\r
- if (!expr2)\r
- return NULL;\r
-\r
- newoperator = get_operator(CHILD(n, 1));\r
- if (!newoperator)\r
- return NULL;\r
-\r
- result = BinOp(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- if (!result)\r
- return NULL;\r
-\r
- nops = (NCH(n) - 1) / 2;\r
- for (i = 1; i < nops; i++) {\r
- expr_ty tmp_result, tmp;\r
- const node* next_oper = CHILD(n, i * 2 + 1);\r
-\r
- newoperator = get_operator(next_oper);\r
- if (!newoperator)\r
- return NULL;\r
-\r
- tmp = ast_for_expr(c, CHILD(n, i * 2 + 2));\r
- if (!tmp)\r
- return NULL;\r
-\r
- tmp_result = BinOp(result, newoperator, tmp,\r
- LINENO(next_oper), next_oper->n_col_offset,\r
- c->c_arena);\r
- if (!tmp_result)\r
- return NULL;\r
- result = tmp_result;\r
- }\r
- return result;\r
-}\r
-\r
-static expr_ty\r
-ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr)\r
-{\r
- /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME\r
- subscriptlist: subscript (',' subscript)* [',']\r
- subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]\r
- */\r
- REQ(n, trailer);\r
- if (TYPE(CHILD(n, 0)) == LPAR) {\r
- if (NCH(n) == 2)\r
- return Call(left_expr, NULL, NULL, NULL, NULL, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- else\r
- return ast_for_call(c, CHILD(n, 1), left_expr);\r
- }\r
- else if (TYPE(CHILD(n, 0)) == DOT ) {\r
- PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1));\r
- if (!attr_id)\r
- return NULL;\r
- return Attribute(left_expr, attr_id, Load,\r
- LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- else {\r
- REQ(CHILD(n, 0), LSQB);\r
- REQ(CHILD(n, 2), RSQB);\r
- n = CHILD(n, 1);\r
- if (NCH(n) == 1) {\r
- slice_ty slc = ast_for_slice(c, CHILD(n, 0));\r
- if (!slc)\r
- return NULL;\r
- return Subscript(left_expr, slc, Load, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- else {\r
- /* The grammar is ambiguous here. The ambiguity is resolved\r
- by treating the sequence as a tuple literal if there are\r
- no slice features.\r
- */\r
- int j;\r
- slice_ty slc;\r
- expr_ty e;\r
- bool simple = true;\r
- asdl_seq *slices, *elts;\r
- slices = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);\r
- if (!slices)\r
- return NULL;\r
- for (j = 0; j < NCH(n); j += 2) {\r
- slc = ast_for_slice(c, CHILD(n, j));\r
- if (!slc)\r
- return NULL;\r
- if (slc->kind != Index_kind)\r
- simple = false;\r
- asdl_seq_SET(slices, j / 2, slc);\r
- }\r
- if (!simple) {\r
- return Subscript(left_expr, ExtSlice(slices, c->c_arena),\r
- Load, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- /* extract Index values and put them in a Tuple */\r
- elts = asdl_seq_new(asdl_seq_LEN(slices), c->c_arena);\r
- if (!elts)\r
- return NULL;\r
- for (j = 0; j < asdl_seq_LEN(slices); ++j) {\r
- slc = (slice_ty)asdl_seq_GET(slices, j);\r
- assert(slc->kind == Index_kind && slc->v.Index.value);\r
- asdl_seq_SET(elts, j, slc->v.Index.value);\r
- }\r
- e = Tuple(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);\r
- if (!e)\r
- return NULL;\r
- return Subscript(left_expr, Index(e, c->c_arena),\r
- Load, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- }\r
-}\r
-\r
-static expr_ty\r
-ast_for_factor(struct compiling *c, const node *n)\r
-{\r
- node *pfactor, *ppower, *patom, *pnum;\r
- expr_ty expression;\r
-\r
- /* If the unary - operator is applied to a constant, don't generate\r
- a UNARY_NEGATIVE opcode. Just store the approriate value as a\r
- constant. The peephole optimizer already does something like\r
- this but it doesn't handle the case where the constant is\r
- (sys.maxint - 1). In that case, we want a PyIntObject, not a\r
- PyLongObject.\r
- */\r
- if (TYPE(CHILD(n, 0)) == MINUS &&\r
- NCH(n) == 2 &&\r
- TYPE((pfactor = CHILD(n, 1))) == factor &&\r
- NCH(pfactor) == 1 &&\r
- TYPE((ppower = CHILD(pfactor, 0))) == power &&\r
- NCH(ppower) == 1 &&\r
- TYPE((patom = CHILD(ppower, 0))) == atom &&\r
- TYPE((pnum = CHILD(patom, 0))) == NUMBER) {\r
- PyObject *pynum;\r
- char *s = PyObject_MALLOC(strlen(STR(pnum)) + 2);\r
- if (s == NULL)\r
- return NULL;\r
- s[0] = '-';\r
- strcpy(s + 1, STR(pnum));\r
- pynum = parsenumber(c, s);\r
- PyObject_FREE(s);\r
- if (!pynum)\r
- return NULL;\r
-\r
- PyArena_AddPyObject(c->c_arena, pynum);\r
- return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
-\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
-\r
- switch (TYPE(CHILD(n, 0))) {\r
- case PLUS:\r
- return UnaryOp(UAdd, expression, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- case MINUS:\r
- return UnaryOp(USub, expression, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- case TILDE:\r
- return UnaryOp(Invert, expression, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- }\r
- PyErr_Format(PyExc_SystemError, "unhandled factor: %d",\r
- TYPE(CHILD(n, 0)));\r
- return NULL;\r
-}\r
-\r
-static expr_ty\r
-ast_for_power(struct compiling *c, const node *n)\r
-{\r
- /* power: atom trailer* ('**' factor)*\r
- */\r
- int i;\r
- expr_ty e, tmp;\r
- REQ(n, power);\r
- e = ast_for_atom(c, CHILD(n, 0));\r
- if (!e)\r
- return NULL;\r
- if (NCH(n) == 1)\r
- return e;\r
- for (i = 1; i < NCH(n); i++) {\r
- node *ch = CHILD(n, i);\r
- if (TYPE(ch) != trailer)\r
- break;\r
- tmp = ast_for_trailer(c, ch, e);\r
- if (!tmp)\r
- return NULL;\r
- tmp->lineno = e->lineno;\r
- tmp->col_offset = e->col_offset;\r
- e = tmp;\r
- }\r
- if (TYPE(CHILD(n, NCH(n) - 1)) == factor) {\r
- expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1));\r
- if (!f)\r
- return NULL;\r
- tmp = BinOp(e, Pow, f, LINENO(n), n->n_col_offset, c->c_arena);\r
- if (!tmp)\r
- return NULL;\r
- e = tmp;\r
- }\r
- return e;\r
-}\r
-\r
-/* Do not name a variable 'expr'! Will cause a compile error.\r
-*/\r
-\r
-static expr_ty\r
-ast_for_expr(struct compiling *c, const node *n)\r
-{\r
- /* handle the full range of simple expressions\r
- test: or_test ['if' or_test 'else' test] | lambdef\r
- or_test: and_test ('or' and_test)*\r
- and_test: not_test ('and' not_test)*\r
- not_test: 'not' not_test | comparison\r
- comparison: expr (comp_op expr)*\r
- expr: xor_expr ('|' xor_expr)*\r
- xor_expr: and_expr ('^' and_expr)*\r
- and_expr: shift_expr ('&' shift_expr)*\r
- shift_expr: arith_expr (('<<'|'>>') arith_expr)*\r
- arith_expr: term (('+'|'-') term)*\r
- term: factor (('*'|'/'|'%'|'//') factor)*\r
- factor: ('+'|'-'|'~') factor | power\r
- power: atom trailer* ('**' factor)*\r
-\r
- As well as modified versions that exist for backward compatibility,\r
- to explicitly allow:\r
- [ x for x in lambda: 0, lambda: 1 ]\r
- (which would be ambiguous without these extra rules)\r
-\r
- old_test: or_test | old_lambdef\r
- old_lambdef: 'lambda' [vararglist] ':' old_test\r
-\r
- */\r
-\r
- asdl_seq *seq;\r
- int i;\r
-\r
- loop:\r
- switch (TYPE(n)) {\r
- case test:\r
- case old_test:\r
- if (TYPE(CHILD(n, 0)) == lambdef ||\r
- TYPE(CHILD(n, 0)) == old_lambdef)\r
- return ast_for_lambdef(c, CHILD(n, 0));\r
- else if (NCH(n) > 1)\r
- return ast_for_ifexpr(c, n);\r
- /* Fallthrough */\r
- case or_test:\r
- case and_test:\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- goto loop;\r
- }\r
- seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);\r
- if (!seq)\r
- return NULL;\r
- for (i = 0; i < NCH(n); i += 2) {\r
- expr_ty e = ast_for_expr(c, CHILD(n, i));\r
- if (!e)\r
- return NULL;\r
- asdl_seq_SET(seq, i / 2, e);\r
- }\r
- if (!strcmp(STR(CHILD(n, 1)), "and"))\r
- return BoolOp(And, seq, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- assert(!strcmp(STR(CHILD(n, 1)), "or"));\r
- return BoolOp(Or, seq, LINENO(n), n->n_col_offset, c->c_arena);\r
- case not_test:\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- goto loop;\r
- }\r
- else {\r
- expr_ty expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
-\r
- return UnaryOp(Not, expression, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- case comparison:\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- goto loop;\r
- }\r
- else {\r
- expr_ty expression;\r
- asdl_int_seq *ops;\r
- asdl_seq *cmps;\r
- ops = asdl_int_seq_new(NCH(n) / 2, c->c_arena);\r
- if (!ops)\r
- return NULL;\r
- cmps = asdl_seq_new(NCH(n) / 2, c->c_arena);\r
- if (!cmps) {\r
- return NULL;\r
- }\r
- for (i = 1; i < NCH(n); i += 2) {\r
- cmpop_ty newoperator;\r
-\r
- newoperator = ast_for_comp_op(c, CHILD(n, i));\r
- if (!newoperator) {\r
- return NULL;\r
- }\r
-\r
- expression = ast_for_expr(c, CHILD(n, i + 1));\r
- if (!expression) {\r
- return NULL;\r
- }\r
-\r
- asdl_seq_SET(ops, i / 2, newoperator);\r
- asdl_seq_SET(cmps, i / 2, expression);\r
- }\r
- expression = ast_for_expr(c, CHILD(n, 0));\r
- if (!expression) {\r
- return NULL;\r
- }\r
-\r
- return Compare(expression, ops, cmps, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- }\r
- break;\r
-\r
- /* The next five cases all handle BinOps. The main body of code\r
- is the same in each case, but the switch turned inside out to\r
- reuse the code for each type of operator.\r
- */\r
- case expr:\r
- case xor_expr:\r
- case and_expr:\r
- case shift_expr:\r
- case arith_expr:\r
- case term:\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- goto loop;\r
- }\r
- return ast_for_binop(c, n);\r
- case yield_expr: {\r
- expr_ty exp = NULL;\r
- if (NCH(n) == 2) {\r
- exp = ast_for_testlist(c, CHILD(n, 1));\r
- if (!exp)\r
- return NULL;\r
- }\r
- return Yield(exp, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- case factor:\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- goto loop;\r
- }\r
- return ast_for_factor(c, n);\r
- case power:\r
- return ast_for_power(c, n);\r
- default:\r
- PyErr_Format(PyExc_SystemError, "unhandled expr: %d", TYPE(n));\r
- return NULL;\r
- }\r
- /* should never get here unless if error is set */\r
- return NULL;\r
-}\r
-\r
-static expr_ty\r
-ast_for_call(struct compiling *c, const node *n, expr_ty func)\r
-{\r
- /*\r
- arglist: (argument ',')* (argument [',']| '*' test [',' '**' test]\r
- | '**' test)\r
- argument: [test '='] test [comp_for] # Really [keyword '='] test\r
- */\r
-\r
- int i, nargs, nkeywords, ngens;\r
- asdl_seq *args;\r
- asdl_seq *keywords;\r
- expr_ty vararg = NULL, kwarg = NULL;\r
-\r
- REQ(n, arglist);\r
-\r
- nargs = 0;\r
- nkeywords = 0;\r
- ngens = 0;\r
- for (i = 0; i < NCH(n); i++) {\r
- node *ch = CHILD(n, i);\r
- if (TYPE(ch) == argument) {\r
- if (NCH(ch) == 1)\r
- nargs++;\r
- else if (TYPE(CHILD(ch, 1)) == comp_for)\r
- ngens++;\r
- else\r
- nkeywords++;\r
- }\r
- }\r
- if (ngens > 1 || (ngens && (nargs || nkeywords))) {\r
- ast_error(n, "Generator expression must be parenthesized "\r
- "if not sole argument");\r
- return NULL;\r
- }\r
-\r
- if (nargs + nkeywords + ngens > 255) {\r
- ast_error(n, "more than 255 arguments");\r
- return NULL;\r
- }\r
-\r
- args = asdl_seq_new(nargs + ngens, c->c_arena);\r
- if (!args)\r
- return NULL;\r
- keywords = asdl_seq_new(nkeywords, c->c_arena);\r
- if (!keywords)\r
- return NULL;\r
- nargs = 0;\r
- nkeywords = 0;\r
- for (i = 0; i < NCH(n); i++) {\r
- node *ch = CHILD(n, i);\r
- if (TYPE(ch) == argument) {\r
- expr_ty e;\r
- if (NCH(ch) == 1) {\r
- if (nkeywords) {\r
- ast_error(CHILD(ch, 0),\r
- "non-keyword arg after keyword arg");\r
- return NULL;\r
- }\r
- if (vararg) {\r
- ast_error(CHILD(ch, 0),\r
- "only named arguments may follow *expression");\r
- return NULL;\r
- }\r
- e = ast_for_expr(c, CHILD(ch, 0));\r
- if (!e)\r
- return NULL;\r
- asdl_seq_SET(args, nargs++, e);\r
- }\r
- else if (TYPE(CHILD(ch, 1)) == comp_for) {\r
- e = ast_for_genexp(c, ch);\r
- if (!e)\r
- return NULL;\r
- asdl_seq_SET(args, nargs++, e);\r
- }\r
- else {\r
- keyword_ty kw;\r
- identifier key;\r
- int k;\r
- char *tmp;\r
-\r
- /* CHILD(ch, 0) is test, but must be an identifier? */\r
- e = ast_for_expr(c, CHILD(ch, 0));\r
- if (!e)\r
- return NULL;\r
- /* f(lambda x: x[0] = 3) ends up getting parsed with\r
- * LHS test = lambda x: x[0], and RHS test = 3.\r
- * SF bug 132313 points out that complaining about a keyword\r
- * then is very confusing.\r
- */\r
- if (e->kind == Lambda_kind) {\r
- ast_error(CHILD(ch, 0),\r
- "lambda cannot contain assignment");\r
- return NULL;\r
- } else if (e->kind != Name_kind) {\r
- ast_error(CHILD(ch, 0), "keyword can't be an expression");\r
- return NULL;\r
- }\r
- key = e->v.Name.id;\r
- if (!forbidden_check(c, CHILD(ch, 0), PyBytes_AS_STRING(key)))\r
- return NULL;\r
- for (k = 0; k < nkeywords; k++) {\r
- tmp = PyString_AS_STRING(\r
- ((keyword_ty)asdl_seq_GET(keywords, k))->arg);\r
- if (!strcmp(tmp, PyString_AS_STRING(key))) {\r
- ast_error(CHILD(ch, 0), "keyword argument repeated");\r
- return NULL;\r
- }\r
- }\r
- e = ast_for_expr(c, CHILD(ch, 2));\r
- if (!e)\r
- return NULL;\r
- kw = keyword(key, e, c->c_arena);\r
- if (!kw)\r
- return NULL;\r
- asdl_seq_SET(keywords, nkeywords++, kw);\r
- }\r
- }\r
- else if (TYPE(ch) == STAR) {\r
- vararg = ast_for_expr(c, CHILD(n, i+1));\r
- if (!vararg)\r
- return NULL;\r
- i++;\r
- }\r
- else if (TYPE(ch) == DOUBLESTAR) {\r
- kwarg = ast_for_expr(c, CHILD(n, i+1));\r
- if (!kwarg)\r
- return NULL;\r
- i++;\r
- }\r
- }\r
-\r
- return Call(func, args, keywords, vararg, kwarg, func->lineno,\r
- func->col_offset, c->c_arena);\r
-}\r
-\r
-static expr_ty\r
-ast_for_testlist(struct compiling *c, const node* n)\r
-{\r
- /* testlist_comp: test (',' test)* [','] */\r
- /* testlist: test (',' test)* [','] */\r
- /* testlist_safe: test (',' test)+ [','] */\r
- /* testlist1: test (',' test)* */\r
- assert(NCH(n) > 0);\r
- if (TYPE(n) == testlist_comp) {\r
- if (NCH(n) > 1)\r
- assert(TYPE(CHILD(n, 1)) != comp_for);\r
- }\r
- else {\r
- assert(TYPE(n) == testlist ||\r
- TYPE(n) == testlist_safe ||\r
- TYPE(n) == testlist1);\r
- }\r
- if (NCH(n) == 1)\r
- return ast_for_expr(c, CHILD(n, 0));\r
- else {\r
- asdl_seq *tmp = seq_for_testlist(c, n);\r
- if (!tmp)\r
- return NULL;\r
- return Tuple(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
-}\r
-\r
-static expr_ty\r
-ast_for_testlist_comp(struct compiling *c, const node* n)\r
-{\r
- /* testlist_comp: test ( comp_for | (',' test)* [','] ) */\r
- /* argument: test [ comp_for ] */\r
- assert(TYPE(n) == testlist_comp || TYPE(n) == argument);\r
- if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == comp_for)\r
- return ast_for_genexp(c, n);\r
- return ast_for_testlist(c, n);\r
-}\r
-\r
-/* like ast_for_testlist() but returns a sequence */\r
-static asdl_seq*\r
-ast_for_class_bases(struct compiling *c, const node* n)\r
-{\r
- /* testlist: test (',' test)* [','] */\r
- assert(NCH(n) > 0);\r
- REQ(n, testlist);\r
- if (NCH(n) == 1) {\r
- expr_ty base;\r
- asdl_seq *bases = asdl_seq_new(1, c->c_arena);\r
- if (!bases)\r
- return NULL;\r
- base = ast_for_expr(c, CHILD(n, 0));\r
- if (!base)\r
- return NULL;\r
- asdl_seq_SET(bases, 0, base);\r
- return bases;\r
- }\r
-\r
- return seq_for_testlist(c, n);\r
-}\r
-\r
-static stmt_ty\r
-ast_for_expr_stmt(struct compiling *c, const node *n)\r
-{\r
- REQ(n, expr_stmt);\r
- /* expr_stmt: testlist (augassign (yield_expr|testlist)\r
- | ('=' (yield_expr|testlist))*)\r
- testlist: test (',' test)* [',']\r
- augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='\r
- | '<<=' | '>>=' | '**=' | '//='\r
- test: ... here starts the operator precendence dance\r
- */\r
-\r
- if (NCH(n) == 1) {\r
- expr_ty e = ast_for_testlist(c, CHILD(n, 0));\r
- if (!e)\r
- return NULL;\r
-\r
- return Expr(e, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- else if (TYPE(CHILD(n, 1)) == augassign) {\r
- expr_ty expr1, expr2;\r
- operator_ty newoperator;\r
- node *ch = CHILD(n, 0);\r
-\r
- expr1 = ast_for_testlist(c, ch);\r
- if (!expr1)\r
- return NULL;\r
- if(!set_context(c, expr1, Store, ch))\r
- return NULL;\r
- /* set_context checks that most expressions are not the left side.\r
- Augmented assignments can only have a name, a subscript, or an\r
- attribute on the left, though, so we have to explicitly check for\r
- those. */\r
- switch (expr1->kind) {\r
- case Name_kind:\r
- case Attribute_kind:\r
- case Subscript_kind:\r
- break;\r
- default:\r
- ast_error(ch, "illegal expression for augmented assignment");\r
- return NULL;\r
- }\r
-\r
- ch = CHILD(n, 2);\r
- if (TYPE(ch) == testlist)\r
- expr2 = ast_for_testlist(c, ch);\r
- else\r
- expr2 = ast_for_expr(c, ch);\r
- if (!expr2)\r
- return NULL;\r
-\r
- newoperator = ast_for_augassign(c, CHILD(n, 1));\r
- if (!newoperator)\r
- return NULL;\r
-\r
- return AugAssign(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- else {\r
- int i;\r
- asdl_seq *targets;\r
- node *value;\r
- expr_ty expression;\r
-\r
- /* a normal assignment */\r
- REQ(CHILD(n, 1), EQUAL);\r
- targets = asdl_seq_new(NCH(n) / 2, c->c_arena);\r
- if (!targets)\r
- return NULL;\r
- for (i = 0; i < NCH(n) - 2; i += 2) {\r
- expr_ty e;\r
- node *ch = CHILD(n, i);\r
- if (TYPE(ch) == yield_expr) {\r
- ast_error(ch, "assignment to yield expression not possible");\r
- return NULL;\r
- }\r
- e = ast_for_testlist(c, ch);\r
- if (!e)\r
- return NULL;\r
-\r
- /* set context to assign */\r
- if (!set_context(c, e, Store, CHILD(n, i)))\r
- return NULL;\r
-\r
- asdl_seq_SET(targets, i / 2, e);\r
- }\r
- value = CHILD(n, NCH(n) - 1);\r
- if (TYPE(value) == testlist)\r
- expression = ast_for_testlist(c, value);\r
- else\r
- expression = ast_for_expr(c, value);\r
- if (!expression)\r
- return NULL;\r
- return Assign(targets, expression, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
-}\r
-\r
-static stmt_ty\r
-ast_for_print_stmt(struct compiling *c, const node *n)\r
-{\r
- /* print_stmt: 'print' ( [ test (',' test)* [','] ]\r
- | '>>' test [ (',' test)+ [','] ] )\r
- */\r
- expr_ty dest = NULL, expression;\r
- asdl_seq *seq = NULL;\r
- bool nl;\r
- int i, j, values_count, start = 1;\r
-\r
- REQ(n, print_stmt);\r
- if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) {\r
- dest = ast_for_expr(c, CHILD(n, 2));\r
- if (!dest)\r
- return NULL;\r
- start = 4;\r
- }\r
- values_count = (NCH(n) + 1 - start) / 2;\r
- if (values_count) {\r
- seq = asdl_seq_new(values_count, c->c_arena);\r
- if (!seq)\r
- return NULL;\r
- for (i = start, j = 0; i < NCH(n); i += 2, ++j) {\r
- expression = ast_for_expr(c, CHILD(n, i));\r
- if (!expression)\r
- return NULL;\r
- asdl_seq_SET(seq, j, expression);\r
- }\r
- }\r
- nl = (TYPE(CHILD(n, NCH(n) - 1)) == COMMA) ? false : true;\r
- return Print(dest, seq, nl, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static asdl_seq *\r
-ast_for_exprlist(struct compiling *c, const node *n, expr_context_ty context)\r
-{\r
- asdl_seq *seq;\r
- int i;\r
- expr_ty e;\r
-\r
- REQ(n, exprlist);\r
-\r
- seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);\r
- if (!seq)\r
- return NULL;\r
- for (i = 0; i < NCH(n); i += 2) {\r
- e = ast_for_expr(c, CHILD(n, i));\r
- if (!e)\r
- return NULL;\r
- asdl_seq_SET(seq, i / 2, e);\r
- if (context && !set_context(c, e, context, CHILD(n, i)))\r
- return NULL;\r
- }\r
- return seq;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_del_stmt(struct compiling *c, const node *n)\r
-{\r
- asdl_seq *expr_list;\r
-\r
- /* del_stmt: 'del' exprlist */\r
- REQ(n, del_stmt);\r
-\r
- expr_list = ast_for_exprlist(c, CHILD(n, 1), Del);\r
- if (!expr_list)\r
- return NULL;\r
- return Delete(expr_list, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static stmt_ty\r
-ast_for_flow_stmt(struct compiling *c, const node *n)\r
-{\r
- /*\r
- flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt\r
- | yield_stmt\r
- break_stmt: 'break'\r
- continue_stmt: 'continue'\r
- return_stmt: 'return' [testlist]\r
- yield_stmt: yield_expr\r
- yield_expr: 'yield' testlist\r
- raise_stmt: 'raise' [test [',' test [',' test]]]\r
- */\r
- node *ch;\r
-\r
- REQ(n, flow_stmt);\r
- ch = CHILD(n, 0);\r
- switch (TYPE(ch)) {\r
- case break_stmt:\r
- return Break(LINENO(n), n->n_col_offset, c->c_arena);\r
- case continue_stmt:\r
- return Continue(LINENO(n), n->n_col_offset, c->c_arena);\r
- case yield_stmt: { /* will reduce to yield_expr */\r
- expr_ty exp = ast_for_expr(c, CHILD(ch, 0));\r
- if (!exp)\r
- return NULL;\r
- return Expr(exp, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- case return_stmt:\r
- if (NCH(ch) == 1)\r
- return Return(NULL, LINENO(n), n->n_col_offset, c->c_arena);\r
- else {\r
- expr_ty expression = ast_for_testlist(c, CHILD(ch, 1));\r
- if (!expression)\r
- return NULL;\r
- return Return(expression, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- case raise_stmt:\r
- if (NCH(ch) == 1)\r
- return Raise(NULL, NULL, NULL, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- else if (NCH(ch) == 2) {\r
- expr_ty expression = ast_for_expr(c, CHILD(ch, 1));\r
- if (!expression)\r
- return NULL;\r
- return Raise(expression, NULL, NULL, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- }\r
- else if (NCH(ch) == 4) {\r
- expr_ty expr1, expr2;\r
-\r
- expr1 = ast_for_expr(c, CHILD(ch, 1));\r
- if (!expr1)\r
- return NULL;\r
- expr2 = ast_for_expr(c, CHILD(ch, 3));\r
- if (!expr2)\r
- return NULL;\r
-\r
- return Raise(expr1, expr2, NULL, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- else if (NCH(ch) == 6) {\r
- expr_ty expr1, expr2, expr3;\r
-\r
- expr1 = ast_for_expr(c, CHILD(ch, 1));\r
- if (!expr1)\r
- return NULL;\r
- expr2 = ast_for_expr(c, CHILD(ch, 3));\r
- if (!expr2)\r
- return NULL;\r
- expr3 = ast_for_expr(c, CHILD(ch, 5));\r
- if (!expr3)\r
- return NULL;\r
-\r
- return Raise(expr1, expr2, expr3, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "unexpected flow_stmt: %d", TYPE(ch));\r
- return NULL;\r
- }\r
-\r
- PyErr_SetString(PyExc_SystemError, "unhandled flow statement");\r
- return NULL;\r
-}\r
-\r
-static alias_ty\r
-alias_for_import_name(struct compiling *c, const node *n, int store)\r
-{\r
- /*\r
- import_as_name: NAME ['as' NAME]\r
- dotted_as_name: dotted_name ['as' NAME]\r
- dotted_name: NAME ('.' NAME)*\r
- */\r
- PyObject *str, *name;\r
-\r
- loop:\r
- switch (TYPE(n)) {\r
- case import_as_name: {\r
- node *name_node = CHILD(n, 0);\r
- str = NULL;\r
- if (NCH(n) == 3) {\r
- node *str_node = CHILD(n, 2);\r
- if (store && !forbidden_check(c, str_node, STR(str_node)))\r
- return NULL;\r
- str = NEW_IDENTIFIER(str_node);\r
- if (!str)\r
- return NULL;\r
- }\r
- else {\r
- if (!forbidden_check(c, name_node, STR(name_node)))\r
- return NULL;\r
- }\r
- name = NEW_IDENTIFIER(name_node);\r
- if (!name)\r
- return NULL;\r
- return alias(name, str, c->c_arena);\r
- }\r
- case dotted_as_name:\r
- if (NCH(n) == 1) {\r
- n = CHILD(n, 0);\r
- goto loop;\r
- }\r
- else {\r
- node *asname_node = CHILD(n, 2);\r
- alias_ty a = alias_for_import_name(c, CHILD(n, 0), 0);\r
- if (!a)\r
- return NULL;\r
- assert(!a->asname);\r
- if (!forbidden_check(c, asname_node, STR(asname_node)))\r
- return NULL;\r
- a->asname = NEW_IDENTIFIER(asname_node);\r
- if (!a->asname)\r
- return NULL;\r
- return a;\r
- }\r
- break;\r
- case dotted_name:\r
- if (NCH(n) == 1) {\r
- node *name_node = CHILD(n, 0);\r
- if (store && !forbidden_check(c, name_node, STR(name_node)))\r
- return NULL;\r
- name = NEW_IDENTIFIER(name_node);\r
- if (!name)\r
- return NULL;\r
- return alias(name, NULL, c->c_arena);\r
- }\r
- else {\r
- /* Create a string of the form "a.b.c" */\r
- int i;\r
- size_t len;\r
- char *s;\r
-\r
- len = 0;\r
- for (i = 0; i < NCH(n); i += 2)\r
- /* length of string plus one for the dot */\r
- len += strlen(STR(CHILD(n, i))) + 1;\r
- len--; /* the last name doesn't have a dot */\r
- str = PyString_FromStringAndSize(NULL, len);\r
- if (!str)\r
- return NULL;\r
- s = PyString_AS_STRING(str);\r
- if (!s)\r
- return NULL;\r
- for (i = 0; i < NCH(n); i += 2) {\r
- char *sch = STR(CHILD(n, i));\r
- strcpy(s, STR(CHILD(n, i)));\r
- s += strlen(sch);\r
- *s++ = '.';\r
- }\r
- --s;\r
- *s = '\0';\r
- PyString_InternInPlace(&str);\r
- PyArena_AddPyObject(c->c_arena, str);\r
- return alias(str, NULL, c->c_arena);\r
- }\r
- break;\r
- case STAR:\r
- str = PyString_InternFromString("*");\r
- PyArena_AddPyObject(c->c_arena, str);\r
- return alias(str, NULL, c->c_arena);\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "unexpected import name: %d", TYPE(n));\r
- return NULL;\r
- }\r
-\r
- PyErr_SetString(PyExc_SystemError, "unhandled import name condition");\r
- return NULL;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_import_stmt(struct compiling *c, const node *n)\r
-{\r
- /*\r
- import_stmt: import_name | import_from\r
- import_name: 'import' dotted_as_names\r
- import_from: 'from' ('.'* dotted_name | '.') 'import'\r
- ('*' | '(' import_as_names ')' | import_as_names)\r
- */\r
- int lineno;\r
- int col_offset;\r
- int i;\r
- asdl_seq *aliases;\r
-\r
- REQ(n, import_stmt);\r
- lineno = LINENO(n);\r
- col_offset = n->n_col_offset;\r
- n = CHILD(n, 0);\r
- if (TYPE(n) == import_name) {\r
- n = CHILD(n, 1);\r
- REQ(n, dotted_as_names);\r
- aliases = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);\r
- if (!aliases)\r
- return NULL;\r
- for (i = 0; i < NCH(n); i += 2) {\r
- alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);\r
- if (!import_alias)\r
- return NULL;\r
- asdl_seq_SET(aliases, i / 2, import_alias);\r
- }\r
- return Import(aliases, lineno, col_offset, c->c_arena);\r
- }\r
- else if (TYPE(n) == import_from) {\r
- int n_children;\r
- int idx, ndots = 0;\r
- alias_ty mod = NULL;\r
- identifier modname = NULL;\r
-\r
- /* Count the number of dots (for relative imports) and check for the\r
- optional module name */\r
- for (idx = 1; idx < NCH(n); idx++) {\r
- if (TYPE(CHILD(n, idx)) == dotted_name) {\r
- mod = alias_for_import_name(c, CHILD(n, idx), 0);\r
- if (!mod)\r
- return NULL;\r
- idx++;\r
- break;\r
- } else if (TYPE(CHILD(n, idx)) != DOT) {\r
- break;\r
- }\r
- ndots++;\r
- }\r
- idx++; /* skip over the 'import' keyword */\r
- switch (TYPE(CHILD(n, idx))) {\r
- case STAR:\r
- /* from ... import * */\r
- n = CHILD(n, idx);\r
- n_children = 1;\r
- break;\r
- case LPAR:\r
- /* from ... import (x, y, z) */\r
- n = CHILD(n, idx + 1);\r
- n_children = NCH(n);\r
- break;\r
- case import_as_names:\r
- /* from ... import x, y, z */\r
- n = CHILD(n, idx);\r
- n_children = NCH(n);\r
- if (n_children % 2 == 0) {\r
- ast_error(n, "trailing comma not allowed without"\r
- " surrounding parentheses");\r
- return NULL;\r
- }\r
- break;\r
- default:\r
- ast_error(n, "Unexpected node-type in from-import");\r
- return NULL;\r
- }\r
-\r
- aliases = asdl_seq_new((n_children + 1) / 2, c->c_arena);\r
- if (!aliases)\r
- return NULL;\r
-\r
- /* handle "from ... import *" special b/c there's no children */\r
- if (TYPE(n) == STAR) {\r
- alias_ty import_alias = alias_for_import_name(c, n, 1);\r
- if (!import_alias)\r
- return NULL;\r
- asdl_seq_SET(aliases, 0, import_alias);\r
- }\r
- else {\r
- for (i = 0; i < NCH(n); i += 2) {\r
- alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);\r
- if (!import_alias)\r
- return NULL;\r
- asdl_seq_SET(aliases, i / 2, import_alias);\r
- }\r
- }\r
- if (mod != NULL)\r
- modname = mod->name;\r
- return ImportFrom(modname, aliases, ndots, lineno, col_offset,\r
- c->c_arena);\r
- }\r
- PyErr_Format(PyExc_SystemError,\r
- "unknown import statement: starts with command '%s'",\r
- STR(CHILD(n, 0)));\r
- return NULL;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_global_stmt(struct compiling *c, const node *n)\r
-{\r
- /* global_stmt: 'global' NAME (',' NAME)* */\r
- identifier name;\r
- asdl_seq *s;\r
- int i;\r
-\r
- REQ(n, global_stmt);\r
- s = asdl_seq_new(NCH(n) / 2, c->c_arena);\r
- if (!s)\r
- return NULL;\r
- for (i = 1; i < NCH(n); i += 2) {\r
- name = NEW_IDENTIFIER(CHILD(n, i));\r
- if (!name)\r
- return NULL;\r
- asdl_seq_SET(s, i / 2, name);\r
- }\r
- return Global(s, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static stmt_ty\r
-ast_for_exec_stmt(struct compiling *c, const node *n)\r
-{\r
- expr_ty expr1, globals = NULL, locals = NULL;\r
- int n_children = NCH(n);\r
- if (n_children != 2 && n_children != 4 && n_children != 6) {\r
- PyErr_Format(PyExc_SystemError,\r
- "poorly formed 'exec' statement: %d parts to statement",\r
- n_children);\r
- return NULL;\r
- }\r
-\r
- /* exec_stmt: 'exec' expr ['in' test [',' test]] */\r
- REQ(n, exec_stmt);\r
- expr1 = ast_for_expr(c, CHILD(n, 1));\r
- if (!expr1)\r
- return NULL;\r
-\r
- if (expr1->kind == Tuple_kind && n_children < 4 &&\r
- (asdl_seq_LEN(expr1->v.Tuple.elts) == 2 ||\r
- asdl_seq_LEN(expr1->v.Tuple.elts) == 3)) {\r
- /* Backwards compatibility: passing exec args as a tuple */\r
- globals = asdl_seq_GET(expr1->v.Tuple.elts, 1);\r
- if (asdl_seq_LEN(expr1->v.Tuple.elts) == 3) {\r
- locals = asdl_seq_GET(expr1->v.Tuple.elts, 2);\r
- }\r
- expr1 = asdl_seq_GET(expr1->v.Tuple.elts, 0);\r
- }\r
-\r
- if (n_children >= 4) {\r
- globals = ast_for_expr(c, CHILD(n, 3));\r
- if (!globals)\r
- return NULL;\r
- }\r
- if (n_children == 6) {\r
- locals = ast_for_expr(c, CHILD(n, 5));\r
- if (!locals)\r
- return NULL;\r
- }\r
-\r
- return Exec(expr1, globals, locals, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
-}\r
-\r
-static stmt_ty\r
-ast_for_assert_stmt(struct compiling *c, const node *n)\r
-{\r
- /* assert_stmt: 'assert' test [',' test] */\r
- REQ(n, assert_stmt);\r
- if (NCH(n) == 2) {\r
- expr_ty expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- return Assert(expression, NULL, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- else if (NCH(n) == 4) {\r
- expr_ty expr1, expr2;\r
-\r
- expr1 = ast_for_expr(c, CHILD(n, 1));\r
- if (!expr1)\r
- return NULL;\r
- expr2 = ast_for_expr(c, CHILD(n, 3));\r
- if (!expr2)\r
- return NULL;\r
-\r
- return Assert(expr1, expr2, LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
- PyErr_Format(PyExc_SystemError,\r
- "improper number of parts to 'assert' statement: %d",\r
- NCH(n));\r
- return NULL;\r
-}\r
-\r
-static asdl_seq *\r
-ast_for_suite(struct compiling *c, const node *n)\r
-{\r
- /* suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT */\r
- asdl_seq *seq;\r
- stmt_ty s;\r
- int i, total, num, end, pos = 0;\r
- node *ch;\r
-\r
- REQ(n, suite);\r
-\r
- total = num_stmts(n);\r
- seq = asdl_seq_new(total, c->c_arena);\r
- if (!seq)\r
- return NULL;\r
- if (TYPE(CHILD(n, 0)) == simple_stmt) {\r
- n = CHILD(n, 0);\r
- /* simple_stmt always ends with a NEWLINE,\r
- and may have a trailing SEMI\r
- */\r
- end = NCH(n) - 1;\r
- if (TYPE(CHILD(n, end - 1)) == SEMI)\r
- end--;\r
- /* loop by 2 to skip semi-colons */\r
- for (i = 0; i < end; i += 2) {\r
- ch = CHILD(n, i);\r
- s = ast_for_stmt(c, ch);\r
- if (!s)\r
- return NULL;\r
- asdl_seq_SET(seq, pos++, s);\r
- }\r
- }\r
- else {\r
- for (i = 2; i < (NCH(n) - 1); i++) {\r
- ch = CHILD(n, i);\r
- REQ(ch, stmt);\r
- num = num_stmts(ch);\r
- if (num == 1) {\r
- /* small_stmt or compound_stmt with only one child */\r
- s = ast_for_stmt(c, ch);\r
- if (!s)\r
- return NULL;\r
- asdl_seq_SET(seq, pos++, s);\r
- }\r
- else {\r
- int j;\r
- ch = CHILD(ch, 0);\r
- REQ(ch, simple_stmt);\r
- for (j = 0; j < NCH(ch); j += 2) {\r
- /* statement terminates with a semi-colon ';' */\r
- if (NCH(CHILD(ch, j)) == 0) {\r
- assert((j + 1) == NCH(ch));\r
- break;\r
- }\r
- s = ast_for_stmt(c, CHILD(ch, j));\r
- if (!s)\r
- return NULL;\r
- asdl_seq_SET(seq, pos++, s);\r
- }\r
- }\r
- }\r
- }\r
- assert(pos == seq->size);\r
- return seq;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_if_stmt(struct compiling *c, const node *n)\r
-{\r
- /* if_stmt: 'if' test ':' suite ('elif' test ':' suite)*\r
- ['else' ':' suite]\r
- */\r
- char *s;\r
-\r
- REQ(n, if_stmt);\r
-\r
- if (NCH(n) == 4) {\r
- expr_ty expression;\r
- asdl_seq *suite_seq;\r
-\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, CHILD(n, 3));\r
- if (!suite_seq)\r
- return NULL;\r
-\r
- return If(expression, suite_seq, NULL, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
-\r
- s = STR(CHILD(n, 4));\r
- /* s[2], the third character in the string, will be\r
- 's' for el_s_e, or\r
- 'i' for el_i_f\r
- */\r
- if (s[2] == 's') {\r
- expr_ty expression;\r
- asdl_seq *seq1, *seq2;\r
-\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- seq1 = ast_for_suite(c, CHILD(n, 3));\r
- if (!seq1)\r
- return NULL;\r
- seq2 = ast_for_suite(c, CHILD(n, 6));\r
- if (!seq2)\r
- return NULL;\r
-\r
- return If(expression, seq1, seq2, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- else if (s[2] == 'i') {\r
- int i, n_elif, has_else = 0;\r
- expr_ty expression;\r
- asdl_seq *suite_seq;\r
- asdl_seq *orelse = NULL;\r
- n_elif = NCH(n) - 4;\r
- /* must reference the child n_elif+1 since 'else' token is third,\r
- not fourth, child from the end. */\r
- if (TYPE(CHILD(n, (n_elif + 1))) == NAME\r
- && STR(CHILD(n, (n_elif + 1)))[2] == 's') {\r
- has_else = 1;\r
- n_elif -= 3;\r
- }\r
- n_elif /= 4;\r
-\r
- if (has_else) {\r
- asdl_seq *suite_seq2;\r
-\r
- orelse = asdl_seq_new(1, c->c_arena);\r
- if (!orelse)\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(n, NCH(n) - 6));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, CHILD(n, NCH(n) - 4));\r
- if (!suite_seq)\r
- return NULL;\r
- suite_seq2 = ast_for_suite(c, CHILD(n, NCH(n) - 1));\r
- if (!suite_seq2)\r
- return NULL;\r
-\r
- asdl_seq_SET(orelse, 0,\r
- If(expression, suite_seq, suite_seq2,\r
- LINENO(CHILD(n, NCH(n) - 6)),\r
- CHILD(n, NCH(n) - 6)->n_col_offset,\r
- c->c_arena));\r
- /* the just-created orelse handled the last elif */\r
- n_elif--;\r
- }\r
-\r
- for (i = 0; i < n_elif; i++) {\r
- int off = 5 + (n_elif - i - 1) * 4;\r
- asdl_seq *newobj = asdl_seq_new(1, c->c_arena);\r
- if (!newobj)\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(n, off));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, CHILD(n, off + 2));\r
- if (!suite_seq)\r
- return NULL;\r
-\r
- asdl_seq_SET(newobj, 0,\r
- If(expression, suite_seq, orelse,\r
- LINENO(CHILD(n, off)),\r
- CHILD(n, off)->n_col_offset, c->c_arena));\r
- orelse = newobj;\r
- }\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, CHILD(n, 3));\r
- if (!suite_seq)\r
- return NULL;\r
- return If(expression, suite_seq, orelse,\r
- LINENO(n), n->n_col_offset, c->c_arena);\r
- }\r
-\r
- PyErr_Format(PyExc_SystemError,\r
- "unexpected token in 'if' statement: %s", s);\r
- return NULL;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_while_stmt(struct compiling *c, const node *n)\r
-{\r
- /* while_stmt: 'while' test ':' suite ['else' ':' suite] */\r
- REQ(n, while_stmt);\r
-\r
- if (NCH(n) == 4) {\r
- expr_ty expression;\r
- asdl_seq *suite_seq;\r
-\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, CHILD(n, 3));\r
- if (!suite_seq)\r
- return NULL;\r
- return While(expression, suite_seq, NULL, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
- else if (NCH(n) == 7) {\r
- expr_ty expression;\r
- asdl_seq *seq1, *seq2;\r
-\r
- expression = ast_for_expr(c, CHILD(n, 1));\r
- if (!expression)\r
- return NULL;\r
- seq1 = ast_for_suite(c, CHILD(n, 3));\r
- if (!seq1)\r
- return NULL;\r
- seq2 = ast_for_suite(c, CHILD(n, 6));\r
- if (!seq2)\r
- return NULL;\r
-\r
- return While(expression, seq1, seq2, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
- }\r
-\r
- PyErr_Format(PyExc_SystemError,\r
- "wrong number of tokens for 'while' statement: %d",\r
- NCH(n));\r
- return NULL;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_for_stmt(struct compiling *c, const node *n)\r
-{\r
- asdl_seq *_target, *seq = NULL, *suite_seq;\r
- expr_ty expression;\r
- expr_ty target, first;\r
- const node *node_target;\r
- /* for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] */\r
- REQ(n, for_stmt);\r
-\r
- if (NCH(n) == 9) {\r
- seq = ast_for_suite(c, CHILD(n, 8));\r
- if (!seq)\r
- return NULL;\r
- }\r
-\r
- node_target = CHILD(n, 1);\r
- _target = ast_for_exprlist(c, node_target, Store);\r
- if (!_target)\r
- return NULL;\r
- /* Check the # of children rather than the length of _target, since\r
- for x, in ... has 1 element in _target, but still requires a Tuple. */\r
- first = (expr_ty)asdl_seq_GET(_target, 0);\r
- if (NCH(node_target) == 1)\r
- target = first;\r
- else\r
- target = Tuple(_target, Store, first->lineno, first->col_offset, c->c_arena);\r
-\r
- expression = ast_for_testlist(c, CHILD(n, 3));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, CHILD(n, 5));\r
- if (!suite_seq)\r
- return NULL;\r
-\r
- return For(target, expression, suite_seq, seq, LINENO(n), n->n_col_offset,\r
- c->c_arena);\r
-}\r
-\r
-static excepthandler_ty\r
-ast_for_except_clause(struct compiling *c, const node *exc, node *body)\r
-{\r
- /* except_clause: 'except' [test [(',' | 'as') test]] */\r
- REQ(exc, except_clause);\r
- REQ(body, suite);\r
-\r
- if (NCH(exc) == 1) {\r
- asdl_seq *suite_seq = ast_for_suite(c, body);\r
- if (!suite_seq)\r
- return NULL;\r
-\r
- return ExceptHandler(NULL, NULL, suite_seq, LINENO(exc),\r
- exc->n_col_offset, c->c_arena);\r
- }\r
- else if (NCH(exc) == 2) {\r
- expr_ty expression;\r
- asdl_seq *suite_seq;\r
-\r
- expression = ast_for_expr(c, CHILD(exc, 1));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, body);\r
- if (!suite_seq)\r
- return NULL;\r
-\r
- return ExceptHandler(expression, NULL, suite_seq, LINENO(exc),\r
- exc->n_col_offset, c->c_arena);\r
- }\r
- else if (NCH(exc) == 4) {\r
- asdl_seq *suite_seq;\r
- expr_ty expression;\r
- expr_ty e = ast_for_expr(c, CHILD(exc, 3));\r
- if (!e)\r
- return NULL;\r
- if (!set_context(c, e, Store, CHILD(exc, 3)))\r
- return NULL;\r
- expression = ast_for_expr(c, CHILD(exc, 1));\r
- if (!expression)\r
- return NULL;\r
- suite_seq = ast_for_suite(c, body);\r
- if (!suite_seq)\r
- return NULL;\r
-\r
- return ExceptHandler(expression, e, suite_seq, LINENO(exc),\r
- exc->n_col_offset, c->c_arena);\r
- }\r
-\r
- PyErr_Format(PyExc_SystemError,\r
- "wrong number of children for 'except' clause: %d",\r
- NCH(exc));\r
- return NULL;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_try_stmt(struct compiling *c, const node *n)\r
-{\r
- const int nch = NCH(n);\r
- int n_except = (nch - 3)/3;\r
- asdl_seq *body, *orelse = NULL, *finally = NULL;\r
-\r
- REQ(n, try_stmt);\r
-\r
- body = ast_for_suite(c, CHILD(n, 2));\r
- if (body == NULL)\r
- return NULL;\r
-\r
- if (TYPE(CHILD(n, nch - 3)) == NAME) {\r
- if (strcmp(STR(CHILD(n, nch - 3)), "finally") == 0) {\r
- if (nch >= 9 && TYPE(CHILD(n, nch - 6)) == NAME) {\r
- /* we can assume it's an "else",\r
- because nch >= 9 for try-else-finally and\r
- it would otherwise have a type of except_clause */\r
- orelse = ast_for_suite(c, CHILD(n, nch - 4));\r
- if (orelse == NULL)\r
- return NULL;\r
- n_except--;\r
- }\r
-\r
- finally = ast_for_suite(c, CHILD(n, nch - 1));\r
- if (finally == NULL)\r
- return NULL;\r
- n_except--;\r
- }\r
- else {\r
- /* we can assume it's an "else",\r
- otherwise it would have a type of except_clause */\r
- orelse = ast_for_suite(c, CHILD(n, nch - 1));\r
- if (orelse == NULL)\r
- return NULL;\r
- n_except--;\r
- }\r
- }\r
- else if (TYPE(CHILD(n, nch - 3)) != except_clause) {\r
- ast_error(n, "malformed 'try' statement");\r
- return NULL;\r
- }\r
-\r
- if (n_except > 0) {\r
- int i;\r
- stmt_ty except_st;\r
- /* process except statements to create a try ... except */\r
- asdl_seq *handlers = asdl_seq_new(n_except, c->c_arena);\r
- if (handlers == NULL)\r
- return NULL;\r
-\r
- for (i = 0; i < n_except; i++) {\r
- excepthandler_ty e = ast_for_except_clause(c, CHILD(n, 3 + i * 3),\r
- CHILD(n, 5 + i * 3));\r
- if (!e)\r
- return NULL;\r
- asdl_seq_SET(handlers, i, e);\r
- }\r
-\r
- except_st = TryExcept(body, handlers, orelse, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- if (!finally)\r
- return except_st;\r
-\r
- /* if a 'finally' is present too, we nest the TryExcept within a\r
- TryFinally to emulate try ... except ... finally */\r
- body = asdl_seq_new(1, c->c_arena);\r
- if (body == NULL)\r
- return NULL;\r
- asdl_seq_SET(body, 0, except_st);\r
- }\r
-\r
- /* must be a try ... finally (except clauses are in body, if any exist) */\r
- assert(finally != NULL);\r
- return TryFinally(body, finally, LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-/* with_item: test ['as' expr] */\r
-static stmt_ty\r
-ast_for_with_item(struct compiling *c, const node *n, asdl_seq *content)\r
-{\r
- expr_ty context_expr, optional_vars = NULL;\r
-\r
- REQ(n, with_item);\r
- context_expr = ast_for_expr(c, CHILD(n, 0));\r
- if (!context_expr)\r
- return NULL;\r
- if (NCH(n) == 3) {\r
- optional_vars = ast_for_expr(c, CHILD(n, 2));\r
-\r
- if (!optional_vars) {\r
- return NULL;\r
- }\r
- if (!set_context(c, optional_vars, Store, n)) {\r
- return NULL;\r
- }\r
- }\r
-\r
- return With(context_expr, optional_vars, content, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
-}\r
-\r
-/* with_stmt: 'with' with_item (',' with_item)* ':' suite */\r
-static stmt_ty\r
-ast_for_with_stmt(struct compiling *c, const node *n)\r
-{\r
- int i;\r
- stmt_ty ret;\r
- asdl_seq *inner;\r
-\r
- REQ(n, with_stmt);\r
-\r
- /* process the with items inside-out */\r
- i = NCH(n) - 1;\r
- /* the suite of the innermost with item is the suite of the with stmt */\r
- inner = ast_for_suite(c, CHILD(n, i));\r
- if (!inner)\r
- return NULL;\r
-\r
- for (;;) {\r
- i -= 2;\r
- ret = ast_for_with_item(c, CHILD(n, i), inner);\r
- if (!ret)\r
- return NULL;\r
- /* was this the last item? */\r
- if (i == 1)\r
- break;\r
- /* if not, wrap the result so far in a new sequence */\r
- inner = asdl_seq_new(1, c->c_arena);\r
- if (!inner)\r
- return NULL;\r
- asdl_seq_SET(inner, 0, ret);\r
- }\r
-\r
- return ret;\r
-}\r
-\r
-static stmt_ty\r
-ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)\r
-{\r
- /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */\r
- PyObject *classname;\r
- asdl_seq *bases, *s;\r
-\r
- REQ(n, classdef);\r
-\r
- if (!forbidden_check(c, n, STR(CHILD(n, 1))))\r
- return NULL;\r
-\r
- if (NCH(n) == 4) {\r
- s = ast_for_suite(c, CHILD(n, 3));\r
- if (!s)\r
- return NULL;\r
- classname = NEW_IDENTIFIER(CHILD(n, 1));\r
- if (!classname)\r
- return NULL;\r
- return ClassDef(classname, NULL, s, decorator_seq, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- }\r
- /* check for empty base list */\r
- if (TYPE(CHILD(n,3)) == RPAR) {\r
- s = ast_for_suite(c, CHILD(n,5));\r
- if (!s)\r
- return NULL;\r
- classname = NEW_IDENTIFIER(CHILD(n, 1));\r
- if (!classname)\r
- return NULL;\r
- return ClassDef(classname, NULL, s, decorator_seq, LINENO(n),\r
- n->n_col_offset, c->c_arena);\r
- }\r
-\r
- /* else handle the base class list */\r
- bases = ast_for_class_bases(c, CHILD(n, 3));\r
- if (!bases)\r
- return NULL;\r
-\r
- s = ast_for_suite(c, CHILD(n, 6));\r
- if (!s)\r
- return NULL;\r
- classname = NEW_IDENTIFIER(CHILD(n, 1));\r
- if (!classname)\r
- return NULL;\r
- return ClassDef(classname, bases, s, decorator_seq,\r
- LINENO(n), n->n_col_offset, c->c_arena);\r
-}\r
-\r
-static stmt_ty\r
-ast_for_stmt(struct compiling *c, const node *n)\r
-{\r
- if (TYPE(n) == stmt) {\r
- assert(NCH(n) == 1);\r
- n = CHILD(n, 0);\r
- }\r
- if (TYPE(n) == simple_stmt) {\r
- assert(num_stmts(n) == 1);\r
- n = CHILD(n, 0);\r
- }\r
- if (TYPE(n) == small_stmt) {\r
- n = CHILD(n, 0);\r
- /* small_stmt: expr_stmt | print_stmt | del_stmt | pass_stmt\r
- | flow_stmt | import_stmt | global_stmt | exec_stmt\r
- | assert_stmt\r
- */\r
- switch (TYPE(n)) {\r
- case expr_stmt:\r
- return ast_for_expr_stmt(c, n);\r
- case print_stmt:\r
- return ast_for_print_stmt(c, n);\r
- case del_stmt:\r
- return ast_for_del_stmt(c, n);\r
- case pass_stmt:\r
- return Pass(LINENO(n), n->n_col_offset, c->c_arena);\r
- case flow_stmt:\r
- return ast_for_flow_stmt(c, n);\r
- case import_stmt:\r
- return ast_for_import_stmt(c, n);\r
- case global_stmt:\r
- return ast_for_global_stmt(c, n);\r
- case exec_stmt:\r
- return ast_for_exec_stmt(c, n);\r
- case assert_stmt:\r
- return ast_for_assert_stmt(c, n);\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "unhandled small_stmt: TYPE=%d NCH=%d\n",\r
- TYPE(n), NCH(n));\r
- return NULL;\r
- }\r
- }\r
- else {\r
- /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt\r
- | funcdef | classdef | decorated\r
- */\r
- node *ch = CHILD(n, 0);\r
- REQ(n, compound_stmt);\r
- switch (TYPE(ch)) {\r
- case if_stmt:\r
- return ast_for_if_stmt(c, ch);\r
- case while_stmt:\r
- return ast_for_while_stmt(c, ch);\r
- case for_stmt:\r
- return ast_for_for_stmt(c, ch);\r
- case try_stmt:\r
- return ast_for_try_stmt(c, ch);\r
- case with_stmt:\r
- return ast_for_with_stmt(c, ch);\r
- case funcdef:\r
- return ast_for_funcdef(c, ch, NULL);\r
- case classdef:\r
- return ast_for_classdef(c, ch, NULL);\r
- case decorated:\r
- return ast_for_decorated(c, ch);\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "unhandled small_stmt: TYPE=%d NCH=%d\n",\r
- TYPE(n), NCH(n));\r
- return NULL;\r
- }\r
- }\r
-}\r
-\r
-static PyObject *\r
-parsenumber(struct compiling *c, const char *s)\r
-{\r
- const char *end;\r
- long x;\r
- double dx;\r
-#ifndef WITHOUT_COMPLEX\r
- Py_complex complex;\r
- int imflag;\r
-#endif\r
-\r
- assert(s != NULL);\r
- errno = 0;\r
- end = s + strlen(s) - 1;\r
-#ifndef WITHOUT_COMPLEX\r
- imflag = *end == 'j' || *end == 'J';\r
-#endif\r
- if (*end == 'l' || *end == 'L')\r
- return PyLong_FromString((char *)s, (char **)0, 0);\r
- x = PyOS_strtol((char *)s, (char **)&end, 0);\r
- if (*end == '\0') {\r
- if (errno != 0)\r
- return PyLong_FromString((char *)s, (char **)0, 0);\r
- return PyInt_FromLong(x);\r
- }\r
- /* XXX Huge floats may silently fail */\r
-#ifndef WITHOUT_COMPLEX\r
- if (imflag) {\r
- complex.real = 0.;\r
- complex.imag = PyOS_string_to_double(s, (char **)&end, NULL);\r
- if (complex.imag == -1.0 && PyErr_Occurred())\r
- return NULL;\r
- return PyComplex_FromCComplex(complex);\r
- }\r
- else\r
-#endif\r
- {\r
- dx = PyOS_string_to_double(s, NULL, NULL);\r
- if (dx == -1.0 && PyErr_Occurred())\r
- return NULL;\r
- return PyFloat_FromDouble(dx);\r
- }\r
-}\r
-\r
-static PyObject *\r
-decode_utf8(struct compiling *c, const char **sPtr, const char *end, char* encoding)\r
-{\r
-#ifndef Py_USING_UNICODE\r
- Py_FatalError("decode_utf8 should not be called in this build.");\r
- return NULL;\r
-#else\r
- PyObject *u, *v;\r
- char *s, *t;\r
- t = s = (char *)*sPtr;\r
- /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */\r
- while (s < end && (*s & 0x80)) s++;\r
- *sPtr = s;\r
- u = PyUnicode_DecodeUTF8(t, s - t, NULL);\r
- if (u == NULL)\r
- return NULL;\r
- v = PyUnicode_AsEncodedString(u, encoding, NULL);\r
- Py_DECREF(u);\r
- return v;\r
-#endif\r
-}\r
-\r
-#ifdef Py_USING_UNICODE\r
-static PyObject *\r
-decode_unicode(struct compiling *c, const char *s, size_t len, int rawmode, const char *encoding)\r
-{\r
- PyObject *v;\r
- PyObject *u = NULL;\r
- char *buf;\r
- char *p;\r
- const char *end;\r
- if (encoding != NULL && strcmp(encoding, "iso-8859-1")) {\r
- /* check for integer overflow */\r
- if (len > PY_SIZE_MAX / 6)\r
- return NULL;\r
- /* "<C3><A4>" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5\r
- "\รค" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */\r
- u = PyString_FromStringAndSize((char *)NULL, len * 6);\r
- if (u == NULL)\r
- return NULL;\r
- p = buf = PyString_AsString(u);\r
- end = s + len;\r
- while (s < end) {\r
- if (*s == '\\') {\r
- *p++ = *s++;\r
- if (*s & 0x80) {\r
- strcpy(p, "u005c");\r
- p += 5;\r
- }\r
- }\r
- if (*s & 0x80) { /* XXX inefficient */\r
- PyObject *w;\r
- char *r;\r
- Py_ssize_t rn, i;\r
- w = decode_utf8(c, &s, end, "utf-32-be");\r
- if (w == NULL) {\r
- Py_DECREF(u);\r
- return NULL;\r
- }\r
- r = PyString_AsString(w);\r
- rn = PyString_Size(w);\r
- assert(rn % 4 == 0);\r
- for (i = 0; i < rn; i += 4) {\r
- sprintf(p, "\\U%02x%02x%02x%02x",\r
- r[i + 0] & 0xFF,\r
- r[i + 1] & 0xFF,\r
- r[i + 2] & 0xFF,\r
- r[i + 3] & 0xFF);\r
- p += 10;\r
- }\r
- Py_DECREF(w);\r
- } else {\r
- *p++ = *s++;\r
- }\r
- }\r
- len = p - buf;\r
- s = buf;\r
- }\r
- if (rawmode)\r
- v = PyUnicode_DecodeRawUnicodeEscape(s, len, NULL);\r
- else\r
- v = PyUnicode_DecodeUnicodeEscape(s, len, NULL);\r
- Py_XDECREF(u);\r
- return v;\r
-}\r
-#endif\r
-\r
-/* s is a Python string literal, including the bracketing quote characters,\r
- * and r &/or u prefixes (if any), and embedded escape sequences (if any).\r
- * parsestr parses it, and returns the decoded Python string object.\r
- */\r
-static PyObject *\r
-parsestr(struct compiling *c, const node *n, const char *s)\r
-{\r
- size_t len, i;\r
- int quote = Py_CHARMASK(*s);\r
- int rawmode = 0;\r
- int need_encoding;\r
- int unicode = c->c_future_unicode;\r
- int bytes = 0;\r
-\r
- if (isalpha(quote) || quote == '_') {\r
- if (quote == 'u' || quote == 'U') {\r
- quote = *++s;\r
- unicode = 1;\r
- }\r
- if (quote == 'b' || quote == 'B') {\r
- quote = *++s;\r
- unicode = 0;\r
- bytes = 1;\r
- }\r
- if (quote == 'r' || quote == 'R') {\r
- quote = *++s;\r
- rawmode = 1;\r
- }\r
- }\r
- if (quote != '\'' && quote != '\"') {\r
- PyErr_BadInternalCall();\r
- return NULL;\r
- }\r
- s++;\r
- len = strlen(s);\r
- if (len > INT_MAX) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "string to parse is too long");\r
- return NULL;\r
- }\r
- if (s[--len] != quote) {\r
- PyErr_BadInternalCall();\r
- return NULL;\r
- }\r
- if (len >= 4 && s[0] == quote && s[1] == quote) {\r
- s += 2;\r
- len -= 2;\r
- if (s[--len] != quote || s[--len] != quote) {\r
- PyErr_BadInternalCall();\r
- return NULL;\r
- }\r
- }\r
- if (Py_Py3kWarningFlag && bytes) {\r
- for (i = 0; i < len; i++) {\r
- if ((unsigned char)s[i] > 127) {\r
- if (!ast_warn(c, n,\r
- "non-ascii bytes literals not supported in 3.x"))\r
- return NULL;\r
- break;\r
- }\r
- }\r
- }\r
-#ifdef Py_USING_UNICODE\r
- if (unicode || Py_UnicodeFlag) {\r
- return decode_unicode(c, s, len, rawmode, c->c_encoding);\r
- }\r
-#endif\r
- need_encoding = (c->c_encoding != NULL &&\r
- strcmp(c->c_encoding, "utf-8") != 0 &&\r
- strcmp(c->c_encoding, "iso-8859-1") != 0);\r
- if (rawmode || strchr(s, '\\') == NULL) {\r
- if (need_encoding) {\r
-#ifndef Py_USING_UNICODE\r
- /* This should not happen - we never see any other\r
- encoding. */\r
- Py_FatalError(\r
- "cannot deal with encodings in this build.");\r
-#else\r
- PyObject *v, *u = PyUnicode_DecodeUTF8(s, len, NULL);\r
- if (u == NULL)\r
- return NULL;\r
- v = PyUnicode_AsEncodedString(u, c->c_encoding, NULL);\r
- Py_DECREF(u);\r
- return v;\r
-#endif\r
- } else {\r
- return PyString_FromStringAndSize(s, len);\r
- }\r
- }\r
-\r
- return PyString_DecodeEscape(s, len, NULL, unicode,\r
- need_encoding ? c->c_encoding : NULL);\r
-}\r
-\r
-/* Build a Python string object out of a STRING atom. This takes care of\r
- * compile-time literal catenation, calling parsestr() on each piece, and\r
- * pasting the intermediate results together.\r
- */\r
-static PyObject *\r
-parsestrplus(struct compiling *c, const node *n)\r
-{\r
- PyObject *v;\r
- int i;\r
- REQ(CHILD(n, 0), STRING);\r
- if ((v = parsestr(c, n, STR(CHILD(n, 0)))) != NULL) {\r
- /* String literal concatenation */\r
- for (i = 1; i < NCH(n); i++) {\r
- PyObject *s;\r
- s = parsestr(c, n, STR(CHILD(n, i)));\r
- if (s == NULL)\r
- goto onError;\r
- if (PyString_Check(v) && PyString_Check(s)) {\r
- PyString_ConcatAndDel(&v, s);\r
- if (v == NULL)\r
- goto onError;\r
- }\r
-#ifdef Py_USING_UNICODE\r
- else {\r
- PyObject *temp = PyUnicode_Concat(v, s);\r
- Py_DECREF(s);\r
- Py_DECREF(v);\r
- v = temp;\r
- if (v == NULL)\r
- goto onError;\r
- }\r
-#endif\r
- }\r
- }\r
- return v;\r
-\r
- onError:\r
- Py_XDECREF(v);\r
- return NULL;\r
-}\r
projects / mirror_edk2.git / blobdiff